Changeset 21183 for trunk/psModules/src/imcombine

Timestamp:

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

Author:

eugene

Message:

incorporating changes from 16bit mask upgrades (eam_branch_20081230)

Location:

trunk/psModules/src/imcombine

Files:

• pmImageCombine.c (modified) (15 diffs)
• pmPSFEnvelope.c (modified) (1 diff)
• pmReadoutCombine.c (modified) (6 diffs)
• pmReadoutCombine.h (modified) (2 diffs)
• pmStack.c (modified) (15 diffs)
• pmStack.h (modified) (2 diffs)
• pmStackReject.c (modified) (2 diffs)
• pmSubtraction.c (modified) (17 diffs)
• pmSubtraction.h (modified) (2 diffs)
• pmSubtractionMask.c (modified) (8 diffs)
• pmSubtractionMask.h (modified) (2 diffs)
• pmSubtractionMatch.c (modified) (4 diffs)
• pmSubtractionMatch.h (modified) (1 diff)
• pmSubtractionStamps.c (modified) (6 diffs)

trunk/psModules/src/imcombine/pmImageCombine.c

@@ -8 +8 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-04-04 22:42:48 $
+ *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-01-27 06:39:38 $
  *
  *  XXX: pmRejectPixels() has a known bug with the pmImageTransform() call.
@@ -17 +17 @@
  */
 
+// XXX this is somewhat messy and unclear on the masking.
+
 #ifdef HAVE_CONFIG_H
 #include <config.h>
@@ -53 +55 @@
 
     buffer->pixels = psVectorAlloc(numImages, PS_TYPE_F32);
-    buffer->masks = psVectorAlloc(numImages, PS_TYPE_MASK);
+    buffer->masks = psVectorAlloc(numImages, PS_TYPE_VECTOR_MASK);
     buffer->errors = psVectorAlloc(numImages, PS_TYPE_F32);
     buffer->stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
@@ -67 +69 @@
                           const psArray *errors, // Array of input error images
                           const psArray *masks, // Array of input masks
-                          psU32 maskVal, // Mask value
+                          psImageMaskType maskVal, // Mask value
                           psS32 numIter, // Number of rejection iterations
                           psF32 sigmaClip, // Number of standard deviations at which to reject
@@ -115 +117 @@
         if (masks) {
             psImage *mask = masks->data[i]; // Mask of interest
-            pixelMasks->data.U8[i] = mask->data.U8[y][x];
-        }        // Set the pixel error data, if necessary
+            pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal);
+        }        
+        // Set the pixel error data, if necessary
         if (errors) {
             psImage *error = errors->data[i]; // Error image of interest
@@ -128 +131 @@
     for (int iter = 0; iter < numIter; iter++) {
         // Combine all the pixels, using the specified stat.
-        if (!psVectorStats(stats, pixelData, pixelErrors, pixelMasks, maskVal)) {
+        if (!psVectorStats(stats, pixelData, pixelErrors, pixelMasks, 0xff)) {
             combine->data.F32[y][x] = NAN;
             psFree(buffer);
@@ -148 +151 @@
         float stdev = stats->sampleStdev;
         for (int i = 0; i < numImages; i++) {
-            if (!(pixelMasks->data.U8[i] & maskVal) &&
+            if (!(pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[i] & 0xff) &&
                     fabs(pixelData->data.F32[i] - combinedPixel) > sigmaClip * stdev) {
                 // Reject pixel as questionable
                 numRejects++;
-                pixelMasks->data.U8[i] = maskVal;
+                pixelMasks->data.PS_TYPE_IMAGE_MASK_DATA[i] = 0xff;
                 if (questionablePixels) {
                     // Mark the pixel as questionable
@@ -191 +194 @@
     const psArray *errors,              ///< Array of input error images
     const psArray *masks,               ///< Array of input masks
-    psU32 maskVal,                      ///< Mask value
+    psImageMaskType maskVal,                      ///< Mask value
     const psPixels *pixels,             ///< Pixels to combine
     psS32 numIter,                      ///< Number of rejection iterations
@@ -231 +234 @@
             psImage *mask  = masks->data[i];
             PS_ASSERT_IMAGE_SIZE(mask, numCols, numRows, NULL);
-            PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
+            PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
         }
     }
@@ -319 +322 @@
     int num = 0;
     psVector *pixels = psVectorAlloc(8, PS_TYPE_F32); // Array of pixels
-    psVector *mask = psVectorAlloc(8, PS_TYPE_U8); // Corresponding mask
+    psVector *mask = psVectorAlloc(8, PS_TYPE_VECTOR_MASK); // Corresponding mask
 
     // Get limits
@@ -329 +332 @@
         for (int j = yMin; j <= yMax; j++) {
             for (int i = xMin; i <= xMax; i++) {
-                if ((i != x) && (j != y) && (0 == imageMask->data.U8[j][i])) {
+                if ((i != x) && (j != y) && (0 == imageMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i])) {
                     pixels->data.F32[num] = image->data.F32[j][i];
-                    mask->data.U8[num] = 0;
+                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0;
                     num++;
                 } else {
-                    mask->data.U8[num] = 1;
+                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 1;
                 }
             }
@@ -347 +350 @@
                 if ((i != x) && (j != y)) {
                     pixels->data.F32[num] = image->data.F32[j][i];
-                    mask->data.U8[num] = 0;
+                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0;
                     num++;
                 } else {
-                    mask->data.U8[num] = 1;
+                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 1;
                 }
             }
@@ -473 +476 @@
     for (psS32 i = 0 ; i < image->numRows ; i++) {
         for (psS32 j = 0 ; j < image->numCols ; j++) {
-            imgF32->data.F32[i][j] = (psF32) image->data.U8[i][j];
+            imgF32->data.F32[i][j] = (psF32) image->data.PS_TYPE_IMAGE_MASK_DATA[i][j];
         }
     }
@@ -518 +521 @@
             PS_ASSERT_IMAGE_NON_NULL(tmpMask, NULL);
             PS_ASSERT_IMAGE_NON_EMPTY(tmpMask, NULL);
-            PS_ASSERT_IMAGE_TYPE(tmpMask, PS_TYPE_F32, NULL);
+            PS_ASSERT_IMAGE_TYPE(tmpMask, PS_TYPE_F32, NULL); // XXX really F32??
             PS_ASSERT_IMAGES_SIZE_EQUAL(tmpImage, tmpMask, NULL);
         }
@@ -571 +574 @@
 
         //
-        // Create a psU8 mask image from the list of cosmic pixels.
+        // Create a psImageMaskType mask image from the list of cosmic pixels.
         //
         psImage *maskImage = NULL;

trunk/psModules/src/imcombine/pmPSFEnvelope.c

@@ -223 +223 @@
     // *** readout->weight = (psImage*)psBinaryOp(NULL, readout->image, "*", psScalarAlloc(WEIGHT_FACTOR, PS_TYPE_F32));
     readout->weight = (psImage*)psBinaryOp(NULL, readout->image, "+", psScalarAlloc(WEIGHT_VAL, PS_TYPE_F32));
-    readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
+    readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
     psImageInit(readout->mask, 0);
 

trunk/psModules/src/imcombine/pmReadoutCombine.c

@@ -105 +105 @@
 
     // note the mask value actually used
-    psMaskType maskVal = params->maskVal; // The mask value
+    psImageMaskType maskVal = params->maskVal; // The mask value
     if (maskVal) {
         psString comment = NULL;        // Comment to add to header
@@ -247 +247 @@
     psF32 *pixelsData = pixels->data.F32; // Dereference pixels
 
-    psVector *mask   = psVectorAlloc(inputs->n, PS_TYPE_U8); // Mask for stack
-    psU8 *maskData = mask->data.U8;     // Dereference mask
+    psVector *mask   = psVectorAlloc(inputs->n, PS_TYPE_VECTOR_MASK); // Mask for stack
+    psVectorMaskType *maskData = mask->data.PS_TYPE_VECTOR_MASK_DATA;     // Dereference mask
 
     psVector *weights = NULL;           // Stack of weights
@@ -260 +260 @@
 
     float keepFrac = 1.0 - params->fracLow - params->fracHigh; // Fraction of pixels to keep
-    psMaskType maskVal = params->maskVal; // The mask value
+    psImageMaskType maskVal = params->maskVal; // The mask value
 
     #ifndef PS_NO_TRACE
@@ -278 +278 @@
     // Dereference output products
     psF32 **outputImage  = output->image->data.F32; // Output image
-    psU8  **outputMask   = output->mask->data.U8; // Output mask
+    psImageMaskType **outputMask   = output->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Output mask
     psF32 **outputWeight = NULL; // Output weight map
     if (output->weight) {
@@ -303 +303 @@
 
             int numValid = 0;           // Number of valid pixels in the stack
-            memset(maskData, 0, mask->n * sizeof(psU8)); // Reset the mask
+            memset(maskData, 0, mask->n * sizeof(psVectorMaskType)); // Reset the mask
             for (int r = 0; r < inputs->n; r++) {
                 pmReadout *readout = inputs->data[r]; // Input readout
@@ -318 +318 @@
                 // Check mask
                 psImage *roMask = readout->mask; // The mask image
-                if (roMask && roMask->data.U8[yIn][xIn] & maskVal) {
+                if (roMask && roMask->data.PS_TYPE_IMAGE_MASK_DATA[yIn][xIn] & maskVal) {
                     maskData[r] = 1;
                     continue;

trunk/psModules/src/imcombine/pmReadoutCombine.h

@@ -5 +5 @@
  * @author Paul Price, IfA
  *
- * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
- * @date $Date: 2008-08-01 00:01:26 $
+ * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-01-27 06:39:38 $
  * Copyright 2004-2006 Institute for Astronomy, University of Hawaii
  */
@@ -22 +22 @@
 typedef struct {
     psStatsOptions combine;             ///< Statistic to use when performing the combination
-    psMaskType maskVal;                 ///< Mask value
-    psMaskType blank;                   ///< Mask value to give blank (i.e., no data) pixels
+    psImageMaskType maskVal;            ///< Mask value
+    psImageMaskType blank;            ///< Mask value to give blank (i.e., no data) pixels
     int nKeep;                          ///< Mimimum number of pixels to keep
     float fracHigh;                     ///< Fraction of high pixels to immediately throw

trunk/psModules/src/imcombine/pmStack.c

@@ -8 +8 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-11-13 03:50:30 $
+ *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-01-27 06:39:38 $
  *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
  *
@@ -63 +63 @@
 
     buffer->pixels = psVectorAlloc(numImages, PS_TYPE_F32);
-    buffer->masks = psVectorAlloc(numImages, PS_TYPE_MASK);
+    buffer->masks = psVectorAlloc(numImages, PS_TYPE_VECTOR_MASK);
     buffer->variances = psVectorAlloc(numImages, PS_TYPE_F32);
     buffer->weights = psVectorAlloc(numImages, PS_TYPE_F32);
@@ -143 +143 @@
     assert(!masks || values->n == masks->n);
     assert(values->type.type == PS_TYPE_F32);
-    assert(!masks || masks->type.type == PS_TYPE_MASK);
+    assert(!masks || masks->type.type == PS_TYPE_VECTOR_MASK);
     assert(sortBuffer && sortBuffer->nalloc >= values->n && sortBuffer->type.type == PS_TYPE_F32);
 
@@ -149 +149 @@
     int num = 0;            // Number of valid values
     for (int i = 0; i < values->n; i++) {
-        if (!masks || !masks->data.PS_TYPE_MASK_DATA[i]) {
+        if (!masks || !masks->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
             sortBuffer->data.F32[num++] = values->data.F32[i];
         }
@@ -215 +215 @@
                           const psVector *reject, // Indices of pixels to reject, or NULL
                           int x, int y, // Coordinates of interest; frame of output image
-                          psMaskType maskVal, // Value to mask
-                          psMaskType bad, // Value to give bad pixels
+                          psImageMaskType maskVal, // Value to mask
+                          psImageMaskType bad, // Value to give bad pixels
                           int numIter, // Number of rejection iterations
                           float rej, // Number of standard deviations at which to reject
@@ -258 +258 @@
         int xIn = x - data->readout->col0, yIn = y - data->readout->row0; // Coordinates on input readout
         psImage *mask = data->readout->mask; // Mask of interest
-        if (mask->data.PS_TYPE_MASK_DATA[yIn][xIn] & maskVal) {
+        if (mask->data.PS_TYPE_IMAGE_MASK_DATA[yIn][xIn] & maskVal) {
             continue;
         }
@@ -283 +283 @@
     // Default option is that the pixel is bad
     float imageValue = NAN, varianceValue = NAN; // Value for combined image and variance map
-    psMaskType maskValue = bad;         // Value for combined mask
+    psImageMaskType maskValue = bad;         // Value for combined mask
     switch (num) {
       case 0:
@@ -382 +382 @@
 // Mask a pixel for inspection
 #define MASK_PIXEL_FOR_INSPECTION() \
-    pixelMasks->data.PS_TYPE_MASK_DATA[j] = 0xff; \
+    pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff; \
     combineInspect(inputs, x, y, pixelSources->data.U16[j]); \
     numClipped++; \
@@ -388 +388 @@
 
               for (int j = 0; j < num; j++) {
-                  if (pixelMasks->data.PS_TYPE_MASK_DATA[j]) {
+                  if (pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[j]) {
                       continue;
                   }
@@ -408 +408 @@
 
     image->data.F32[y][x] = imageValue;
-    mask->data.PS_TYPE_MASK_DATA[y][x] = maskValue;
+    mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = maskValue;
     if (variance) {
         variance->data.F32[y][x] = varianceValue;
@@ -438 +438 @@
     PS_ASSERT_IMAGE_TYPE(data->readout->image, PS_TYPE_F32, false);
     PS_ASSERT_IMAGE_NON_NULL(data->readout->mask, false);
-    PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_MASK, false);
+    PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_IMAGE_MASK, false);
     PS_ASSERT_IMAGES_SIZE_EQUAL(data->readout->image, data->readout->mask, false);
     *numCols = data->readout->image->numCols;
@@ -469 +469 @@
         PS_ASSERT_IMAGE_NON_NULL(data->readout->mask, false);
         PS_ASSERT_IMAGE_TYPE(data->readout->image, PS_TYPE_F32, false);
-        PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_MASK, false);
+        PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_IMAGE_MASK, false);
         PS_ASSERT_IMAGE_SIZE(data->readout->image, *numCols, *numRows, false);
         PS_ASSERT_IMAGES_SIZE_EQUAL(data->readout->image, data->readout->mask, false);
@@ -562 +562 @@
 
 /// Stack input images
-bool pmStackCombine(pmReadout *combined, psArray *input, psMaskType maskVal, psMaskType bad,
+bool pmStackCombine(pmReadout *combined, psArray *input, psImageMaskType maskVal, psImageMaskType bad,
                     int kernelSize, int numIter, float rej, float sys,
                     bool entire, bool useVariance, bool safe)
@@ -587 +587 @@
         PS_ASSERT_IMAGE_TYPE(combined->image, PS_TYPE_F32, false);
         PS_ASSERT_IMAGE_NON_NULL(combined->mask, false);
-        PS_ASSERT_IMAGE_TYPE(combined->mask, PS_TYPE_MASK, false);
+        PS_ASSERT_IMAGE_TYPE(combined->mask, PS_TYPE_IMAGE_MASK, false);
         PS_ASSERT_IMAGES_SIZE_EQUAL(combined->image, combined->mask, false);
     }
@@ -698 +698 @@
         psImage *combinedMask = combined->mask; // Combined mask
         if (!combinedMask) {
-            combined->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
+            combined->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
             combinedMask = combined->mask;
         }

trunk/psModules/src/imcombine/pmStack.h

@@ -8 +8 @@
  * @author GLG, MHPCC
  *
- * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
- * @date $Date: 2008-11-01 02:59:33 $
+ * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-01-27 06:39:38 $
  *
  * Copyright 2004-2007 Institute for Astronomy, University of Hawaii
@@ -43 +43 @@
 bool pmStackCombine(pmReadout *combined,///< Combined readout (output)
                     psArray *input,     ///< Input array of pmStackData
-                    psMaskType maskVal, ///< Mask value of bad pixels
-                    psMaskType bad,     ///< Mask value to give rejected pixels
+                    psImageMaskType maskVal, ///< Mask value of bad pixels
+                    psImageMaskType bad,     ///< Mask value to give rejected pixels
                     int kernelSize,     ///< Half-size of the convolution kernel
                     int numIter,        ///< Number of iterations

trunk/psModules/src/imcombine/pmStackReject.c

@@ -61 +61 @@
         }
 
-        int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK); // Number of bytes to copy
+        int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK); // Number of bytes to copy
         psAssert(convolved->numCols - 2 * box == xMax - xMin, "Bad number of columns");
         psAssert(convolved->numRows - 2 * box == yMax - yMin, "Bad number of rows");
 
         for (int yTarget = yMin, ySource = box; yTarget < yMax; yTarget++, ySource++) {
-            memcpy(&target->data.PS_TYPE_MASK_DATA[yTarget][xMin],
-                   &convolved->data.PS_TYPE_MASK_DATA[ySource][box], numBytes);
+            memcpy(&target->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin],
+                   &convolved->data.PS_TYPE_IMAGE_MASK_DATA[ySource][box], numBytes);
         }
         psFree(convolved);
     } else {
         // Just copy over
-        int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK); // Number of bytes to copy
+        int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK); // Number of bytes to copy
         for (int yTarget = yMin; yTarget < yMax; yTarget++) {
-            memcpy(&target->data.PS_TYPE_MASK_DATA[yTarget][xMin],
-                   &source->data.PS_TYPE_MASK_DATA[yTarget][xMin], numBytes);
+            memcpy(&target->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin],
+                   &source->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin], numBytes);
         }
     }
@@ -262 +262 @@
     bool oldThreads = psImageConvolveSetThreads(false); // Old value of threading for psImageColvolve
 
-    psImage *target = psImageRecycle(convolved, numCols, numRows, PS_TYPE_MASK); // Grown image
+    psImage *target = psImageRecycle(convolved, numCols, numRows, PS_TYPE_IMAGE_MASK); // Grown image
     psImageInit(target, 0);
     if (threaded) {

trunk/psModules/src/imcombine/pmSubtraction.c

@@ -246 +246 @@
                         psImage *image, // Image to convolve
                         psImage *mask, // Mask image
-                        psMaskType maskVal, // Value to mask
+                        psImageMaskType maskVal, // Value to mask
                         const psKernel *kernel, // Kernel by which to convolve
                         psRegion region,// Region of interest
@@ -291 +291 @@
                               psImage *sys, // Systematic error image
                               psImage *mask, // Mask image
-                              psMaskType maskVal, // Value to mask
+                              psImageMaskType maskVal, // Value to mask
                               const psKernel *kernel, // Kernel by which to convolve
                               psRegion region,// Region of interest
@@ -373 +373 @@
                                   float background, // Background value to apply
                                   psRegion region, // Region to convolve
-                                  psMaskType maskBad, // Value to give bad pixels
-                                  psMaskType maskPoor, // Value to give poor pixels
+                                  psImageMaskType maskBad, // Value to give bad pixels
+                                  psImageMaskType maskPoor, // Value to give poor pixels
                                   float poorFrac, // Fraction for "poor"
                                   bool useFFT,  // Use FFT to convolve?
@@ -385 +385 @@
     }
 
-    psMaskType subBad;                  // Bad pixels in subtraction mask
-    psMaskType subConvBad;              // Bad pixels in subtraction mask when convolving
-    psMaskType subConvPoor;             // Poor pixels in subtraction mask when convolving
+    psImageMaskType subBad;                  // Bad pixels in subtraction mask
+    psImageMaskType subConvBad;              // Bad pixels in subtraction mask when convolving
+    psImageMaskType subConvPoor;             // Poor pixels in subtraction mask when convolving
     if (kernels->mode == PM_SUBTRACTION_MODE_1 || (kernels->mode == PM_SUBTRACTION_MODE_DUAL && !wantDual)) {
         subBad = PM_SUBTRACTION_MASK_BAD_1;
@@ -437 +437 @@
             for (int yTarget = rowMin, ySource = box; yTarget < rowMax; yTarget++, ySource++) {
                 // Dereference images
-                psMaskType *target = &convMask->data.PS_TYPE_MASK_DATA[yTarget][colMin]; // Target values
-                psMaskType *source = &convolved->data.PS_TYPE_MASK_DATA[ySource][box]; // Source values
+                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) {
@@ -783 +783 @@
     PS_ASSERT_VECTOR_TYPE(deviations, PS_TYPE_F32, -1);
     PS_ASSERT_IMAGE_NON_EMPTY(subMask, -1);
-    PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, -1);
+    PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, -1);
 
     // I used to measure the rms deviation about zero, and use that as the sigma against which to clip, but
@@ -794 +794 @@
 
     int numStamps = 0;                  // Number of used stamps
-    psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_MASK); // Mask, for statistics
+    psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_VECTOR_MASK); // Mask, for statistics
     psVectorInit(mask, 0);
     for (int i = 0; i < stamps->num; i++) {
         pmSubtractionStamp *stamp = stamps->stamps->data[i]; // Stamp of interest
         if (stamp->status != PM_SUBTRACTION_STAMP_USED) {
-            mask->data.PS_TYPE_MASK_DATA[i] = 0xff;
+            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
             continue;
         }
@@ -869 +869 @@
                 for (int y = stamp->y - footprint; y <= stamp->y + footprint; y++) {
                     for (int x = stamp->x - footprint; x <= stamp->x + footprint; x++) {
-                        subMask->data.PS_TYPE_MASK_DATA[y][x] |= PM_SUBTRACTION_MASK_REJ;
+                        subMask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= PM_SUBTRACTION_MASK_REJ;
                     }
                 }
@@ -997 +997 @@
                                      psImage *sys1, psImage *sys2, // Systematic error images
                                      psImage *subMask, // Input subtraction mask
-                                     psMaskType maskBad, // Mask value to give bad pixels
-                                     psMaskType maskPoor, // Mask value to give poor pixels
+                                     psImageMaskType maskBad, // Mask value to give bad pixels
+                                     psImageMaskType maskPoor, // Mask value to give poor pixels
                                      float poorFrac, // Fraction for "poor"
                                      const psRegion *region, // Patch to convolve
@@ -1035 +1035 @@
 
     if ((kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro1->mask) {
-        psMaskType **target = convMask->data.PS_TYPE_MASK_DATA; // Target mask
-        psMaskType **source = ro1->mask->data.PS_TYPE_MASK_DATA; // Source mask
+        psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
+        psImageMaskType **source = ro1->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask
 
         for (int y = yMin; y < yMax; y++) {
@@ -1045 +1045 @@
     }
     if ((kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro2->mask) {
-        psMaskType **target = convMask->data.PS_TYPE_MASK_DATA; // Target mask
-        psMaskType **source = ro2->mask->data.PS_TYPE_MASK_DATA; // Source mask
+        psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
+        psImageMaskType **source = ro2->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask
 
         for (int y = yMin; y < yMax; y++) {
@@ -1075 +1075 @@
     psImage *sys2 = args->data[10]; // Systematic error image 2
     psImage *subMask = args->data[11]; // Subtraction mask
-    psMaskType maskBad = PS_SCALAR_VALUE(args->data[12], U8); // Output mask value for bad pixels
-    psMaskType maskPoor = PS_SCALAR_VALUE(args->data[13], U8); // Output mask value for poor pixels
+    psImageMaskType maskBad = PS_SCALAR_VALUE(args->data[12], PS_TYPE_IMAGE_MASK_DATA); // Output mask value for bad pixels
+    psImageMaskType maskPoor = PS_SCALAR_VALUE(args->data[13], PS_TYPE_IMAGE_MASK_DATA); // Output mask value for poor pixels
     float poorFrac = PS_SCALAR_VALUE(args->data[14], F32); // Fraction for "poor"
     const psRegion *region = args->data[15]; // Region to convolve
     const pmSubtractionKernels *kernels = args->data[16]; // Kernels
-    bool doBG = PS_SCALAR_VALUE(args->data[17], U8); // Do background subtraction?
-    bool useFFT = PS_SCALAR_VALUE(args->data[18], U8); // Use FFT for convolution?
+    bool doBG = PS_SCALAR_VALUE(args->data[17], PS_TYPE_IMAGE_MASK_DATA); // Do background subtraction?
+    bool useFFT = PS_SCALAR_VALUE(args->data[18], PS_TYPE_IMAGE_MASK_DATA); // Use FFT for convolution?
 
     return subtractionConvolvePatch(numCols, numRows, x0, y0, out1, out2, convMask, ro1, ro2, sys1, sys2,
@@ -1088 +1088 @@
 
 bool pmSubtractionConvolve(pmReadout *out1, pmReadout *out2, const pmReadout *ro1, const pmReadout *ro2,
-                           psImage *subMask, int stride, psMaskType maskBad, psMaskType maskPoor,
+                           psImage *subMask, int stride, psImageMaskType maskBad, psImageMaskType maskPoor,
                            float poorFrac, float sysError, const psRegion *region,
                            const pmSubtractionKernels *kernels, bool doBG, bool useFFT)
@@ -1121 +1121 @@
     if (subMask) {
         PS_ASSERT_IMAGE_NON_NULL(subMask, false);
-        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, false);
+        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, false);
         PS_ASSERT_IMAGE_SIZE(subMask, numCols, numRows, false);
     }
@@ -1182 +1182 @@
         if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
             if (!out1->mask) {
-                out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
+                out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
             }
             convMask = out1->mask;
@@ -1194 +1194 @@
             } else {
                 if (!out2->mask) {
-                    out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
+                    out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
                 }
                 convMask = out2->mask;
@@ -1285 +1285 @@
                     psMutexUnlock(subMask);
                 }
-                PS_ARRAY_ADD_SCALAR(args, maskBad, PS_TYPE_U8);
-                PS_ARRAY_ADD_SCALAR(args, maskPoor, PS_TYPE_U8);
+                PS_ARRAY_ADD_SCALAR(args, maskBad, PS_TYPE_IMAGE_MASK);
+                PS_ARRAY_ADD_SCALAR(args, maskPoor, PS_TYPE_IMAGE_MASK);
                 PS_ARRAY_ADD_SCALAR(args, poorFrac, PS_TYPE_F32);
                 psArrayAdd(args, 1, subRegion);

trunk/psModules/src/imcombine/pmSubtraction.h

@@ -6 +6 @@
  * @author GLG, MHPCC
  *
- * @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
- * @date $Date: 2008-11-07 00:03:18 $
+ * @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-01-27 06:39:38 $
  * Copyright 2004-207 Institute for Astronomy, University of Hawaii
  */
@@ -104 +104 @@
                            psImage *subMask, ///< Subtraction mask (or NULL)
                            int stride,  ///< Size of convolution patches
-                           psMaskType maskBad, ///< Mask value to give bad pixels
-                           psMaskType maskPoor, ///< Mask value to give poor pixels
+                           psImageMaskType maskBad, ///< Mask value to give bad pixels
+                           psImageMaskType maskPoor, ///< Mask value to give poor pixels
                            float poorFrac, ///< Fraction for "poor"
                            float sysError, ///< Relative systematic error

trunk/psModules/src/imcombine/pmSubtractionMask.c

@@ -20 +20 @@
                              psImage *weight, // Weight map to mark as blank (or NULL)
                              int x, int y, // Coordinates to mark blank
-                             psMaskType blank // Blank mask value
+                             psImageMaskType blank // Blank mask value
     )
 {
     image->data.F32[y][x] = NAN;
     if (mask) {
-        mask->data.PS_TYPE_MASK_DATA[y][x] |= blank;
+        mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= blank;
     }
     if (weight) {
@@ -37 +37 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-psImage *pmSubtractionMask(const psImage *mask1, const psImage *mask2, psMaskType maskVal,
+psImage *pmSubtractionMask(const psImage *mask1, const psImage *mask2, psImageMaskType maskVal,
                            int size, int footprint, float badFrac, bool useFFT)
 {
     PS_ASSERT_IMAGE_NON_NULL(mask1, NULL);
-    PS_ASSERT_IMAGE_TYPE(mask1, PS_TYPE_MASK, NULL);
+    PS_ASSERT_IMAGE_TYPE(mask1, PS_TYPE_IMAGE_MASK, NULL);
     if (mask2) {
         PS_ASSERT_IMAGE_NON_NULL(mask2, NULL);
-        PS_ASSERT_IMAGE_TYPE(mask2, PS_TYPE_MASK, NULL);
+        PS_ASSERT_IMAGE_TYPE(mask2, PS_TYPE_IMAGE_MASK, NULL);
         PS_ASSERT_IMAGES_SIZE_EQUAL(mask2, mask1, NULL);
     }
@@ -57 +57 @@
 
     // Dereference inputs for convenience
-    psMaskType **data1 = mask1->data.PS_TYPE_MASK_DATA;
-    psMaskType **data2 = NULL;
+    psImageMaskType **data1 = mask1->data.PS_TYPE_IMAGE_MASK_DATA;
+    psImageMaskType **data2 = NULL;
     if (mask2) {
-        data2 = mask2->data.PS_TYPE_MASK_DATA;
+        data2 = mask2->data.PS_TYPE_IMAGE_MASK_DATA;
     }
 
@@ -86 +86 @@
 
     // Worried about the masks for bad pixels and bad stamps colliding, so make our own mask
-    psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); // The global mask
+    psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); // The global mask
     psImageInit(mask, 0);
-    psMaskType **maskData = mask->data.PS_TYPE_MASK_DATA; // Dereference for convenience
+    psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA; // Dereference for convenience
 
     // Block out a border around the edge of the image
@@ -161 +161 @@
 
 bool pmSubtractionBorder(psImage *image, psImage *weight, psImage *mask,
-                         int size, psMaskType blank)
+                         int size, psImageMaskType blank)
 {
     PS_ASSERT_IMAGE_NON_NULL(image, false);
@@ -168 +168 @@
         PS_ASSERT_IMAGE_NON_NULL(mask, false);
         PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
-        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
+        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
     }
     if (weight) {
@@ -211 +211 @@
     }
     PS_ASSERT_IMAGE_NON_NULL(mask, false);
-    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
+    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
     PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
 
@@ -233 +233 @@
 
     int numCols = image->numCols, numRows = image->numRows; // Size of image
-    psMaskType **maskData = mask->data.PS_TYPE_MASK_DATA; // Dereference mask
+    psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA; // Dereference mask
 
     for (int y = 0; y < numRows; y++) {

trunk/psModules/src/imcombine/pmSubtractionMask.h

@@ -7 +7 @@
 psImage *pmSubtractionMask(const psImage *refMask, ///< Mask for the reference image (will be convolved)
                            const psImage *inMask, ///< Mask for the input image, or NULL
-                           psMaskType maskVal, ///< Value to mask out
+                           psImageMaskType maskVal, ///< Value to mask out
                            int size, ///< Half-size of the kernel (pmSubtractionKernels.size)
                            int footprint, ///< Half-size of the kernel footprint
@@ -19 +19 @@
                          psImage *mask, ///< Mask (or NULL)
                          int size,      ///< Kernel half-size
-                         psMaskType blank ///< Mask value for blank regions
+                         psImageMaskType blank ///< Mask value for blank regions
     );
 

trunk/psModules/src/imcombine/pmSubtractionMatch.c

@@ -98 +98 @@
                         int inner, int ringsOrder, int binning, float penalty,
                         bool optimum, const psVector *optFWHMs, int optOrder, float optThreshold,
-                        int iter, float rej, float sysError, psMaskType maskVal, psMaskType maskBad,
-                        psMaskType maskPoor, float poorFrac, float badFrac, pmSubtractionMode subMode)
+                        int iter, float rej, float sysError, psImageMaskType maskVal, psImageMaskType maskBad,
+                        psImageMaskType maskPoor, float poorFrac, float badFrac, pmSubtractionMode subMode)
 {
     if (subMode != PM_SUBTRACTION_MODE_2) {
@@ -565 +565 @@
     if (width1 == 0 || width2 == 0) {
         ratios->data.F32[index] = NAN;
-        mask->data.PS_TYPE_MASK_DATA[index] = 0xff;
+        mask->data.PS_TYPE_IMAGE_MASK_DATA[index] = 0xff;
     } else {
         ratios->data.F32[index] = (float)width1 / (float)width2;
-        mask->data.PS_TYPE_MASK_DATA[index] = 0;
+        mask->data.PS_TYPE_IMAGE_MASK_DATA[index] = 0;
         psTrace("psModules.imcombine", 3, "Stamp %d (%.1f,%.1f) widths: %d, %d --> %f\n",
                 index, stamp->x, stamp->y, width1, width2, ratios->data.F32[index]);
@@ -596 +596 @@
     PM_ASSERT_SUBTRACTION_STAMP_LIST_NON_NULL(stamps, PM_SUBTRACTION_MODE_ERR);
 
-    psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_MASK); // Mask for stamps
+    psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_VECTOR_MASK); // Mask for stamps
     psVector *ratios = psVectorAlloc(stamps->num, PS_TYPE_F32); // Ratios of widths
 
@@ -624 +624 @@
         pmSubtractionStamp *stamp = stamps->stamps->data[i]; // Stamp of interest
         if (stamp->status != PM_SUBTRACTION_STAMP_CALCULATE && stamp->status != PM_SUBTRACTION_STAMP_USED) {
-            mask->data.PS_TYPE_MASK_DATA[i] = 0xff;
+            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
             continue;
         }

trunk/psModules/src/imcombine/pmSubtractionMatch.h

@@ -40 +40 @@
                         float rej,      ///< Rejection threshold
                         float sysError, ///< Relative systematic error
-                        psMaskType maskVal, ///< Value to mask for input
-                        psMaskType maskBad, ///< Mask for output bad pixels
-                        psMaskType maskPoor, ///< Mask for output poor pixels
+                        psImageMaskType maskVal, ///< Value to mask for input
+                        psImageMaskType maskBad, ///< Mask for output bad pixels
+                        psImageMaskType maskPoor, ///< Mask for output poor pixels
                         float poorFrac, ///< Fraction for "poor"
                         float badFrac,   ///< Maximum fraction of bad input pixels to accept

trunk/psModules/src/imcombine/pmSubtractionStamps.c

@@ -98 +98 @@
 
     // Determine mask value
-    psMaskType maskVal = PM_SUBTRACTION_MASK_BORDER | PM_SUBTRACTION_MASK_BAD_1 | PM_SUBTRACTION_MASK_BAD_2;
+    psImageMaskType maskVal = PM_SUBTRACTION_MASK_BORDER | PM_SUBTRACTION_MASK_BAD_1 | PM_SUBTRACTION_MASK_BAD_2;
     switch (mode) {
       case PM_SUBTRACTION_MODE_1:
@@ -115 +115 @@
 
     // Check the immediate pixel
-    if (clean && (mask->data.PS_TYPE_MASK_DATA[y][x] & (maskVal | PM_SUBTRACTION_MASK_REJ))) {
+    if (clean && (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & (maskVal | PM_SUBTRACTION_MASK_REJ))) {
         clean = false;
     }
@@ -126 +126 @@
         for (int j = yMin; j <= yMax; j++) {
             for (int i = xMin; i <= xMax; i++) {
-                if (mask->data.PS_TYPE_MASK_DATA[j][i] & maskVal) {
+                if (mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] & maskVal) {
                     clean = false;
                     goto CHECK_STAMP_MASK_DONE;
@@ -139 +139 @@
         for (int j = yMin; j <= yMax; j++) {
             for (int i = xMin; i <= xMax; i++) {
-                mask->data.PS_TYPE_MASK_DATA[j][i] |= PM_SUBTRACTION_MASK_REJ;
+                mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= PM_SUBTRACTION_MASK_REJ;
             }
         }
@@ -235 +235 @@
         PS_ASSERT_IMAGE_NON_NULL(subMask, NULL);
         PS_ASSERT_IMAGES_SIZE_EQUAL(image, subMask, NULL);
-        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, NULL);
+        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, NULL);
     }
     PS_ASSERT_INT_NONNEGATIVE(footprint, NULL);
@@ -377 +377 @@
     if (subMask) {
         PS_ASSERT_IMAGE_NON_NULL(subMask, NULL);
-        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, NULL);
+        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, NULL);
         if (image) {
             PS_ASSERT_IMAGE_NON_NULL(image, NULL);