Index: /branches/eam_branch_20081230/psModules/src/detrend/pmShutterCorrection.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/detrend/pmShutterCorrection.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/detrend/pmShutterCorrection.c	(revision 21075)
@@ -198,5 +198,5 @@
 pmShutterCorrection *pmShutterCorrectionLinFit(const psVector *exptime, const psVector *counts,
                                                const psVector *cntError, const psVector *mask, float offref,
-                                               int nIter, float rej, psMaskType maskVal)
+                                               int nIter, float rej)
 {
     PS_ASSERT_VECTOR_NON_NULL(exptime, NULL);
@@ -241,5 +241,5 @@
     stats->clipIter = nIter;
 
-    if (!psVectorClipFitPolynomial2D(line, stats, mask, maskVal, counts, cntError, x, y)) {
+    if (!psVectorClipFitPolynomial2D(line, stats, mask, 0xff, counts, cntError, x, y)) {
         psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to fit shutter correction.\n");
         psFree(stats);
@@ -371,5 +371,5 @@
 
 bool pmShutterCorrectionMeasure(pmReadout *output, const psArray *readouts, int size, psStatsOptions meanStat,
-                                psStatsOptions stdevStat, int nIter, float rej, psMaskType maskVal)
+                                psStatsOptions stdevStat, int nIter, float rej, psImageMaskType maskVal)
 {
     PS_ASSERT_ARRAY_NON_NULL(readouts, NULL);
@@ -457,5 +457,5 @@
             masks->data[i] = psMemIncrRefCounter(mask);
 
-            if (mask->type.type != PS_TYPE_U8) {
+            if (mask->type.type != PS_TYPE_IMAGE_MASK) {
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Bad type for mask: %x\n", mask->type.type);
                 goto MEASURE_ERROR;
@@ -582,5 +582,5 @@
     psImage *shutter = psImageAlloc(numCols, numRows, PS_TYPE_F32); // Shutter correction image
     psImage *pattern = psImageAlloc(numCols, numRows, PS_TYPE_F32); // Illumination pattern
-    psVector *mask = psVectorAlloc(num, PS_TYPE_U8); // Mask for each image
+    psVector *mask = psVectorAlloc(num, PS_TYPE_VECTOR_MASK); // Mask for each image
     psVectorInit(mask, 0);
     psTrace("psModules.detrend", 2, "Performing linear fit on individual pixels...\n");
@@ -592,5 +592,5 @@
                 psImage *maskImage;     // Mask image
                 if (masks && (maskImage = masks->data[i])) {
-                    mask->data.U8[i] = maskImage->data.U8[y][x];
+                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (maskImage->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal);
                 }
                 psImage *weight;        // Weight image
@@ -602,6 +602,5 @@
             }
 
-            pmShutterCorrection *corr = pmShutterCorrectionLinFit(exptimes, counts, errors, mask, meanRef,
-                                        nIter, rej, maskVal);
+            pmShutterCorrection *corr = pmShutterCorrectionLinFit(exptimes, counts, errors, mask, meanRef, nIter, rej);
             shutter->data.F32[y][x] = corr->offset;
             pattern->data.F32[y][x] = corr->scale;
@@ -665,5 +664,5 @@
 
     float exptime    = PS_SCALAR_VALUE(job->args->data[3],F32);
-    psMaskType blank = PS_SCALAR_VALUE(job->args->data[4],U8);
+    psImageMaskType blank = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA);
     int rowStart     = PS_SCALAR_VALUE(job->args->data[5],S32);
     int rowStop      = PS_SCALAR_VALUE(job->args->data[6],S32);
@@ -672,10 +671,10 @@
 
 bool pmShutterCorrectionApplyScan(psImage *image, const psImage *shutterImage, psImage *mask, float exptime,
-                                  psMaskType blank, int rowStart, int rowStop)
+                                  psImageMaskType blank, int rowStart, int rowStop)
 {
     for (int y = rowStart; y < rowStop; y++) {
         for (int x = 0; x < image->numCols; x++) {
             if (mask && !isfinite(shutterImage->data.F32[y][x])) {
-                mask->data.PS_TYPE_MASK_DATA[y][x] |= blank;
+                mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= blank;
                 image->data.F32[y][x] = NAN;
                 continue;
@@ -687,5 +686,5 @@
 }
 
-bool pmShutterCorrectionApply(pmReadout *readout, const pmReadout *shutter, psMaskType blank)
+bool pmShutterCorrectionApply(pmReadout *readout, const pmReadout *shutter, psImageMaskType blank)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -746,5 +745,5 @@
             for (int x = 0; x < image->numCols; x++) {
                 if (mask && !isfinite(shutterImage->data.F32[y][x])) {
-                    mask->data.PS_TYPE_MASK_DATA[y][x] |= blank;
+                    mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= blank;
                     image->data.F32[y][x] = NAN;
                     continue;
@@ -770,5 +769,5 @@
                 psArrayAdd(job->args, 1, mask);
                 PS_ARRAY_ADD_SCALAR(job->args, exptime, PS_TYPE_F32);
-                PS_ARRAY_ADD_SCALAR(job->args, blank, PS_TYPE_MASK);
+                PS_ARRAY_ADD_SCALAR(job->args, blank, PS_TYPE_IMAGE_MASK);
                 PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
                 PS_ARRAY_ADD_SCALAR(job->args, rowStop, PS_TYPE_S32);
@@ -860,5 +859,5 @@
                                    psStatsOptions meanStat, ///< Statistic to use for mean
                                    psStatsOptions stdevStat, ///< Statistic to use for stdev
-                                   psMaskType maskVal, ///< Mask value
+                                   psImageMaskType maskVal, ///< Mask value
                                    psRandom *rng ///< Random number generator
     )
@@ -876,5 +875,5 @@
     if (readout->mask) {
         PS_ASSERT_IMAGE_NON_NULL(readout->mask, NULL);
-        PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_MASK, NULL);
+        PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_IMAGE_MASK, NULL);
         PS_ASSERT_IMAGE_SIZE(readout->mask, data->numCols, data->numRows, NULL);
     }
@@ -1022,5 +1021,5 @@
 
 bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs,
-                                        psMaskType maskVal)
+                                        psImageMaskType maskVal)
 {
     PS_ASSERT_PTR_NON_NULL(shutter, false);
@@ -1084,5 +1083,5 @@
 bool pmShutterCorrectionGenerate(pmReadout *shutter, pmReadout *pattern, const psArray *inputs,
                                  float reference, const pmShutterCorrectionData *data,
-                                 int nIter, float rej, psMaskType maskVal)
+                                 int nIter, float rej, psImageMaskType maskVal)
 {
     PS_ASSERT_PTR_NON_NULL(shutter, false);
@@ -1116,5 +1115,5 @@
     psVector *counts = psVectorAlloc(num, PS_TYPE_F32); // Counts in each image
     psVector *errors = psVectorAlloc(num, PS_TYPE_F32); // Counts in each image
-    psVector *mask = psVectorAlloc(num, PS_TYPE_MASK); // Mask for each image
+    psVector *mask = psVectorAlloc(num, PS_TYPE_VECTOR_MASK); // Mask for each image
     psTrace("psModules.detrend", 2, "Performing linear fit on individual pixels...\n");
     for (int i = minInputRows; i < maxInputRows; i++) {
@@ -1132,5 +1131,5 @@
                 counts->data.F32[r] = image->data.F32[yIn][xIn] * ref;
                 if (readout->mask) {
-                    mask->data.PS_TYPE_MASK_DATA[r] = readout->mask->data.PS_TYPE_MASK_DATA[yIn][xIn];
+                    mask->data.PS_TYPE_VECTOR_MASK_DATA[r] = (readout->mask->data.PS_TYPE_IMAGE_MASK_DATA[yIn][xIn] & maskVal);
                 }
                 if (readout->weight) {
@@ -1142,6 +1141,5 @@
             }
 
-            pmShutterCorrection *corr = pmShutterCorrectionLinFit(data->exptimes, counts, errors, mask,
-                                                                  reference, nIter, rej, maskVal);
+            pmShutterCorrection *corr = pmShutterCorrectionLinFit(data->exptimes, counts, errors, mask, reference, nIter, rej);
             if (!corr) {
                 // Nothing we can do about it
Index: /branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.c	(revision 21075)
@@ -105,5 +105,5 @@
 
     // 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,6 +247,6 @@
     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,5 +260,5 @@
 
     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,5 +278,5 @@
     // 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,5 +303,5 @@
 
             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(psImageMaskType)); // Reset the mask
             for (int r = 0; r < inputs->n; r++) {
                 pmReadout *readout = inputs->data[r]; // Input readout
@@ -318,5 +318,5 @@
                 // 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;
Index: /branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.h
===================================================================
--- /branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.h	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.h	(revision 21075)
@@ -5,6 +5,6 @@
  * @author Paul Price, IfA
  *
- * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
- * @date $Date: 2008-08-01 00:01:26 $
+ * @version $Revision: 1.14.24.1 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2008-12-31 20:31:28 $
  * Copyright 2004-2006 Institute for Astronomy, University of Hawaii
  */
@@ -22,6 +22,6 @@
 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
Index: /branches/eam_branch_20081230/psModules/src/imcombine/pmStack.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/imcombine/pmStack.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/imcombine/pmStack.c	(revision 21075)
@@ -8,6 +8,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-11-13 03:50:30 $
+ *  @version $Revision: 1.45.6.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:28 $
  *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
  *
@@ -63,5 +63,5 @@
 
     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,5 +143,5 @@
     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,5 +149,5 @@
     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,6 +215,6 @@
                           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,5 +258,5 @@
         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,5 +283,5 @@
     // 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,5 +382,5 @@
 // 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,5 +388,5 @@
 
               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,5 +408,5 @@
 
     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,5 +438,5 @@
     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,5 +469,5 @@
         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,5 +562,5 @@
 
 /// 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,5 +587,5 @@
         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,5 +698,5 @@
         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;
         }
Index: /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtraction.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtraction.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtraction.c	(revision 21075)
@@ -246,5 +246,5 @@
                         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,5 +291,5 @@
                               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,6 +373,6 @@
                                   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,7 +385,7 @@
     }
 
-    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,6 +437,6 @@
             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,5 +783,5 @@
     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,10 +794,10 @@
 
     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,5 +869,5 @@
                 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,6 +997,6 @@
                                      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,6 +1035,6 @@
 
     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,6 +1045,6 @@
     }
     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,11 +1075,11 @@
     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,5 +1088,5 @@
 
 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,5 +1121,5 @@
     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,5 +1182,5 @@
         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,5 +1194,5 @@
             } 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,6 +1285,6 @@
                     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);
Index: /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMask.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMask.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMask.c	(revision 21075)
@@ -20,10 +20,10 @@
                              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,12 +37,12 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-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,8 +57,8 @@
 
     // 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,7 +86,7 @@
 
     // 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,5 +161,5 @@
 
 bool pmSubtractionBorder(psImage *image, psImage *weight, psImage *mask,
-                         int size, psMaskType blank)
+                         int size, psImageMaskType blank)
 {
     PS_ASSERT_IMAGE_NON_NULL(image, false);
@@ -168,5 +168,5 @@
         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,5 +211,5 @@
     }
     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,5 +233,5 @@
 
     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++) {
Index: /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMatch.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMatch.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMatch.c	(revision 21075)
@@ -98,6 +98,6 @@
                         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,8 +565,8 @@
     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;
     }
 
@@ -594,5 +594,5 @@
     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_IMAGE_MASK); // Mask for stamps
     psVector *ratios = psVectorAlloc(stamps->num, PS_TYPE_F32); // Ratios of widths
 
@@ -622,5 +622,5 @@
         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_IMAGE_MASK_DATA[i] = 0xff;
             continue;
         }
Index: /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionStamps.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionStamps.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionStamps.c	(revision 21075)
@@ -98,5 +98,5 @@
 
     // 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,5 +115,5 @@
 
     // 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,5 +126,5 @@
         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,5 +139,5 @@
         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,5 +235,5 @@
         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,5 +377,5 @@
     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);
Index: /branches/eam_branch_20081230/psModules/src/objects/pmFootprintFindAtPoint.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmFootprintFindAtPoint.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmFootprintFindAtPoint.c	(revision 21075)
@@ -4,6 +4,6 @@
  * @author RHL, Princeton & IfA; EAM, IfA
  *
- * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
- * @date $Date: 2008-12-08 02:51:14 $
+ * @version $Revision: 1.3.4.1 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2008-12-31 20:31:29 $
  * Copyright 2006 Institute for Astronomy, University of Hawaii
  */
@@ -77,5 +77,5 @@
     
     if (mask != NULL) {			// remember that we've detected these pixels
-	psMaskType *mpix = &mask->data.PS_TYPE_MASK_DATA[span->y - mask->row0][span->x0 - mask->col0];
+	psImageMaskType *mpix = &mask->data.PS_TYPE_IMAGE_MASK_DATA[span->y - mask->row0][span->x0 - mask->col0];
 
 	for (int i = 0; i <= span->x1 - span->x0; i++) {
@@ -143,5 +143,5 @@
     psF32 *imgRowF32 = NULL;		// row pointer if F32
     psS32 *imgRowS32 = NULL;		//  "   "   "  "  !F32
-    psMaskType *maskRow = NULL;		//  masks's row pointer
+    psImageMaskType *maskRow = NULL;		//  masks's row pointer
     
     const int row0 = img->row0;
@@ -186,5 +186,5 @@
 	imgRowF32 = img->data.F32[i];	// only one of
 	imgRowS32 = img->data.S32[i];	//      these is valid!
-	maskRow = mask->data.PS_TYPE_MASK_DATA[i];
+	maskRow = mask->data.PS_TYPE_IMAGE_MASK_DATA[i];
 	//
 	// Search left from the pixel diagonally to the left of (i - di, x0). If there's
@@ -354,5 +354,5 @@
  * looking for the rest of the pmFootprint.  These are generally set from peaks.
  */
-   psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
+   psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    P_PSIMAGE_SET_ROW0(mask, row0);
    P_PSIMAGE_SET_COL0(mask, col0);
@@ -365,5 +365,5 @@
        for (int i = 0; i < peaks->n; i++) {
 	   pmPeak *peak = peaks->data[i];
-	   mask->data.PS_TYPE_MASK_DATA[peak->y - mask->row0][peak->x - mask->col0] |= PM_SSPAN_STOP;
+	   mask->data.PS_TYPE_IMAGE_MASK_DATA[peak->y - mask->row0][peak->x - mask->col0] |= PM_SSPAN_STOP;
        }
    }
@@ -375,5 +375,5 @@
    imgRowF32 = img->data.F32[row];	// only one of
    imgRowS32 = img->data.S32[row];	//      these is valid!
-   psMaskType *maskRow = mask->data.PS_TYPE_MASK_DATA[row];
+   psImageMaskType *maskRow = mask->data.PS_TYPE_IMAGE_MASK_DATA[row];
    {
        int i;
Index: /branches/eam_branch_20081230/psModules/src/objects/pmGrowthCurveGenerate.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmGrowthCurveGenerate.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmGrowthCurveGenerate.c	(revision 21075)
@@ -5,6 +5,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-12-08 02:51:14 $
+ *  @version $Revision: 1.4.4.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Institute for Astronomy, University of Hawaii
@@ -41,5 +41,5 @@
 #include "pmErrorCodes.h"
 
-pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType markVal, float xc, float yc);
+pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType markVal, float xc, float yc);
 
 /*****************************************************************************/
@@ -48,5 +48,5 @@
 
 // we generate the growth curve for the center of the image with the specified psf model
-bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType markVal)
+bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType markVal)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -119,5 +119,5 @@
 }
 
-pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType markVal, float xc, float yc) {
+pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType markVal, float xc, float yc) {
 
     float fitMag, apMag;
@@ -162,5 +162,5 @@
     psImage *view = psImageSubset (image, region);
     psImage *pixels = psImageCopy (NULL, view, PS_TYPE_F32);
-    psImage *mask = psImageCopy (NULL, view, PS_TYPE_U8);
+    psImage *mask = psImageCopy (NULL, view, PS_TYPE_IMAGE_MASK);
 
     psImageInit (pixels, 0.0);
@@ -189,5 +189,5 @@
 	    return NULL;
         }
-        psImageKeepCircle (mask, xc, yc, radius, "AND", PS_NOT_U8(markVal));
+        psImageKeepCircle (mask, xc, yc, radius, "AND", PS_NOT_IMAGE_MASK(markVal));
 
         // the 'ignore' mode is for testing
Index: /branches/eam_branch_20081230/psModules/src/objects/pmModel.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmModel.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmModel.c	(revision 21075)
@@ -6,6 +6,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-11-09 00:28:18 $
+ *  @version $Revision: 1.25.6.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -172,5 +172,5 @@
                           pmModelOpMode mode,
                           bool add,
-                          psMaskType maskVal,
+                          psImageMaskType maskVal,
                           int dx,
                           int dy
@@ -229,5 +229,5 @@
     psF32 **Rx = NULL;
     psF32 **Ry = NULL;
-    psU8  **Rm = NULL;
+    psImageMaskType **Rm = NULL;
 
     if (model->residuals) {
@@ -237,5 +237,5 @@
 	Rx = (model->residuals->Rx)   ? model->residuals->Rx->data.F32 : NULL;
 	Ry = (model->residuals->Ry)   ? model->residuals->Ry->data.F32 : NULL;
-	Rm = (model->residuals->mask) ? model->residuals->mask->data.U8 : NULL;
+	Rm = (model->residuals->mask) ? model->residuals->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
 	if (Ro) {
 	    NX = model->residuals->Ro->numCols;
@@ -249,5 +249,5 @@
     for (psS32 iy = 0; iy < image->numRows; iy++) {
         for (psS32 ix = 0; ix < image->numCols; ix++) {
-            if ((mask != NULL) && (mask->data.U8[iy][ix] & maskVal))
+            if ((mask != NULL) && (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] & maskVal))
                 continue;
 
@@ -351,5 +351,5 @@
                 pmModel *model,
                 pmModelOpMode mode,
-                psMaskType maskVal)
+                psImageMaskType maskVal)
 {
     psTrace("psModules.objects", 3, "---- %s() begin ----\n", __func__);
@@ -365,5 +365,5 @@
                 pmModel *model,
                 pmModelOpMode mode,
-                psMaskType maskVal)
+                psImageMaskType maskVal)
 {
     psTrace("psModules.objects", 3, "---- %s() begin ----\n", __func__);
@@ -379,5 +379,5 @@
                           pmModel *model,
                           pmModelOpMode mode,
-                          psMaskType maskVal,
+                          psImageMaskType maskVal,
                           int dx,
                           int dy)
@@ -395,5 +395,5 @@
                           pmModel *model,
                           pmModelOpMode mode,
-                          psMaskType maskVal,
+                          psImageMaskType maskVal,
                           int dx,
                           int dy)
Index: /branches/eam_branch_20081230/psModules/src/objects/pmPSFtry.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmPSFtry.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmPSFtry.c	(revision 21075)
@@ -5,6 +5,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.67 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-12-08 02:51:14 $
+ *  @version $Revision: 1.67.4.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -115,5 +115,5 @@
     test->metricErr = psVectorAlloc (sources->n, PS_TYPE_F32);
     test->fitMag    = psVectorAlloc (sources->n, PS_TYPE_F32);
-    test->mask      = psVectorAlloc (sources->n, PS_TYPE_U8);
+    test->mask      = psVectorAlloc (sources->n, PS_TYPE_VECTOR_MASK);
 
     psVectorInit (test->mask,        0);
@@ -148,5 +148,5 @@
 
 // generate a pmPSFtry with a copy of the test PSF sources
-pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psMaskType maskVal, psMaskType markVal)
+pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psImageMaskType maskVal, psImageMaskType markVal)
 {
     bool status;
@@ -189,9 +189,9 @@
 
         // clear object mask to define valid pixels
-        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
+        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
 
         // exclude the poor fits
         if (!status) {
-            psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL;
+            psfTry->mask->data.PS_TYPE_IMAGE_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL;
             psTrace ("psModules.objects", 4, "masking %d (%d,%d) : status is poor\n", i, source->peak->x, source->peak->y);
             continue;
@@ -222,5 +222,5 @@
 
         // masked for: bad model fit, outlier in parameters
-        if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL) {
+        if (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL) {
             psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : source is masked\n", i, source->peak->x, source->peak->y);
             continue;
@@ -230,5 +230,5 @@
         source->modelPSF = pmModelFromPSF (source->modelEXT, psfTry->psf);
         if (source->modelPSF == NULL) {
-            psfTry->mask->data.U8[i] = PSFTRY_MASK_BAD_MODEL;
+            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_BAD_MODEL;
             abort();
             continue;
@@ -244,6 +244,6 @@
         // skip poor fits
         if (!status) {
-            psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
-            psfTry->mask->data.U8[i] = PSFTRY_MASK_PSF_FAIL;
+            psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
+            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_PSF_FAIL;
             psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : failed PSF fit\n", i, source->peak->x, source->peak->y);
             continue;
@@ -252,6 +252,6 @@
         status = pmSourceMagnitudes (source, psfTry->psf, PM_SOURCE_PHOT_INTERP, maskVal);
         if (!status || isnan(source->apMag)) {
-            psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
-            psfTry->mask->data.U8[i] = PSFTRY_MASK_BAD_PHOT;
+            psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
+            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_BAD_PHOT;
             psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : poor photometry\n", i, source->peak->x, source->peak->y);
             continue;
@@ -259,5 +259,5 @@
 
         // clear object mask to define valid pixels
-        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
+        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
 
         psfTry->fitMag->data.F32[i] = source->psfMag;
@@ -291,9 +291,9 @@
             flux->data.F32[i] = 0.0;
             chisq->data.F32[i] = 0.0;
-            mask->data.U8[i] = 0xff;
+            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
         } else {
             flux->data.F32[i] = source->modelPSF->params->data.F32[PM_PAR_I0];
             chisq->data.F32[i] = source->modelPSF->chisq / source->modelPSF->nDOF;
-            mask->data.U8[i] = 0;
+            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0;
         }
     }
@@ -361,5 +361,5 @@
 
     for (int i = 0; i < psfTry->sources->n; i++) {
-        if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL)
+        if (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL)
             continue;
         r2rflux->data.F32[i] = PS_SQR(RADIUS) * pow(10.0, 0.4*psfTry->fitMag->data.F32[i]);
@@ -370,5 +370,5 @@
         FILE *f = fopen ("apresid.dat", "w");
         for (int i = 0; i < psfTry->sources->n; i++) {
-            int keep = (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL);
+            int keep = (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL);
 
             pmSource *source = psfTry->sources->data[i];
@@ -418,5 +418,5 @@
         psVector *apfit = psPolynomial1DEvalVector (poly, r2rflux);
         for (int i = 0; i < psfTry->sources->n; i++) {
-            int keep = (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL);
+            int keep = (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL);
 
             pmSource *source = psfTry->sources->data[i];
@@ -613,5 +613,5 @@
 
         psVector *dz = NULL;
-        psVector *mask = psVectorAlloc (sources->n, PS_TYPE_U8);
+        psVector *mask = psVectorAlloc (sources->n, PS_TYPE_VECTOR_MASK);
 
         // check the fit residuals and increase Nx,Ny until the error is minimized
@@ -647,5 +647,5 @@
 	// copy mask back to srcMask
 	for (int i = 0; i < mask->n; i++) {
-	    srcMask->data.U8[i] = mask->data.U8[i];
+	    srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = mask->data.PS_TYPE_VECTOR_MASK_DATA[i];
 	}
 
@@ -720,5 +720,5 @@
                      pmTrend2DEval (psf->params->data[PM_PAR_E1], x->data.F32[i], y->data.F32[i]),
                      pmTrend2DEval (psf->params->data[PM_PAR_E2], x->data.F32[i], y->data.F32[i]),
-                     srcMask->data.U8[i]);
+                     srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
         }
         fclose (f);
@@ -835,5 +835,5 @@
 
     // the mask marks the values not used to calculate the ApTrend
-    psVector *fitMask = psVectorAlloc (x_fit->n, PS_TYPE_U8);
+    psVector *fitMask = psVectorAlloc (x_fit->n, PS_TYPE_VECTOR_MASK);
     psVectorInit (fitMask, 0);
 
@@ -924,5 +924,5 @@
     // XXX copy fitMask values back to mask
     for (int i = 0; i < fitMask->n; i++) {
-	mask->data.U8[i] = fitMask->data.U8[i];
+	mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = fitMask->data.PS_TYPE_VECTOR_MASK_DATA[i];
     }
     psFree (fitMask);
@@ -975,5 +975,5 @@
     psVector *dE1subset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
     psVector *dE2subset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
-    psVector *mkSubset  = psVectorAllocEmpty (nGroup, PS_TYPE_U8);
+    psVector *mkSubset  = psVectorAllocEmpty (nGroup, PS_TYPE_VECTOR_MASK);
 
     int n = 0;
@@ -988,6 +988,6 @@
             dE2subset->data.F32[j] = e2res->data.F32[N];
 
-            mkSubset->data.U8[j]   = mask->data.U8[N];
-	    if (!mask->data.U8[N]) nValid ++;
+            mkSubset->data.PS_TYPE_VECTOR_MASK_DATA[j]   = mask->data.PS_TYPE_VECTOR_MASK_DATA[N];
+	    if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[N]) nValid ++;
         }
 	if (nValid < 3) continue;
Index: /branches/eam_branch_20081230/psModules/src/objects/pmSource.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmSource.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmSource.c	(revision 21075)
@@ -6,6 +6,6 @@
  *  @author EAM, IfA: significant modifications.
  *
- *  @version $Revision: 1.66 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-12-08 02:51:14 $
+ *  @version $Revision: 1.66.4.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -505,5 +505,5 @@
 *****************************************************************************/
 
-bool pmSourceRoughClass(psRegion *region, psArray *sources, psMetadata *recipe, pmPSFClump clump, psMaskType maskSat)
+bool pmSourceRoughClass(psRegion *region, psArray *sources, psMetadata *recipe, pmPSFClump clump, psImageMaskType maskSat)
 {
     psTrace("psModules.objects", 5, "---- begin ----");
@@ -738,5 +738,5 @@
         psF32 *vPix = source->pixels->data.F32[row];
         psF32 *vWgt = source->weight->data.F32[row];
-        psU8  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.U8[row];
+        psImageMaskType *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
 
         for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) {
@@ -848,5 +848,5 @@
 # endif
 // construct a realization of the source model
-bool pmSourceCacheModel (pmSource *source, psMaskType maskVal) {
+bool pmSourceCacheModel (pmSource *source, psImageMaskType maskVal) {
     PS_ASSERT_PTR_NON_NULL(source, false);
     // select appropriate model
@@ -867,5 +867,5 @@
 // construct a realization of the source model
 // XXX this function should optionally save an existing psf image from modelFlux
-bool pmSourceCachePSF (pmSource *source, psMaskType maskVal) {
+bool pmSourceCachePSF (pmSource *source, psImageMaskType maskVal) {
     PS_ASSERT_PTR_NON_NULL(source, false);
 
@@ -885,5 +885,5 @@
 
 // should we call pmSourceCacheModel if it does not exist?
-bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psMaskType maskVal, int dx, int dy)
+bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psImageMaskType maskVal, int dx, int dy)
 {
     PS_ASSERT_PTR_NON_NULL(source, false);
@@ -915,7 +915,7 @@
         }
 
-        psU8 **mask = NULL;
+        psImageMaskType **mask = NULL;
         if (source->maskObj) {
-            mask = source->maskObj->data.U8;
+            mask = source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA;
         }
 
@@ -957,17 +957,17 @@
 }
 
-bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psMaskType maskVal) {
+bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal) {
     return pmSourceOp (source, mode, true, maskVal, 0, 0);
 }
 
-bool pmSourceSub (pmSource *source, pmModelOpMode mode, psMaskType maskVal) {
+bool pmSourceSub (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal) {
     return pmSourceOp (source, mode, false, maskVal, 0, 0);
 }
 
-bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy) {
+bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy) {
     return pmSourceOp (source, mode, true, maskVal, dx, dy);
 }
 
-bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy) {
+bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy) {
     return pmSourceOp (source, mode, false, maskVal, dx, dy);
 }
Index: /branches/eam_branch_20081230/psModules/src/objects/pmSourceFitModel.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmSourceFitModel.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmSourceFitModel.c	(revision 21075)
@@ -6,6 +6,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-12-08 02:51:14 $
+ *  @version $Revision: 1.28.4.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -56,5 +56,5 @@
                        pmModel *model,
                        pmSourceFitMode mode,
-                       psMaskType maskVal)
+                       psImageMaskType maskVal)
 {
     psTrace("psModules.objects", 5, "---- %s begin ----\n", __func__);
@@ -81,5 +81,5 @@
         for (psS32 j = 0; j < source->pixels->numCols; j++) {
             // skip masked points
-            if (source->maskObj->data.U8[i][j] & maskVal) {
+            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j] & maskVal) {
                 continue;
             }
@@ -121,5 +121,5 @@
     // create the minimization constraints
     psMinConstraint *constraint = psMinConstraintAlloc();
-    constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_U8);
+    constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK_DATA);
     constraint->checkLimits = model->modelLimits;
 
@@ -131,5 +131,5 @@
         nParams = 1;
         psVectorInit (constraint->paramMask, 1);
-        constraint->paramMask->data.U8[PM_PAR_I0] = 0;
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0;
         break;
     case PM_SOURCE_FIT_PSF:
@@ -137,7 +137,7 @@
         nParams = 3;
         psVectorInit (constraint->paramMask, 1);
-        constraint->paramMask->data.U8[PM_PAR_I0] = 0;
-        constraint->paramMask->data.U8[PM_PAR_XPOS] = 0;
-        constraint->paramMask->data.U8[PM_PAR_YPOS] = 0;
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0;
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_XPOS] = 0;
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_YPOS] = 0;
         break;
     case PM_SOURCE_FIT_EXT:
@@ -145,5 +145,5 @@
         nParams = params->n - 1;
         psVectorInit (constraint->paramMask, 0);
-        constraint->paramMask->data.U8[PM_PAR_SKY] = 1;
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1;
         break;
     default:
@@ -175,5 +175,5 @@
             fprintf (stderr, "%f ", params->data.F32[i]);
         }
-        if ((constraint->paramMask != NULL) && constraint->paramMask->data.U8[i])
+        if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
             continue;
         dparams->data.F32[i] = sqrt(covar->data.F32[i][i]);
@@ -192,13 +192,13 @@
     if (constraint->paramMask != NULL) {
         psVector *delta = psVectorAlloc (params->n, PS_TYPE_F32);
-        psVector *altmask = psVectorAlloc (params->n, PS_TYPE_U8);
-        altmask->data.U8[0] = 1;
+        psVector *altmask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
+        altmask->data.PS_TYPE_VECTOR_MASK_DATA[0] = 1;
         for (int i = 1; i < dparams->n; i++) {
-            altmask->data.U8[i] = (constraint->paramMask->data.U8[i]) ? 0 : 1;
+            altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1;
         }
         psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, model->modelFunc);
 
         for (int i = 0; i < dparams->n; i++) {
-            if (!constraint->paramMask->data.U8[i])
+            if (!constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
                 continue;
             // note that delta is the value *subtracted* from the parameter
Index: /branches/eam_branch_20081230/psModules/src/objects/pmSourceFitSet.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmSourceFitSet.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmSourceFitSet.c	(revision 21075)
@@ -6,6 +6,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-12-08 02:51:14 $
+ *  @version $Revision: 1.12.4.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -281,5 +281,5 @@
             for (int j = 0; j < paramOne->n; j++) {
                 if (j == PM_PAR_I0) continue;
-                constraint->paramMask->data.U8[n + j] = 1;
+                constraint->paramMask->data.PS_TYPE_IMAGE_MASK_DATA[n + j] = 1;
             }
             break;
@@ -290,10 +290,10 @@
                 if (j == PM_PAR_YPOS) continue;
                 if (j == PM_PAR_I0) continue;
-                constraint->paramMask->data.U8[n + j] = 1;
+                constraint->paramMask->data.PS_TYPE_IMAGE_MASK_DATA[n + j] = 1;
             }
             break;
           case PM_SOURCE_FIT_EXT:
             // EXT model fits all params (except sky)
-            constraint->paramMask->data.U8[n + PM_PAR_SKY] = 1;
+            constraint->paramMask->data.PS_TYPE_IMAGE_MASK_DATA[n + PM_PAR_SKY] = 1;
             break;
           default:
@@ -332,5 +332,5 @@
                      psArray *modelSet,
                      pmSourceFitMode mode,
-                     psMaskType maskVal)
+                     psImageMaskType maskVal)
 {
     psTrace("psModules.objects", 3, "---- %s begin ----\n", __func__);
@@ -356,5 +356,5 @@
         for (psS32 j = 0; j < source->pixels->numCols; j++) {
             // skip masked points
-            if (source->maskObj->data.U8[i][j] & maskVal) {
+            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j] & maskVal) {
                 continue;
             }
@@ -402,5 +402,5 @@
     // create the minimization constraints
     psMinConstraint *constraint = psMinConstraintAlloc();
-    constraint->paramMask = psVectorAlloc (thisSet->nParamSet, PS_TYPE_U8);
+    constraint->paramMask = psVectorAlloc (thisSet->nParamSet, PS_TYPE_VECTOR_MASK);
     constraint->checkLimits = pmSourceFitSetCheckLimits;
 
@@ -415,5 +415,5 @@
     if (psTraceGetLevel("psModules.objects") >= 5) {
         for (int i = 0; i < params->n; i++) {
-            fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.U8[i]);
+            fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
         }
     }
@@ -448,5 +448,5 @@
     psVector *dparams = psVectorAlloc (thisSet->nParamSet, PS_TYPE_F32);
     for (int i = 0; i < dparams->n; i++) {
-        if ((constraint->paramMask != NULL) && constraint->paramMask->data.U8[i])
+        if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
             continue;
         dparams->data.F32[i] = sqrt(covar->data.F32[i][i]);
@@ -456,13 +456,13 @@
     if (constraint->paramMask != NULL) {
         psVector *delta = psVectorAlloc (params->n, PS_TYPE_F32);
-        psVector *altmask = psVectorAlloc (params->n, PS_TYPE_U8);
-        altmask->data.U8[0] = 1;
+        psVector *altmask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
+        altmask->data.PS_TYPE_VECTOR_MASK_DATA[0] = 1;
         for (int i = 1; i < dparams->n; i++) {
-            altmask->data.U8[i] = (constraint->paramMask->data.U8[i]) ? 0 : 1;
+            altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1;
         }
         psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, pmSourceFitSetFunction);
 
         for (int i = 0; i < dparams->n; i++) {
-            if (!constraint->paramMask->data.U8[i])
+            if (!constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
                 continue;
             // note that delta is the value *subtracted* from the parameter
Index: /branches/eam_branch_20081230/psModules/src/objects/pmSourcePhotometry.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmSourcePhotometry.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmSourcePhotometry.c	(revision 21075)
@@ -3,6 +3,6 @@
  *  @author EAM, IfA; GLG, MHPCC
  *
- *  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-12-08 02:51:14 $
+ *  @version $Revision: 1.47.4.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -66,5 +66,5 @@
 
 // XXX masked region should be (optionally) elliptical
-bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psMaskType maskVal)
+bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal)
 {
     PS_ASSERT_PTR_NON_NULL(source, false);
@@ -306,5 +306,5 @@
 
 // return source aperture magnitude
-bool pmSourcePhotometryAper (float *apMag, pmModel *model, psImage *image, psImage *mask, psMaskType maskVal)
+bool pmSourcePhotometryAper (float *apMag, pmModel *model, psImage *image, psImage *mask, psImageMaskType maskVal)
 {
     PS_ASSERT_PTR_NON_NULL(apMag, false);
@@ -324,5 +324,5 @@
 
     psF32 **imData = image->data.F32;
-    psU8 **mkData = mask->data.U8;
+    psImageMaskType **mkData = mask->data.PS_TYPE_IMAGE_MASK_DATA;
 
     // measure apMag
@@ -344,5 +344,5 @@
 
 // return source aperture magnitude
-bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psMaskType maskVal)
+bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psImageMaskType maskVal)
 {
     PS_ASSERT_PTR_NON_NULL(pixWeight, false);
@@ -412,5 +412,5 @@
             if (my >= NY)
                 continue;
-            if (mask->data.U8[my][mx] & maskVal)
+            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[my][mx] & maskVal)
                 continue;
 
@@ -475,7 +475,7 @@
     for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
         for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
-            if (Ti->data.U8[yi][xi])
-                continue;
-            if (Tj->data.U8[yj][xj])
+            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
+                continue;
+            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
                 continue;
 
@@ -540,7 +540,7 @@
     for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
         for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
-            if (Ti->data.U8[yi][xi])
-                continue;
-            if (Tj->data.U8[yj][xj])
+            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
+                continue;
+            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
                 continue;
 
@@ -578,5 +578,5 @@
     for (int yi = 0; yi < Pi->numRows; yi++) {
         for (int xi = 0; xi < Pi->numCols; xi++) {
-            if (Ti->data.U8[yi][xi])
+            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
                 continue;
             if (!unweighted_sum) {
@@ -613,5 +613,5 @@
 
 bool pmSourceChisq (pmModel *model, psImage *image, psImage *mask, psImage *weight,
-                    psMaskType maskVal)
+                    psImageMaskType maskVal)
 {
     PS_ASSERT_PTR_NON_NULL(model, false);
@@ -624,5 +624,5 @@
     for (int j = 0; j < image->numRows; j++) {
         for (int i = 0; i < image->numCols; i++) {
-            if (mask->data.U8[j][i] & maskVal)
+            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] & maskVal)
                 continue;
             if (weight->data.F32[j][i] <= 0)
@@ -657,5 +657,5 @@
     for (int yi = 0; yi < Pi->numRows; yi++) {
         for (int xi = 0; xi < Pi->numCols; xi++) {
-            if (Ti->data.U8[yi][xi])
+            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
                 continue;
             if (!unweighted_sum) {
@@ -734,7 +734,7 @@
     for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
         for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
-            if (Ti->data.U8[yi][xi])
-                continue;
-            if (Tj->data.U8[yj][xj])
+            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
+                continue;
+            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
                 continue;
 
@@ -798,7 +798,7 @@
     for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
         for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
-            if (Ti->data.U8[yi][xi])
-                continue;
-            if (Tj->data.U8[yj][xj])
+            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
+                continue;
+            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
                 continue;
 
Index: /branches/eam_branch_20081230/psModules/src/objects/pmSourceSky.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmSourceSky.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmSourceSky.c	(revision 21075)
@@ -6,6 +6,6 @@
  *  @author EAM, IfA: significant modifications.
  *
- *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-12-08 02:51:14 $
+ *  @version $Revision: 1.18.4.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -52,6 +52,6 @@
     psStatsOptions statsOptions,
     psF32 Radius,
-    psMaskType maskVal,
-    psMaskType markVal)
+    psImageMaskType maskVal,
+    psImageMaskType markVal)
 {
     psTrace("psModules.objects", 3, "---- %s() begin ----\n", __func__);
@@ -86,5 +86,5 @@
         return false;
     }
-    psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_U8(markVal));
+    psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_IMAGE_MASK(markVal));
     double value = psStatsGetValue(myStats, statistic);
     psFree(myStats);
@@ -107,6 +107,6 @@
     psStatsOptions statsOptions,
     psF32 Radius,
-    psMaskType maskVal,
-    psMaskType markVal
+    psImageMaskType maskVal,
+    psImageMaskType markVal
 )
 {
@@ -142,5 +142,5 @@
         return false;
     }
-    psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_U8(markVal));
+    psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_IMAGE_MASK(markVal));
     double value = psStatsGetValue(myStats, statistic);
     psFree(myStats);
Index: /branches/eam_branch_20081230/psModules/src/objects/pmTrend2D.c
===================================================================
--- /branches/eam_branch_20081230/psModules/src/objects/pmTrend2D.c	(revision 21074)
+++ /branches/eam_branch_20081230/psModules/src/objects/pmTrend2D.c	(revision 21075)
@@ -3,6 +3,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-10-07 22:47:04 $
+ *  @version $Revision: 1.10.14.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-12-31 20:31:29 $
  *  Copyright 2004 Institute for Astronomy, University of Hawaii
  *
@@ -179,5 +179,5 @@
 }
 
-bool pmTrend2DFit(pmTrend2D *trend, psVector *mask, psMaskType maskVal, const psVector *x,
+bool pmTrend2DFit(pmTrend2D *trend, psVector *mask, psVectorMaskType maskVal, const psVector *x,
                   const psVector *y, const psVector *f, const psVector *df)
 {