Index: trunk/psphot/src/psphot.h
===================================================================
--- trunk/psphot/src/psphot.h	(revision 21177)
+++ trunk/psphot/src/psphot.h	(revision 21183)
@@ -40,5 +40,6 @@
 bool            psphotMomentsStats (pmReadout *readout, psMetadata *recipe, psArray *sources);
 bool            psphotFitSourcesLinear (pmReadout *readout, psArray *sources, psMetadata *recipe, pmPSF *psf, bool final);
-bool            psphotReplaceUnfitSources (psArray *sources, psMaskType maskVal);
+bool            psphotReplaceUnfitSources (psArray *sources, psImageMaskType maskVal);
+
 bool            psphotReplaceAllSources (psArray *sources, psMetadata *recipe);
 bool            psphotRemoveAllSources (psArray *sources, psMetadata *recipe);
@@ -70,7 +71,7 @@
 
 // used by psphotFindDetections
-psImage        *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal);
+psImage        *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal);
 psArray        *psphotFindPeaks (psImage *significance, pmReadout *readout, psMetadata *recipe, const float threshold, const int nMax);
-bool            psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal);
+bool            psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal);
 psErrorCode     psphotCullPeaks(const psImage *img, const psImage *weight, const psMetadata *recipe, psArray *footprints);
 
@@ -81,5 +82,5 @@
 // basic support functions
 void            psphotModelClassInit (void);
-bool            psphotGrowthCurve (pmReadout *readout, pmPSF *psf, bool ignore, psMaskType maskVal);
+bool            psphotGrowthCurve (pmReadout *readout, pmPSF *psf, bool ignore, psImageMaskType maskVal);
 bool            psphotSetMaskAndWeight (pmConfig *config, pmReadout *readout, psMetadata *recipe);
 void            psphotSourceFreePixels (psArray *sources);
@@ -87,8 +88,8 @@
 // functions to set the correct source pixels
 bool            psphotInitRadiusPSF (const psMetadata *recipe, const pmModelType type);
-bool            psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal);
-bool            psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal, float dR);
+bool            psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal);
+bool            psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal, float dR);
 bool            psphotInitRadiusEXT (psMetadata *recipe, pmModelType type);
-bool            psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal);
+bool            psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal);
 
 // output functions
@@ -109,12 +110,12 @@
 bool            psphotInitLimitsPSF (psMetadata *recipe, pmReadout *readout);
 bool            psphotInitLimitsEXT (psMetadata *recipe);
-bool            psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal);
-bool            psphotFitBlob (pmReadout *readout, pmSource *source, psArray *sources, pmPSF *psf, psMaskType maskVal, psMaskType markVal);
-bool            psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal);
-pmModel        *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal);
-psArray        *psphotFitDBL (pmReadout *readout, pmSource *source, psMaskType maskVal, psMaskType markVal);
+bool            psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal);
+bool            psphotFitBlob (pmReadout *readout, pmSource *source, psArray *sources, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal);
+bool            psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal);
+pmModel        *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal);
+psArray        *psphotFitDBL (pmReadout *readout, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal);
 
 // functions to support simultaneous multi-source fitting
-bool            psphotFitSet (pmSource *oneSrc, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psMaskType maskVal);
+bool            psphotFitSet (pmSource *oneSrc, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psImageMaskType maskVal);
 
 // plotting functions (available if libkapa is installed)
@@ -137,21 +138,21 @@
 bool            psphotMosaicSubimage (psImage *outImage, pmSource *source, int Xo, int Yo, int DX, int DY, bool normalize);
 
-bool            psphotAddWithTest (pmSource *source, bool useState, psMaskType maskVal);
-bool            psphotSubWithTest (pmSource *source, bool useState, psMaskType maskVal);
-bool            psphotSetState (pmSource *source, bool curState, psMaskType maskVal);
+bool            psphotAddWithTest (pmSource *source, bool useState, psImageMaskType maskVal);
+bool            psphotSubWithTest (pmSource *source, bool useState, psImageMaskType maskVal);
+bool            psphotSetState (pmSource *source, bool curState, psImageMaskType maskVal);
 bool            psphotDeblendSatstars (psArray *sources, psMetadata *recipe);
 bool            psphotSourceSize (pmConfig *config, pmReadout *readout, psArray *sources, psMetadata *recipe, long first);
 
-bool            psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psMaskType maskVal);
-
-pmModel        *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal, int psfSize);
+bool            psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psImageMaskType maskVal);
+
+pmModel        *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize);
 
 psKernel       *psphotKernelFromPSF (pmSource *source, int nPix);
 
-bool            psphotRadialProfile (pmSource *source, psMetadata *recipe, psMaskType maskVal);
-bool            psphotPetrosian (pmSource *source, psMetadata *recipe, psMaskType maskVal);
-bool            psphotIsophotal (pmSource *source, psMetadata *recipe, psMaskType maskVal);
-bool            psphotAnnuli (pmSource *source, psMetadata *recipe, psMaskType maskVal);
-bool            psphotKron (pmSource *source, psMetadata *recipe, psMaskType maskVal);
+bool            psphotRadialProfile (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
+bool            psphotPetrosian (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
+bool            psphotIsophotal (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
+bool            psphotAnnuli (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
+bool            psphotKron (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
 
 // psphotVisual functions
@@ -168,5 +169,5 @@
 bool psphotVisualShowSatStars (psMetadata *recipe, pmPSF *psf, psArray *sources);
 bool psphotVisualShowPSFModel (pmReadout *readout, pmPSF *psf);
-bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psMaskType maskVal);
+bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psImageMaskType maskVal);
 bool psphotVisualPlotRadialProfiles (psMetadata *recipe, psArray *sources);
 bool psphotVisualShowFlags (psArray *sources);
@@ -223,5 +224,5 @@
 bool psphotMakeFluxScale (psImage *image, psMetadata *recipe, pmPSF *psf);
 bool psphotMakeGrowthCurve (pmReadout *readout, psMetadata *recipe, pmPSF *psf);
-bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psMaskType maskVal, psMaskType markVal);
+bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psImageMaskType maskVal, psImageMaskType markVal);
 
 bool psphotCheckStarDistribution (psArray *sources, psArray *stars, pmPSFOptions *options);
Index: trunk/psphot/src/psphotAddNoise.c
===================================================================
--- trunk/psphot/src/psphotAddNoise.c	(revision 21177)
+++ trunk/psphot/src/psphotAddNoise.c	(revision 21183)
@@ -23,5 +23,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
Index: trunk/psphot/src/psphotAnnuli.c
===================================================================
--- trunk/psphot/src/psphotAnnuli.c	(revision 21177)
+++ trunk/psphot/src/psphotAnnuli.c	(revision 21183)
@@ -1,5 +1,5 @@
 # include "psphotInternal.h"
 
-bool psphotAnnuli (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
+bool psphotAnnuli (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
 
   assert (source->extpars);
Index: trunk/psphot/src/psphotApResid.c
===================================================================
--- trunk/psphot/src/psphotApResid.c	(revision 21177)
+++ trunk/psphot/src/psphotApResid.c	(revision 21183)
@@ -44,9 +44,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
@@ -100,5 +100,5 @@
 	    psArrayAdd(job->args, 1, psf);
 	    PS_ARRAY_ADD_SCALAR(job->args, photMode, PS_TYPE_S32);
-	    PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8); // XXX change this to use abstract mask type info
+	    PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
 
 	    PS_ARRAY_ADD_SCALAR(job->args, 0,        PS_TYPE_S32); // this is used as a return value for Nskip
@@ -139,5 +139,5 @@
 
     // gather the stats to assess the aperture residuals
-    psVector *mask    = psVectorAllocEmpty (300, PS_TYPE_U8);
+    psVector *mask    = psVectorAllocEmpty (300, PS_TYPE_VECTOR_MASK);
     psVector *mag     = psVectorAllocEmpty (300, PS_TYPE_F32);
     psVector *xPos    = psVectorAllocEmpty (300, PS_TYPE_F32);
@@ -176,5 +176,5 @@
         yPos->data.F32[Npsf]    = model->params->data.F32[PM_PAR_YPOS];
 
-        mask->data.U8[Npsf] = 0;
+        mask->data.PS_TYPE_VECTOR_MASK_DATA[Npsf] = 0;
 
         dMag->data.F32[Npsf] = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
@@ -242,5 +242,5 @@
                      mag->data.F32[i], dMag->data.F32[i], dMagSys->data.F32[i],
                      apResid->data.F32[i], apResidRes->data.F32[i],
-                     mask->data.U8[i]);
+                     mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
         }
         fclose (dumpFile);
@@ -325,5 +325,5 @@
     psVector *dMSubset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
     psVector *dASubset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
-    psVector *mkSubset = psVectorAllocEmpty (nGroup, PS_TYPE_U8);
+    psVector *mkSubset = psVectorAllocEmpty (nGroup, PS_TYPE_VECTOR_MASK);
 
     int n = 0;
@@ -334,5 +334,5 @@
             dMSubset->data.F32[j] = dMag->data.F32[N];
             dASubset->data.F32[j] = dap->data.F32[N];
-            mkSubset->data.U8[j]  = mask->data.U8[N];
+            mkSubset->data.PS_TYPE_VECTOR_MASK_DATA[j] = mask->data.PS_TYPE_VECTOR_MASK_DATA[N];
         }
         dMSubset->n = j;
@@ -460,5 +460,5 @@
     pmPSF *psf                      = job->args->data[1];
     pmSourcePhotometryMode photMode = PS_SCALAR_VALUE(job->args->data[2],S32);
-    psMaskType maskVal              = PS_SCALAR_VALUE(job->args->data[3],U8);
+    psImageMaskType maskVal         = PS_SCALAR_VALUE(job->args->data[3],PS_TYPE_IMAGE_MASK_DATA);
 
     for (int i = 0; i < sources->n; i++) {
Index: trunk/psphot/src/psphotBlendFit.c
===================================================================
--- trunk/psphot/src/psphotBlendFit.c	(revision 21177)
+++ trunk/psphot/src/psphotBlendFit.c	(revision 21183)
@@ -133,9 +133,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
Index: trunk/psphot/src/psphotChoosePSF.c
===================================================================
--- trunk/psphot/src/psphotChoosePSF.c	(revision 21177)
+++ trunk/psphot/src/psphotChoosePSF.c	(revision 21183)
@@ -24,9 +24,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
@@ -258,5 +258,5 @@
     for (int i = 0; i < try->sources->n; i++) {
         pmSource *source = try->sources->data[i];
-        if (try->mask->data.U8[i]) {
+        if (try->mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
             source->mode &= ~PM_SOURCE_MODE_PSFSTAR;
         }
Index: trunk/psphot/src/psphotExtendedSourceAnalysis.c
===================================================================
--- trunk/psphot/src/psphotExtendedSourceAnalysis.c	(revision 21177)
+++ trunk/psphot/src/psphotExtendedSourceAnalysis.c	(revision 21183)
@@ -12,5 +12,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
Index: trunk/psphot/src/psphotExtendedSourceFits.c
===================================================================
--- trunk/psphot/src/psphotExtendedSourceFits.c	(revision 21177)
+++ trunk/psphot/src/psphotExtendedSourceFits.c	(revision 21183)
@@ -13,8 +13,8 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT"); // Mask value for bad pixels
     assert (markVal);
 
Index: trunk/psphot/src/psphotExtendedSources.c
===================================================================
--- trunk/psphot/src/psphotExtendedSources.c	(revision 21177)
+++ trunk/psphot/src/psphotExtendedSources.c	(revision 21183)
@@ -12,5 +12,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
Index: trunk/psphot/src/psphotFindDetections.c
===================================================================
--- trunk/psphot/src/psphotFindDetections.c	(revision 21177)
+++ trunk/psphot/src/psphotFindDetections.c	(revision 21183)
@@ -10,5 +10,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
Index: trunk/psphot/src/psphotFindFootprints.c
===================================================================
--- trunk/psphot/src/psphotFindFootprints.c	(revision 21177)
+++ trunk/psphot/src/psphotFindFootprints.c	(revision 21183)
@@ -1,5 +1,5 @@
 # include "psphotInternal.h"
 
-bool psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal) {
+bool psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal) {
 
     bool status;
Index: trunk/psphot/src/psphotFitSet.c
===================================================================
--- trunk/psphot/src/psphotFitSet.c	(revision 21177)
+++ trunk/psphot/src/psphotFitSet.c	(revision 21183)
@@ -2,5 +2,5 @@
 
 // This is only used by psphotModelTest.c
-bool psphotFitSet (pmSource *source, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psMaskType maskVal) {
+bool psphotFitSet (pmSource *source, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psImageMaskType maskVal) {
 
     double x, y, Io;
Index: trunk/psphot/src/psphotFitSourcesLinear.c
===================================================================
--- trunk/psphot/src/psphotFitSourcesLinear.c	(revision 21177)
+++ trunk/psphot/src/psphotFitSourcesLinear.c	(revision 21183)
@@ -10,5 +10,5 @@
 // the analysis is performed wrt the simulated pixel values
 
-static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psMaskType markVal);
+static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psImageMaskType markVal);
 
 bool psphotFitSourcesLinear (pmReadout *readout, psArray *sources, psMetadata *recipe, pmPSF *psf, bool final) {
@@ -23,9 +23,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
@@ -233,5 +233,5 @@
 // on the pixels which correspond to all of the sources of interest.  These elements fill in
 // the border matrix components in the sparse matrix equation.
-static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psMaskType markVal) {
+static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psImageMaskType markVal) {
 
     // generate the image-wide weight terms
@@ -248,5 +248,5 @@
         float x = model->params->data.F32[PM_PAR_XPOS];
         float y = model->params->data.F32[PM_PAR_YPOS];
-        psImageMaskCircle (source->maskView, x, y, model->radiusFit, "AND", PS_NOT_U8(markVal));
+        psImageMaskCircle (source->maskView, x, y, model->radiusFit, "AND", PS_NOT_IMAGE_MASK(markVal));
     }
 
@@ -254,5 +254,5 @@
     psF32 **image  = readout->image->data.F32;
     psF32 **weight = readout->weight->data.F32;
-    psU8  **mask   = readout->mask->data.U8;
+    psImageMaskType  **mask   = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA;
 
     double w, x, y, x2, xy, y2, xc, yc, wt, f, fo, fx, fy;
@@ -288,5 +288,5 @@
 
     // turn off MARK for all image pixels
-    psImageMaskRegion (readout->mask, fullArray, "AND", PS_NOT_U8(markVal));
+    psImageMaskRegion (readout->mask, fullArray, "AND", PS_NOT_IMAGE_MASK(markVal));
 
     // set the Border T elements
Index: trunk/psphot/src/psphotGuessModels.c
===================================================================
--- trunk/psphot/src/psphotGuessModels.c	(revision 21177)
+++ trunk/psphot/src/psphotGuessModels.c	(revision 21183)
@@ -41,9 +41,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
@@ -73,6 +73,6 @@
 
 	    // XXX change these to use abstract mask type info
-	    PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
-	    PS_ARRAY_ADD_SCALAR(job->args, markVal,  PS_TYPE_U8);
+	    PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
+	    PS_ARRAY_ADD_SCALAR(job->args, markVal,  PS_TYPE_IMAGE_MASK);
 
 	    if (!psThreadJobAddPending(job)) {
@@ -130,6 +130,6 @@
     pmPSF *psf         = job->args->data[2];
     
-    psMaskType maskVal = PS_SCALAR_VALUE(job->args->data[3],U8);
-    psMaskType markVal = PS_SCALAR_VALUE(job->args->data[4],U8);
+    psImageMaskType maskVal = PS_SCALAR_VALUE(job->args->data[3],PS_TYPE_IMAGE_MASK_DATA);
+    psImageMaskType markVal = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA);
 
     int nSrc = 0;
Index: trunk/psphot/src/psphotIsophotal.c
===================================================================
--- trunk/psphot/src/psphotIsophotal.c	(revision 21177)
+++ trunk/psphot/src/psphotIsophotal.c	(revision 21183)
@@ -1,5 +1,5 @@
 # include "psphotInternal.h"
 
-bool psphotIsophotal (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
+bool psphotIsophotal (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
 
   assert (source->extpars);
Index: trunk/psphot/src/psphotKron.c
===================================================================
--- trunk/psphot/src/psphotKron.c	(revision 21177)
+++ trunk/psphot/src/psphotKron.c	(revision 21183)
@@ -1,5 +1,5 @@
 # include "psphotInternal.h"
 
-bool psphotKron (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
+bool psphotKron (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
 
   psLogMsg ("psphot", PS_LOG_INFO, "not implemented\n");
Index: trunk/psphot/src/psphotMagnitudes.c
===================================================================
--- trunk/psphot/src/psphotMagnitudes.c	(revision 21177)
+++ trunk/psphot/src/psphotMagnitudes.c	(revision 21183)
@@ -28,9 +28,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
Index: trunk/psphot/src/psphotMakeGrowthCurve.c
===================================================================
--- trunk/psphot/src/psphotMakeGrowthCurve.c	(revision 21177)
+++ trunk/psphot/src/psphotMakeGrowthCurve.c	(revision 21183)
@@ -11,9 +11,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
Index: trunk/psphot/src/psphotMakeResiduals.c
===================================================================
--- trunk/psphot/src/psphotMakeResiduals.c	(revision 21177)
+++ trunk/psphot/src/psphotMakeResiduals.c	(revision 21183)
@@ -1,9 +1,9 @@
 # include "psphotInternal.h"
 
-bool psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psMaskType maskVal) {
+bool psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psImageMaskType maskVal) {
 
     bool status, isPSF;
     double flux, dflux;
-    psU8 mflux;
+    psImageMaskType mflux;
 
     psTimerStart ("psphot.residuals");
@@ -69,8 +69,15 @@
     // - set output pixel, weight, and mask
 
-    // XXX need to set these correctly!!
-    const int badMask = 1;              // mask bits
-    const int poorMask = 2;             //       from psImageInterpolate
-    const int clippedMask = 4;          // mask bit set for clipped values
+    // these mask values do not correspond to the recipe values: they
+    // are not propagated to images: they just need to fit in an 8-bit
+    // value.  they are supplied to psImageInterpolate, which takes a
+    // psImageMaskType; the mask portion of the result from
+    // psImageInterpolate is supplied to fmasks, which is then used by
+    // psVectorStats
+
+    const psImageMaskType badMask     = 0x01;	// mask bits
+    const psImageMaskType poorMask    = 0x02;	// from psImageInterpolate
+    const psImageMaskType clippedMask = 0x04;	// mask bit set for clipped values
+    const psVectorMaskType fmaskVal = badMask | poorMask | clippedMask;
 
     // determine the maximum image size from the input sources
@@ -95,5 +102,5 @@
         psImage *image  = psImageCopy (NULL, source->pixels,   PS_TYPE_F32);
         psImage *weight = psImageCopy (NULL, source->weight,   PS_TYPE_F32);
-        psImage *mask   = psImageCopy (NULL, source->maskView, PS_TYPE_U8);
+        psImage *mask   = psImageCopy (NULL, source->maskView, PS_TYPE_IMAGE_MASK);
         pmModelSub (image, mask, model, PM_MODEL_OP_FUNC, maskVal);
 
@@ -103,9 +110,9 @@
         psBinaryOp (weight, weight, "/", psScalarAlloc(Io*Io, PS_TYPE_F32));
 
-        // we will interpolate the image and weight - include the mask or not?
-        // XXX consider better values for the mask bits
-        psImageInterpolation *interp =
-            psImageInterpolationAlloc(mode, image, weight, NULL, 0xff, 0.0, 0.0, badMask, poorMask, 0.0, 0);
-        psArrayAdd (input,  100, interp);
+        // we interpolate the image and weight - include the mask or not?
+	// XXX why not the mask?
+        // psImageInterpolation *interp = psImageInterpolationAlloc(mode, image, weight, mask, maskVal, 0.0, 0.0, badMask, poorMask, 0.0, 0);
+        psImageInterpolation *interp = psImageInterpolationAlloc(mode, image, weight, NULL, 0xff, 0.0, 0.0, badMask, poorMask, 0.0, 0);
+        psArrayAdd (input, 100, interp);
 
         // save the X,Y position for future reference
@@ -131,5 +138,5 @@
     psVector *fluxes  = psVectorAlloc (input->n, PS_TYPE_F32);
     psVector *dfluxes = psVectorAlloc (input->n, PS_TYPE_F32);
-    psVector *fmasks  = psVectorAlloc (input->n, PS_TYPE_U8);
+    psVector *fmasks  = psVectorAlloc (input->n, PS_TYPE_VECTOR_MASK);
 
     // statistic to use to determine baseline for clipping
@@ -164,21 +171,22 @@
                 bool offImage = false;
                 if (psImageInterpolate (&flux, &dflux, &mflux, ix, iy, interp) == PS_INTERPOLATE_STATUS_OFF) {
+                    // fprintf (stderr, "off image: %f %f : %f %f\n", ix, iy, flux, dflux);
                     // This pixel is off the image
                     offImage = true;
-                    fmasks->data.U8[i] = 1;
-                    // fprintf (stderr, "off image: %f %f : %f %f\n", ix, iy, flux, dflux);
-                }
-                fluxes->data.F32[i] = flux;
-                dfluxes->data.F32[i] = dflux;
-                fmasks->data.U8[i] = mflux;
+                    fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = badMask;
+                } else {
+		  fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = mflux; // XXX is mflux IMAGE or VECTOR type?
+		}
+		fluxes->data.F32[i] = flux;
+		dfluxes->data.F32[i] = dflux;
                 if (isnan(flux)) {
-                    fmasks->data.U8[i] = 1;
-                }
-                if (fmasks->data.U8[i] == 0) {
+                    fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = badMask;
+                }
+                if (fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) {
                     nGoodPixel ++;
                 }
             }
 
-            // skip pixels which are off the image...
+            // skip pixels with insufficient data
             bool validPixel = (SPATIAL_ORDER == 0) ? (nGoodPixel > 1) : (nGoodPixel > 3);
             if (!validPixel) {
@@ -186,5 +194,5 @@
                 resid->Rx->data.F32[oy][ox] = 0.0;
                 resid->Ry->data.F32[oy][ox] = 0.0;
-                resid->mask->data.U8[oy][ox] = 1;
+                resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox] = badMask;
                 continue;
             }
@@ -192,5 +200,5 @@
             // measure the robust median to determine a baseline reference value
             *fluxClip = *fluxClipDef;
-            psVectorStats (fluxClip, fluxes, NULL, fmasks, 0xff);
+            psVectorStats (fluxClip, fluxes, NULL, fmasks, fmaskVal);
             psErrorClear();             // clear (ignore) any outstanding errors
 
@@ -202,9 +210,9 @@
                 float swing = fabs(delta) / sigma;
 
-                // make this a user option
+		// mask pixels which are out of range
                 if (swing > nSigma) {
-                    fmasks->data.U8[i] = clippedMask;
-                }
-		if (!fmasks->data.U8[i]) nKeep++;
+                    fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = clippedMask;
+                }
+		if (!fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i]) nKeep++;
             }
 
@@ -212,5 +220,5 @@
                 // measure the desired statistic on the unclipped pixels
                 *fluxStats = *fluxStatsDef;
-                psVectorStats (fluxStats, fluxes, NULL, fmasks, 0xff);
+                psVectorStats (fluxStats, fluxes, NULL, fmasks, fmaskVal);
                 psErrorClear();         // clear (ignore) any outstanding errors
 
@@ -220,8 +228,8 @@
 
                 if (fabs(resid->Ro->data.F32[oy][ox]) < pixelSN*fluxStats->sampleStdev/sqrt(nKeep)) {
-                  resid->mask->data.U8[oy][ox] = 1;
-                }
-
-		// fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n", ox, oy, resid->Ro->data.F32[oy][ox], fluxStats->sampleStdev, fluxStats->sampleStdev/sqrt(nKeep), nKeep, resid->mask->data.U8[oy][ox]);
+                  resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox] = 1;
+                }
+
+		// fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n", ox, oy, resid->Ro->data.F32[oy][ox], fluxStats->sampleStdev, fluxStats->sampleStdev/sqrt(nKeep), nKeep, resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox]);
 
             } else {
@@ -230,5 +238,5 @@
                 psVectorInit(B, 0.0);
                 for (int i = 0; i < fluxes->n; i++) {
-                    if (fmasks->data.U8[i]) continue;
+                    if (fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
                     B->data.F64[0] += fluxes->data.F32[i]/dfluxes->data.F32[i];
                     B->data.F64[1] += fluxes->data.F32[i]*xC->data.F32[i]/dfluxes->data.F32[i];
@@ -260,8 +268,9 @@
 
                 float dRo = sqrt(A->data.F32[0][0]);
-		// fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n", ox, oy, resid->Ro->data.F32[oy][ox], dRo, dRo/sqrt(nKeep), nKeep, resid->mask->data.U8[oy][ox]);
+		// fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n", 
+		// ox, oy, resid->Ro->data.F32[oy][ox], dRo, dRo/sqrt(nKeep), nKeep, resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox]);
 
                 if (fabs(resid->Ro->data.F32[oy][ox]) < pixelSN*dRo/sqrt(nKeep)) {
-                  resid->mask->data.U8[oy][ox] = 1;
+                  resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox] = 1;
                 }
                 //resid->weight->data.F32[oy][ox] = XXX;
Index: trunk/psphot/src/psphotMaskReadout.c
===================================================================
--- trunk/psphot/src/psphotMaskReadout.c	(revision 21177)
+++ trunk/psphot/src/psphotMaskReadout.c	(revision 21183)
@@ -9,9 +9,9 @@
     // XXX drop the write to recipe and move config into psphotRoughClass?
     // XXX alternatively, define a function to set the psphot recipe masks
-    psMaskType maskSat  = pmConfigMaskGet("SAT", config); // Mask value for saturated pixels
-    psMetadataAddU8 (recipe, PS_LIST_TAIL, "MASK.SAT", PS_META_REPLACE, "user-defined mask", maskSat);
+    psImageMaskType maskSat  = pmConfigMaskGet("SAT", config); // Mask value for saturated pixels
+    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MASK.SAT", PS_META_REPLACE, "user-defined mask", maskSat);
 
-    psMaskType maskBad  = pmConfigMaskGet("BAD", config); // Mask value for bad pixels
-    psMetadataAddU8 (recipe, PS_LIST_TAIL, "MASK.BAD", PS_META_REPLACE, "user-defined mask", maskBad);
+    psImageMaskType maskBad  = pmConfigMaskGet("BAD", config); // Mask value for bad pixels
+    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MASK.BAD", PS_META_REPLACE, "user-defined mask", maskBad);
 
     // generate mask & weight images if they don't already exit
Index: trunk/psphot/src/psphotModelBackground.c
===================================================================
--- trunk/psphot/src/psphotModelBackground.c	(revision 21177)
+++ trunk/psphot/src/psphotModelBackground.c	(revision 21183)
@@ -46,5 +46,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
Index: trunk/psphot/src/psphotModelTest.c
===================================================================
--- trunk/psphot/src/psphotModelTest.c	(revision 21177)
+++ trunk/psphot/src/psphotModelTest.c	(revision 21183)
@@ -13,9 +13,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
Index: trunk/psphot/src/psphotModelWithPSF.c
===================================================================
--- trunk/psphot/src/psphotModelWithPSF.c	(revision 21177)
+++ trunk/psphot/src/psphotModelWithPSF.c	(revision 21183)
@@ -20,5 +20,5 @@
         paramMask = constraint->paramMask;
         if (paramMask != NULL) {
-            PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_U8, false);
+	  PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
             PS_ASSERT_VECTORS_SIZE_EQUAL(params, paramMask, false);
         }
@@ -145,10 +145,10 @@
 	psImageInit (covar, 0.0);
 	for (int j = 0, J = 0; j < params->n; j++) {
-	    if (paramMask && (paramMask->data.U8[j])) {
+	    if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
 		covar->data.F32[j][j] = 1.0;
 		continue;
 	    }
 	    for (int k = 0, K = 0; k < params->n; k++) {
-		if (paramMask && (paramMask->data.U8[k])) continue;
+		if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
 		covar->data.F32[j][k] = Alpha->data.F32[J][K];
 		K++;
@@ -197,5 +197,5 @@
     PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, false);
     if (paramMask) {
-        PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_MASK, false);
+        PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
     }
 
@@ -224,5 +224,5 @@
 	    // XXX probably should not skipped masked points: 
 	    // XXX skip if convolution of unmasked pixels will not see this pixel
-            // if (source->maskObj->data.U8[i][j]) {
+            // if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
 	    // continue;
 	    // }
@@ -246,5 +246,5 @@
 
 	    for (int n = 0; n < params->n; n++) {
-		if ((paramMask != NULL) && (paramMask->data.U8[n])) { continue; }
+		if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
 		psImage *dmodel = pcm->dmodels->data[n];
 		dmodel->data.F32[i][j] = deriv->data.F32[n];
@@ -285,5 +285,5 @@
 	    // XXX are we doing the right thing with the mask?
             // skip masked points
-            if (source->maskObj->data.U8[i][j]) {
+            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
                 continue;
             }
@@ -308,9 +308,9 @@
 	    // alpha & beta only contain unmasked elements 
 	    for (int n1 = 0, N1 = 0; n1 < params->n; n1++) {
-		if ((paramMask != NULL) && (paramMask->data.U8[n1])) continue;
+		if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n1])) continue;
 		psImage *dmodel = pcm->dmodelsConv->data[n1];
 		float weight = dmodel->data.F32[i][j] * yweight;
 		for (int n2 = 0, N2 = 0; n2 <= n1; n2++) {
-		    if ((paramMask != NULL) && (paramMask->data.U8[n2])) continue;
+		    if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n2])) continue;
 		    dmodel = pcm->dmodelsConv->data[n2];
 		    alpha->data.F32[N1][N2] += weight * dmodel->data.F32[i][j];
@@ -357,5 +357,5 @@
     for (psS32 n = 0; n < params->n; n++) {
 	pcm->dmodels->data[n] = NULL;
-	if ((paramMask != NULL) && (paramMask->data.U8[n])) { continue; }
+	if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
 	pcm->dmodels->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
     }
@@ -366,5 +366,5 @@
     for (psS32 n = 0; n < params->n; n++) {
 	pcm->dmodelsConv->data[n] = NULL;
-	if ((paramMask != NULL) && (paramMask->data.U8[n])) { continue; }
+	if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
 	pcm->dmodelsConv->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
     }
Index: trunk/psphot/src/psphotMosaicChip.c
===================================================================
--- trunk/psphot/src/psphotMosaicChip.c	(revision 21177)
+++ trunk/psphot/src/psphotMosaicChip.c	(revision 21183)
@@ -25,5 +25,5 @@
     }
 
-    psMaskType blankMask = pmConfigMaskGet("BLANK", config);
+    psImageMaskType blankMask = pmConfigMaskGet("BLANK", config);
 
     // mosaic the chip, forcing a deep copy (resulting images are not subimages)
Index: trunk/psphot/src/psphotOutput.c
===================================================================
--- trunk/psphot/src/psphotOutput.c	(revision 21177)
+++ trunk/psphot/src/psphotOutput.c	(revision 21183)
@@ -74,5 +74,5 @@
         for (int j = 0; j < source->pixels->numCols; j++) {
             // skip masked points
-            if (source->maskObj->data.U8[i][j]) {
+            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
                 continue;
             }
@@ -87,5 +87,5 @@
                      source->pixels->data.F32[i][j],
                      1.0 / source->weight->data.F32[i][j],
-                     source->maskObj->data.U8[i][j]);
+                     source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]);
         }
     }
@@ -237,5 +237,5 @@
 
 // XXX add args as needed
-bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psMaskType maskVal, psMaskType markVal) {
+bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psImageMaskType maskVal, psImageMaskType markVal) {
 
     psphotSaveImage (NULL, readout->image,  "rawstars.fits");
@@ -243,5 +243,5 @@
     for (int i = 0; i < try->sources->n; i++) {
 	// masked for: bad model fit, outlier in parameters
-	if (try->mask->data.U8[i] & PSFTRY_MASK_ALL)
+	if (try->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL)
 	    continue;
 
@@ -256,5 +256,5 @@
 	psImageKeepCircle (source->maskObj, x, y, radius, "OR", markVal);
 	pmModelSub (source->pixels, source->maskObj, source->modelPSF, PM_MODEL_OP_FULL, maskVal);
-	psImageKeepCircle (source->maskObj, x, y, radius, "AND", PS_NOT_U8(markVal));
+	psImageKeepCircle (source->maskObj, x, y, radius, "AND", PS_NOT_IMAGE_MASK(markVal));
     }
 
@@ -264,5 +264,5 @@
 
 	// masked for: bad model fit, outlier in parameters
-	if (try->mask->data.U8[i] & PSFTRY_MASK_ALL) continue;
+	if (try->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL) continue;
 
 	pmSource *source = try->sources->data[i];
Index: trunk/psphot/src/psphotPSFConvModel.c
===================================================================
--- trunk/psphot/src/psphotPSFConvModel.c	(revision 21177)
+++ trunk/psphot/src/psphotPSFConvModel.c	(revision 21183)
@@ -9,5 +9,5 @@
 // modelConv to contain the fitted parameters, and the modelFlux to contain the 
 // convolved model image.
-pmModel *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal, int psfSize) {
+pmModel *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) {
     
     // maskVal is used to test for rejected pixels, and must include markVal
@@ -72,5 +72,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);
     constraint->checkLimits = modelConv->modelLimits;
 
@@ -79,5 +79,5 @@
     int 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;
 
     // force the floating parameters to fall within the contraint ranges
@@ -97,5 +97,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]);
Index: trunk/psphot/src/psphotPetrosian.c
===================================================================
--- trunk/psphot/src/psphotPetrosian.c	(revision 21177)
+++ trunk/psphot/src/psphotPetrosian.c	(revision 21183)
@@ -1,5 +1,5 @@
 # include "psphotInternal.h"
 
-bool psphotPetrosian (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
+bool psphotPetrosian (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
 
   bool status;
Index: trunk/psphot/src/psphotRadialPlot.c
===================================================================
--- trunk/psphot/src/psphotRadialPlot.c	(revision 21177)
+++ trunk/psphot/src/psphotRadialPlot.c	(revision 21183)
@@ -60,5 +60,5 @@
     for (int iy = 0; iy < source->pixels->numRows; iy++) {
 	for (int ix = 0; ix < source->pixels->numCols; ix++) {
-	    if (source->maskObj->data.U8[iy][ix]) {
+	    if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) {
 		rb->data.F32[nb] = hypot (ix - Xo, iy - Yo) ;
 		fb->data.F32[nb] = log10(source->pixels->data.F32[iy][ix]);
Index: trunk/psphot/src/psphotRadialProfile.c
===================================================================
--- trunk/psphot/src/psphotRadialProfile.c	(revision 21177)
+++ trunk/psphot/src/psphotRadialProfile.c	(revision 21183)
@@ -17,5 +17,5 @@
 }
 
-bool psphotRadialProfile (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
+bool psphotRadialProfile (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
 
     // allocate pmSourceExtendedParameters, if not already defined
@@ -54,5 +54,5 @@
     for (int iy = 0; iy < source->pixels->numRows; iy++) {
         for (int ix = 0; ix < source->pixels->numCols; ix++) {
-            if (source->maskObj->data.U8[iy][ix]) continue;
+            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) continue;
             radius->data.F32[n] = hypot (ix - Xo, iy - Yo) ;
             flux->data.F32[n]   = source->pixels->data.F32[iy][ix];
Index: trunk/psphot/src/psphotRadiusChecks.c
===================================================================
--- trunk/psphot/src/psphotRadiusChecks.c	(revision 21177)
+++ trunk/psphot/src/psphotRadiusChecks.c	(revision 21183)
@@ -19,5 +19,5 @@
 
 // call this function whenever you (re)-define the PSF model
-bool psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal)
+bool psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal)
 {
     psF32 *PAR = model->params->data.F32;
@@ -50,5 +50,5 @@
 }
 
-bool psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal, float dR) {
+bool psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal, float dR) {
 
     psF32 *PAR = model->params->data.F32;
@@ -86,5 +86,5 @@
 
 // call this function whenever you (re)-define the EXT model
-bool psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal) {
+bool psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal) {
 
     psF32 *PAR = model->params->data.F32;
Index: trunk/psphot/src/psphotReplaceUnfit.c
===================================================================
--- trunk/psphot/src/psphotReplaceUnfit.c	(revision 21177)
+++ trunk/psphot/src/psphotReplaceUnfit.c	(revision 21183)
@@ -2,5 +2,5 @@
 
 // replace the flux for sources which failed
-bool psphotReplaceUnfitSources (psArray *sources, psMaskType maskVal) {
+bool psphotReplaceUnfitSources (psArray *sources, psImageMaskType maskVal) {
 
     pmSource *source;
@@ -31,5 +31,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
@@ -55,5 +55,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
@@ -72,5 +72,5 @@
 
 // add source, if the source has been subtracted; do not modify state
-bool psphotAddWithTest (pmSource *source, bool useState, psMaskType maskVal) {
+bool psphotAddWithTest (pmSource *source, bool useState, psImageMaskType maskVal) {
 
     // what is current state? (true : add; false : sub)
@@ -83,5 +83,5 @@
 
 // sub source, if the source has been added; do not modify state
-bool psphotSubWithTest (pmSource *source, bool useState, psMaskType maskVal) {
+bool psphotSubWithTest (pmSource *source, bool useState, psImageMaskType maskVal) {
 
     // what is current state? (true : sub; false : add)
@@ -94,5 +94,5 @@
 
 // add or sub source to match recorded state: supply current state as true (add) or false (sub)
-bool psphotSetState (pmSource *source, bool curState, psMaskType maskVal) {
+bool psphotSetState (pmSource *source, bool curState, psImageMaskType maskVal) {
 
     // what is desired state? (true : add; false : sub)
Index: trunk/psphot/src/psphotRoughClass.c
===================================================================
--- trunk/psphot/src/psphotRoughClass.c	(revision 21177)
+++ trunk/psphot/src/psphotRoughClass.c	(revision 21183)
@@ -57,5 +57,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskSat = psMetadataLookupU8(&status, recipe, "MASK.SAT"); // Mask value for bad pixels
+    psImageMaskType maskSat = psMetadataLookupImageMask(&status, recipe, "MASK.SAT"); // Mask value for bad pixels
     assert (maskSat);
 
Index: trunk/psphot/src/psphotSetMaskBits.c
===================================================================
--- trunk/psphot/src/psphotSetMaskBits.c	(revision 21177)
+++ trunk/psphot/src/psphotSetMaskBits.c	(revision 21183)
@@ -10,6 +10,6 @@
 bool psphotSetMaskBits (pmConfig *config) {
 
-    psMaskType maskValue;
-    psMaskType markValue;
+    psImageMaskType maskValue;
+    psImageMaskType markValue;
 
     if (!pmConfigMaskSetBits (&maskValue, &markValue, config)) {
@@ -26,6 +26,6 @@
 
     // set maskValue and markValue in the psphot recipe
-    psMetadataAddU8 (recipe, PS_LIST_TAIL, "MARK.PSPHOT", PS_META_REPLACE, "user-defined mask", markValue);
-    psMetadataAddU8 (recipe, PS_LIST_TAIL, "MASK.PSPHOT", PS_META_REPLACE, "user-defined mask", maskValue);
+    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MARK.PSPHOT", PS_META_REPLACE, "user-defined mask", markValue);
+    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MASK.PSPHOT", PS_META_REPLACE, "user-defined mask", maskValue);
 
     return true;
Index: trunk/psphot/src/psphotSignificanceImage.c
===================================================================
--- trunk/psphot/src/psphotSignificanceImage.c	(revision 21177)
+++ trunk/psphot/src/psphotSignificanceImage.c	(revision 21183)
@@ -4,5 +4,5 @@
 // (S/N)^2.  If FWMH_X,Y have been recorded, use them, otherwise use PEAKS_SMOOTH_SIGMA for the
 // smoothing kernel.
-psImage *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal) {
+psImage *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal) {
 
     float SIGMA_SMTH, NSIGMA_SMTH;
@@ -110,5 +110,5 @@
         for (int i = 0; i < smooth_im->numCols; i++) {
             float value = smooth_im->data.F32[j][i];
-            if (value < 0 || smooth_wt->data.F32[j][i] <= 0 || (mask->data.U8[j][i] & maskVal)) {
+            if (value < 0 || smooth_wt->data.F32[j][i] <= 0 || (mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] & maskVal)) {
                 smooth_im->data.F32[j][i] = 0.0;
             } else {
Index: trunk/psphot/src/psphotSkyReplace.c
===================================================================
--- trunk/psphot/src/psphotSkyReplace.c	(revision 21177)
+++ trunk/psphot/src/psphotSkyReplace.c	(revision 21183)
@@ -17,5 +17,5 @@
     // select the corresponding images
     psF32 **image = readout->image->data.F32;
-    psU8  **mask  = readout->mask->data.U8;
+    psImageMaskType  **mask  = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA;
     psF32 **back  = background->image->data.F32;
 
Index: trunk/psphot/src/psphotSourceFits.c
===================================================================
--- trunk/psphot/src/psphotSourceFits.c	(revision 21177)
+++ trunk/psphot/src/psphotSourceFits.c	(revision 21183)
@@ -22,5 +22,5 @@
 }
 
-bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal) {
+bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) {
 
     float x, y, dR;
@@ -147,5 +147,5 @@
 }
 
-bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal) {
+bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) {
 
     double chiTrend;
@@ -208,5 +208,5 @@
 }
 
-bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *newSources, pmPSF *psf, psMaskType maskVal, psMaskType markVal) {
+bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *newSources, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) {
 
     bool okEXT, okDBL;
@@ -318,5 +318,5 @@
 
 // fit a double PSF source to an extended blob
-psArray *psphotFitDBL (pmReadout *readout, pmSource *source, psMaskType maskVal, psMaskType markVal) {
+psArray *psphotFitDBL (pmReadout *readout, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal) {
 
     float dx, dy;
@@ -370,5 +370,5 @@
 }
 
-pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal) {
+pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal) {
 
     NfitEXT ++;
Index: trunk/psphot/src/psphotSourcePlots.c
===================================================================
--- trunk/psphot/src/psphotSourcePlots.c	(revision 21177)
+++ trunk/psphot/src/psphotSourcePlots.c	(revision 21183)
@@ -7,5 +7,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
Index: trunk/psphot/src/psphotSourceSize.c
===================================================================
--- trunk/psphot/src/psphotSourceSize.c	(revision 21177)
+++ trunk/psphot/src/psphotSourceSize.c	(revision 21183)
@@ -3,8 +3,8 @@
 
 static float psphotModelContour(const psImage *image, const psImage *weight, const psImage *mask,
-                                psMaskType maskVal, const pmModel *model, float Ro);
-
-bool psphotMaskCosmicRay_Old (pmSource *source, psMaskType maskVal, psMaskType crMask);
-bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psMaskType maskVal, psMaskType crMask);
+                                psImageMaskType maskVal, const pmModel *model, float Ro);
+
+bool psphotMaskCosmicRay_Old (pmSource *source, psImageMaskType maskVal, psImageMaskType crMask);
+bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psImageMaskType maskVal, psImageMaskType crMask);
 
 // we need to call this function after sources have been fitted to the PSF model and
@@ -21,9 +21,9 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
     // bit to mask the cosmic-ray pixels
-    psMaskType crMask  = pmConfigMaskGet("CR", config); // Mask value for cosmic rays
+    psImageMaskType crMask  = pmConfigMaskGet("CR", config); // Mask value for cosmic rays
 
     float CR_NSIGMA_LIMIT = psMetadataLookupF32 (&status, recipe, "PSPHOT.CR.NSIGMA.LIMIT");
@@ -63,5 +63,5 @@
         psF32 **resid  = source->pixels->data.F32;
         psF32 **weight = source->weight->data.F32;
-        psU8 **mask    = source->maskObj->data.U8;
+        psImageMaskType **mask    = source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA;
 
         // check for extendedness: measure the delta flux significance at the 1 sigma contour
@@ -191,5 +191,5 @@
 // deviations?
 static float psphotModelContour(const psImage *image, const psImage *weight, const psImage *mask,
-                                psMaskType maskVal, const pmModel *model, float Ro)
+                                psImageMaskType maskVal, const pmModel *model, float Ro)
 {
     psF32 *PAR = model->params->data.F32; // Model parameters
@@ -239,5 +239,5 @@
 
         if (yPixM >= 0 && yPixM < image->numRows &&
-            !(mask && (mask->data.PS_TYPE_MASK_DATA[yPixM][xPix] & maskVal))) {
+            !(mask && (mask->data.PS_TYPE_IMAGE_MASK_DATA[yPixM][xPix] & maskVal))) {
             float dSigma = image->data.F32[yPixM][xPix] / sqrtf(weight->data.F32[yPixM][xPix]);
             nSigma += dSigma;
@@ -250,5 +250,5 @@
 
         if (yPixP >= 0 && yPixP < image->numRows &&
-            !(mask && (mask->data.PS_TYPE_MASK_DATA[yPixP][xPix] & maskVal))) {
+            !(mask && (mask->data.PS_TYPE_IMAGE_MASK_DATA[yPixP][xPix] & maskVal))) {
             float dSigma = image->data.F32[yPixP][xPix] / sqrtf(weight->data.F32[yPixP][xPix]);
             nSigma += dSigma;
@@ -260,5 +260,5 @@
 }
 
-bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psMaskType maskVal, psMaskType crMask) {
+bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psImageMaskType maskVal, psImageMaskType crMask) {
 
     // replace the source flux
@@ -294,5 +294,5 @@
 	
 	for (int ix = xs; ix < xe; ix++) {
-	    mask->data.U8[iy][ix] |= crMask;
+	    mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] |= crMask;
 	}
     }
@@ -300,5 +300,5 @@
 }
 
-bool psphotMaskCosmicRay_Old (pmSource *source, psMaskType maskVal, psMaskType crMask) {
+bool psphotMaskCosmicRay_Old (pmSource *source, psImageMaskType maskVal, psImageMaskType crMask) {
 
     source->mode |= PM_SOURCE_MODE_CR_LIMIT;
@@ -320,5 +320,5 @@
 	float SN = pixels->data.F32[yo][ix] / sqrt(weight->data.F32[yo][ix]);
 	if (SN > SN_LIMIT) {
-	    mask->data.U8[yo][ix] |= crMask;
+	    mask->data.PS_TYPE_IMAGE_MASK_DATA[yo][ix] |= crMask;
 	}
     }
@@ -326,5 +326,5 @@
 	float SN = pixels->data.F32[yo][ix] / sqrt(weight->data.F32[yo][ix]);
 	if (SN > SN_LIMIT) {
-	    mask->data.U8[yo][ix] |= crMask;
+	    mask->data.PS_TYPE_IMAGE_MASK_DATA[yo][ix] |= crMask;
 	}
     }
@@ -339,10 +339,10 @@
 
 	    bool valid = false;
-	    valid |= (mask->data.U8[iy+1][ix] & crMask);
-	    valid |= (ix > 0) ? (mask->data.U8[iy+1][ix-1] & crMask) : 0;
-	    valid |= (ix <= mask->numCols) ? (mask->data.U8[iy+1][ix+1] & crMask) : 0;
+	    valid |= (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+1][ix] & crMask);
+	    valid |= (ix > 0) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+1][ix-1] & crMask) : 0;
+	    valid |= (ix <= mask->numCols) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+1][ix+1] & crMask) : 0;
 
 	    if (!valid) continue;
-	    mask->data.U8[iy][ix] |= crMask;
+	    mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] |= crMask;
 	}
     }
@@ -355,10 +355,10 @@
 
 	    bool valid = false;
-	    valid |= (mask->data.U8[iy-1][ix] & crMask);
-	    valid |= (ix > 0) ? (mask->data.U8[iy-1][ix-1] & crMask) : 0;
-	    valid |= (ix <= mask->numCols) ? (mask->data.U8[iy-1][ix+1] & crMask) : 0;
+	    valid |= (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy-1][ix] & crMask);
+	    valid |= (ix > 0) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy-1][ix-1] & crMask) : 0;
+	    valid |= (ix <= mask->numCols) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy-1][ix+1] & crMask) : 0;
 
 	    if (!valid) continue;
-	    mask->data.U8[iy][ix] |= crMask;
+	    mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] |= crMask;
 	}
     }
Index: trunk/psphot/src/psphotSourceStats.c
===================================================================
--- trunk/psphot/src/psphotSourceStats.c	(revision 21177)
+++ trunk/psphot/src/psphotSourceStats.c	(revision 21183)
@@ -17,5 +17,4 @@
 	nThreads = 0;
     }
-    // nThreads = 0; // XXX until testing is complete, do not thread this function
 
     // determine properties (sky, moments) of initial sources
@@ -144,9 +143,9 @@
 
     // bit-masks to test for good/bad pixels
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
     assert (maskVal);
 
     // bit-mask to mark pixels not used in analysis
-    psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
+    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
     assert (markVal);
 
Index: trunk/psphot/src/psphotSubtractBackground.c
===================================================================
--- trunk/psphot/src/psphotSubtractBackground.c	(revision 21177)
+++ trunk/psphot/src/psphotSubtractBackground.c	(revision 21183)
@@ -28,5 +28,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
Index: trunk/psphot/src/psphotTestPSF.c
===================================================================
--- trunk/psphot/src/psphotTestPSF.c	(revision 21177)
+++ trunk/psphot/src/psphotTestPSF.c	(revision 21183)
@@ -111,5 +111,5 @@
         psImageKeepCircle (source->mask, x, y, RADIUS, "OR", markVal);
         status = pmSourceFitModel (source, model, PM_SOURCE_FIT_EXT);
-        psImageKeepCircle (source->mask, x, y, RADIUS, "AND", PS_NOT_U8(markVal));
+        psImageKeepCircle (source->mask, x, y, RADIUS, "AND", PS_NOT_IMAGE_MASK(markVal));
 
 	// write fitted parameters to file
Index: trunk/psphot/src/psphotTestSourceOutput.c
===================================================================
--- trunk/psphot/src/psphotTestSourceOutput.c	(revision 21177)
+++ trunk/psphot/src/psphotTestSourceOutput.c	(revision 21183)
@@ -80,5 +80,5 @@
 		float oy = yBin*(iy + 0.5 + image->row0 - yCenter) + yResidCenter;
 
-		psU8 mflux = 0;
+		psImageMaskType mflux = 0;
 		double Fo = 0.0;
 		double Fx = 0.0;
Index: trunk/psphot/src/psphotVisual.c
===================================================================
--- trunk/psphot/src/psphotVisual.c	(revision 21177)
+++ trunk/psphot/src/psphotVisual.c	(revision 21183)
@@ -51,5 +51,5 @@
 	ALLOCATE (image.data2d[iy], float, image.Nx);
 	for (int ix = 0; ix < image.Nx; ix++) {
-	    image.data2d[iy][ix] = inImage->data.U8[iy][ix];
+	    image.data2d[iy][ix] = inImage->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix];
 	}
     }
@@ -813,5 +813,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
@@ -973,5 +973,5 @@
 
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);
 
@@ -1097,5 +1097,5 @@
 }
 
-bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psMaskType maskVal) {
+bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psImageMaskType maskVal) {
 
     Graphdata graphdata;
@@ -1118,5 +1118,5 @@
     for (int iy = 0; iy < source->pixels->numRows; iy++) {
 	for (int ix = 0; ix < source->pixels->numCols; ix++) {
-	    if (source->maskObj->data.U8[iy][ix]) {
+	    if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) {
 		// rb->data.F32[nb] = hypot (ix + 0.5 - Xo, iy + 0.5 - Yo) ;
 		rb->data.F32[nb] = hypot (ix - Xo, iy - Yo) ;
@@ -1227,5 +1227,5 @@
     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
     bool status;
-    psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
+    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     assert (maskVal);