Index: trunk/psModules/src/astrom/pmAstrometryDistortion.c =================================================================== --- trunk/psModules/src/astrom/pmAstrometryDistortion.c (revision 21174) +++ trunk/psModules/src/astrom/pmAstrometryDistortion.c (revision 21183) @@ -7,6 +7,6 @@ * @author EAM, IfA * -* @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ -* @date $Date: 2008-09-02 19:05:09 $ +* @version $Revision: 1.23 $ $Name: not supported by cvs2svn $ +* @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2006 Institute for Astronomy, University of Hawaii @@ -121,5 +121,5 @@ // this analysis has too few data points to use the robust median method stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_STDEV); - mask = psVectorAlloc (Npts, PS_TYPE_MASK); + mask = psVectorAlloc (Npts, PS_TYPE_VECTOR_MASK); psVectorInit (mask, 0); @@ -206,5 +206,5 @@ // this analysis has too few data points to use the robust median method psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_STDEV); - psVector *mask = psVectorAlloc (gradients->n, PS_TYPE_MASK); + psVector *mask = psVectorAlloc (gradients->n, PS_TYPE_VECTOR_MASK); psVectorInit (mask, 0); Index: trunk/psModules/src/astrom/pmAstrometryObjects.c =================================================================== --- trunk/psModules/src/astrom/pmAstrometryObjects.c (revision 21174) +++ trunk/psModules/src/astrom/pmAstrometryObjects.c (revision 21183) @@ -8,6 +8,6 @@ * @author EAM, IfA * -* @version $Revision: 1.42 $ $Name: not supported by cvs2svn $ -* @date $Date: 2008-11-20 01:26:07 $ +* @version $Revision: 1.43 $ $Name: not supported by cvs2svn $ +* @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -227,5 +227,5 @@ // constant errors - psVector *mask = psVectorAlloc (match->n, PS_TYPE_U8); + psVector *mask = psVectorAlloc (match->n, PS_TYPE_VECTOR_MASK); psVectorInit (mask, 0); Index: trunk/psModules/src/camera/pmCellSquish.c =================================================================== --- trunk/psModules/src/camera/pmCellSquish.c (revision 21174) +++ trunk/psModules/src/camera/pmCellSquish.c (revision 21183) @@ -12,5 +12,5 @@ -bool pmCellSquish(pmCell *cell, psMaskType maskVal, bool useShifts) +bool pmCellSquish(pmCell *cell, psImageMaskType maskVal, bool useShifts) { PS_ASSERT_PTR_NON_NULL(cell, false); @@ -116,5 +116,5 @@ psImage *squishImage = psImageAlloc(numCols, numRows, PS_TYPE_F32); // Squished image psImageInit(squishImage, 0.0); - psImage *squishMask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); // Squished mask + psImage *squishMask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); // Squished mask psImageInit(squishMask, 0); @@ -159,5 +159,5 @@ squishImage->data.F32[ySquish][xSquish] += image->data.F32[y][x]; if (mask) { - squishMask->data.PS_TYPE_MASK_DATA[ySquish][xSquish] |= mask->data.U8[y][x] & maskVal; + squishMask->data.PS_TYPE_IMAGE_MASK_DATA[ySquish][xSquish] |= mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal; } } Index: trunk/psModules/src/camera/pmCellSquish.h =================================================================== --- trunk/psModules/src/camera/pmCellSquish.h (revision 21174) +++ trunk/psModules/src/camera/pmCellSquish.h (revision 21183) @@ -7,5 +7,5 @@ /// already have been read) and masks. bool pmCellSquish(pmCell *cell, ///< Cell to have readouts combined - psMaskType maskVal, ///< Value to be masked + psImageMaskType maskVal, ///< Value to be masked bool useShifts ///< Use the shifts when squishing? ); Index: trunk/psModules/src/camera/pmFPABin.c =================================================================== --- trunk/psModules/src/camera/pmFPABin.c (revision 21174) +++ trunk/psModules/src/camera/pmFPABin.c (revision 21183) @@ -9,5 +9,5 @@ #include "pmFPABin.h" -bool pmReadoutRebin(pmReadout *out, const pmReadout *in, psMaskType maskVal, int xBin, int yBin) +bool pmReadoutRebin(pmReadout *out, const pmReadout *in, psImageMaskType maskVal, int xBin, int yBin) { PM_ASSERT_READOUT_NON_NULL(out, false); @@ -50,5 +50,5 @@ for (int y = yStart; y < yStop; y++) { for (int x = xStart; x < xStop; x++) { - if (inMask && (inMask->data.PS_TYPE_MASK_DATA[y][x] & maskVal)) { + if (inMask && (inMask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal)) { continue; } Index: trunk/psModules/src/camera/pmFPABin.h =================================================================== --- trunk/psModules/src/camera/pmFPABin.h (revision 21174) +++ trunk/psModules/src/camera/pmFPABin.h (revision 21183) @@ -9,5 +9,5 @@ bool pmReadoutRebin(pmReadout *out, ///< Output readout const pmReadout *in,///< Input readout - psMaskType maskVal, ///< Value to mask + psImageMaskType maskVal, ///< Value to mask int xBin, int yBin ///< Binning factors in x and y ); Index: trunk/psModules/src/camera/pmFPAMaskWeight.c =================================================================== --- trunk/psModules/src/camera/pmFPAMaskWeight.c (revision 21174) +++ trunk/psModules/src/camera/pmFPAMaskWeight.c (revision 21183) @@ -42,5 +42,5 @@ continue; } - masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8); + masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_IMAGE_MASK); psImageInit(masks->data[i], 0); } @@ -98,5 +98,5 @@ ////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool pmReadoutSetMask(pmReadout *readout, psMaskType satMask, psMaskType badMask) +bool pmReadoutSetMask(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask) { PS_ASSERT_PTR_NON_NULL(readout, false); @@ -124,5 +124,5 @@ if (!readout->mask) { // Generate a (throwaway) mask image, if required - readout->mask = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8); + readout->mask = psImageAlloc(image->numCols, image->numRows, PS_TYPE_IMAGE_MASK); } psImage *mask = readout->mask; // The mask pixels @@ -131,5 +131,5 @@ // Dereference pointers for speed psF32 **imageData = image->data.F32;// The image - psU8 **maskData = mask->data.U8; // The mask + psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA; // The mask for (int i = 0; i < image->numRows; i++) { @@ -153,5 +153,5 @@ // pixels. currently, it will set mask bits if (value <= BAD) or (value >= SATURATION) // should we optionally ignore these tests? -bool pmReadoutGenerateMask(pmReadout *readout, psMaskType satMask, psMaskType badMask) +bool pmReadoutGenerateMask(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask) { PS_ASSERT_PTR_NON_NULL(readout, false); @@ -294,5 +294,5 @@ } -bool pmReadoutGenerateMaskWeight(pmReadout *readout, psMaskType satMask, psMaskType badMask, bool poisson) +bool pmReadoutGenerateMaskWeight(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask, bool poisson) { PS_ASSERT_PTR_NON_NULL(readout, false); @@ -306,5 +306,5 @@ } -bool pmCellGenerateMaskWeight(pmCell *cell, psMaskType satMask, psMaskType badMask, bool poisson) +bool pmCellGenerateMaskWeight(pmCell *cell, psImageMaskType satMask, psImageMaskType badMask, bool poisson) { PS_ASSERT_PTR_NON_NULL(cell, false); @@ -321,5 +321,5 @@ -bool pmReadoutWeightRenormPixels(const pmReadout *readout, psMaskType maskVal, +bool pmReadoutWeightRenormPixels(const pmReadout *readout, psImageMaskType maskVal, psStatsOptions meanStat, psStatsOptions stdevStat, psRandom *rng) { @@ -363,5 +363,5 @@ -bool pmReadoutWeightRenormPhot(const pmReadout *readout, psMaskType maskVal, int num, float width, +bool pmReadoutWeightRenormPhot(const pmReadout *readout, psImageMaskType maskVal, int num, float width, psStatsOptions meanStat, psStatsOptions stdevStat, psRandom *rng) { @@ -411,5 +411,5 @@ psVector *source = psVectorAlloc(num, PS_TYPE_F32); // Measurements of fake sources psVector *guess = psVectorAlloc(num, PS_TYPE_F32); // Guess at significance - psVector *photMask = psVectorAlloc(num, PS_TYPE_MASK); // Mask for fluxes + psVector *photMask = psVectorAlloc(num, PS_TYPE_VECTOR_MASK); // Mask for fluxes for (int i = 0; i < num; i++) { // Coordinates of interest @@ -433,5 +433,5 @@ float yGauss = gauss->data.F32[v]; // Value of Gaussian in y for (int u = 0, x = xPix - size; u < fullSize; u++, x++) { - if (mask && mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) { + if (mask && mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) { continue; } @@ -453,5 +453,5 @@ } - photMask->data.PS_TYPE_MASK_DATA[i] = ((isfinite(sumNoise) && isfinite(sumSource) && + photMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = ((isfinite(sumNoise) && isfinite(sumSource) && isfinite(sumWeight) && sumGauss > 0 && sumGauss2 > 0) ? 0 : 0xFF); @@ -493,5 +493,5 @@ ratio->data.F32[i] = measuredSig / guess->data.F32[i]; if (guess->data.F32[i] <= 0.0 || source->data.F32[i] <= 0.0 || !isfinite(ratio->data.F32[i])) { - photMask->data.PS_TYPE_MASK_DATA[i] = 0xFF; + photMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xFF; } psTrace("psModules.camera", 9, "Ratio %d: %f, %f, %f\n", @@ -523,5 +523,5 @@ -bool pmReadoutWeightRenorm(const pmReadout *readout, psMaskType maskVal, psStatsOptions meanStat, +bool pmReadoutWeightRenorm(const pmReadout *readout, psImageMaskType maskVal, psStatsOptions meanStat, psStatsOptions stdevStat, int width, psRandom *rng) { @@ -591,5 +591,5 @@ -bool pmReadoutMaskNonfinite(pmReadout *readout, psMaskType maskVal) +bool pmReadoutMaskNonfinite(pmReadout *readout, psImageMaskType maskVal) { PM_ASSERT_READOUT_NON_NULL(readout, false); @@ -601,5 +601,5 @@ if (!readout->mask) { - readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); } psImage *mask = readout->mask; // Readout's mask @@ -608,5 +608,5 @@ for (int x = 0; x < numCols; x++) { if (!isfinite(image->data.F32[y][x]) || (weight && !isfinite(weight->data.F32[y][x]))) { - mask->data.PS_TYPE_MASK_DATA[y][x] |= maskVal; + mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= maskVal; } } @@ -618,5 +618,5 @@ -bool pmReadoutMaskApply(pmReadout *readout, psMaskType maskVal) +bool pmReadoutMaskApply(pmReadout *readout, psImageMaskType maskVal) { PM_ASSERT_READOUT_NON_NULL(readout, false); @@ -625,5 +625,5 @@ int numCols = readout->image->numCols, numRows = readout->image->numRows; // Size of image - psMaskType **maskData = readout->mask->data.PS_TYPE_MASK_DATA; // Dereference mask + psImageMaskType **maskData = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Dereference mask psF32 **imageData = readout->image->data.F32;// Dereference image psF32 **weightData = readout->weight ? readout->weight->data.F32 : NULL; // Dereference weight map @@ -644,6 +644,6 @@ -bool pmReadoutInterpolateBadPixels(pmReadout *readout, psMaskType maskVal, psImageInterpolateMode mode, - float poorFrac, psMaskType maskPoor, psMaskType maskBad) +bool pmReadoutInterpolateBadPixels(pmReadout *readout, psImageMaskType maskVal, psImageInterpolateMode mode, + float poorFrac, psImageMaskType maskPoor, psImageMaskType maskBad) { PM_ASSERT_READOUT_NON_NULL(readout, false); @@ -667,14 +667,15 @@ psVector *imagePix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_F32); // Corresponding values for image psVector *weightPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_F32); // Corresponding values for weight - psVector *maskPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_MASK); // Corresponding values for mask + psVector *maskPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_IMAGE_MASK); // Corresponding values for mask + // NOTE: maskPix carries the actual image mask values -- do NOT use + // PS_TYPE_VECTOR_MASK here; it is storage, and is not treated as a vector mask long numBad = 0; // Number of bad pixels interpolated for (int y = 0; y < numRows; y++) { for (int x = 0; x < numCols; x++) { - if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) { + if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) { double imageValue, weightValue; // Image and weight value from interpolation - psMaskType maskValue = 0; // Mask value from interpolation - psImageInterpolateStatus status = psImageInterpolate(&imageValue, &weightValue, &maskValue, - x, y, interp); + psImageMaskType maskValue = 0; // Mask value from interpolation + psImageInterpolateStatus status = psImageInterpolate(&imageValue, &weightValue, &maskValue, x, y, interp); if (status == PS_INTERPOLATE_STATUS_ERROR || status == PS_INTERPOLATE_STATUS_OFF) { psError(PS_ERR_UNKNOWN, false, "Unable to interpolate readout at %d,%d", x, y); @@ -697,5 +698,5 @@ imagePix->data.F32[numBad] = imageValue; weightPix->data.F32[numBad] = weightValue; - maskPix->data.PS_TYPE_MASK_DATA[numBad] = maskValue; + maskPix->data.PS_TYPE_IMAGE_MASK_DATA[numBad] = maskValue; numBad++; } @@ -709,5 +710,5 @@ image->data.F32[y][x] = imagePix->data.F32[i]; weight->data.F32[y][x] = weightPix->data.F32[i]; - mask->data.PS_TYPE_MASK_DATA[y][x] = maskPix->data.PS_TYPE_MASK_DATA[i]; + mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = maskPix->data.PS_TYPE_IMAGE_MASK_DATA[i]; } Index: trunk/psModules/src/camera/pmFPAMaskWeight.h =================================================================== --- trunk/psModules/src/camera/pmFPAMaskWeight.h (revision 21174) +++ trunk/psModules/src/camera/pmFPAMaskWeight.h (revision 21183) @@ -5,6 +5,6 @@ * @author Eugene Magnier, IfA * - * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-10-31 21:50:16 $ + * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2005-2006 Institute for Astronomy, University of Hawaii */ @@ -42,6 +42,6 @@ /// iterating using pmReadoutReadNext, in which case the HDU can't be generated. bool pmReadoutSetMask(pmReadout *readout, ///< Readout for which to set mask - psMaskType satMask, ///< Mask value to give saturated pixels - psMaskType badMask ///< Mask value to give bad (low) pixels + psImageMaskType satMask, ///< Mask value to give saturated pixels + psImageMaskType badMask ///< Mask value to give bad (low) pixels ); @@ -62,6 +62,6 @@ /// is suitable for output (complete with HDU entry). This is intended for most operations. bool pmReadoutGenerateMask(pmReadout *readout, ///< Readout for which to generate mask - psMaskType sat, ///< Mask value to give saturated pixels - psMaskType bad ///< Mask value to give bad (low) pixels + psImageMaskType sat, ///< Mask value to give saturated pixels + psImageMaskType bad ///< Mask value to give bad (low) pixels ); @@ -79,6 +79,6 @@ /// Calls pmReadoutGenerateMask and pmReadoutGenerateWeight for the readout bool pmReadoutGenerateMaskWeight(pmReadout *readout, ///< Readout for which to generate mask and weights - psMaskType sat, ///< Mask value to give saturated pixels - psMaskType bad, ///< Mask value to give bad (low) pixels + psImageMaskType sat, ///< Mask value to give saturated pixels + psImageMaskType bad, ///< Mask value to give bad (low) pixels bool poisson ///< Use poisson weights (in addition to read noise)? ); @@ -88,6 +88,6 @@ /// Calls pmReadoutGenerateMaskWeight for each readout within the cell. bool pmCellGenerateMaskWeight(pmCell *cell, ///< Cell for which to generate mask and weights - psMaskType sat, ///< Mask value to give saturated pixels - psMaskType bad, ///< Mask value to give bad (low) pixels + psImageMaskType sat, ///< Mask value to give saturated pixels + psImageMaskType bad, ///< Mask value to give bad (low) pixels bool poisson ///< Use poisson weights (in addition to read noise)? ); @@ -98,5 +98,5 @@ bool pmReadoutWeightRenormPixels( const pmReadout *readout, ///< Readout to normalise - psMaskType maskVal, ///< Value to mask + psImageMaskType maskVal, ///< Value to mask psStatsOptions meanStat, ///< Statistic to measure the mean (of the variance map) psStatsOptions stdevStat, ///< Statistic to measure the stdev (of the image) @@ -110,5 +110,5 @@ bool pmReadoutWeightRenormPhot( const pmReadout *readout, ///< Readout to normalise - psMaskType maskVal, ///< Value to mask + psImageMaskType maskVal, ///< Value to mask int num, ///< Number of instances to measure over the image float width, ///< Photometry width @@ -123,5 +123,5 @@ /// that patch corresponds. bool pmReadoutWeightRenorm(const pmReadout *readout, // Readout to normalise - psMaskType maskVal, // Value to mask + psImageMaskType maskVal, // Value to mask psStatsOptions meanStat, // Statistic to measure the mean (of the variance map) psStatsOptions stdevStat, // Statistic to measure the stdev (of the image) @@ -136,5 +136,5 @@ /// the provided value. bool pmReadoutMaskNonfinite(pmReadout *readout, ///< Readout to mask - psMaskType maskVal ///< Mask value to give non-finite pixels + psImageMaskType maskVal ///< Mask value to give non-finite pixels ); @@ -145,5 +145,5 @@ /// sets masked areas to NAN in the image and weight. bool pmReadoutMaskApply(pmReadout *readout, ///< Readout to mask - psMaskType maskVal ///< Mask value for which to apply mask + psImageMaskType maskVal ///< Mask value for which to apply mask ); @@ -152,9 +152,9 @@ /// Scan the mask image for bad pixels, and interpolate over them using the nominated options bool pmReadoutInterpolateBadPixels(pmReadout *readout, ///< Readout to work on - psMaskType maskVal, ///< Value to mask + psImageMaskType maskVal, ///< Value to mask psImageInterpolateMode mode, ///< Interpolation mode float poorFrac, ///< Maximum bad fraction of kernel for "poor" status - psMaskType maskPoor, ///< Mask value to give poor pixels - psMaskType maskBad ///< Mask value to give bad pixels + psImageMaskType maskPoor, ///< Mask value to give poor pixels + psImageMaskType maskBad ///< Mask value to give bad pixels ); Index: trunk/psModules/src/camera/pmFPAMosaic.c =================================================================== --- trunk/psModules/src/camera/pmFPAMosaic.c (revision 21174) +++ trunk/psModules/src/camera/pmFPAMosaic.c (revision 21183) @@ -471,6 +471,4 @@ numImages++; - // Only implemented for F32 and U8 images so far. - assert(image->type.type == PS_TYPE_F32 || image->type.type == PS_TYPE_U8); // All input types must be the same if (type == 0) { @@ -537,6 +535,14 @@ if (xBinSource->data.S32[i] == xBinTarget && yBinSource->data.S32[i] == yBinTarget) { switch (type) { + COPY_WITH_PARITY_DIFFERENCE(U8); + COPY_WITH_PARITY_DIFFERENCE(U16); + COPY_WITH_PARITY_DIFFERENCE(U32); + COPY_WITH_PARITY_DIFFERENCE(U64); + COPY_WITH_PARITY_DIFFERENCE(S8); + COPY_WITH_PARITY_DIFFERENCE(S16); + COPY_WITH_PARITY_DIFFERENCE(S32); + COPY_WITH_PARITY_DIFFERENCE(S64); COPY_WITH_PARITY_DIFFERENCE(F32); - COPY_WITH_PARITY_DIFFERENCE(U8); + COPY_WITH_PARITY_DIFFERENCE(F64); default: psAbort("Should never get here.\n"); @@ -548,6 +554,14 @@ // We have to do all of the hard work ourselves switch (type) { - FILL_IN(F32); - FILL_IN(U8); + FILL_IN(U8); + FILL_IN(U16); + FILL_IN(U32); + FILL_IN(U64); + FILL_IN(S8); + FILL_IN(S16); + FILL_IN(S32); + FILL_IN(S64); + FILL_IN(F32); + FILL_IN(F64); default: psAbort("Should never get here.\n"); @@ -730,5 +744,5 @@ const pmChip *chip, // Chip to mosaic const pmCell *targetCell, // Cell to which to mosaic - psMaskType blank // Mask value to give blank pixels + psImageMaskType blank // Mask value to give blank pixels ) { @@ -838,5 +852,5 @@ const pmChip *targetChip, // Chip to which to mosaic const pmCell *targetCell, // Cell to which to mosaic - psMaskType blank // Mask value to give blank pixels + psImageMaskType blank // Mask value to give blank pixels ) { @@ -994,5 +1008,5 @@ // the mosaic image. -bool pmChipMosaic(pmChip *target, const pmChip *source, bool deepCopy, psMaskType blank) +bool pmChipMosaic(pmChip *target, const pmChip *source, bool deepCopy, psImageMaskType blank) { // Target exists, and has only a single cell @@ -1225,5 +1239,5 @@ -bool pmFPAMosaic(pmFPA *target, const pmFPA *source, bool deepCopy, psMaskType blank) +bool pmFPAMosaic(pmFPA *target, const pmFPA *source, bool deepCopy, psImageMaskType blank) { // Target exists, and has only a single chip with single cell Index: trunk/psModules/src/camera/pmFPAMosaic.h =================================================================== --- trunk/psModules/src/camera/pmFPAMosaic.h (revision 21174) +++ trunk/psModules/src/camera/pmFPAMosaic.h (revision 21183) @@ -4,6 +4,6 @@ * @author Paul Price, IfA * - * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-06-20 02:22:26 $ + * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2005-2006 Institute for Astronomy, University of Hawaii */ @@ -24,5 +24,5 @@ const pmChip *source, ///< Source chip whose cells will be mosaicked bool deepCopy, ///< Require a deep copy (disregard 'nice' chip) - psMaskType blank ///< Mask value to give blank pixels + psImageMaskType blank ///< Mask value to give blank pixels ); @@ -36,5 +36,5 @@ const pmFPA *source, ///< FPA whose chips and cells will be mosaicked bool deepCopy, ///< Require a deep copy (disregard 'nice' chip) - psMaskType blank ///< Mask value to give blank pixels + psImageMaskType blank ///< Mask value to give blank pixels ); /// @} Index: trunk/psModules/src/camera/pmFPARead.c =================================================================== --- trunk/psModules/src/camera/pmFPARead.c (revision 21174) +++ trunk/psModules/src/camera/pmFPARead.c (revision 21183) @@ -35,5 +35,5 @@ static psElemType pixelTypes[] = { PS_TYPE_F32, - PS_TYPE_MASK, + PS_TYPE_IMAGE_MASK, PS_TYPE_F32, 0 Index: trunk/psModules/src/camera/pmFPA_JPEG.c =================================================================== --- trunk/psModules/src/camera/pmFPA_JPEG.c (revision 21174) +++ trunk/psModules/src/camera/pmFPA_JPEG.c (revision 21183) @@ -5,6 +5,6 @@ * @author EAM, IfA * - * @version $Revision: 1.26 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-09-23 02:00:36 $ + * @version $Revision: 1.27 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -157,5 +157,5 @@ psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); stats->nSubsample = 10000; - psMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask + psImageMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask float mean = 0, delta = 0; // if (!psImageBackground(stats, NULL, readout->image, readout->mask, maskVal, rng)) { Index: trunk/psModules/src/camera/pmHDU.c =================================================================== --- trunk/psModules/src/camera/pmHDU.c (revision 21174) +++ trunk/psModules/src/camera/pmHDU.c (revision 21183) @@ -167,5 +167,5 @@ const psArray *images, // Images to write const psArray *masks, // Masks to use when writing - psMaskType maskVal,// Value to mask + psImageMaskType maskVal,// Value to mask psFits *fits // FITS file to which to write ) @@ -222,5 +222,5 @@ PS_ASSERT_PTR_NON_NULL(fits, false); - psMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask + psImageMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask return hduWrite(hdu, hdu->images, hdu->masks, maskVal, fits); } @@ -240,5 +240,5 @@ PS_ASSERT_PTR_NON_NULL(fits, false); - psMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask + psImageMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask return hduWrite(hdu, hdu->weights, hdu->masks, maskVal, fits); } Index: trunk/psModules/src/camera/pmReadoutStack.c =================================================================== --- trunk/psModules/src/camera/pmReadoutStack.c (revision 21174) +++ trunk/psModules/src/camera/pmReadoutStack.c (revision 21183) @@ -78,5 +78,5 @@ // XXX for the moment, use col0, row0, numCols, numRows supplied from the outside -bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psMaskType blank) +bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psImageMaskType blank) { PS_ASSERT_PTR_NON_NULL(readout, false); @@ -94,5 +94,5 @@ // XXX is this an error? if (readout->mask) return false; - readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); psImageInit(readout->mask, blank); } @@ -163,5 +163,5 @@ bool pmReadoutUpdateSize(pmReadout *readout, int minCols, int minRows, int numCols, int numRows, bool mask, bool weight, - psMaskType blank) + psImageMaskType blank) { PS_ASSERT_PTR_NON_NULL(readout, false); @@ -191,9 +191,9 @@ if (mask) { if (!readout->mask) { - readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); psImageInit(readout->mask, blank); } if (readout->mask->numCols < numCols || readout->mask->numRows < numRows) { - psImage *newMask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + psImage *newMask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); psImageInit(newMask, blank); psImageOverlaySection(newMask, readout->mask, readout->col0, readout->row0, "="); Index: trunk/psModules/src/camera/pmReadoutStack.h =================================================================== --- trunk/psModules/src/camera/pmReadoutStack.h (revision 21174) +++ trunk/psModules/src/camera/pmReadoutStack.h (revision 21183) @@ -14,5 +14,5 @@ bool mask, ///< Worry about the mask? bool weight, ///< Worry about the weight? - psMaskType blank ///< Mask value to give to blank pixels + psImageMaskType blank ///< Mask value to give to blank pixels ); @@ -47,5 +47,5 @@ // XXX for the moment, use col0, row0, numCols, numRows supplied from the outside -bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psMaskType blank); +bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psImageMaskType blank); bool pmReadoutStackSetOutputSize(int *col0, int *row0, int *numCols, int *numRows, const psArray *inputs); Index: trunk/psModules/src/concepts/pmConceptsStandard.c =================================================================== --- trunk/psModules/src/concepts/pmConceptsStandard.c (revision 21174) +++ trunk/psModules/src/concepts/pmConceptsStandard.c (revision 21183) @@ -16,4 +16,6 @@ #include "pmConceptsWrite.h" #include "pmConceptsStandard.h" + +// XXX why are these functions not supporting all types (S64, U64 often missing)? // The functions in this file are intended to be called solely within the psModules concepts code. For this @@ -591,7 +593,9 @@ TYPE_CASE(binning, concept, U16); TYPE_CASE(binning, concept, U32); + // TYPE_CASE(binning, concept, U64); TYPE_CASE(binning, concept, S8); TYPE_CASE(binning, concept, S16); TYPE_CASE(binning, concept, S32); + // TYPE_CASE(binning, concept, S64); default: psError(PS_ERR_UNKNOWN, true, "Note sure how to parse %s of type %x --- assuming 1.\n", pattern->name, Index: trunk/psModules/src/config/pmConfigMask.c =================================================================== --- trunk/psModules/src/config/pmConfigMask.c (revision 21174) +++ trunk/psModules/src/config/pmConfigMask.c (revision 21183) @@ -9,103 +9,79 @@ #include "pmConfigMask.h" -////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Private functions -////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -// maskSetValues examine named mask values and set the bits for maskValue and markValue. -// Ensures that the below-named bad mask values are set, and calculates the mask value to catch them all -// Ensure that the below-named other mask values are set (to 0x00 if necessary) - -// List of mask names for "bad" (i.e., mask me please) pixels -static const char *badMaskNames[] = { "DETECTOR", // Something is wrong with the detector - "DARK", // Pixel doesn't dark-subtract properly - "FLAT", // Pixel doesn't flat-field properly - "BLANK", // Pixel doesn't contain valid data - "RANGE",// Pixel is out-of-range of linearity - "SAT", // Pixel is saturated - // "LOW", // Pixel is low - // "CONV", // Pixel is bad after convolution with a bad pixel - "BAD", // Pixel is low - "BAD.WARP", // Pixel is bad after convolution with a bad pixel - "CR", // Pixel contains a cosmic ray - "GHOST",// Pixel contains an optical ghost - NULL // End marker +static pmConfigMaskInfo masks[] = { + { "DETECTOR", NULL, 0x00, true }, // Something is wrong with the detector + { "DARK", "DETECTOR", 0x00, true }, // Pixel doesn't dark-subtract properly + { "FLAT", "DETECTOR", 0x01, true }, // Pixel doesn't flat-field properly + { "BLANK", "DETECTOR", 0x01, true }, // Pixel doesn't contain valid data + { "RANGE", NULL, 0x00, true }, // Pixel is out-of-range of linearity + { "SAT", "RANGE", 0x01, true }, // Pixel is saturated + { "BAD", "RANGE", 0x01, true }, // Pixel is low + { "BAD.WARP", NULL, 0x01, true }, // Pixel is bad after convolution with a bad pixel + { "CR", NULL, 0x00, true }, // Pixel contains a cosmic ray + { "GHOST", NULL, 0x00, true }, // Pixel contains an optical ghost + { "POOR.WARP", NULL, 0x00, false }, // Pixel is poor after convolution with a bad pixel + // "LOW" Pixel is low + // "CONV" Pixel is bad after convolution with a bad pixel }; -// Fallback names in case a bad mask name is not defined -static const char *fallbackMaskNames[] = { NULL, // DETECTOR - "DETECTOR", // DARK - "DETECTOR", // FLAT - "DETECTOR", // BLANK - NULL, // RANGE - "RANGE", // SAT - "RANGE", // LOW - NULL, // CONV - NULL, // CR - NULL, // GHOST -}; -// Default values in case a bad mask name and its fallback is not defined -static const psMaskType defaultMask[] = { 0x00, // DETECTOR - 0x00, // DARK - 0x01, // FLAT - 0x01, // BLANK - 0x00, // RANGE - 0x01, // SAT - 0x01, // LOW - 0x01, // CONV - 0x00, // CR - 0x00 // GHOST -}; -// Other mask names to ensure exist; these shouldn't be combined in the MASK.VALUE -static const char *otherMaskNames[] = { // "POOR", // Pixel is poor after convolution with a bad pixel - "POOR.WARP", // Pixel is poor after convolution with a bad pixel - NULL // End marker -}; - -static bool maskSetValues(psMaskType *outMaskValue, // Value of MASK.VALUE, returned - psMaskType *outMarkValue, // Value of MARK.VALUE, returned - psMetadata *source // Source of mask bits - ) + +// The functions in this file do not force the recipe or header values to be stored as the same +// type as psImageMaskType : they only check that the given values will fit in the space +// provided by psImageMaskType. This should allow some backwards compatibility (old 8-bit +// masks will work with a 16-bit system), but will catch unhandled conflicts (trying to fit 16 +// bits in 8-bits of space). + +// XXX this file does not have psError vs psWarning worked out correctly. some of the +// failure modes should result in errors, not just warnings. + +// pmConfigMaskSetInMetadata examines named mask values and set the bits for maskValue and +// markValue. Ensures that the below-named mask values are set, and calculates the mask value +// to catch all of the mask values marked as 'bad'. Supplies the fallback name if the primary +// name is not found, or the default values if the fallback name is not found. + +bool pmConfigMaskSetInMetadata(psImageMaskType *outMaskValue, // Value of MASK.VALUE, returned + psImageMaskType *outMarkValue, // Value of MARK.VALUE, returned + psMetadata *source // Source of mask bits + ) { PS_ASSERT_METADATA_NON_NULL(source, false); - + // Ensure all the bad mask names exist, and set the value to catch all bad pixels - psMaskType maskValue = 0; // Value to mask to catch all the bad pixels - for (int i = 0; badMaskNames[i]; i++) { - const char *name = badMaskNames[i]; // Name for mask - const char *fallback = fallbackMaskNames[i]; // Fallback for mask - + psImageMaskType maskValue = 0; // Value to mask to catch all the bad pixels + psImageMaskType allMasks = 0; // Value to mask to catch all masked bits (to set MARK) + + int nMasks = sizeof (masks) / sizeof (pmConfigMaskInfo); + + for (int i = 0; i < nMasks; i++) { bool mdok; // Status of MD lookup - psMaskType value = psMetadataLookupU8(&mdok, source, name); // Value of mask + psImageMaskType value = psMetadataLookupImageMaskFromGeneric(&mdok, source, masks[i].badMaskName); // Value of mask + if (!mdok) { + psWarning ("problem with mask value %s\n", masks[i].badMaskName); + } + if (!value) { - if (fallback) { - value = psMetadataLookupU8(&mdok, source, fallback); - } - if (!value) { - value = defaultMask[i]; - } - psMetadataAddU8(source, PS_LIST_TAIL, name, PS_META_REPLACE, NULL, value); - } - maskValue |= value; - } - - // Ensure all the other mask names exist - for (int i = 0; otherMaskNames[i]; i++) { - const char *name = otherMaskNames[i]; // Name for mask - bool mdok; // Status of MD lookup - psMaskType value = psMetadataLookupU8(&mdok, source, name); // Value of mask - if (!value) { - psMetadataAddU8(source, PS_LIST_TAIL, name, PS_META_REPLACE, NULL, 0x00); - } + if (masks[i].fallbackName) { + value = psMetadataLookupImageMaskFromGeneric(&mdok, source, masks[i].fallbackName); + } + if (!value) { + value = masks[i].defaultMaskValue; + } + psMetadataAddImageMask(source, PS_LIST_TAIL, masks[i].badMaskName, PS_META_REPLACE, NULL, value); + } + if (masks[i].isBad) { + maskValue |= value; + } + allMasks |= value; } // search for an unset bit to use for MARK: - psMaskType markValue = 0x80; - - int nBits = sizeof(psMaskType) * 8; + psImageMaskType markValue = 0x00; + psImageMaskType markTrial = 0x01; + + int nBits = sizeof(psImageMaskType) * 8; for (int i = 0; !markValue && (i < nBits); i++) { - if (maskValue & markValue) { - markValue >>= 1; + if (allMasks & markTrial) { + markTrial <<= 1; } else { - markValue = markValue; + markValue = markTrial; } } @@ -116,6 +92,6 @@ // update the list with the results - psMetadataAddU8(source, PS_LIST_TAIL, "MASK.VALUE", PS_META_REPLACE, NULL, maskValue); - psMetadataAddU8(source, PS_LIST_TAIL, "MARK.VALUE", PS_META_REPLACE, NULL, markValue); + psMetadataAddImageMask(source, PS_LIST_TAIL, "MASK.VALUE", PS_META_REPLACE, NULL, maskValue); + psMetadataAddImageMask(source, PS_LIST_TAIL, "MARK.VALUE", PS_META_REPLACE, NULL, markValue); if (outMaskValue) { @@ -130,9 +106,9 @@ // Get a mask value by name(s) -static psMaskType maskGet(psMetadata *source, // Source of masks - const char *masks // Mask values to get - ) -{ - psMaskType mask = 0; // Mask value, to return +psImageMaskType pmConfigMaskGetFromMetadata(psMetadata *source, // Source of masks + const char *masks // Mask values to get + ) +{ + psImageMaskType mask = 0; // Mask value, to return psArray *names = psStringSplitArray(masks, " ,;", false); // Array of symbolic names @@ -140,13 +116,13 @@ const char *name = names->data[i]; // Symbolic name of interest bool mdok; // Status of MD lookup - psMaskType value = psMetadataLookupU8(&mdok, source, name); + psImageMaskType value = psMetadataLookupImageMaskFromGeneric(&mdok, source, name); if (!mdok) { // Try and generate the value if we can if (strcmp(name, "MASK.VALUE") == 0 || strcmp(name, "MARK.VALUE") == 0) { - if (!maskSetValues(NULL, NULL, source)) { + if (!pmConfigMaskSetInMetadata(NULL, NULL, source)) { psError(PS_ERR_UNKNOWN, false, "Unable to set mask bits."); return 0; } - value = psMetadataLookupU8(&mdok, source, name); + value = psMetadataLookupImageMaskFromGeneric(&mdok, source, name); psAssert(mdok, "Should have generated mask value"); } else { @@ -163,8 +139,67 @@ } +// lookup an image mask value by name from a psMetadata, without requiring the entry to +// be of type psImageMaskType, but verifying that it will fit in psImageMaskType +psImageMaskType psMetadataLookupImageMaskFromGeneric (bool *status, const psMetadata *md, const char *name) { + + *status = true; + + // select the mask bit name from the header + psMetadataItem *item = psMetadataLookup (md, name); + if (!item) { + psWarning("Unable to find header keyword %s when parsing mask", name); + *status = false; + return 0; + } + + // the value may be any of the U8, U16, U32, U64 types : accept the value regardless of type size + psU64 fullValue = 0; + switch (item->type) { + case PS_DATA_U8: + fullValue = item->data.U8; + break; + case PS_DATA_U16: + fullValue = item->data.U16; + break; + case PS_DATA_U32: + fullValue = item->data.U32; + break; + case PS_DATA_U64: + fullValue = item->data.U64; + break; + case PS_DATA_S8: + fullValue = item->data.S8; + break; + case PS_DATA_S16: + fullValue = item->data.S16; + break; + case PS_DATA_S32: + fullValue = item->data.S32; + break; + case PS_DATA_S64: + fullValue = item->data.S64; + break; + default: + psWarning("Mask entry %s in metadata is not of a mask type", name); + *status = false; + return 0; + } + + // will the incoming value fit within the current image mask type? + if (fullValue > PS_MAX_IMAGE_MASK_TYPE) { + psWarning("Mask entry %s in metadata is larger than allowed by the psImageMaskType", name); + *status = false; + return 0; + } + psImageMaskType value = fullValue; + // XXX validate that value is a 2^n value? + + return value; +} + // Remove from the header keywords starting with the provided string -static int maskRemoveHeader(psMetadata *header, // Header from which to remove keywords - const char *start // Remove keywords that start with this string - ) +int pmConfigMaskRemoveHeaderKeywords(psMetadata *header, // Header from which to remove keywords + const char *start // Remove keywords that start with this string + ) { psString regex = NULL; // Regular expression for keywords @@ -182,4 +217,208 @@ } +// look up the named mask value(s) from the MASKS recipe in the config system +psImageMaskType pmConfigMaskGet(const char *masks, const pmConfig *config) +{ + psAssert(config, "Require configuration"); + PS_ASSERT_STRING_NON_EMPTY(masks, 0); + + bool mdok; // Status of MD lookup + psMetadata *recipe = psMetadataLookupMetadata(&mdok, config->recipes, "MASKS"); // The recipe + if (!recipe) { + psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); + return 0; + } + + psImageMaskType mask = pmConfigMaskGetFromMetadata (recipe, masks); + return mask; +} + +bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psImageMaskType maskValue) +{ + psAssert(config, "Require configuration"); + PS_ASSERT_STRING_NON_EMPTY(maskName, false); + + psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe + if (!recipe) { + psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); + return false; + } + + bool status = psMetadataAddImageMask(recipe, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue); + return status; +} + + +// replace the named masks in the recipe with values in the header: +// replace only the names in the header in the recipe +bool pmConfigMaskReadHeader(pmConfig *config, const psMetadata *header) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + PS_ASSERT_METADATA_NON_NULL(header, false); + + bool status = false; + + psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe + if (!recipe) { + psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); + return false; + } + + // MASK.VALUE and MARK.VALUE aren't usually set in the recipe, but may be set in the header: create fake + // versions so that it won't complain later + if (!psMetadataLookup(recipe, "MASK.VALUE")) { + psMetadataAddImageMask(recipe, PS_LIST_TAIL, "MASK.VALUE", 0, "Bits to mask", 0); + } + if (!psMetadataLookup(recipe, "MARK.VALUE")) { + psMetadataAddImageMask(recipe, PS_LIST_TAIL, "MARK.VALUE", 0, "Bits for marking", 0); + } + + // How many mask values do we need to read? We raise an error if this is not found, + // unless the MASK.FORCE is set to true in the camera config + int nMask = psMetadataLookupS32(&status, header, "MSKNUM"); + if (!status) { + if (psMetadataLookupBool(&status, config->camera, "MASK.FORCE")) { + psWarning("No mask values in header. Assuming MASKS recipe is accurate because of MASK.FORCE"); + return true; + } + psError(PS_ERR_UNKNOWN, true, "Unable to find MSKNUM in header."); + return false; + } + + // Loop over the expected number of header mask names. For each named mask value, there + // should be a pair of header keywords, one for the name and one for the value + char namekey[80]; // Keyword name for symbolic name of mask entry + char valuekey[80]; // Keyword name for value of mask entry + for (int i = 0; i < nMask; i++) { + snprintf(namekey, 64, "MSKNAM%02d", i); + snprintf(valuekey, 64, "MSKVAL%02d", i); + + char *name = psMetadataLookupStr(&status, header, namekey); + if (!status || !name) { + psWarning("Unable to find header keyword %s when parsing mask", namekey); + continue; + } + + psImageMaskType headerValue = psMetadataLookupImageMaskFromGeneric (&status, header, valuekey); + if (!status) { + psWarning("Failed to get mask value %s from header, skipping", valuekey); + continue; + } + + // since we may read multiple mask files, we need to warn (or error?) if any of the + // header mask values conflict with other header mask values; However, the original + // mask values from the recipe do not need to match the header values. + + // when we add a header mask value, we will also add the NAME.ALREADY entry; check for + // the NAME.ALREADY entry to see if we have previously added this mask value from a + // header. + + psString nameAlready = NULL; // Name of key with ".ALREADY" added + psStringAppend(&nameAlready, "%s.ALREADY", name); + bool already = psMetadataLookupBool(&status, recipe, nameAlready); // Already read this one? + + bool inRecipe = false; + psImageMaskType recipeValue = psMetadataLookupImageMaskFromGeneric (&inRecipe, recipe, name); + if (!inRecipe) { + psWarning("Mask value %s is not defined in the recipe", name); + } + + if (already) { + assert (inRecipe); // XXX makes no sense for NAME.ALREADY to be in without NAME + if (recipeValue != headerValue) { + psWarning("New mask header value does not match previously loaded entry: %x vs %x", headerValue, recipeValue); + psMetadataAddImageMask(recipe, PS_LIST_TAIL, name, PS_META_REPLACE, "Bitmask bit value", headerValue); + // XXX alternatively, error here + } + } else { + psMetadataAddBool(recipe, PS_LIST_TAIL, nameAlready, 0, "Already read this mask value", true); + psMetadataAddImageMask(recipe, PS_LIST_TAIL, name, PS_META_REPLACE, "Bitmask bit value", headerValue); + } + + psFree(nameAlready); + } + + return true; +} + +// write the named mask bits to the header +bool pmConfigMaskWriteHeader(const pmConfig *config, psMetadata *header) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + PS_ASSERT_METADATA_NON_NULL(header, false); + + pmConfigMaskRemoveHeaderKeywords(header, "MSKNAM"); + pmConfigMaskRemoveHeaderKeywords(header, "MSKVAL"); + if (psMetadataLookup(header, "MSKNUM")) { + psMetadataRemoveKey(header, "MSKNUM"); + } + + char namekey[80]; + char valuekey[80]; + + psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe + if (!recipe) { + psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); + return false; + } + + int nMask = 0; + + psMetadataIterator *iter = psMetadataIteratorAlloc(recipe, PS_LIST_HEAD, NULL); // Iterator + psMetadataItem *item; // Item from iteration + while ((item = psMetadataGetAndIncrement(iter))) { + + // XXX this would give a false positive for mask which include '.ALREADY' in their names + char *ptr = strstr (item->name, ".ALREADY"); + if (ptr) continue; + + psU64 fullValue = 0; + switch (item->type) { + case PS_DATA_U8: + fullValue = item->data.U8; + break; + case PS_DATA_U16: + fullValue = item->data.U16; + break; + case PS_DATA_U32: + fullValue = item->data.U32; + break; + case PS_DATA_U64: + fullValue = item->data.U64; + break; + default: + psWarning("mask recipe entry %s is not a bit value\n", item->name); + continue; + } + assert (fullValue <= PS_MAX_IMAGE_MASK_TYPE); // this should have been asserted on read... + + snprintf(namekey, 64, "MSKNAM%02d", nMask); + snprintf(valuekey, 64, "MSKVAL%02d", nMask); + + psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name); + psMetadataAddImageMask(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", fullValue); + nMask++; + } + psFree(iter); + + psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Bitmask bit count", nMask); + return true; +} + + +bool pmConfigMaskSetBits(psImageMaskType *outMaskValue, psImageMaskType *outMarkValue, const pmConfig *config) +{ + PS_ASSERT_PTR_NON_NULL(config, false); + + psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe + if (!recipe) { + psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); + return false; + } + + bool status = pmConfigMaskSetInMetadata(outMaskValue, outMarkValue, recipe); + return status; +} + ////////////////////////////////////////////////////////////////////////////////////////////////////////////// // FPA version of mask functions. These are not ready to go yet. @@ -187,12 +426,48 @@ #if 0 -bool pmFPAMaskSetValues(psMaskType *outMaskValue, psMaskType *outMarkValue, pmFPA *fpa) -{ + +bool pmFPAMaskWriteHeader(psMetadata *header, const pmFPA *fpa) +{ + PS_ASSERT_METADATA_NON_NULL(header, false); PS_ASSERT_PTR_NON_NULL(fpa, false); + // clear out the header of the associated keywords: + pmConfigMaskRemoveHeaderKeywords(header, "MSKNAM"); + pmConfigMaskRemoveHeaderKeywords(header, "MSKVAL"); + if (psMetadataLookup(header, "MSKNUM")) { + psMetadataRemoveKey(header, "MSKNUM"); + } + + char namekey[80], valuekey[80]; // Mask name and mask value header keywords + int numMask = 0; // Number of mask entries + + psMetadataIterator *iter = psMetadataIteratorAlloc(fpa->masks, PS_LIST_HEAD, NULL); // Iterator + psMetadataItem *item; // Item from iteration + while ((item = psMetadataGetAndIncrement(iter))) { + if (item->type != PS_TYPE_IMAGE_MASK) { + psWarning("mask recipe entry %s is not of a mask type (%x)", item->name, item->type); + continue; + } + + snprintf(namekey, 64, "MSKNAM%02d", numMask); + snprintf(valuekey, 64, "MSKVAL%02d", numMask); + + psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name); + psMetadataAddImageMask(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", item->data.PS_TYPE_IMAGE_MASK_DATA); + numMask++; + } + psFree(iter); + + return psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Number of named mask entries", numMask); +} + +bool pmFPAMaskSetValues(psImageMaskType *outMaskValue, psImageMaskType *outMarkValue, pmFPA *fpa) +{ + PS_ASSERT_PTR_NON_NULL(fpa, false); + return maskSetValues(outMaskValue, outMarkValue, fpa->masks); } -psMaskType pmFPAMaskGet(const pmFPA *fpa, const char *masks, const pmConfig *config) +psImageMaskType pmFPAMaskGet(const pmFPA *fpa, const char *masks, const pmConfig *config) { PS_ASSERT_PTR_NON_NULL(fpa, 0); @@ -201,10 +476,10 @@ if (fpa->masks) { - return maskGet(fpa->masks, masks); + return pmConfigMaskGetFromMetadata(fpa->masks, masks); } return pmConfigMaskGet(masks, config); } -bool pmFPAMaskSet(pmFPA *fpa, const char *maskName, psMaskType maskValue) +bool pmFPAMaskSet(pmFPA *fpa, const char *maskName, psImageMaskType maskValue) { PS_ASSERT_PTR_NON_NULL(fpa, 0); @@ -214,5 +489,5 @@ fpa->masks = psMetadataAlloc(); } - return psMetadataAddU8(fpa->masks, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue); + return psMetadataAddImageMask(fpa->masks, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue); } @@ -250,5 +525,5 @@ continue; } - psU8 bit = psMetadataLookupU8(&mdok, header, valuekey); + psImageMaskType bit = psMetadataLookupImageMask(&mdok, header, valuekey); if (!mdok) { psWarning("Unable to find header keyword %s when parsing mask", namekey); @@ -260,12 +535,12 @@ psMetadataItem *item = psMetadataLookup(fpa->masks, name); // Item in recipe with current value if (item) { - psAssert(item->type == PS_TYPE_MASK, "Mask entry %s is not of a mask type (%x)", + psAssert(item->type == PS_TYPE_IMAGE_MASK, "Mask entry %s is not of a mask type (%x)", name, item->type); - if (item->data.PS_TYPE_MASK_DATA != bit) { + if (item->data.PS_TYPE_IMAGE_MASK_DATA != bit) { psWarning("New mask entry %s doesn't match previously loaded entry: %x vs %x", - name, bit, item->data.PS_TYPE_MASK_DATA); + name, bit, item->data.PS_TYPE_IMAGE_MASK_DATA); } } else { - psMetadataAddU8(fpa->masks, PS_LIST_TAIL, name, 0, NULL, bit); + psMetadataAddImageMask(fpa->masks, PS_LIST_TAIL, name, 0, NULL, bit); } } @@ -281,11 +556,11 @@ psMetadataItem *item; // Item from iteration while ((item = psMetadataGetAndIncrement(iter))) { - if (item->type != PS_TYPE_MASK) { + if (item->type != PS_TYPE_IMAGE_MASK) { psWarning("Recipe mask entry %s is not of a mask type (%x)", item->name, item->type); continue; } if (!psMetadataLookup(fpa->masks, item->name)) { - psMetadataAddU8(fpa->masks, PS_LIST_TAIL, item->name, 0, item->comment, - item->data.PS_TYPE_MASK_DATA); + psMetadataAddImageMask(fpa->masks, PS_LIST_TAIL, item->name, 0, item->comment, + item->data.PS_TYPE_IMAGE_MASK_DATA); } } @@ -294,220 +569,3 @@ return true; } - - -bool pmFPAMaskWriteHeader(psMetadata *header, const pmFPA *fpa) -{ - PS_ASSERT_METADATA_NON_NULL(header, false); - PS_ASSERT_PTR_NON_NULL(fpa, false); - - maskRemoveHeader(header, "MSKNAM"); - maskRemoveHeader(header, "MSKVAL"); - if (psMetadataLookup(header, "MSKNUM")) { - psMetadataRemoveKey(header, "MSKNUM"); - } - - char namekey[80], valuekey[80]; // Mask name and mask value header keywords - int numMask = 0; // Number of mask entries - - psMetadataIterator *iter = psMetadataIteratorAlloc(fpa->masks, PS_LIST_HEAD, NULL); // Iterator - psMetadataItem *item; // Item from iteration - while ((item = psMetadataGetAndIncrement(iter))) { - if (item->type != PS_TYPE_MASK) { - psWarning("mask recipe entry %s is not of a mask type (%x)", item->name, item->type); - continue; - } - - snprintf(namekey, 64, "MSKNAM%02d", numMask); - snprintf(valuekey, 64, "MSKVAL%02d", numMask); - - psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name); - psMetadataAddU8(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", item->data.PS_TYPE_MASK_DATA); - numMask++; - } - psFree(iter); - - return psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Number of named mask entries", numMask); -} - #endif - - -psMaskType pmConfigMaskGet(const char *masks, const pmConfig *config) -{ - psAssert(config, "Require configuration"); - PS_ASSERT_STRING_NON_EMPTY(masks, 0); - - bool mdok; // Status of MD lookup - psMetadata *recipe = psMetadataLookupMetadata(&mdok, config->recipes, "MASKS"); // The recipe - if (!recipe) { - psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); - return 0; - } - return maskGet(recipe, masks); -} - - -bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psMaskType maskValue) -{ - psAssert(config, "Require configuration"); - PS_ASSERT_STRING_NON_EMPTY(maskName, false); - - psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe - if (!recipe) { - psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); - return false; - } - - return psMetadataAddU8(recipe, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue); -} - - -// replace the named masks in the recipe with values in the header: -// replace only the names in the header in the recipe -bool pmConfigMaskReadHeader(pmConfig *config, const psMetadata *header) -{ - PS_ASSERT_PTR_NON_NULL(config, false); - PS_ASSERT_METADATA_NON_NULL(header, false); - - bool status = false; - - psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe - if (!recipe) { - psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); - return false; - } - - // MASK.VALUE and MARK.VALUE aren't usually set in the recipe, but may be set in the header: create fake - // versions so that it won't complain later - if (!psMetadataLookup(recipe, "MASK.VALUE")) { - psMetadataAddU8(recipe, PS_LIST_TAIL, "MASK.VALUE", 0, "Bits to mask", 0); - } - if (!psMetadataLookup(recipe, "MARK.VALUE")) { - psMetadataAddU8(recipe, PS_LIST_TAIL, "MARK.VALUE", 0, "Bits for marking", 0); - } - - int nMask = psMetadataLookupS32(&status, header, "MSKNUM"); - if (!status) { - if (psMetadataLookupBool(&status, config->camera, "MASK.FORCE")) { - psWarning("No mask values in header. Assuming MASKS recipe is accurate because of MASK.FORCE"); - return true; - } - psError(PS_ERR_UNKNOWN, true, "Unable to find MSKNUM in header."); - return false; - } - - char namekey[80]; // Keyword name for symbolic name of mask entry - char valuekey[80]; // Keyword name for value of mask entry - for (int i = 0; i < nMask; i++) { - snprintf(namekey, 64, "MSKNAM%02d", i); - snprintf(valuekey, 64, "MSKVAL%02d", i); - - char *name = psMetadataLookupStr(&status, header, namekey); - if (!status || !name) { - psWarning("Unable to find header keyword %s when parsing mask", namekey); - continue; - } - psU8 bit = psMetadataLookupU8(&status, header, valuekey); - if (!status) { - psWarning("Unable to find header keyword %s when parsing mask", namekey); - continue; - } - - // XXX validate that bit is a 2^n value? - - psString nameAlready = NULL; // Name of key with ".ALREADY" added - psStringAppend(&nameAlready, "%s.ALREADY", name); - bool already = psMetadataLookupBool(&status, recipe, nameAlready); // Already read this one? - - psMetadataItem *item = psMetadataLookup(recipe, name); // Item in recipe with current value - if (item && item->type != PS_TYPE_MASK) { - psWarning("Mask recipe entry is not of a mask type (%x)", item->type); - item->type = PS_TYPE_MASK; - } - - if (already) { - if (item && item->data.U8 != bit) { - psWarning("New mask recipe entry doesn't match previously loaded entry: %x vs %x", - bit, item->data.U8); - } - } else { - psMetadataAddBool(recipe, PS_LIST_TAIL, nameAlready, 0, "Already read this mask value", true); - } - - if (!item) { - psWarning("Mask recipe entry %s not in recipe\n", name); - psMetadataAddU8(recipe, PS_LIST_TAIL, name, 0, "Bitmask bit value", bit); - } else { - item->data.U8 = bit; - } - - psFree(nameAlready); - } - - - return true; -} - - - -// write the named mask bits to the header -bool pmConfigMaskWriteHeader(const pmConfig *config, psMetadata *header) -{ - PS_ASSERT_PTR_NON_NULL(config, false); - PS_ASSERT_METADATA_NON_NULL(header, false); - - maskRemoveHeader(header, "MSKNAM"); - maskRemoveHeader(header, "MSKVAL"); - if (psMetadataLookup(header, "MSKNUM")) { - psMetadataRemoveKey(header, "MSKNUM"); - } - - char namekey[80]; - char valuekey[80]; - - psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe - if (!recipe) { - psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); - return false; - } - - int nMask = 0; - - psMetadataIterator *iter = psMetadataIteratorAlloc(recipe, PS_LIST_HEAD, NULL); // Iterator - psMetadataItem *item; // Item from iteration - while ((item = psMetadataGetAndIncrement(iter))) { - if (strcmp(item->name + strlen(item->name) - strlen(".ALREADY"), ".ALREADY") == 0) { - continue; - } - - if (item->type != PS_DATA_U8) { - psWarning("mask recipe entry %s is not a bit value\n", item->name); - continue; - } - - snprintf(namekey, 64, "MSKNAM%02d", nMask); - snprintf(valuekey, 64, "MSKVAL%02d", nMask); - - psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name); - psMetadataAddU8(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", item->data.U8); - nMask++; - } - psFree(iter); - - psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Bitmask bit count", nMask); - return true; -} - - -bool pmConfigMaskSetBits(psMaskType *outMaskValue, psMaskType *outMarkValue, const pmConfig *config) -{ - PS_ASSERT_PTR_NON_NULL(config, false); - - psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe - if (!recipe) { - psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe."); - return false; - } - - return maskSetValues(outMaskValue, outMarkValue, recipe); -} Index: trunk/psModules/src/config/pmConfigMask.h =================================================================== --- trunk/psModules/src/config/pmConfigMask.h (revision 21174) +++ trunk/psModules/src/config/pmConfigMask.h (revision 21183) @@ -4,6 +4,6 @@ * @author Paul Price, IfA * - * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-07-17 20:37:20 $ + * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2007 Institute for Astronomy, University of Hawaii */ @@ -20,12 +20,45 @@ /// @{ +// structure to hold the properties of a mask value +typedef struct { + char *badMaskName; // name for "bad" (i.e., mask me please) pixels + char *fallbackName; // Fallback name in case a bad mask name is not defined + psImageMaskType defaultMaskValue; // Default value in case a bad mask name and its fallback are not defined + bool isBad; // include this value as part of the MASK.VALUE entry (generically bad) +} pmConfigMaskInfo; + +// pmConfigMaskSetInMetadata examines named mask values and set the bits for maskValue and +// markValue. Ensures that the below-named mask values are set, and calculates the mask value +// to catch all of the mask values marked as 'bad'. Supplies the fallback name if the primary +// name is not found, or the default values if the fallback name is not found. +bool pmConfigMaskSetInMetadata(psImageMaskType *outMaskValue, // Value of MASK.VALUE, returned + psImageMaskType *outMarkValue, // Value of MARK.VALUE, returned + psMetadata *source // Source of mask bits + ); + + +// Get a mask value by name(s) +psImageMaskType pmConfigMaskGetFromMetadata(psMetadata *source, // Source of masks + const char *masks // Mask values to get + ); + + +// lookup an image mask value by name from a psMetadata, without requiring the entry to +// be of type psImageMaskType, but verifying that it will fit in psImageMaskType +psImageMaskType psMetadataLookupImageMaskFromGeneric (bool *status, const psMetadata *md, const char *name); + +// Remove from the header keywords starting with the provided string +int pmConfigMaskRemoveHeaderKeywords(psMetadata *header, // Header from which to remove keywords + const char *start // Remove keywords that start with this string + ); + /// Return a mask value given a list of symbolic names /// /// The mask values are derived from the MASKS recipe -psMaskType pmConfigMaskGet(const char *masks, ///< List of symbolic names, space/comma delimited +psImageMaskType pmConfigMaskGet(const char *masks, ///< List of symbolic names, space/comma delimited const pmConfig *config ///< Configuration ); -bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psMaskType maskValue); +bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psImageMaskType maskValue); // replace the named masks in the recipe with values in the header: @@ -36,5 +69,5 @@ bool pmConfigMaskWriteHeader(const pmConfig *config, psMetadata *header); -bool pmConfigMaskSetBits(psMaskType *outMaskValue, psMaskType *outMarkValue, const pmConfig *config); +bool pmConfigMaskSetBits(psImageMaskType *outMaskValue, psImageMaskType *outMarkValue, const pmConfig *config); #endif Index: trunk/psModules/src/detrend/pmBias.c =================================================================== --- trunk/psModules/src/detrend/pmBias.c (revision 21174) +++ trunk/psModules/src/detrend/pmBias.c (revision 21183) @@ -45,5 +45,5 @@ inImage->data.F32[i][j] -= subImage->data.F32[i+yOffset][j+xOffset]; if (inMask && subMask) { - inMask->data.U8[i][j] |= subMask->data.U8[i+yOffset][j+xOffset]; + inMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] |= subMask->data.PS_TYPE_IMAGE_MASK_DATA[i+yOffset][j+xOffset]; } } @@ -54,5 +54,5 @@ inImage->data.F32[i][j] -= subImage->data.F32[i+yOffset][j+xOffset] * scale; if (inMask && subMask) { - inMask->data.U8[i][j] |= subMask->data.U8[i+yOffset][j+xOffset]; + inMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] |= subMask->data.PS_TYPE_IMAGE_MASK_DATA[i+yOffset][j+xOffset]; } } Index: trunk/psModules/src/detrend/pmDark.c =================================================================== --- trunk/psModules/src/detrend/pmDark.c (revision 21174) +++ trunk/psModules/src/detrend/pmDark.c (revision 21183) @@ -103,5 +103,5 @@ { psArray *values = psArrayAlloc(inputs->n); - psVector *roMask = psVectorAlloc(inputs->n, PS_TYPE_U8); // Mask for bad readouts + psVector *roMask = psVectorAlloc(inputs->n, PS_TYPE_VECTOR_MASK); // Mask for bad readouts psVector *norm = normConcept ? psVectorAlloc(inputs->n, PS_TYPE_F32) : NULL; // Normalizations for each psVector *orders = psVectorAlloc(ordinates->n, PS_TYPE_U8); // Orders for each concept @@ -121,5 +121,5 @@ if (!ordinateLookup(&normValue, &inRange, normConcept, false, NAN, NAN, readout)) { psWarning("Unable to find value of %s for readout %d", normConcept, i); - roMask->data.U8[i] = 0xff; + roMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff; norm->data.F32[i] = NAN; numBadInputs++; @@ -128,5 +128,5 @@ if (normValue == 0.0) { psWarning("Normalisation value (%s) for readout %d is zero", normConcept, i); - roMask->data.U8[i] = 0xff; + roMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff; norm->data.F32[i] = NAN; numBadInputs++; @@ -151,5 +151,5 @@ for (int j = 0; j < inputs->n; j++) { psVector *val = values->data[j]; // Value vector for readout - if (roMask->data.U8[j]) { + if (roMask->data.PS_TYPE_VECTOR_MASK_DATA[j]) { val->data.F32[i] = NAN; continue; @@ -159,5 +159,5 @@ float value = NAN; // Value of ordinate if (!ordinateLookup(&value, &inRange, ord->name, ord->scale, ord->min, ord->max, readout)) { - roMask->data.U8[j] = 0xff; + roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff; val->data.F32[i] = NAN; numBadInputs++; @@ -165,5 +165,5 @@ } if (!inRange) { - roMask->data.U8[j] = 0xff; + roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff; val->data.F32[i] = NAN; numBadInputs++; @@ -263,5 +263,5 @@ // do the combine work for this portion of the output (range is set by input data) -bool pmDarkCombine(pmCell *output, const psArray *inputs, int iter, float rej, psMaskType maskVal) +bool pmDarkCombine(pmCell *output, const psArray *inputs, int iter, float rej, psImageMaskType maskVal) { PS_ASSERT_PTR_NON_NULL(output, false); @@ -314,5 +314,5 @@ // Iterate over pixels, fitting polynomial psVector *pixels = psVectorAlloc(inputs->n, PS_TYPE_F32); // Stack of pixels - psVector *mask = psVectorAlloc(inputs->n, PS_TYPE_MASK); // Mask for stack + psVector *mask = psVectorAlloc(inputs->n, PS_TYPE_VECTOR_MASK); // Mask for stack for (int i = minInputRows; i < maxInputRows; i++) { int yOut = i - outReadout->row0; // y position on output readout @@ -330,6 +330,6 @@ psVectorInit(mask, 0); for (int r = 0; r < inputs->n; r++) { - if (roMask->data.U8[r]) { - mask->data.PS_TYPE_MASK_DATA[r] = 0xff; + if (roMask->data.PS_TYPE_VECTOR_MASK_DATA[r]) { + mask->data.PS_TYPE_VECTOR_MASK_DATA[r] = 0xff; continue; } @@ -343,10 +343,10 @@ } 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 (!psPolynomialMDClipFit(poly, pixels, NULL, mask, maskVal, values, iter, rej)) { + if (!psPolynomialMDClipFit(poly, pixels, NULL, mask, 0xff, values, iter, rej)) { psErrorClear(); // Nothing we can do about it psVectorInit(poly->coeff, NAN); @@ -376,5 +376,5 @@ const psVector *values = job->args->data[3]; // Values for each ordinate - psMaskType bad = PS_SCALAR_VALUE(job->args->data[4], U8); // Mask value to give bad pixels + psImageMaskType bad = PS_SCALAR_VALUE(job->args->data[4], PS_TYPE_IMAGE_MASK_DATA); // Mask value to give bad pixels bool doNorm = PS_SCALAR_VALUE(job->args->data[5], U8); // Normalise values? float norm = PS_SCALAR_VALUE(job->args->data[6], F32); // Value by which to normalise @@ -386,5 +386,5 @@ bool pmDarkApplyScan(pmReadout *readout, const pmCell *dark, const psVector *orders, const psVector *values, - psMaskType bad, bool doNorm, float norm, int rowStart, int rowStop) + psImageMaskType bad, bool doNorm, float norm, int rowStart, int rowStop) { int numCols = readout->image->numCols; @@ -405,5 +405,5 @@ readout->image->data.F32[y][x] -= value; if (readout->mask && !isfinite(value)) { - readout->mask->data.PS_TYPE_MASK_DATA[y][x] = bad; + readout->mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = bad; } } @@ -414,5 +414,5 @@ } -bool pmDarkApply(pmReadout *readout, pmCell *dark, psMaskType bad) +bool pmDarkApply(pmReadout *readout, pmCell *dark, psImageMaskType bad) { PS_ASSERT_PTR_NON_NULL(readout, false); @@ -424,5 +424,5 @@ PS_ASSERT_IMAGE_NON_NULL(readout->mask, false); PS_ASSERT_IMAGES_SIZE_EQUAL(readout->mask, readout->image, false); - PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_IMAGE_MASK, false); } int numTerms = dark->readouts->n; // Number of polynomial terms @@ -496,5 +496,5 @@ psArrayAdd(job->args, 1, orders); psArrayAdd(job->args, 1, values); - PS_ARRAY_ADD_SCALAR(job->args, bad, PS_TYPE_MASK); + PS_ARRAY_ADD_SCALAR(job->args, bad, PS_TYPE_IMAGE_MASK); PS_ARRAY_ADD_SCALAR(job->args, doNorm, PS_TYPE_U8); PS_ARRAY_ADD_SCALAR(job->args, norm, PS_TYPE_F32); Index: trunk/psModules/src/detrend/pmDark.h =================================================================== --- trunk/psModules/src/detrend/pmDark.h (revision 21174) +++ trunk/psModules/src/detrend/pmDark.h (revision 21183) @@ -37,5 +37,5 @@ int iter, // Number of rejection iterations float rej, // Rejection threshold (standard deviations) - psMaskType maskVal // Value to mask + psImageMaskType maskVal // Value to mask ); @@ -49,5 +49,5 @@ const psVector *orders, // Polynomial orders for each ordinate const psVector *values, // Values for each ordinate - psMaskType bad, // Value to give bad pixels + psImageMaskType bad, // Value to give bad pixels bool doNorm, // Normalise values? float norm, // Value by which to normalise @@ -58,5 +58,5 @@ bool pmDarkApply(pmReadout *readout, // Readout to which to apply dark pmCell *dark, // Dark to apply - psMaskType bad // Mask value to give bad pixels + psImageMaskType bad // Mask value to give bad pixels ); Index: trunk/psModules/src/detrend/pmFlatField.c =================================================================== --- trunk/psModules/src/detrend/pmFlatField.c (revision 21174) +++ trunk/psModules/src/detrend/pmFlatField.c (revision 21183) @@ -22,5 +22,5 @@ const psImage *flatMask = job->args->data[3]; // Flat-field mask - psMaskType badFlat = PS_SCALAR_VALUE(job->args->data[4],U8); + psImageMaskType badFlat = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA); int xOffset = PS_SCALAR_VALUE(job->args->data[5],S32); int yOffset = PS_SCALAR_VALUE(job->args->data[6],S32); @@ -38,7 +38,7 @@ ps##TYPE flatValue = flatImage->data.TYPE[j + yOffset][i + xOffset]; \ if (!isfinite(flatValue) || flatValue <= 0.0 || \ - (flatMask && flatMask->data.U8[j + yOffset][i + xOffset])) { \ + (flatMask && flatMask->data.PS_TYPE_IMAGE_MASK_DATA[j + yOffset][i + xOffset])) { \ if (inMask) { \ - inMask->data.PS_TYPE_MASK_DATA[j][i] |= badFlat; \ + inMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= badFlat; \ } \ inImage->data.TYPE[j][i] = SPECIAL; \ @@ -51,5 +51,5 @@ bool pmFlatFieldScan(psImage *inImage, psImage *inMask, const psImage *flatImage, const psImage *flatMask, - psMaskType badFlat, int xOffset, int yOffset, int rowStart, int rowStop) + psImageMaskType badFlat, int xOffset, int yOffset, int rowStart, int rowStop) { switch (inImage->type.type) { @@ -72,5 +72,5 @@ } -bool pmFlatField(pmReadout *in, const pmReadout *flat, psMaskType badFlat) +bool pmFlatField(pmReadout *in, const pmReadout *flat, psImageMaskType badFlat) { PS_ASSERT_PTR_NON_NULL(in, false); @@ -81,10 +81,10 @@ PS_ASSERT_IMAGE_NON_EMPTY(flat->image, false); if (in->mask) { - PS_ASSERT_IMAGE_TYPE(in->mask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(in->mask, PS_TYPE_IMAGE_MASK, false); PS_ASSERT_IMAGES_SIZE_EQUAL(in->mask, in->image, false); } PS_ASSERT_IMAGE_TYPE(flat->image, in->image->type.type, false); if (flat->mask) { - PS_ASSERT_IMAGE_TYPE(flat->mask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(flat->mask, PS_TYPE_IMAGE_MASK, false); PS_ASSERT_IMAGES_SIZE_EQUAL(flat->mask, flat->image, false); } @@ -148,5 +148,5 @@ psArrayAdd(job->args, 1, flatImage); psArrayAdd(job->args, 1, flatMask); - PS_ARRAY_ADD_SCALAR(job->args, badFlat, PS_TYPE_U8); + PS_ARRAY_ADD_SCALAR(job->args, badFlat, PS_TYPE_IMAGE_MASK); PS_ARRAY_ADD_SCALAR(job->args, xOffset, PS_TYPE_S32); PS_ARRAY_ADD_SCALAR(job->args, yOffset, PS_TYPE_S32); Index: trunk/psModules/src/detrend/pmFlatField.h =================================================================== --- trunk/psModules/src/detrend/pmFlatField.h (revision 21174) +++ trunk/psModules/src/detrend/pmFlatField.h (revision 21183) @@ -5,6 +5,6 @@ * @author Paul Price, IfA * - * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-09-09 04:10:14 $ + * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004-2006 Institute for Astronomy, University of Hawaii */ @@ -25,5 +25,5 @@ bool pmFlatField(pmReadout *in, ///< Readout with input image const pmReadout *flat, ///< Readout with flat image - psMaskType badFlat ///< Mask value to give bad flat pixels + psImageMaskType badFlat ///< Mask value to give bad flat pixels ); @@ -38,5 +38,5 @@ const psImage *flatImage, ///< Flat-field image const psImage *flatMask, ///< Flat-field mask - psMaskType badFlag, ///< Mask value to give bad pixels + psImageMaskType badFlag, ///< Mask value to give bad pixels int xOffset, int yOffset, ///< Offset between input and flat-field int rowStart, int rowStop ///< Scan range Index: trunk/psModules/src/detrend/pmFlatNormalize.c =================================================================== --- trunk/psModules/src/detrend/pmFlatNormalize.c (revision 21174) +++ trunk/psModules/src/detrend/pmFlatNormalize.c (revision 21183) @@ -9,4 +9,6 @@ #include "pmFlatNormalize.h" + +// XXX this function should take the abstract mask names and set bad values in a more precise way // I'm not sure that many many iterations are required, but rather suspect that the system converges within a @@ -55,9 +57,9 @@ // Take the logarithms psImage *flux = psImageCopy(NULL, bgMatrix, PS_TYPE_F32); // Copy of the input flux levels matrix - psImage *fluxMask = psImageAlloc(numChips, numExps, PS_TYPE_U8); // Mask for bad measurements + psImage *fluxMask = psImageAlloc(numChips, numExps, PS_TYPE_IMAGE_MASK); // Mask for bad measurements psImageInit(fluxMask, 0); - psVector *gainMask = psVectorAlloc(numChips, PS_TYPE_U8); // Mask for bad gains + psVector *gainMask = psVectorAlloc(numChips, PS_TYPE_VECTOR_MASK); // Mask for bad gains psVectorInit(gainMask, 0); - psVector *expMask = psVectorAlloc(numExps, PS_TYPE_U8); // Mask for bad exposures + psVector *expMask = psVectorAlloc(numExps, PS_TYPE_VECTOR_MASK); // Mask for bad exposures psVectorInit(expMask, 0); for (int i = 0; i < numChips; i++) { @@ -75,5 +77,5 @@ } else { // Blank out this measurement - fluxMask->data.U8[j][i] = 1; + fluxMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] = 1; flux->data.F32[j][i] = NAN; } @@ -90,5 +92,5 @@ int numFluxes = 0; // Number of fluxes for (int i = 0; i < numExps; i++) { - if (expMask->data.U8[i]) { + if (expMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { psTrace("psModules.detrend", 7, "Flux for exposure %d is masked.\n", i); continue; @@ -98,5 +100,5 @@ int number = 0; // Number of chips contributing for (int j = 0; j < numChips; j++) { - if (!gainMask->data.U8[j] && !fluxMask->data.U8[i][j]) { + if (!gainMask->data.PS_TYPE_VECTOR_MASK_DATA[j] && !fluxMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) { sum += flux->data.F32[i][j] - chipGains->data.F32[j]; number++; @@ -106,5 +108,5 @@ expFluxes->data.F32[i] = sum / (float)number; } else { - expMask->data.U8[i] = 1; + expMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1; expFluxes->data.F32[i] = NAN; } @@ -116,5 +118,5 @@ int numGains = 0; // Number of gains for (int i = 0; i < numChips; i++) { - if (gainMask->data.U8[i]) { + if (gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { continue; } @@ -122,5 +124,5 @@ int number = 0; // Numer of sources contributing for (int j = 0; j < numExps; j++) { - if (!fluxMask->data.U8[j][i]) { + if (!fluxMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i]) { sum += flux->data.F32[j][i] - expFluxes->data.F32[j]; number++; @@ -130,5 +132,5 @@ chipGains->data.F32[i] = sum / (float)number; } else { - gainMask->data.U8[i] = 1; + gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1; chipGains->data.F32[i] = NAN; } @@ -144,5 +146,5 @@ diff = 0.0; for (int i = 0; i < numChips; i++) { - if (gainMask->data.U8[i]) { + if (gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { continue; } @@ -151,5 +153,5 @@ } for (int i = 0; i < numExps; i++) { - if (expMask->data.U8[i]) { + if (expMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { continue; } @@ -171,10 +173,10 @@ // Un-log the vectors for (int i = 0; i < numChips; i++) { - if (!gainMask->data.U8[i]) { + if (!gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { chipGains->data.F32[i] = expf(chipGains->data.F32[i]); } } for (int i = 0; i < numExps; i++) { - if (!expMask->data.U8[i]) { + if (!expMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { expFluxes->data.F32[i] = expf(expFluxes->data.F32[i]); } Index: trunk/psModules/src/detrend/pmFringeStats.c =================================================================== --- trunk/psModules/src/detrend/pmFringeStats.c (revision 21174) +++ trunk/psModules/src/detrend/pmFringeStats.c (revision 21183) @@ -70,5 +70,5 @@ fringe->x = psVectorRecycle(fringe->x, fringe->nRequested, PS_TYPE_F32); fringe->y = psVectorRecycle(fringe->y, fringe->nRequested, PS_TYPE_F32); - fringe->mask = psVectorRecycle(fringe->mask, fringe->nRequested, PS_TYPE_U8); + fringe->mask = psVectorRecycle(fringe->mask, fringe->nRequested, PS_TYPE_VECTOR_MASK); fringe->x->n = fringe->y->n = fringe->mask->n = fringe->nRequested; psVectorInit(fringe->mask, 0); @@ -115,5 +115,5 @@ if (mask) { PS_ASSERT_VECTOR_NON_NULL(mask, false); - PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false); + PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false); PS_ASSERT_VECTOR_SIZE(mask, (long)numRows, false); } @@ -142,9 +142,9 @@ psMetadataAddF32(row, PS_LIST_TAIL, "x", PS_META_REPLACE, "Fringe position in x", x->data.F32[i]); psMetadataAddF32(row, PS_LIST_TAIL, "y", PS_META_REPLACE, "Fringe position in y", y->data.F32[i]); - psU8 maskValue = 0; - if (mask && mask->data.U8[i]) { + psVectorMaskType maskValue = 0; + if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { maskValue = 0xff; } - psMetadataAddU8(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue); + psMetadataAddVectorMask(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue); table->data[i] = row; } @@ -207,11 +207,11 @@ psVector *x = psVectorAlloc(numRows, PS_TYPE_F32); // x position psVector *y = psVectorAlloc(numRows, PS_TYPE_F32); // y position - psVector *mask = psVectorAlloc(numRows, PS_TYPE_U8); // mask + psVector *mask = psVectorAlloc(numRows, PS_TYPE_VECTOR_MASK); // mask regions->x = x; regions->y = y; regions->mask = mask; - #define READ_REGIONS_ROW(VECTOR, TYPE, NAME, DESCRIPTION) \ - VECTOR->data.TYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \ + #define READ_REGIONS_ROW(VECTOR, TYPE, DATATYPE, NAME, DESCRIPTION) \ + VECTOR->data.DATATYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \ if (!mdok) { \ psError(PS_ERR_IO, true, "Unable to find " #DESCRIPTION " .\n"); \ @@ -224,7 +224,7 @@ for (long i = 0; i < numRows; i++) { psMetadata *row = table->data[i]; // Table row - READ_REGIONS_ROW(x, F32, "x", "x position"); - READ_REGIONS_ROW(y, F32, "y", "y position"); - READ_REGIONS_ROW(mask, U8, "mask", "mask"); + READ_REGIONS_ROW(x, F32, F32, "x", "x position"); + READ_REGIONS_ROW(y, F32, F32, "y", "y position"); + READ_REGIONS_ROW(mask, VectorMask, PS_TYPE_VECTOR_MASK_DATA, "mask", "mask"); } psFree(table); @@ -259,5 +259,5 @@ } -pmFringeStats *pmFringeStatsMeasure(pmFringeRegions *fringe, const pmReadout *readout, psMaskType maskVal) +pmFringeStats *pmFringeStatsMeasure(pmFringeRegions *fringe, const pmReadout *readout, psImageMaskType maskVal) { PS_ASSERT_PTR_NON_NULL(fringe, NULL); @@ -490,5 +490,5 @@ newRegions->x = psVectorAlloc(numPoints, PS_TYPE_F32); newRegions->y = psVectorAlloc(numPoints, PS_TYPE_F32); - newRegions->mask = psVectorAlloc(numPoints, PS_TYPE_U8); + newRegions->mask = psVectorAlloc(numPoints, PS_TYPE_VECTOR_MASK); pmFringeStats *newStats = pmFringeStatsAlloc(newRegions); // The new list of statistics @@ -500,5 +500,5 @@ memcpy(&newRegions->x->data.F32[offset], regions->x->data.F32, regions->x->n * sizeof(psF32)); memcpy(&newRegions->y->data.F32[offset], regions->y->data.F32, regions->y->n * sizeof(psF32)); - memcpy(&newRegions->mask->data.U8[offset], regions->mask->data.U8, regions->mask->n * sizeof(psU8)); + memcpy(&newRegions->mask->data.PS_TYPE_VECTOR_MASK_DATA[offset], regions->mask->data.PS_TYPE_VECTOR_MASK_DATA, regions->mask->n * sizeof(psVectorMaskType)); memcpy(&newStats->f->data.F32[offset], fringe->f->data.F32, fringe->f->n * sizeof(psF32)); memcpy(&newStats->df->data.F32[offset], fringe->df->data.F32, fringe->df->n * sizeof(psF32)); @@ -549,5 +549,5 @@ if (mask) { PS_ASSERT_VECTOR_NON_NULL(mask, false); - PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false); + PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false); PS_ASSERT_VECTOR_SIZE(mask, (long)numRows, false); } @@ -580,6 +580,6 @@ psMetadataAddF32(row, PS_LIST_TAIL, "x", PS_META_REPLACE, "Fringe position in x", x->data.F32[i]); psMetadataAddF32(row, PS_LIST_TAIL, "y", PS_META_REPLACE, "Fringe position in y", y->data.F32[i]); - psU8 maskValue = 0; // Mask value - if (mask && mask->data.U8[i]) { + psVectorMaskType maskValue = 0; // Mask value + if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { maskValue = 0xff; } @@ -601,5 +601,5 @@ psFree(df); - psMetadataAddU8(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue); + psMetadataAddVectorMask(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue); table->data[i] = row; } @@ -648,5 +648,5 @@ psVector *x = psVectorAlloc(numRows, PS_TYPE_F32); // x position psVector *y = psVectorAlloc(numRows, PS_TYPE_F32); // y position - psVector *mask = psVectorAlloc(numRows, PS_TYPE_U8); // mask + psVector *mask = psVectorAlloc(numRows, PS_TYPE_VECTOR_MASK); // mask regions->x = x; regions->y = y; @@ -656,7 +656,7 @@ psArray *fringes = NULL; // Array of fringes, to return - #define READ_FRINGES_VECTOR_ROW(VECTOR, TYPE, NAME, DESCRIPTION) \ + #define READ_FRINGES_VECTOR_ROW(VECTOR, TYPE, DATATYPE, NAME, DESCRIPTION) \ { \ - VECTOR->data.TYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \ + VECTOR->data.DATATYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \ if (!mdok) { \ psError(PS_ERR_IO, true, "Unable to find " #DESCRIPTION " for row %ld.\n", i); \ @@ -686,10 +686,11 @@ } + // XXX : need to extend this to support arbitrary types for the vectors on disk // Translate the table into vectors for (long i = 0; i < numRows; i++) { psMetadata *row = table->data[i]; // Table row - READ_FRINGES_VECTOR_ROW(x, F32, "x", "x position"); - READ_FRINGES_VECTOR_ROW(y, F32, "y", "y position"); - READ_FRINGES_VECTOR_ROW(mask, U8, "mask", "mask"); + READ_FRINGES_VECTOR_ROW(x, F32, F32, "x", "x position"); + READ_FRINGES_VECTOR_ROW(y, F32, F32, "y", "y position"); + READ_FRINGES_VECTOR_ROW(mask, VectorMask, PS_TYPE_VECTOR_MASK_DATA, "mask", "mask"); READ_FRINGES_ARRAY_ROW(f, F32, "f", "fringe measurement"); READ_FRINGES_ARRAY_ROW(df, F32, "df", "fringe error"); @@ -782,5 +783,5 @@ double matrix = 0.0; // The matrix sum for (int k = 0; k < numPoints; k++) { - if (!mask->data.U8[k]) { + if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[k]) { psF32 f1 = (fringe1) ? fringe1->data.F32[k] : 1.0; // Contribution from i fringe psF32 f2 = (fringe2) ? fringe2->data.F32[k] : 1.0; // Contribution from j fringe @@ -799,5 +800,5 @@ double vector = 0.0; // The vector sum for (int k = 0; k < numPoints; k++) { - if (!mask->data.U8[k]) { + if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[k]) { psF32 f1 = (fringe1) ? fringe1->data.F32[k] : 1.0; // Contribution from fringe 1 psF32 s = science->f->data.F32[k]; // Contribution from science measurement @@ -855,5 +856,5 @@ for (int i = 0; i < diff->n; i++) { - if (!mask->data.U8[i]) { + if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { float difference = science->f->data.F32[i] - scale->coeff->data.F32[0]; for (int j = 0; j < fringes->n; j++) { @@ -877,5 +878,5 @@ assert(diffs->type.type == PS_TYPE_F32); assert(mask); - assert(mask->type.type == PS_TYPE_U8); + assert(mask->type.type == PS_TYPE_VECTOR_MASK); assert(diffs->n == mask->n); @@ -888,8 +889,8 @@ int numClipped = 0; // Number clipped for (int i = 0; i < diffs->n; i++) { - psTrace("psModules.detrend", 10, "Region %d (%d): %f\n", i, mask->data.U8[i], diffs->data.F32[i]); - if (!mask->data.U8[i] && fabs(diffs->data.F32[i]) > middle + thresh) { + psTrace("psModules.detrend", 10, "Region %d (%d): %f\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i], diffs->data.F32[i]); + if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[i] && fabs(diffs->data.F32[i]) > middle + thresh) { psTrace("psModules.detrend", 5, "Masking %d: %f\n", i, diffs->data.F32[i]); - mask->data.U8[i] = 1; + mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1; numClipped++; } @@ -931,5 +932,5 @@ // Set up the mask if (!regions->mask) { - regions->mask = psVectorAlloc(numRegions, PS_TYPE_U8); + regions->mask = psVectorAlloc(numRegions, PS_TYPE_VECTOR_MASK); psVectorInit(regions->mask, 0); } @@ -946,5 +947,5 @@ for (int j = 0; j < numRegions; j++) { if (!isfinite(fringe->f->data.F32[j])) { - mask->data.U8[j] = 1; + mask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 1; psTrace("psModules.detrend", 9, "Masking region %d because not finite in fringe %d.\n", j, i); } @@ -956,5 +957,5 @@ FILE *f = fopen ("fringe.dat", "w"); for (int j = 0; j < numRegions; j++) { - if (mask->data.U8[j]) continue; + if (mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) continue; fprintf (f, "%d %f %f ", j, science->f->data.F32[j], science->df->data.F32[j]); for (int i = 0; i < fringes->n; i++) { @@ -1014,5 +1015,5 @@ // XXX note that this modifies the input fringe images psImage *pmFringeCorrect(pmReadout *readout, pmFringeRegions *fringes, psArray *fringeImages, - psArray *fringeStats, psMaskType maskVal, float rej, + psArray *fringeStats, psImageMaskType maskVal, float rej, unsigned int nIter, float keepFrac) { Index: trunk/psModules/src/detrend/pmFringeStats.h =================================================================== --- trunk/psModules/src/detrend/pmFringeStats.h (revision 21174) +++ trunk/psModules/src/detrend/pmFringeStats.h (revision 21183) @@ -5,6 +5,6 @@ * @author Paul Price, IfA * - * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-01-24 02:54:15 $ + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004-2006 Institute for Astronomy, University of Hawaii */ @@ -102,5 +102,5 @@ pmFringeStats *pmFringeStatsMeasure(pmFringeRegions *fringe, ///< Fringe regions at which to measure const pmReadout *readout, ///< Readout for which to measure - psMaskType maskVal ///< Mask value for image + psImageMaskType maskVal ///< Mask value for image ); @@ -206,5 +206,5 @@ psArray *fringeImages, ///< Fringe template images to use in correction psArray *fringeStats, ///< Fringe stats (for templates) to use in correction - psMaskType maskVal, ///< Value to mask for science image + psImageMaskType maskVal, ///< Value to mask for science image float rej, ///< Rejection threshold, for pmFringeScaleMeasure unsigned int nIter, ///< Maximum number of iterations, for pmFringeScaleMeasure Index: trunk/psModules/src/detrend/pmMaskBadPixels.c =================================================================== --- trunk/psModules/src/detrend/pmMaskBadPixels.c (revision 21174) +++ trunk/psModules/src/detrend/pmMaskBadPixels.c (revision 21183) @@ -14,13 +14,13 @@ #include "pmMaskBadPixels.h" -bool pmMaskBadPixels(pmReadout *input, const pmReadout *mask, psMaskType maskVal) +bool pmMaskBadPixels(pmReadout *input, const pmReadout *mask, psImageMaskType maskVal) { PS_ASSERT_PTR_NON_NULL(input, false); PS_ASSERT_PTR_NON_NULL(input->mask, false); - PS_ASSERT_IMAGE_TYPE(input->mask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(input->mask, PS_TYPE_IMAGE_MASK, false); PS_ASSERT_PTR_NON_NULL(mask, false); PS_ASSERT_PTR_NON_NULL(mask->mask, false); - PS_ASSERT_IMAGE_TYPE(mask->mask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(mask->mask, PS_TYPE_IMAGE_MASK, false); psImage *inMask = input->mask; @@ -53,7 +53,7 @@ int offRow = input->row0 - mask->row0; - // masks are both of type PS_TYPE_MASK - psMaskType **exVal = exMask->data.U8; - psMaskType **inVal = inMask->data.U8; + // masks are both of type PS_TYPE_IMAGE_MASK + psImageMaskType **exVal = exMask->data.PS_TYPE_IMAGE_MASK_DATA; + psImageMaskType **inVal = inMask->data.PS_TYPE_IMAGE_MASK_DATA; // apply exMask values @@ -82,5 +82,5 @@ bool pmMaskFlagSuspectPixels(pmReadout *output, const pmReadout *readout, float median, float stdev, - float rej, psMaskType maskVal) + float rej, psImageMaskType maskVal) { PS_ASSERT_PTR_NON_NULL(readout, false); @@ -92,5 +92,5 @@ PS_ASSERT_IMAGE_NON_EMPTY(readout->mask, false); PS_ASSERT_IMAGES_SIZE_EQUAL(readout->image, readout->mask, false); - PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_IMAGE_MASK, false); } PS_ASSERT_PTR_NON_NULL(output, false); @@ -128,5 +128,5 @@ for (int x = 0; x < image->numCols; x++) { if (fabs((image->data.F32[y][x] - median) / stdev) < rej) continue; - if (mask && (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal)) continue; + if (mask && (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal)) continue; suspect->data.F32[y][x] += 1.0; } @@ -142,5 +142,5 @@ // the maskVal supplied here is the value SET for this mask (ie, it is not used to avoid pixels) -bool pmMaskIdentifyBadPixels(pmReadout *output, psMaskType maskVal, float thresh, pmMaskIdentifyMode mode) +bool pmMaskIdentifyBadPixels(pmReadout *output, psImageMaskType maskVal, float thresh, pmMaskIdentifyMode mode) { PS_ASSERT_PTR_NON_NULL(output, false); @@ -155,7 +155,7 @@ PS_ASSERT_IMAGE_NON_EMPTY(output->mask, false); PS_ASSERT_IMAGES_SIZE_EQUAL(output->mask, suspects, false); - PS_ASSERT_IMAGE_TYPE(output->mask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(output->mask, PS_TYPE_IMAGE_MASK, false); } else { - output->mask = psImageAlloc(suspects->numCols, suspects->numRows, PS_TYPE_MASK); + output->mask = psImageAlloc(suspects->numCols, suspects->numRows, PS_TYPE_IMAGE_MASK); } int num = psMetadataLookupS32(NULL, output->analysis, PM_MASK_ANALYSIS_NUM); // Number of inputs @@ -246,5 +246,5 @@ for (int x = 0; x < suspects->numCols; x++) { if (suspects->data.F32[y][x] >= limit) { - badpix->data.PS_TYPE_MASK_DATA[y][x] = maskVal; + badpix->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = maskVal; } } Index: trunk/psModules/src/detrend/pmMaskBadPixels.h =================================================================== --- trunk/psModules/src/detrend/pmMaskBadPixels.h (revision 21174) +++ trunk/psModules/src/detrend/pmMaskBadPixels.h (revision 21183) @@ -5,6 +5,6 @@ * @author Eugene Magnier, IfA * - * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-03-29 03:10:17 $ + * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Institute for Astronomy, University of Hawaii */ @@ -40,5 +40,5 @@ bool pmMaskBadPixels(pmReadout *input, ///< Input science image const pmReadout *mask, ///< Mask image to apply - psMaskType maskVal ///< Mask value to apply + psImageMaskType maskVal ///< Mask value to apply ); @@ -56,5 +56,5 @@ float stdev, ///< Image standard deviation float rej, ///< Rejection threshold (standard deviations) - psMaskType maskVal ///< Mask value for statistics + psImageMaskType maskVal ///< Mask value for statistics ); @@ -64,5 +64,5 @@ /// according to the chosen mode. bool pmMaskIdentifyBadPixels(pmReadout *output, ///< Output readout, with suspect pixels imageOut - psMaskType maskVal, ///< Value to set for bad pixels + psImageMaskType maskVal, ///< Value to set for bad pixels float thresh, ///< Threshold for bad pixel pmMaskIdentifyMode mode ///< Mode for identifying bad pixels Index: trunk/psModules/src/detrend/pmOverscan.c =================================================================== --- trunk/psModules/src/detrend/pmOverscan.c (revision 21174) +++ trunk/psModules/src/detrend/pmOverscan.c (revision 21183) @@ -67,10 +67,10 @@ psVector *reduced = psVectorAlloc(pixels->n, PS_TYPE_F32); // Overscan for each row psVector *ordinate = psVectorAlloc(pixels->n, PS_TYPE_F32); // Ordinate - psVector *mask = psVectorAlloc(pixels->n, PS_TYPE_U8); // Mask for fitting + psVector *mask = psVectorAlloc(pixels->n, PS_TYPE_VECTOR_MASK); // Mask for fitting for (int i = 0; i < pixels->n; i++) { psVector *values = pixels->data[i]; // Vector with overscan values if (values->n > 0) { - mask->data.U8[i] = 0; + mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0; ordinate->data.F32[i] = 2.0*(float)i/(float)pixels->n - 1.0; // Scale to [-1,1] psVectorStats(myStats, values, NULL, NULL, 0); @@ -82,5 +82,5 @@ } else { // We'll fit this one out - mask->data.U8[i] = 1; + mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1; } } Index: trunk/psModules/src/detrend/pmRemnance.c =================================================================== --- trunk/psModules/src/detrend/pmRemnance.c (revision 21174) +++ trunk/psModules/src/detrend/pmRemnance.c (revision 21183) @@ -13,6 +13,6 @@ bool pmRemnance(pmReadout *ro, ///< Readout with input image - psMaskType maskVal, ///< Value of mask - psMaskType maskRem, ///< Value to give remance + psImageMaskType maskVal, ///< Value of mask + psImageMaskType maskRem, ///< Value to give remance int size, ///< Size of accumulation patches float threshold ///< Threshold for masking @@ -23,5 +23,7 @@ PM_ASSERT_READOUT_MASK(ro, false); - psImage *image = ro->image, *mask = ro->mask; // Mask and image from readout + psImage *image = ro->image; + psImage *mask = ro->mask; // Mask and image from readout + int numCols = image->numCols, numRows = image->numRows; // Size of image @@ -33,5 +35,5 @@ psErrorClear(); psWarning("Unable to calculate image statistics: masking entire readout."); - psBinaryOp(mask, mask, "|", psScalarAlloc(maskRem, PS_TYPE_MASK)); + psBinaryOp(mask, mask, "|", psScalarAlloc(maskRem, PS_TYPE_IMAGE_MASK)); psFree(stats); psFree(rng); @@ -57,5 +59,5 @@ } for (int y = min; y < max; y++) { - if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) { + if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) { continue; } @@ -84,5 +86,5 @@ } for (int y = 0; y < maxMask; y++) { - mask->data.PS_TYPE_MASK_DATA[y][x] |= maskRem; + mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= maskRem; } numMasked += maxMask; Index: trunk/psModules/src/detrend/pmRemnance.h =================================================================== --- trunk/psModules/src/detrend/pmRemnance.h (revision 21174) +++ trunk/psModules/src/detrend/pmRemnance.h (revision 21183) @@ -13,6 +13,6 @@ // GPC1 leaves remnance that flows down from where the annoyed pixels are. bool pmRemnance(pmReadout *ro, ///< Readout with input image - psMaskType maskVal, ///< Value of mask - psMaskType maskRem, ///< Value to give remance + psImageMaskType maskVal, ///< Value of mask + psImageMaskType maskRem, ///< Value to give remance int size, ///< Size of accumulation patches float threshold ///< Threshold for masking Index: trunk/psModules/src/detrend/pmShifts.c =================================================================== --- trunk/psModules/src/detrend/pmShifts.c (revision 21174) +++ trunk/psModules/src/detrend/pmShifts.c (revision 21183) @@ -412,5 +412,5 @@ } -bool pmShiftsConvolve(pmReadout *detrend, const pmCell *source, psMaskType maskVal) +bool pmShiftsConvolve(pmReadout *detrend, const pmCell *source, psImageMaskType maskVal) { PS_ASSERT_PTR(detrend, false); Index: trunk/psModules/src/detrend/pmShifts.h =================================================================== --- trunk/psModules/src/detrend/pmShifts.h (revision 21174) +++ trunk/psModules/src/detrend/pmShifts.h (revision 21183) @@ -46,5 +46,5 @@ bool pmShiftsConvolve(pmReadout *detrend, ///< Detrend readout to convolve const pmCell *source, ///< Science exposure, containing a shifts kernel - psMaskType maskVal ///< Mask value to smear + psImageMaskType maskVal ///< Mask value to smear ); Index: trunk/psModules/src/detrend/pmShutterCorrection.c =================================================================== --- trunk/psModules/src/detrend/pmShutterCorrection.c (revision 21174) +++ trunk/psModules/src/detrend/pmShutterCorrection.c (revision 21183) @@ -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: trunk/psModules/src/detrend/pmShutterCorrection.h =================================================================== --- trunk/psModules/src/detrend/pmShutterCorrection.h (revision 21174) +++ trunk/psModules/src/detrend/pmShutterCorrection.h (revision 21183) @@ -5,6 +5,6 @@ * @author Paul Price, IfA * - * @version $Revision: 1.21 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-09-09 04:10:14 $ + * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2006 Institute for Astronomy, University of Hawaii */ @@ -91,6 +91,5 @@ float offref, ///< Reference time offset int nIter, ///< Number of iterations - float rej, ///< Rejection threshold (sigma) - psMaskType maskVal ///< Mask value + float rej ///< Rejection threshold (sigma) ); @@ -121,5 +120,5 @@ int nIter, ///< Number of iterations float rej, ///< Rejection threshold (sigma) - psMaskType maskVal ///< Mask value + psImageMaskType maskVal ///< Mask value ); @@ -135,5 +134,5 @@ psImage *mask, ///< Input mask image float exptime, ///< Exposure time to which to correct - psMaskType blank, ///< Mask value to give blank pixels + psImageMaskType blank, ///< Mask value to give blank pixels int rowStart, int rowStop ///< Range of scan ); @@ -145,5 +144,5 @@ pmReadout *readout, ///< Readout to which to apply shutter correction const pmReadout *shutter, ///< Shutter correction readout, with dT for each pixel - psMaskType blank ///< Value to give blank pixels + psImageMaskType blank ///< Value to give blank pixels ); @@ -181,5 +180,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 ); @@ -201,10 +200,10 @@ int nIter, ///< Number of iterations float rej, ///< Rejection threshold (sigma) - psMaskType maskVal ///< Mask value + psImageMaskType maskVal ///< Mask value ); // prepare outputs for shutter correction bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs, - psMaskType maskVal); + psImageMaskType maskVal); /// @} Index: trunk/psModules/src/detrend/pmSkySubtract.c =================================================================== --- trunk/psModules/src/detrend/pmSkySubtract.c (revision 21174) +++ trunk/psModules/src/detrend/pmSkySubtract.c (revision 21183) @@ -6,6 +6,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-04-04 22:42:48 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -114,5 +114,5 @@ psVector *binVector = psVectorAlloc(binFactor * binFactor, PS_TYPE_F32); - psVector *binMask = psVectorAlloc(binFactor * binFactor, PS_TYPE_U8); + psVector *binMask = psVectorAlloc(binFactor * binFactor, PS_TYPE_VECTOR_MASK); psStats *myStats = psStatsAlloc(statOptions); @@ -126,8 +126,8 @@ binVector->data.F32[count] = origImage->data.F32[row + binRow][col + binCol]; - binMask->data.U8[count] = 0; + binMask->data.PS_TYPE_VECTOR_MASK_DATA[count] = 0; } else { binVector->data.F32[count] = 0.0; - binMask->data.U8[count] = 1; + binMask->data.PS_TYPE_VECTOR_MASK_DATA[count] = 1; } count++; @@ -313,5 +313,5 @@ PS_ASSERT_IMAGE_NON_NULL(maskImage, NULL); PS_ASSERT_IMAGE_NON_EMPTY(maskImage, NULL); - PS_ASSERT_IMAGE_TYPE(maskImage, PS_TYPE_U8, NULL); + PS_ASSERT_IMAGE_TYPE(maskImage, PS_TYPE_IMAGE_MASK, NULL); PS_ASSERT_IMAGES_SIZE_EQUAL(dataImage, maskImage, NULL); psS32 oldPolyX = -1; @@ -361,5 +361,5 @@ for (x=0;xnumRows;x++) { for (y=0;ynumCols;y++) { - if (maskImage->data.U8[x][y] == 0) { + if (maskImage->data.PS_TYPE_IMAGE_MASK_DATA[x][y] == 0) { buildSums((psF64) x, (psF64) y, myPoly->nX, myPoly->nY); @@ -572,5 +572,5 @@ if (in->mask != NULL) { - binnedMaskImage = psImageCopy(binnedMaskImage, in->mask, PS_TYPE_U8); + binnedMaskImage = psImageCopy(binnedMaskImage, in->mask, PS_TYPE_IMAGE_MASK); if (binnedMaskImage == NULL) { psError(PS_ERR_UNKNOWN, false, "psImageCopy() returned NULL. Returning in image.\n"); @@ -581,5 +581,5 @@ binnedMaskImage = psImageAlloc(binnedImage->numCols, binnedImage->numRows, - PS_TYPE_U8); + PS_TYPE_IMAGE_MASK); psImageInit(binnedMaskImage, 0); } @@ -592,5 +592,5 @@ binnedMaskImage = psImageAlloc(binnedImage->numCols, binnedImage->numRows, - PS_TYPE_U8); + PS_TYPE_IMAGE_MASK); psImageInit(binnedMaskImage, 0); } @@ -625,5 +625,5 @@ if (fabs(binnedImage->data.F32[row][col] - binnedMean) > (clipSD * binnedStdev)) { - binnedMaskImage->data.U8[row][col] = 1; + binnedMaskImage->data.PS_TYPE_IMAGE_MASK_DATA[row][col] = 1; } } Index: trunk/psModules/src/imcombine/pmImageCombine.c =================================================================== --- trunk/psModules/src/imcombine/pmImageCombine.c (revision 21174) +++ trunk/psModules/src/imcombine/pmImageCombine.c (revision 21183) @@ -8,6 +8,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-04-04 22:42:48 $ + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * XXX: pmRejectPixels() has a known bug with the pmImageTransform() call. @@ -17,4 +17,6 @@ */ +// XXX this is somewhat messy and unclear on the masking. + #ifdef HAVE_CONFIG_H #include @@ -53,5 +55,5 @@ buffer->pixels = psVectorAlloc(numImages, PS_TYPE_F32); - buffer->masks = psVectorAlloc(numImages, PS_TYPE_MASK); + buffer->masks = psVectorAlloc(numImages, PS_TYPE_VECTOR_MASK); buffer->errors = psVectorAlloc(numImages, PS_TYPE_F32); buffer->stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV); @@ -67,5 +69,5 @@ const psArray *errors, // Array of input error images const psArray *masks, // Array of input masks - psU32 maskVal, // Mask value + psImageMaskType maskVal, // Mask value psS32 numIter, // Number of rejection iterations psF32 sigmaClip, // Number of standard deviations at which to reject @@ -115,6 +117,7 @@ if (masks) { psImage *mask = masks->data[i]; // Mask of interest - pixelMasks->data.U8[i] = mask->data.U8[y][x]; - } // Set the pixel error data, if necessary + pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal); + } + // Set the pixel error data, if necessary if (errors) { psImage *error = errors->data[i]; // Error image of interest @@ -128,5 +131,5 @@ for (int iter = 0; iter < numIter; iter++) { // Combine all the pixels, using the specified stat. - if (!psVectorStats(stats, pixelData, pixelErrors, pixelMasks, maskVal)) { + if (!psVectorStats(stats, pixelData, pixelErrors, pixelMasks, 0xff)) { combine->data.F32[y][x] = NAN; psFree(buffer); @@ -148,9 +151,9 @@ float stdev = stats->sampleStdev; for (int i = 0; i < numImages; i++) { - if (!(pixelMasks->data.U8[i] & maskVal) && + if (!(pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[i] & 0xff) && fabs(pixelData->data.F32[i] - combinedPixel) > sigmaClip * stdev) { // Reject pixel as questionable numRejects++; - pixelMasks->data.U8[i] = maskVal; + pixelMasks->data.PS_TYPE_IMAGE_MASK_DATA[i] = 0xff; if (questionablePixels) { // Mark the pixel as questionable @@ -191,5 +194,5 @@ const psArray *errors, ///< Array of input error images const psArray *masks, ///< Array of input masks - psU32 maskVal, ///< Mask value + psImageMaskType maskVal, ///< Mask value const psPixels *pixels, ///< Pixels to combine psS32 numIter, ///< Number of rejection iterations @@ -231,5 +234,5 @@ psImage *mask = masks->data[i]; PS_ASSERT_IMAGE_SIZE(mask, numCols, numRows, NULL); - PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL); } } @@ -319,5 +322,5 @@ int num = 0; psVector *pixels = psVectorAlloc(8, PS_TYPE_F32); // Array of pixels - psVector *mask = psVectorAlloc(8, PS_TYPE_U8); // Corresponding mask + psVector *mask = psVectorAlloc(8, PS_TYPE_VECTOR_MASK); // Corresponding mask // Get limits @@ -329,10 +332,10 @@ for (int j = yMin; j <= yMax; j++) { for (int i = xMin; i <= xMax; i++) { - if ((i != x) && (j != y) && (0 == imageMask->data.U8[j][i])) { + if ((i != x) && (j != y) && (0 == imageMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i])) { pixels->data.F32[num] = image->data.F32[j][i]; - mask->data.U8[num] = 0; + mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0; num++; } else { - mask->data.U8[num] = 1; + mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 1; } } @@ -347,8 +350,8 @@ if ((i != x) && (j != y)) { pixels->data.F32[num] = image->data.F32[j][i]; - mask->data.U8[num] = 0; + mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0; num++; } else { - mask->data.U8[num] = 1; + mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 1; } } @@ -473,5 +476,5 @@ for (psS32 i = 0 ; i < image->numRows ; i++) { for (psS32 j = 0 ; j < image->numCols ; j++) { - imgF32->data.F32[i][j] = (psF32) image->data.U8[i][j]; + imgF32->data.F32[i][j] = (psF32) image->data.PS_TYPE_IMAGE_MASK_DATA[i][j]; } } @@ -518,5 +521,5 @@ PS_ASSERT_IMAGE_NON_NULL(tmpMask, NULL); PS_ASSERT_IMAGE_NON_EMPTY(tmpMask, NULL); - PS_ASSERT_IMAGE_TYPE(tmpMask, PS_TYPE_F32, NULL); + PS_ASSERT_IMAGE_TYPE(tmpMask, PS_TYPE_F32, NULL); // XXX really F32?? PS_ASSERT_IMAGES_SIZE_EQUAL(tmpImage, tmpMask, NULL); } @@ -571,5 +574,5 @@ // - // Create a psU8 mask image from the list of cosmic pixels. + // Create a psImageMaskType mask image from the list of cosmic pixels. // psImage *maskImage = NULL; Index: trunk/psModules/src/imcombine/pmPSFEnvelope.c =================================================================== --- trunk/psModules/src/imcombine/pmPSFEnvelope.c (revision 21174) +++ trunk/psModules/src/imcombine/pmPSFEnvelope.c (revision 21183) @@ -223,5 +223,5 @@ // *** readout->weight = (psImage*)psBinaryOp(NULL, readout->image, "*", psScalarAlloc(WEIGHT_FACTOR, PS_TYPE_F32)); readout->weight = (psImage*)psBinaryOp(NULL, readout->image, "+", psScalarAlloc(WEIGHT_VAL, PS_TYPE_F32)); - readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); psImageInit(readout->mask, 0); Index: trunk/psModules/src/imcombine/pmReadoutCombine.c =================================================================== --- trunk/psModules/src/imcombine/pmReadoutCombine.c (revision 21174) +++ trunk/psModules/src/imcombine/pmReadoutCombine.c (revision 21183) @@ -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(psVectorMaskType)); // 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: trunk/psModules/src/imcombine/pmReadoutCombine.h =================================================================== --- trunk/psModules/src/imcombine/pmReadoutCombine.h (revision 21174) +++ trunk/psModules/src/imcombine/pmReadoutCombine.h (revision 21183) @@ -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.15 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * 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: trunk/psModules/src/imcombine/pmStack.c =================================================================== --- trunk/psModules/src/imcombine/pmStack.c (revision 21174) +++ trunk/psModules/src/imcombine/pmStack.c (revision 21183) @@ -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.46 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * 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: trunk/psModules/src/imcombine/pmStack.h =================================================================== --- trunk/psModules/src/imcombine/pmStack.h (revision 21174) +++ trunk/psModules/src/imcombine/pmStack.h (revision 21183) @@ -8,6 +8,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-11-01 02:59:33 $ + * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004-2007 Institute for Astronomy, University of Hawaii @@ -43,6 +43,6 @@ bool pmStackCombine(pmReadout *combined,///< Combined readout (output) psArray *input, ///< Input array of pmStackData - psMaskType maskVal, ///< Mask value of bad pixels - psMaskType bad, ///< Mask value to give rejected pixels + psImageMaskType maskVal, ///< Mask value of bad pixels + psImageMaskType bad, ///< Mask value to give rejected pixels int kernelSize, ///< Half-size of the convolution kernel int numIter, ///< Number of iterations Index: trunk/psModules/src/imcombine/pmStackReject.c =================================================================== --- trunk/psModules/src/imcombine/pmStackReject.c (revision 21174) +++ trunk/psModules/src/imcombine/pmStackReject.c (revision 21183) @@ -61,19 +61,19 @@ } - int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK); // Number of bytes to copy + int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK); // Number of bytes to copy psAssert(convolved->numCols - 2 * box == xMax - xMin, "Bad number of columns"); psAssert(convolved->numRows - 2 * box == yMax - yMin, "Bad number of rows"); for (int yTarget = yMin, ySource = box; yTarget < yMax; yTarget++, ySource++) { - memcpy(&target->data.PS_TYPE_MASK_DATA[yTarget][xMin], - &convolved->data.PS_TYPE_MASK_DATA[ySource][box], numBytes); + memcpy(&target->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin], + &convolved->data.PS_TYPE_IMAGE_MASK_DATA[ySource][box], numBytes); } psFree(convolved); } else { // Just copy over - int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK); // Number of bytes to copy + int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK); // Number of bytes to copy for (int yTarget = yMin; yTarget < yMax; yTarget++) { - memcpy(&target->data.PS_TYPE_MASK_DATA[yTarget][xMin], - &source->data.PS_TYPE_MASK_DATA[yTarget][xMin], numBytes); + memcpy(&target->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin], + &source->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin], numBytes); } } @@ -262,5 +262,5 @@ bool oldThreads = psImageConvolveSetThreads(false); // Old value of threading for psImageColvolve - psImage *target = psImageRecycle(convolved, numCols, numRows, PS_TYPE_MASK); // Grown image + psImage *target = psImageRecycle(convolved, numCols, numRows, PS_TYPE_IMAGE_MASK); // Grown image psImageInit(target, 0); if (threaded) { Index: trunk/psModules/src/imcombine/pmSubtraction.c =================================================================== --- trunk/psModules/src/imcombine/pmSubtraction.c (revision 21174) +++ trunk/psModules/src/imcombine/pmSubtraction.c (revision 21183) @@ -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: trunk/psModules/src/imcombine/pmSubtraction.h =================================================================== --- trunk/psModules/src/imcombine/pmSubtraction.h (revision 21174) +++ trunk/psModules/src/imcombine/pmSubtraction.h (revision 21183) @@ -6,6 +6,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.34 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-11-07 00:03:18 $ + * @version $Revision: 1.35 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004-207 Institute for Astronomy, University of Hawaii */ @@ -104,6 +104,6 @@ psImage *subMask, ///< Subtraction mask (or NULL) int stride, ///< Size of convolution patches - psMaskType maskBad, ///< Mask value to give bad pixels - psMaskType maskPoor, ///< Mask value to give poor pixels + psImageMaskType maskBad, ///< Mask value to give bad pixels + psImageMaskType maskPoor, ///< Mask value to give poor pixels float poorFrac, ///< Fraction for "poor" float sysError, ///< Relative systematic error Index: trunk/psModules/src/imcombine/pmSubtractionMask.c =================================================================== --- trunk/psModules/src/imcombine/pmSubtractionMask.c (revision 21174) +++ trunk/psModules/src/imcombine/pmSubtractionMask.c (revision 21183) @@ -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: trunk/psModules/src/imcombine/pmSubtractionMask.h =================================================================== --- trunk/psModules/src/imcombine/pmSubtractionMask.h (revision 21174) +++ trunk/psModules/src/imcombine/pmSubtractionMask.h (revision 21183) @@ -7,5 +7,5 @@ psImage *pmSubtractionMask(const psImage *refMask, ///< Mask for the reference image (will be convolved) const psImage *inMask, ///< Mask for the input image, or NULL - psMaskType maskVal, ///< Value to mask out + psImageMaskType maskVal, ///< Value to mask out int size, ///< Half-size of the kernel (pmSubtractionKernels.size) int footprint, ///< Half-size of the kernel footprint @@ -19,5 +19,5 @@ psImage *mask, ///< Mask (or NULL) int size, ///< Kernel half-size - psMaskType blank ///< Mask value for blank regions + psImageMaskType blank ///< Mask value for blank regions ); Index: trunk/psModules/src/imcombine/pmSubtractionMatch.c =================================================================== --- trunk/psModules/src/imcombine/pmSubtractionMatch.c (revision 21174) +++ trunk/psModules/src/imcombine/pmSubtractionMatch.c (revision 21183) @@ -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; psTrace("psModules.imcombine", 3, "Stamp %d (%.1f,%.1f) widths: %d, %d --> %f\n", index, stamp->x, stamp->y, width1, width2, ratios->data.F32[index]); @@ -596,5 +596,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_VECTOR_MASK); // Mask for stamps psVector *ratios = psVectorAlloc(stamps->num, PS_TYPE_F32); // Ratios of widths @@ -624,5 +624,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_VECTOR_MASK_DATA[i] = 0xff; continue; } Index: trunk/psModules/src/imcombine/pmSubtractionMatch.h =================================================================== --- trunk/psModules/src/imcombine/pmSubtractionMatch.h (revision 21174) +++ trunk/psModules/src/imcombine/pmSubtractionMatch.h (revision 21183) @@ -40,7 +40,7 @@ float rej, ///< Rejection threshold float sysError, ///< Relative systematic error - psMaskType maskVal, ///< Value to mask for input - psMaskType maskBad, ///< Mask for output bad pixels - psMaskType maskPoor, ///< Mask for output poor pixels + psImageMaskType maskVal, ///< Value to mask for input + psImageMaskType maskBad, ///< Mask for output bad pixels + psImageMaskType maskPoor, ///< Mask for output poor pixels float poorFrac, ///< Fraction for "poor" float badFrac, ///< Maximum fraction of bad input pixels to accept Index: trunk/psModules/src/imcombine/pmSubtractionStamps.c =================================================================== --- trunk/psModules/src/imcombine/pmSubtractionStamps.c (revision 21174) +++ trunk/psModules/src/imcombine/pmSubtractionStamps.c (revision 21183) @@ -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: trunk/psModules/src/objects/pmFootprintArrayGrow.c =================================================================== --- trunk/psModules/src/objects/pmFootprintArrayGrow.c (revision 21174) +++ trunk/psModules/src/objects/pmFootprintArrayGrow.c (revision 21183) @@ -3,6 +3,6 @@ * @author RHL, Princeton & IfA; EAM, IfA * - * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-12-08 02:51:14 $ + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2006 Institute for Astronomy, University of Hawaii */ @@ -45,5 +45,5 @@ // Use a separable convolution: should be faster idImage = (psImage*)psBinaryOp(idImage, idImage, "MIN", psScalarAlloc(1, PS_TYPE_S32)); - psImage *idImageMask = psImageCopy(NULL, idImage, PS_TYPE_MASK); // Image with 1 = object + psImage *idImageMask = psImageCopy(NULL, idImage, PS_TYPE_IMAGE_MASK); // Image with 1 = object psImage *grownIdImage = psImageConvolveMask(NULL, idImageMask, 0x01, 0x01, -r, r, -r, r); // Grown mask if (!grownIdImage) { Index: trunk/psModules/src/objects/pmFootprintFindAtPoint.c =================================================================== --- trunk/psModules/src/objects/pmFootprintFindAtPoint.c (revision 21174) +++ trunk/psModules/src/objects/pmFootprintFindAtPoint.c (revision 21183) @@ -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.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * 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: trunk/psModules/src/objects/pmGrowthCurveGenerate.c =================================================================== --- trunk/psModules/src/objects/pmGrowthCurveGenerate.c (revision 21174) +++ trunk/psModules/src/objects/pmGrowthCurveGenerate.c (revision 21183) @@ -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.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * 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: trunk/psModules/src/objects/pmModel.c =================================================================== --- trunk/psModules/src/objects/pmModel.c (revision 21174) +++ trunk/psModules/src/objects/pmModel.c (revision 21183) @@ -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.26 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * 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: trunk/psModules/src/objects/pmModel.h =================================================================== --- trunk/psModules/src/objects/pmModel.h (revision 21174) +++ trunk/psModules/src/objects/pmModel.h (revision 21183) @@ -5,6 +5,6 @@ * @author EAM, IfA * - * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-12-09 21:16:09 $ + * @version $Revision: 1.18 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -150,5 +150,5 @@ pmModel *model, ///< The input pmModel pmModelOpMode mode, ///< mode to control how the model is added into the image - psMaskType maskVal ///< Value to mask + psImageMaskType maskVal ///< Value to mask ); @@ -168,5 +168,5 @@ pmModel *model, ///< The input pmModel pmModelOpMode mode, ///< mode to control how the model is added into the image - psMaskType maskVal ///< Value to mask + psImageMaskType maskVal ///< Value to mask ); @@ -175,5 +175,5 @@ pmModel *model, pmModelOpMode mode, - psMaskType maskVal, + psImageMaskType maskVal, int dx, int dy); @@ -183,5 +183,5 @@ pmModel *model, pmModelOpMode mode, - psMaskType maskVal, + psImageMaskType maskVal, int dx, int dy); Index: trunk/psModules/src/objects/pmPSF.h =================================================================== --- trunk/psModules/src/objects/pmPSF.h (revision 21174) +++ trunk/psModules/src/objects/pmPSF.h (revision 21183) @@ -6,6 +6,6 @@ * @author EAM, IfA * - * @version $Revision: 1.21 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-12-09 21:16:09 $ + * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -102,5 +102,5 @@ double pmPSF_SXYtoModel (psF32 *fittedPar); -bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType mark); +bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType mark); pmPSF *pmPSFBuildSimple (char *typeName, float sxx, float syy, float sxy, ...); Index: trunk/psModules/src/objects/pmPSF_IO.c =================================================================== --- trunk/psModules/src/objects/pmPSF_IO.c (revision 21174) +++ trunk/psModules/src/objects/pmPSF_IO.c (revision 21183) @@ -6,6 +6,6 @@ * @author EAM, IfA * - * @version $Revision: 1.36 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-12-08 02:51:14 $ + * @version $Revision: 1.37 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -871,4 +871,5 @@ psFitsReadImageBuffer(psf->residuals->Ry, file->fits, fullImage, 2); // Desired pixels } + // XXX notice that we are not saving the resid->mask } Index: trunk/psModules/src/objects/pmPSFtry.c =================================================================== --- trunk/psModules/src/objects/pmPSFtry.c (revision 21174) +++ trunk/psModules/src/objects/pmPSFtry.c (revision 21183) @@ -5,7 +5,6 @@ * @author EAM, IfA * - * @version $Revision: 1.68 $ $Name: not supported by cvs2svn $ - * @date $Date: 2009-01-27 00:01:33 $ - * + * @version $Revision: 1.69 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii * @@ -115,5 +114,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 +147,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; @@ -176,9 +175,9 @@ pmSource *source = psfTry->sources->data[i]; if (!source->moments) { - psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL; + psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL; continue; } if (!source->moments->nPixels) { - psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL; + psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL; continue; } @@ -186,5 +185,5 @@ source->modelEXT = pmSourceModelGuess (source, psfTry->psf->type); if (source->modelEXT == NULL) { - psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL; + psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL; psTrace ("psModules.objects", 4, "masking %d (%d,%d) : failed to generate model guess\n", i, source->peak->x, source->peak->y); continue; @@ -198,9 +197,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_VECTOR_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; @@ -231,5 +230,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; @@ -239,5 +238,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; @@ -253,6 +252,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; @@ -261,6 +260,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; @@ -268,5 +267,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; @@ -292,5 +291,5 @@ psVector *flux = psVectorAlloc (psfTry->sources->n, PS_TYPE_F32); psVector *chisq = psVectorAlloc (psfTry->sources->n, PS_TYPE_F32); - psVector *mask = psVectorAlloc (psfTry->sources->n, PS_TYPE_MASK); + psVector *mask = psVectorAlloc (psfTry->sources->n, PS_TYPE_VECTOR_MASK); // generate the x and y vectors, and mask missing models @@ -300,9 +299,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; } } @@ -312,6 +311,5 @@ // linear clipped fit of chisq trend vs flux - bool result = psVectorClipFitPolynomial1D(psfTry->psf->ChiTrend, options->stats, mask, - 0xff, chisq, NULL, flux); + bool result = psVectorClipFitPolynomial1D(psfTry->psf->ChiTrend, options->stats, mask, 0xff, chisq, NULL, flux); psStatsOptions meanStat = psStatsMeanOption(options->stats->options); // Statistic for mean psStatsOptions stdevStat = psStatsStdevOption(options->stats->options); // Statistic for stdev @@ -370,5 +368,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]); @@ -379,5 +377,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]; @@ -427,5 +425,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]; @@ -603,5 +601,5 @@ for (int i = 0; i < sources->n; i++) { // skip any masked sources (failed to fit one of the model steps or get a magnitude) - if (srcMask->data.U8[i]) continue; + if (srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue; pmSource *source = sources->data[i]; @@ -624,5 +622,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 @@ -632,5 +630,5 @@ // copy srcMask to mask (we do not want the mask values set in pmPSFFitShapeParamsMap to be sticky) for (int i = 0; i < mask->n; i++) { - mask->data.U8[i] = srcMask->data.U8[i]; + mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]; } if (!pmPSFFitShapeParamsMap (psf, i, &scatterTotal, mask, x, y, mag, e0, e1, e2, dz)) { @@ -651,5 +649,5 @@ // copy srcMask to mask (we do not want the mask values set in pmPSFFitShapeParamsMap to be sticky) for (int i = 0; i < mask->n; i++) { - mask->data.U8[i] = srcMask->data.U8[i]; + mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]; } if (!pmPSFFitShapeParamsMap (psf, entryMin, &scatterTotal, mask, x, y, mag, e0, e1, e2, dz)) { @@ -663,5 +661,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]; } @@ -736,5 +734,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); @@ -851,8 +849,8 @@ // 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); // copy mask values to fitMask as a starting point for (int i = 0; i < fitMask->n; i++) { - fitMask->data.U8[i] = mask->data.U8[i]; + fitMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = mask->data.PS_TYPE_VECTOR_MASK_DATA[i]; } @@ -943,5 +941,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); @@ -951,5 +949,5 @@ // calculate the scatter of the parameters -bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psMaskType maskValue, psStatsOptions stdevOpt) +bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psVectorMaskType maskValue, psStatsOptions stdevOpt) { @@ -994,5 +992,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; @@ -1007,6 +1005,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: trunk/psModules/src/objects/pmPSFtry.h =================================================================== --- trunk/psModules/src/objects/pmPSFtry.h (revision 21174) +++ trunk/psModules/src/objects/pmPSFtry.h (revision 21183) @@ -6,6 +6,6 @@ * @author EAM, IfA * - * @version $Revision: 1.21 $ $Name: not supported by cvs2svn $ - * @date $Date: 2009-01-27 00:02:16 $ + * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -48,5 +48,5 @@ pmPSF *psf; ///< Add comment. psArray *sources; ///< pointers to the original sources - psVector *mask; ///< Add comment. + psVector *mask; ///< PS_TYPE_VECTOR_MASK to flag good and bad sources psVector *metric; ///< Add comment. psVector *metricErr; ///< Add comment. @@ -89,5 +89,5 @@ * */ -pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psMaskType maskVal, psMaskType mark); +pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psImageMaskType maskVal, psImageMaskType mark); /** pmPSFtryMetric() @@ -129,5 +129,5 @@ bool pmPSFFitShapeParams (pmPSF *psf, psArray *sources, psVector *x, psVector *y, psVector *srcMask); bool pmPSFFitShapeParamsMap (pmPSF *psf, int scale, float *scatterTotal, psVector *mask, psVector *x, psVector *y, psVector *mag, psVector *e0obs, psVector *e1obs, psVector *e2obs, psVector *dz); -bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psMaskType maskValue, psStatsOptions stdevOpt); +bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psVectorMaskType maskValue, psStatsOptions stdevOpt); bool pmPSFShapeParamsErrors (float *errorFloor, psVector *mag, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, int nGroup, psStatsOptions stdevOpt); Index: trunk/psModules/src/objects/pmResiduals.c =================================================================== --- trunk/psModules/src/objects/pmResiduals.c (revision 21174) +++ trunk/psModules/src/objects/pmResiduals.c (revision 21183) @@ -4,6 +4,6 @@ * * @author EAM, IfA - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-11-10 01:09:20 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 IfA, University of Hawaii */ @@ -43,5 +43,7 @@ resid->Ry = psImageAlloc (nX, nY, PS_TYPE_F32); resid->weight = psImageAlloc (nX, nY, PS_TYPE_F32); - resid->mask = psImageAlloc (nX, nY, PS_TYPE_U8); + resid->mask = psImageAlloc (nX, nY, PM_TYPE_RESID_MASK); + + // NOTE : the residual mask is internal only : 1 byte is sufficient resid->xBin = xBin; Index: trunk/psModules/src/objects/pmResiduals.h =================================================================== --- trunk/psModules/src/objects/pmResiduals.h (revision 21174) +++ trunk/psModules/src/objects/pmResiduals.h (revision 21183) @@ -4,6 +4,6 @@ * * @author EAM, IfA - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-11-10 01:09:20 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 IfA, University of Hawaii */ @@ -31,4 +31,11 @@ bool psMemCheckResiduals(psPtr ptr); +// macros to abstract the resid mask type : these values must be consistent +#define PM_TYPE_RESID_MASK PS_TYPE_U8 /**< the psElemType to use for mask image */ +#define PM_TYPE_RESID_MASK_DATA U8 /**< the data member to use for mask image */ +#define PM_TYPE_RESID_MASK_NAME "psU8" /**< the data type for mask as a string */ +typedef psU8 pmResidMaskType; ///< the C datatype for a mask image +#define PM_NOT_RESID_MASK(A)(UINT8_MAX-(A)) + /// @} # endif Index: trunk/psModules/src/objects/pmSource.c =================================================================== --- trunk/psModules/src/objects/pmSource.c (revision 21174) +++ trunk/psModules/src/objects/pmSource.c (revision 21183) @@ -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.67 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -171,5 +171,5 @@ // the maskObj is a unique mask array; create a new mask image - source->maskObj = in->maskObj ? psImageCopy (NULL, in->maskObj, PS_TYPE_MASK) : NULL; + source->maskObj = in->maskObj ? psImageCopy (NULL, in->maskObj, PS_TYPE_IMAGE_MASK) : NULL; source->type = in->type; @@ -205,5 +205,5 @@ mySource->maskView = psImageSubset(readout->mask, srcRegion); // the object mask is a copy, and used to define the source pixels - mySource->maskObj = psImageCopy(NULL, mySource->maskView, PS_TYPE_MASK); + mySource->maskObj = psImageCopy(NULL, mySource->maskView, PS_TYPE_IMAGE_MASK); } mySource->region = srcRegion; @@ -255,5 +255,5 @@ // re-copy the main mask pixels. NOTE: the user will need to reset the object mask // pixels (eg, with psImageKeepCircle) - mySource->maskObj = psImageCopy (mySource->maskObj, mySource->maskView, PS_TYPE_MASK); + mySource->maskObj = psImageCopy (mySource->maskObj, mySource->maskView, PS_TYPE_IMAGE_MASK); // drop the old modelFlux pixels and force the user to re-create @@ -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: trunk/psModules/src/objects/pmSource.h =================================================================== --- trunk/psModules/src/objects/pmSource.h (revision 21174) +++ trunk/psModules/src/objects/pmSource.h (revision 21183) @@ -3,6 +3,6 @@ * @author EAM, IfA; GLG, MHPCC * - * @version $Revision: 1.26 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-12-09 21:16:09 $ + * @version $Revision: 1.27 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -210,5 +210,5 @@ psMetadata *metadata, ///< Contains classification parameters pmPSFClump clump, ///< Statistics about the PSF clump - psMaskType maskSat ///< Mask value for saturated pixels + psImageMaskType maskSat ///< Mask value for saturated pixels ); @@ -231,12 +231,12 @@ pmModel *pmSourceGetModel (bool *isPSF, const pmSource *source); -bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psMaskType maskVal); -bool pmSourceSub (pmSource *source, pmModelOpMode mode, psMaskType maskVal); -bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy); -bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy); - -bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psMaskType maskVal, int dx, int dy); -bool pmSourceCacheModel (pmSource *source, psMaskType maskVal); -bool pmSourceCachePSF (pmSource *source, psMaskType maskVal); +bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal); +bool pmSourceSub (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal); +bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy); +bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy); + +bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psImageMaskType maskVal, int dx, int dy); +bool pmSourceCacheModel (pmSource *source, psImageMaskType maskVal); +bool pmSourceCachePSF (pmSource *source, psImageMaskType maskVal); int pmSourceSortBySN (const void **a, const void **b); Index: trunk/psModules/src/objects/pmSourceFitModel.c =================================================================== --- trunk/psModules/src/objects/pmSourceFitModel.c (revision 21174) +++ trunk/psModules/src/objects/pmSourceFitModel.c (revision 21183) @@ -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.29 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * 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); 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: trunk/psModules/src/objects/pmSourceFitModel.h =================================================================== --- trunk/psModules/src/objects/pmSourceFitModel.h (revision 21174) +++ trunk/psModules/src/objects/pmSourceFitModel.h (revision 21183) @@ -3,6 +3,6 @@ * @author EAM, IfA; GLG, MHPCC * - * @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-06-20 02:22:26 $ + * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -41,5 +41,5 @@ pmModel *model, ///< model to be fitted pmSourceFitMode mode, ///< define parameters to be fitted - psMaskType maskVal ///< Value to mask + psImageMaskType maskVal ///< Value to mask ); @@ -71,5 +71,5 @@ psArray *modelSet, ///< model to be fitted pmSourceFitMode mode, ///< define parameters to be fitted - psMaskType maskVal ///< Vale to mask + psImageMaskType maskVal ///< Vale to mask ); Index: trunk/psModules/src/objects/pmSourceFitSet.c =================================================================== --- trunk/psModules/src/objects/pmSourceFitSet.c (revision 21174) +++ trunk/psModules/src/objects/pmSourceFitSet.c (revision 21183) @@ -6,7 +6,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ - * @date $Date: 2009-01-24 20:52:26 $ - * + * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii * @@ -394,5 +393,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_VECTOR_MASK_DATA[n + j] = 1; } break; @@ -403,10 +402,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_VECTOR_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_VECTOR_MASK_DATA[n + PM_PAR_SKY] = 1; break; default: @@ -445,5 +444,5 @@ psArray *modelSet, pmSourceFitMode mode, - psMaskType maskVal) + psImageMaskType maskVal) { psTrace("psModules.objects", 3, "---- %s begin ----\n", __func__); @@ -469,5 +468,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; } @@ -515,5 +514,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; @@ -528,5 +527,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]); } } @@ -560,5 +559,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]); @@ -568,13 +567,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: trunk/psModules/src/objects/pmSourceFitSet.h =================================================================== --- trunk/psModules/src/objects/pmSourceFitSet.h (revision 21174) +++ trunk/psModules/src/objects/pmSourceFitSet.h (revision 21183) @@ -3,6 +3,6 @@ * @author EAM, IfA; GLG, MHPCC * - * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ - * @date $Date: 2009-01-24 20:52:26 $ + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -54,8 +54,8 @@ */ bool pmSourceFitSet( - pmSource *source, ///< The input pmSource - psArray *modelSet, ///< model to be fitted - pmSourceFitMode mode, ///< define parameters to be fitted - psMaskType maskVal ///< Vale to mask + pmSource *source, ///< The input pmSource + psArray *modelSet, ///< model to be fitted + pmSourceFitMode mode, ///< define parameters to be fitted + psImageMaskType maskVal ///< Vale to mask ); Index: trunk/psModules/src/objects/pmSourceMatch.c =================================================================== --- trunk/psModules/src/objects/pmSourceMatch.c (revision 21174) +++ trunk/psModules/src/objects/pmSourceMatch.c (revision 21183) @@ -122,5 +122,5 @@ match->image = psVectorAllocEmpty(num, PS_TYPE_U32); match->index = psVectorAllocEmpty(num, PS_TYPE_U32); - match->mask = psVectorAllocEmpty(num, PS_TYPE_MASK); + match->mask = psVectorAllocEmpty(num, PS_TYPE_VECTOR_MASK); return match; @@ -143,5 +143,5 @@ match->image->data.S32[num] = image; match->index->data.S32[num] = index; - match->mask->data.PS_TYPE_MASK_DATA[num] = 0; + match->mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0; match->num++; @@ -316,5 +316,5 @@ double star = 0.0, starErr = 0.0; // Accumulators for star for (int j = 0; j < match->num; j++) { - if (match->mask->data.PS_TYPE_MASK_DATA[j]) { + if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) { continue; } @@ -347,5 +347,5 @@ pmSourceMatch *match = matches->data[i]; // Matched stars for (int j = 0; j < match->num; j++) { - if (match->mask->data.PS_TYPE_MASK_DATA[j]) { + if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) { continue; } @@ -373,5 +373,5 @@ pmSourceMatch *match = matches->data[i]; // Matched stars for (int j = 0; j < match->num; j++) { - if (match->mask->data.PS_TYPE_MASK_DATA[j]) { + if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) { continue; } @@ -474,5 +474,5 @@ pmSourceMatch *match = matches->data[i]; // Matched stars for (int j = 0; j < match->num; j++) { - if (match->mask->data.PS_TYPE_MASK_DATA[j]) { + if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) { continue; } @@ -488,5 +488,5 @@ if (PS_SQR(dev) > starClip * (PS_SQR(magErr) + sysErr2)) { numRejected++; - match->mask->data.PS_TYPE_MASK_DATA[j] = 0xFF; + match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xFF; } } Index: trunk/psModules/src/objects/pmSourceMoments.c =================================================================== --- trunk/psModules/src/objects/pmSourceMoments.c (revision 21174) +++ trunk/psModules/src/objects/pmSourceMoments.c (revision 21183) @@ -6,6 +6,6 @@ * @author EAM, IfA: significant modifications. * - * @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-12-08 02:51:14 $ + * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -100,5 +100,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++) { @@ -190,5 +190,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++) { @@ -342,5 +342,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++) { Index: trunk/psModules/src/objects/pmSourcePhotometry.c =================================================================== --- trunk/psModules/src/objects/pmSourcePhotometry.c (revision 21174) +++ trunk/psModules/src/objects/pmSourcePhotometry.c (revision 21183) @@ -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.48 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * 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: trunk/psModules/src/objects/pmSourcePhotometry.h =================================================================== --- trunk/psModules/src/objects/pmSourcePhotometry.h (revision 21174) +++ trunk/psModules/src/objects/pmSourcePhotometry.h (revision 21183) @@ -4,6 +4,6 @@ * @author EAM, IfA; GLG, MHPCC * - * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ - * @date $Date: 2008-07-15 20:25:00 $ + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -46,11 +46,11 @@ psImage *image, ///< image pixels to be used psImage *mask, ///< mask of pixels to ignore - psMaskType maskVal ///< Value to mask + psImageMaskType maskVal ///< Value to mask ); bool pmSourceMagnitudesInit (psMetadata *config); -bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psMaskType maskVal); -bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psMaskType maskVal); -bool pmSourceChisq (pmModel *model, psImage *image, psImage *mask, psImage *weight, psMaskType maskVal); +bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal); +bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psImageMaskType maskVal); +bool pmSourceChisq (pmModel *model, psImage *image, psImage *mask, psImage *weight, psImageMaskType maskVal); Index: trunk/psModules/src/objects/pmSourceSky.c =================================================================== --- trunk/psModules/src/objects/pmSourceSky.c (revision 21174) +++ trunk/psModules/src/objects/pmSourceSky.c (revision 21183) @@ -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.19 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * * 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: trunk/psModules/src/objects/pmSourceSky.h =================================================================== --- trunk/psModules/src/objects/pmSourceSky.h (revision 21174) +++ trunk/psModules/src/objects/pmSourceSky.h (revision 21183) @@ -2,6 +2,6 @@ * @author EAM, IfA; GLG, MHPCC * - * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-06-20 02:22:26 $ + * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -30,6 +30,6 @@ psStatsOptions statsOptions, ///< The statistic used in calculating the background sky float Radius, ///< The inner radius of the square annulus to exclude - psMaskType maskVal, ///< Value to mask - psMaskType mark ///< Mask value for marking + psImageMaskType maskVal, ///< Value to mask + psImageMaskType mark ///< Mask value for marking ); @@ -40,6 +40,6 @@ psStatsOptions statsOptions, ///< The statistic used in calculating the background sky float Radius, ///< The inner radius of the square annulus to exclude - psMaskType maskVal, ///< Value to mask - psMaskType mark ///< Mask value for marking + psImageMaskType maskVal, ///< Value to mask + psImageMaskType mark ///< Mask value for marking ); Index: trunk/psModules/src/objects/pmSourceVisual.c =================================================================== --- trunk/psModules/src/objects/pmSourceVisual.c (revision 21174) +++ trunk/psModules/src/objects/pmSourceVisual.c (revision 21183) @@ -57,5 +57,5 @@ model->data.F32[i] = pmTrend2DEval (trend, x->data.F32[i], y->data.F32[i]); resid->data.F32[i] = param->data.F32[i] - model->data.F32[i]; - if (mask->data.U8[i]) continue; + if (mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue; min = PS_MIN (min, resid->data.F32[i]); max = PS_MAX (max, resid->data.F32[i]); Index: trunk/psModules/src/objects/pmTrend2D.c =================================================================== --- trunk/psModules/src/objects/pmTrend2D.c (revision 21174) +++ trunk/psModules/src/objects/pmTrend2D.c (revision 21183) @@ -3,6 +3,6 @@ * @author EAM, IfA * - * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ - * @date $Date: 2009-01-27 00:00:44 $ + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * 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) { @@ -234,5 +234,5 @@ } -psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psMaskType maskValue, const psVector *x, const psVector *y) +psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psVectorMaskType maskValue, const psVector *x, const psVector *y) { PM_ASSERT_TREND2D_NON_NULL(trend, NULL); Index: trunk/psModules/src/objects/pmTrend2D.h =================================================================== --- trunk/psModules/src/objects/pmTrend2D.h (revision 21174) +++ trunk/psModules/src/objects/pmTrend2D.h (revision 21183) @@ -5,6 +5,6 @@ * @author EAM, IfA * - * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ - * @date $Date: 2009-01-27 00:00:45 $ + * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-01-27 06:39:38 $ * Copyright 2004 Maui High Performance Computing Center, University of Hawaii */ @@ -80,5 +80,5 @@ bool pmTrend2DFit(pmTrend2D *trend, psVector *mask, // Warning: mask is modified! - psMaskType maskVal, + psVectorMaskType maskVal, const psVector *x, const psVector *y, @@ -90,5 +90,5 @@ float x, float y ); -psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psMaskType maskValue, +psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psVectorMaskType maskValue, const psVector *x, const psVector *y );