IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21183 for trunk/psModules


Ignore:
Timestamp:
Jan 26, 2009, 8:40:07 PM (17 years ago)
Author:
eugene
Message:

incorporating changes from 16bit mask upgrades (eam_branch_20081230)

Location:
trunk/psModules/src
Files:
76 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/src/astrom/pmAstrometryDistortion.c

    r19305 r21183  
    77*  @author EAM, IfA
    88*
    9 *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2008-09-02 19:05:09 $
     9*  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2009-01-27 06:39:38 $
    1111*
    1212*  Copyright 2006 Institute for Astronomy, University of Hawaii
    … …  
    121121            // this analysis has too few data points to use the robust median method
    122122            stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_STDEV);
    123             mask = psVectorAlloc (Npts, PS_TYPE_MASK);
     123            mask = psVectorAlloc (Npts, PS_TYPE_VECTOR_MASK);
    124124            psVectorInit (mask, 0);
    125125
    … …  
    206206    // this analysis has too few data points to use the robust median method
    207207    psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_STDEV);
    208     psVector *mask = psVectorAlloc (gradients->n, PS_TYPE_MASK);
     208    psVector *mask = psVectorAlloc (gradients->n, PS_TYPE_VECTOR_MASK);
    209209    psVectorInit (mask, 0);
    210210

  • trunk/psModules/src/astrom/pmAstrometryObjects.c

    r20801 r21183  
    88*  @author EAM, IfA
    99*
    10 *  @version $Revision: 1.42 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2008-11-20 01:26:07 $
     10*  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2009-01-27 06:39:38 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    227227
    228228    // constant errors
    229     psVector *mask = psVectorAlloc (match->n, PS_TYPE_U8);
     229    psVector *mask = psVectorAlloc (match->n, PS_TYPE_VECTOR_MASK);
    230230    psVectorInit (mask, 0);
    231231

  • trunk/psModules/src/camera/pmCellSquish.c

    r12696 r21183  
    1212
    1313
    14 bool pmCellSquish(pmCell *cell, psMaskType maskVal, bool useShifts)
     14bool pmCellSquish(pmCell *cell, psImageMaskType maskVal, bool useShifts)
    1515{
    1616    PS_ASSERT_PTR_NON_NULL(cell, false);
    … …  
    116116    psImage *squishImage = psImageAlloc(numCols, numRows, PS_TYPE_F32); // Squished image
    117117    psImageInit(squishImage, 0.0);
    118     psImage *squishMask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); // Squished mask
     118    psImage *squishMask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); // Squished mask
    119119    psImageInit(squishMask, 0);
    120120
    … …  
    159159                squishImage->data.F32[ySquish][xSquish] += image->data.F32[y][x];
    160160                if (mask) {
    161                     squishMask->data.PS_TYPE_MASK_DATA[ySquish][xSquish] |= mask->data.U8[y][x] & maskVal;
     161                    squishMask->data.PS_TYPE_IMAGE_MASK_DATA[ySquish][xSquish] |= mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal;
    162162                }
    163163            }

  • trunk/psModules/src/camera/pmCellSquish.h

    r12696 r21183  
    77/// already have been read) and masks.
    88bool pmCellSquish(pmCell *cell,         ///< Cell to have readouts combined
    9                   psMaskType maskVal,   ///< Value to be masked
     9                  psImageMaskType maskVal,   ///< Value to be masked
    1010                  bool useShifts        ///< Use the shifts when squishing?
    1111    );

  • trunk/psModules/src/camera/pmFPABin.c

    r20442 r21183  
    99#include "pmFPABin.h"
    1010
    11 bool pmReadoutRebin(pmReadout *out, const pmReadout *in, psMaskType maskVal, int xBin, int yBin)
     11bool pmReadoutRebin(pmReadout *out, const pmReadout *in, psImageMaskType maskVal, int xBin, int yBin)
    1212{
    1313    PM_ASSERT_READOUT_NON_NULL(out, false);
    … …  
    5050            for (int y = yStart; y < yStop; y++) {
    5151                for (int x = xStart; x < xStop; x++) {
    52                     if (inMask && (inMask->data.PS_TYPE_MASK_DATA[y][x] & maskVal)) {
     52                    if (inMask && (inMask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal)) {
    5353                        continue;
    5454                    }

  • trunk/psModules/src/camera/pmFPABin.h

    r19695 r21183  
    99bool pmReadoutRebin(pmReadout *out,     ///< Output readout
    1010                    const pmReadout *in,///< Input readout
    11                     psMaskType maskVal, ///< Value to mask
     11                    psImageMaskType maskVal, ///< Value to mask
    1212                    int xBin, int yBin  ///< Binning factors in x and y
    1313    );

  • trunk/psModules/src/camera/pmFPAMaskWeight.c

    r20749 r21183  
    4242            continue;
    4343        }
    44         masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8);
     44        masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_IMAGE_MASK);
    4545        psImageInit(masks->data[i], 0);
    4646    }
    … …  
    9898//////////////////////////////////////////////////////////////////////////////////////////////////////////////
    9999
    100 bool pmReadoutSetMask(pmReadout *readout, psMaskType satMask, psMaskType badMask)
     100bool pmReadoutSetMask(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask)
    101101{
    102102    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    124124    if (!readout->mask) {
    125125        // Generate a (throwaway) mask image, if required
    126         readout->mask = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8);
     126        readout->mask = psImageAlloc(image->numCols, image->numRows, PS_TYPE_IMAGE_MASK);
    127127    }
    128128    psImage *mask = readout->mask;      // The mask pixels
    … …  
    131131    // Dereference pointers for speed
    132132    psF32 **imageData = image->data.F32;// The image
    133     psU8  **maskData  = mask->data.U8;  // The mask
     133    psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA;  // The mask
    134134
    135135    for (int i = 0; i < image->numRows; i++) {
    … …  
    153153// pixels.  currently, it will set mask bits if (value <= BAD) or (value >= SATURATION)
    154154// should we optionally ignore these tests?
    155 bool pmReadoutGenerateMask(pmReadout *readout, psMaskType satMask, psMaskType badMask)
     155bool pmReadoutGenerateMask(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask)
    156156{
    157157    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    294294}
    295295
    296 bool pmReadoutGenerateMaskWeight(pmReadout *readout, psMaskType satMask, psMaskType badMask, bool poisson)
     296bool pmReadoutGenerateMaskWeight(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask, bool poisson)
    297297{
    298298    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    306306}
    307307
    308 bool pmCellGenerateMaskWeight(pmCell *cell, psMaskType satMask, psMaskType badMask, bool poisson)
     308bool pmCellGenerateMaskWeight(pmCell *cell, psImageMaskType satMask, psImageMaskType badMask, bool poisson)
    309309{
    310310    PS_ASSERT_PTR_NON_NULL(cell, false);
    … …  
    321321
    322322
    323 bool pmReadoutWeightRenormPixels(const pmReadout *readout, psMaskType maskVal,
     323bool pmReadoutWeightRenormPixels(const pmReadout *readout, psImageMaskType maskVal,
    324324                                 psStatsOptions meanStat, psStatsOptions stdevStat, psRandom *rng)
    325325{
    … …  
    363363
    364364
    365 bool pmReadoutWeightRenormPhot(const pmReadout *readout, psMaskType maskVal, int num, float width,
     365bool pmReadoutWeightRenormPhot(const pmReadout *readout, psImageMaskType maskVal, int num, float width,
    366366                               psStatsOptions meanStat, psStatsOptions stdevStat, psRandom *rng)
    367367{
    … …  
    411411    psVector *source = psVectorAlloc(num, PS_TYPE_F32); // Measurements of fake sources
    412412    psVector *guess = psVectorAlloc(num, PS_TYPE_F32); // Guess at significance
    413     psVector *photMask = psVectorAlloc(num, PS_TYPE_MASK); // Mask for fluxes
     413    psVector *photMask = psVectorAlloc(num, PS_TYPE_VECTOR_MASK); // Mask for fluxes
    414414    for (int i = 0; i < num; i++) {
    415415        // Coordinates of interest
    … …  
    433433            float yGauss = gauss->data.F32[v]; // Value of Gaussian in y
    434434            for (int u = 0, x = xPix - size; u < fullSize; u++, x++) {
    435                 if (mask && mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
     435                if (mask && mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
    436436                    continue;
    437437                }
    … …  
    453453        }
    454454
    455         photMask->data.PS_TYPE_MASK_DATA[i] = ((isfinite(sumNoise) && isfinite(sumSource) &&
     455        photMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = ((isfinite(sumNoise) && isfinite(sumSource) &&
    456456                                                isfinite(sumWeight) && sumGauss > 0 && sumGauss2 > 0) ?
    457457                                               0 : 0xFF);
    … …  
    493493        ratio->data.F32[i] = measuredSig / guess->data.F32[i];
    494494        if (guess->data.F32[i] <= 0.0 || source->data.F32[i] <= 0.0 || !isfinite(ratio->data.F32[i])) {
    495             photMask->data.PS_TYPE_MASK_DATA[i] = 0xFF;
     495            photMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xFF;
    496496        }
    497497        psTrace("psModules.camera", 9, "Ratio %d: %f, %f, %f\n",
    … …  
    523523
    524524
    525 bool pmReadoutWeightRenorm(const pmReadout *readout, psMaskType maskVal, psStatsOptions meanStat,
     525bool pmReadoutWeightRenorm(const pmReadout *readout, psImageMaskType maskVal, psStatsOptions meanStat,
    526526                           psStatsOptions stdevStat, int width, psRandom *rng)
    527527{
    … …  
    591591
    592592
    593 bool pmReadoutMaskNonfinite(pmReadout *readout, psMaskType maskVal)
     593bool pmReadoutMaskNonfinite(pmReadout *readout, psImageMaskType maskVal)
    594594{
    595595    PM_ASSERT_READOUT_NON_NULL(readout, false);
    … …  
    601601
    602602    if (!readout->mask) {
    603         readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     603        readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    604604    }
    605605    psImage *mask = readout->mask;      // Readout's mask
    … …  
    608608        for (int x = 0; x < numCols; x++) {
    609609            if (!isfinite(image->data.F32[y][x]) || (weight && !isfinite(weight->data.F32[y][x]))) {
    610                 mask->data.PS_TYPE_MASK_DATA[y][x] |= maskVal;
     610                mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= maskVal;
    611611            }
    612612        }
    … …  
    618618
    619619
    620 bool pmReadoutMaskApply(pmReadout *readout, psMaskType maskVal)
     620bool pmReadoutMaskApply(pmReadout *readout, psImageMaskType maskVal)
    621621{
    622622    PM_ASSERT_READOUT_NON_NULL(readout, false);
    … …  
    625625
    626626    int numCols = readout->image->numCols, numRows = readout->image->numRows; // Size of image
    627     psMaskType **maskData = readout->mask->data.PS_TYPE_MASK_DATA; // Dereference mask
     627    psImageMaskType **maskData = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Dereference mask
    628628    psF32 **imageData = readout->image->data.F32;// Dereference image
    629629    psF32 **weightData = readout->weight ? readout->weight->data.F32 : NULL; // Dereference weight map
    … …  
    644644
    645645
    646 bool pmReadoutInterpolateBadPixels(pmReadout *readout, psMaskType maskVal, psImageInterpolateMode mode,
    647                                    float poorFrac, psMaskType maskPoor, psMaskType maskBad)
     646bool pmReadoutInterpolateBadPixels(pmReadout *readout, psImageMaskType maskVal, psImageInterpolateMode mode,
     647                                   float poorFrac, psImageMaskType maskPoor, psImageMaskType maskBad)
    648648{
    649649    PM_ASSERT_READOUT_NON_NULL(readout, false);
    … …  
    667667    psVector *imagePix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_F32); // Corresponding values for image
    668668    psVector *weightPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_F32); // Corresponding values for weight
    669     psVector *maskPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_MASK); // Corresponding values for mask
     669    psVector *maskPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_IMAGE_MASK); // Corresponding values for mask
     670    // NOTE: maskPix carries the actual image mask values -- do NOT use
     671    // PS_TYPE_VECTOR_MASK here; it is storage, and is not treated as a vector mask
    670672
    671673    long numBad = 0;                    // Number of bad pixels interpolated
    672674    for (int y = 0; y < numRows; y++) {
    673675        for (int x = 0; x < numCols; x++) {
    674             if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
     676            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
    675677                double imageValue, weightValue; // Image and weight value from interpolation
    676                 psMaskType maskValue = 0; // Mask value from interpolation
    677                 psImageInterpolateStatus status = psImageInterpolate(&imageValue, &weightValue, &maskValue,
    678                                                                      x, y, interp);
     678                psImageMaskType maskValue = 0; // Mask value from interpolation
     679                psImageInterpolateStatus status = psImageInterpolate(&imageValue, &weightValue, &maskValue, x, y, interp);
    679680                if (status == PS_INTERPOLATE_STATUS_ERROR || status == PS_INTERPOLATE_STATUS_OFF) {
    680681                    psError(PS_ERR_UNKNOWN, false, "Unable to interpolate readout at %d,%d", x, y);
    … …  
    697698                imagePix->data.F32[numBad] = imageValue;
    698699                weightPix->data.F32[numBad] = weightValue;
    699                 maskPix->data.PS_TYPE_MASK_DATA[numBad] = maskValue;
     700                maskPix->data.PS_TYPE_IMAGE_MASK_DATA[numBad] = maskValue;
    700701                numBad++;
    701702            }
    … …  
    709710        image->data.F32[y][x] = imagePix->data.F32[i];
    710711        weight->data.F32[y][x] = weightPix->data.F32[i];
    711         mask->data.PS_TYPE_MASK_DATA[y][x] = maskPix->data.PS_TYPE_MASK_DATA[i];
     712        mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = maskPix->data.PS_TYPE_IMAGE_MASK_DATA[i];
    712713    }
    713714

  • trunk/psModules/src/camera/pmFPAMaskWeight.h

    r20486 r21183  
    55 * @author Eugene Magnier, IfA
    66 *
    7  * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-10-31 21:50:16 $
     7 * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 * Copyright 2005-2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    4242/// iterating using pmReadoutReadNext, in which case the HDU can't be generated.
    4343bool pmReadoutSetMask(pmReadout *readout, ///< Readout for which to set mask
    44                       psMaskType satMask, ///< Mask value to give saturated pixels
    45                       psMaskType badMask  ///< Mask value to give bad (low) pixels
     44                      psImageMaskType satMask, ///< Mask value to give saturated pixels
     45                      psImageMaskType badMask  ///< Mask value to give bad (low) pixels
    4646    );
    4747
    … …  
    6262/// is suitable for output (complete with HDU entry).  This is intended for most operations.
    6363bool pmReadoutGenerateMask(pmReadout *readout, ///< Readout for which to generate mask
    64                            psMaskType sat, ///< Mask value to give saturated pixels
    65                            psMaskType bad ///< Mask value to give bad (low) pixels
     64                           psImageMaskType sat, ///< Mask value to give saturated pixels
     65                           psImageMaskType bad ///< Mask value to give bad (low) pixels
    6666    );
    6767
    … …  
    7979/// Calls pmReadoutGenerateMask and pmReadoutGenerateWeight for the readout
    8080bool pmReadoutGenerateMaskWeight(pmReadout *readout, ///< Readout for which to generate mask and weights
    81                                  psMaskType sat, ///< Mask value to give saturated pixels
    82                                  psMaskType bad, ///< Mask value to give bad (low) pixels
     81                                 psImageMaskType sat, ///< Mask value to give saturated pixels
     82                                 psImageMaskType bad, ///< Mask value to give bad (low) pixels
    8383                                 bool poisson ///< Use poisson weights (in addition to read noise)?
    8484                                );
    … …  
    8888/// Calls pmReadoutGenerateMaskWeight for each readout within the cell.
    8989bool pmCellGenerateMaskWeight(pmCell *cell, ///< Cell for which to generate mask and weights
    90                               psMaskType sat, ///< Mask value to give saturated pixels
    91                               psMaskType bad, ///< Mask value to give bad (low) pixels
     90                              psImageMaskType sat, ///< Mask value to give saturated pixels
     91                              psImageMaskType bad, ///< Mask value to give bad (low) pixels
    9292                              bool poisson ///< Use poisson weights (in addition to read noise)?
    9393                             );
    … …  
    9898bool pmReadoutWeightRenormPixels(
    9999    const pmReadout *readout,           ///< Readout to normalise
    100     psMaskType maskVal,                 ///< Value to mask
     100    psImageMaskType maskVal,                 ///< Value to mask
    101101    psStatsOptions meanStat,            ///< Statistic to measure the mean (of the variance map)
    102102    psStatsOptions stdevStat,           ///< Statistic to measure the stdev (of the image)
    … …  
    110110bool pmReadoutWeightRenormPhot(
    111111    const pmReadout *readout,           ///< Readout to normalise
    112     psMaskType maskVal,                 ///< Value to mask
     112    psImageMaskType maskVal,                 ///< Value to mask
    113113    int num,                            ///< Number of instances to measure over the image
    114114    float width,                        ///< Photometry width
    … …  
    123123/// that patch corresponds.
    124124bool pmReadoutWeightRenorm(const pmReadout *readout, // Readout to normalise
    125                            psMaskType maskVal, // Value to mask
     125                           psImageMaskType maskVal, // Value to mask
    126126                           psStatsOptions meanStat, // Statistic to measure the mean (of the variance map)
    127127                           psStatsOptions stdevStat, // Statistic to measure the stdev (of the image)
    … …  
    136136/// the provided value.
    137137bool pmReadoutMaskNonfinite(pmReadout *readout, ///< Readout to mask
    138                             psMaskType maskVal ///< Mask value to give non-finite pixels
     138                            psImageMaskType maskVal ///< Mask value to give non-finite pixels
    139139    );
    140140
    … …  
    145145/// sets masked areas to NAN in the image and weight.
    146146bool pmReadoutMaskApply(pmReadout *readout, ///< Readout to mask
    147                         psMaskType maskVal ///< Mask value for which to apply mask
     147                        psImageMaskType maskVal ///< Mask value for which to apply mask
    148148    );
    149149
    … …  
    152152/// Scan the mask image for bad pixels, and interpolate over them using the nominated options
    153153bool pmReadoutInterpolateBadPixels(pmReadout *readout, ///< Readout to work on
    154                                    psMaskType maskVal, ///< Value to mask
     154                                   psImageMaskType maskVal, ///< Value to mask
    155155                                   psImageInterpolateMode mode, ///< Interpolation mode
    156156                                   float poorFrac, ///< Maximum bad fraction of kernel for "poor" status
    157                                    psMaskType maskPoor, ///< Mask value to give poor pixels
    158                                    psMaskType maskBad ///< Mask value to give bad pixels
     157                                   psImageMaskType maskPoor, ///< Mask value to give poor pixels
     158                                   psImageMaskType maskBad ///< Mask value to give bad pixels
    159159    );
    160160

  • trunk/psModules/src/camera/pmFPAMosaic.c

    r19073 r21183  
    471471        numImages++;
    472472
    473         // Only implemented for F32 and U8 images so far.
    474         assert(image->type.type == PS_TYPE_F32 || image->type.type == PS_TYPE_U8);
    475473        // All input types must be the same
    476474        if (type == 0) {
    … …  
    537535        if (xBinSource->data.S32[i] == xBinTarget && yBinSource->data.S32[i] == yBinTarget) {
    538536            switch (type) {
     537                COPY_WITH_PARITY_DIFFERENCE(U8);
     538                COPY_WITH_PARITY_DIFFERENCE(U16);
     539                COPY_WITH_PARITY_DIFFERENCE(U32);
     540                COPY_WITH_PARITY_DIFFERENCE(U64);
     541                COPY_WITH_PARITY_DIFFERENCE(S8);
     542                COPY_WITH_PARITY_DIFFERENCE(S16);
     543                COPY_WITH_PARITY_DIFFERENCE(S32);
     544                COPY_WITH_PARITY_DIFFERENCE(S64);
    539545                COPY_WITH_PARITY_DIFFERENCE(F32);
    540                 COPY_WITH_PARITY_DIFFERENCE(U8);
     546                COPY_WITH_PARITY_DIFFERENCE(F64);
    541547              default:
    542548                psAbort("Should never get here.\n");
    … …  
    548554        // We have to do all of the hard work ourselves
    549555        switch (type) {
    550             FILL_IN(F32);
    551             FILL_IN(U8);
     556            FILL_IN(U8);
     557            FILL_IN(U16);
     558            FILL_IN(U32);
     559            FILL_IN(U64);
     560            FILL_IN(S8);
     561            FILL_IN(S16);
     562            FILL_IN(S32);
     563            FILL_IN(S64);
     564            FILL_IN(F32);
     565            FILL_IN(F64);
    552566          default:
    553567            psAbort("Should never get here.\n");
    … …  
    730744                       const pmChip *chip, // Chip to mosaic
    731745                       const pmCell *targetCell, // Cell to which to mosaic
    732                        psMaskType blank // Mask value to give blank pixels
     746                       psImageMaskType blank // Mask value to give blank pixels
    733747                      )
    734748{
    … …  
    838852                      const pmChip *targetChip, // Chip to which to mosaic
    839853                      const pmCell *targetCell, // Cell to which to mosaic
    840                       psMaskType blank  // Mask value to give blank pixels
     854                      psImageMaskType blank  // Mask value to give blank pixels
    841855                     )
    842856{
    … …  
    9941008// the mosaic image.
    9951009
    996 bool pmChipMosaic(pmChip *target, const pmChip *source, bool deepCopy, psMaskType blank)
     1010bool pmChipMosaic(pmChip *target, const pmChip *source, bool deepCopy, psImageMaskType blank)
    9971011{
    9981012    // Target exists, and has only a single cell
    … …  
    12251239
    12261240
    1227 bool pmFPAMosaic(pmFPA *target, const pmFPA *source, bool deepCopy, psMaskType blank)
     1241bool pmFPAMosaic(pmFPA *target, const pmFPA *source, bool deepCopy, psImageMaskType blank)
    12281242{
    12291243    // Target exists, and has only a single chip with single cell

  • trunk/psModules/src/camera/pmFPAMosaic.h

    r13898 r21183  
    44 * @author Paul Price, IfA
    55 *
    6  * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    7  * @date $Date: 2007-06-20 02:22:26 $
     6 * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2009-01-27 06:39:38 $
    88 * Copyright 2005-2006 Institute for Astronomy, University of Hawaii
    99 */
    … …  
    2424                  const pmChip *source, ///< Source chip whose cells will be mosaicked
    2525                  bool deepCopy,        ///< Require a deep copy (disregard 'nice' chip)
    26                   psMaskType blank      ///< Mask value to give blank pixels
     26                  psImageMaskType blank      ///< Mask value to give blank pixels
    2727    );
    2828
    … …  
    3636                 const pmFPA *source,   ///< FPA whose chips and cells will be mosaicked
    3737                 bool deepCopy,         ///< Require a deep copy (disregard 'nice' chip)
    38                  psMaskType blank       ///< Mask value to give blank pixels
     38                 psImageMaskType blank       ///< Mask value to give blank pixels
    3939                );
    4040/// @}

  • trunk/psModules/src/camera/pmFPARead.c

    r19246 r21183  
    3535static psElemType pixelTypes[] = {
    3636    PS_TYPE_F32,
    37     PS_TYPE_MASK,
     37    PS_TYPE_IMAGE_MASK,
    3838    PS_TYPE_F32,
    3939    0

  • trunk/psModules/src/camera/pmFPA_JPEG.c

    r19653 r21183  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2008-09-23 02:00:36 $
     7 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2009-01-27 06:39:38 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    157157    psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
    158158    stats->nSubsample = 10000;
    159     psMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
     159    psImageMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
    160160    float mean = 0, delta = 0;          //
    161161    if (!psImageBackground(stats, NULL, readout->image, readout->mask, maskVal, rng)) {

  • trunk/psModules/src/camera/pmHDU.c

    r19385 r21183  
    167167                     const psArray *images, // Images to write
    168168                     const psArray *masks, // Masks to use when writing
    169                      psMaskType maskVal,// Value to mask
     169                     psImageMaskType maskVal,// Value to mask
    170170                     psFits *fits       // FITS file to which to write
    171171                    )
    … …  
    222222    PS_ASSERT_PTR_NON_NULL(fits, false);
    223223
    224     psMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
     224    psImageMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
    225225    return hduWrite(hdu, hdu->images, hdu->masks, maskVal, fits);
    226226}
    … …  
    240240    PS_ASSERT_PTR_NON_NULL(fits, false);
    241241
    242     psMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
     242    psImageMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
    243243    return hduWrite(hdu, hdu->weights, hdu->masks, maskVal, fits);
    244244}

  • trunk/psModules/src/camera/pmReadoutStack.c

    r18830 r21183  
    7878
    7979// XXX for the moment, use col0, row0, numCols, numRows supplied from the outside
    80 bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psMaskType blank)
     80bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psImageMaskType blank)
    8181{
    8282    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    9494        // XXX is this an error?
    9595        if (readout->mask) return false;
    96         readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     96        readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    9797        psImageInit(readout->mask, blank);
    9898    }
    … …  
    163163bool pmReadoutUpdateSize(pmReadout *readout, int minCols, int minRows,
    164164                         int numCols, int numRows, bool mask, bool weight,
    165                          psMaskType blank)
     165                         psImageMaskType blank)
    166166{
    167167    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    191191    if (mask) {
    192192        if (!readout->mask) {
    193             readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     193            readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    194194            psImageInit(readout->mask, blank);
    195195        }
    196196        if (readout->mask->numCols < numCols || readout->mask->numRows < numRows) {
    197             psImage *newMask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     197            psImage *newMask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    198198            psImageInit(newMask, blank);
    199199            psImageOverlaySection(newMask, readout->mask, readout->col0, readout->row0, "=");

  • trunk/psModules/src/camera/pmReadoutStack.h

    r18830 r21183  
    1414                         bool mask,     ///< Worry about the mask?
    1515                         bool weight,   ///< Worry about the weight?
    16                          psMaskType blank ///< Mask value to give to blank pixels
     16                         psImageMaskType blank ///< Mask value to give to blank pixels
    1717    );
    1818
    … …  
    4747
    4848// XXX for the moment, use col0, row0, numCols, numRows supplied from the outside
    49 bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psMaskType blank);
     49bool pmReadoutStackDefineOutput(pmReadout *readout, int col0, int row0, int numCols, int numRows, bool mask, bool weight, psImageMaskType blank);
    5050
    5151bool pmReadoutStackSetOutputSize(int *col0, int *row0, int *numCols, int *numRows, const psArray *inputs);

  • trunk/psModules/src/concepts/pmConceptsStandard.c

    r20598 r21183  
    1616#include "pmConceptsWrite.h"
    1717#include "pmConceptsStandard.h"
     18
     19// XXX why are these functions not supporting all types (S64, U64 often missing)?
    1820
    1921// The functions in this file are intended to be called solely within the psModules concepts code.  For this
    … …  
    591593        TYPE_CASE(binning, concept, U16);
    592594        TYPE_CASE(binning, concept, U32);
     595        // TYPE_CASE(binning, concept, U64);
    593596        TYPE_CASE(binning, concept, S8);
    594597        TYPE_CASE(binning, concept, S16);
    595598        TYPE_CASE(binning, concept, S32);
     599        // TYPE_CASE(binning, concept, S64);
    596600      default:
    597601        psError(PS_ERR_UNKNOWN, true, "Note sure how to parse %s of type %x --- assuming 1.\n", pattern->name,

  • trunk/psModules/src/config/pmConfigMask.c

    r19870 r21183  
    99#include "pmConfigMask.h"
    1010
    11 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    12 // Private functions
    13 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    14 
    15 // maskSetValues examine named mask values and set the bits for maskValue and markValue.
    16 // Ensures that the below-named bad mask values are set, and calculates the mask value to catch them all
    17 // Ensure that the below-named other mask values are set (to 0x00 if necessary)
    18 
    19 // List of mask names for "bad" (i.e., mask me please) pixels
    20 static const char *badMaskNames[] = { "DETECTOR", // Something is wrong with the detector
    21                                       "DARK", // Pixel doesn't dark-subtract properly
    22                                       "FLAT", // Pixel doesn't flat-field properly
    23                                       "BLANK", // Pixel doesn't contain valid data
    24                                       "RANGE",// Pixel is out-of-range of linearity
    25                                       "SAT",  // Pixel is saturated
    26                                       // "LOW",  // Pixel is low
    27                                       // "CONV", // Pixel is bad after convolution with a bad pixel
    28                                       "BAD", // Pixel is low
    29                                       "BAD.WARP", // Pixel is bad after convolution with a bad pixel
    30                                       "CR",   // Pixel contains a cosmic ray
    31                                       "GHOST",// Pixel contains an optical ghost
    32                                       NULL // End marker
     11static pmConfigMaskInfo masks[] = {
     12    { "DETECTOR",  NULL,       0x00, true  },   // Something is wrong with the detector
     13    { "DARK",      "DETECTOR", 0x00, true  },   // Pixel doesn't dark-subtract properly
     14    { "FLAT",      "DETECTOR", 0x01, true  },   // Pixel doesn't flat-field properly
     15    { "BLANK",     "DETECTOR", 0x01, true  },   // Pixel doesn't contain valid data
     16    { "RANGE",     NULL,       0x00, true  },   // Pixel is out-of-range of linearity
     17    { "SAT",       "RANGE",    0x01, true  },   // Pixel is saturated
     18    { "BAD",       "RANGE",    0x01, true  },   // Pixel is low
     19    { "BAD.WARP",  NULL,       0x01, true  },   // Pixel is bad after convolution with a bad pixel
     20    { "CR",        NULL,       0x00, true  },   // Pixel contains a cosmic ray
     21    { "GHOST",     NULL,       0x00, true  },   // Pixel contains an optical ghost
     22    { "POOR.WARP", NULL,       0x00, false },   // Pixel is poor after convolution with a bad pixel
     23    // "LOW"  Pixel is low
     24    // "CONV" Pixel is bad after convolution with a bad pixel
    3325};
    34 // Fallback names in case a bad mask name is not defined
    35 static const char *fallbackMaskNames[] = { NULL, // DETECTOR
    36                                            "DETECTOR", // DARK
    37                                            "DETECTOR", // FLAT
    38                                            "DETECTOR", // BLANK
    39                                            NULL, // RANGE
    40                                            "RANGE", // SAT
    41                                            "RANGE", // LOW
    42                                            NULL, // CONV
    43                                            NULL, // CR
    44                                            NULL, // GHOST
    45 };
    46 // Default values in case a bad mask name and its fallback is not defined
    47 static const psMaskType defaultMask[] = { 0x00, // DETECTOR
    48                                           0x00, // DARK
    49                                           0x01, // FLAT
    50                                           0x01, // BLANK
    51                                           0x00, // RANGE
    52                                           0x01, // SAT
    53                                           0x01, // LOW
    54                                           0x01, // CONV
    55                                           0x00, // CR
    56                                           0x00  // GHOST
    57 };
    58 // Other mask names to ensure exist; these shouldn't be combined in the MASK.VALUE
    59 static const char *otherMaskNames[] = { // "POOR", // Pixel is poor after convolution with a bad pixel
    60                                         "POOR.WARP", // Pixel is poor after convolution with a bad pixel
    61                                         NULL // End marker
    62 };
    63 
    64 static bool maskSetValues(psMaskType *outMaskValue, // Value of MASK.VALUE, returned
    65                           psMaskType *outMarkValue, // Value of MARK.VALUE, returned
    66                           psMetadata *source  // Source of mask bits
    67                           )
     26
     27// The functions in this file do not force the recipe or header values to be stored as the same
     28// type as psImageMaskType : they only check that the given values will fit in the space
     29// provided by psImageMaskType.  This should allow some backwards compatibility (old 8-bit
     30// masks will work with a 16-bit system), but will catch unhandled conflicts (trying to fit 16
     31// bits in 8-bits of space).
     32
     33// XXX this file does not have psError vs psWarning worked out correctly.  some of the
     34// failure modes should result in errors, not just warnings.
     35
     36// pmConfigMaskSetInMetadata examines named mask values and set the bits for maskValue and
     37// markValue.  Ensures that the below-named mask values are set, and calculates the mask value
     38// to catch all of the mask values marked as 'bad'.  Supplies the fallback name if the primary
     39// name is not found, or the default values if the fallback name is not found.
     40
     41bool pmConfigMaskSetInMetadata(psImageMaskType *outMaskValue, // Value of MASK.VALUE, returned
     42                               psImageMaskType *outMarkValue, // Value of MARK.VALUE, returned
     43                               psMetadata *source  // Source of mask bits
     44    )
    6845{
    6946    PS_ASSERT_METADATA_NON_NULL(source, false);
    70 
     47   
    7148    // Ensure all the bad mask names exist, and set the value to catch all bad pixels
    72     psMaskType maskValue = 0;           // Value to mask to catch all the bad pixels
    73     for (int i = 0; badMaskNames[i]; i++) {
    74         const char *name = badMaskNames[i]; // Name for mask
    75         const char *fallback = fallbackMaskNames[i]; // Fallback for mask
    76 
     49    psImageMaskType maskValue = 0;           // Value to mask to catch all the bad pixels
     50    psImageMaskType allMasks = 0;            // Value to mask to catch all masked bits (to set MARK)
     51
     52    int nMasks = sizeof (masks) / sizeof (pmConfigMaskInfo);
     53
     54    for (int i = 0; i < nMasks; i++) {
    7755        bool mdok;                      // Status of MD lookup
    78         psMaskType value = psMetadataLookupU8(&mdok, source, name); // Value of mask
     56        psImageMaskType value = psMetadataLookupImageMaskFromGeneric(&mdok, source, masks[i].badMaskName); // Value of mask
     57        if (!mdok) {
     58            psWarning ("problem with mask value %s\n", masks[i].badMaskName);
     59        }
     60
    7961        if (!value) {
    80             if (fallback) {
    81                 value = psMetadataLookupU8(&mdok, source, fallback);
    82             }
    83             if (!value) {
    84                 value = defaultMask[i];
    85             }
    86             psMetadataAddU8(source, PS_LIST_TAIL, name, PS_META_REPLACE, NULL, value);
    87         }
    88         maskValue |= value;
    89     }
    90 
    91     // Ensure all the other mask names exist
    92     for (int i = 0; otherMaskNames[i]; i++) {
    93         const char *name = otherMaskNames[i]; // Name for mask
    94         bool mdok;                      // Status of MD lookup
    95         psMaskType value = psMetadataLookupU8(&mdok, source, name); // Value of mask
    96         if (!value) {
    97             psMetadataAddU8(source, PS_LIST_TAIL, name, PS_META_REPLACE, NULL, 0x00);
    98         }
     62            if (masks[i].fallbackName) {
     63                value = psMetadataLookupImageMaskFromGeneric(&mdok, source, masks[i].fallbackName);
     64            }
     65            if (!value) {
     66                value = masks[i].defaultMaskValue;
     67            }
     68            psMetadataAddImageMask(source, PS_LIST_TAIL, masks[i].badMaskName, PS_META_REPLACE, NULL, value);
     69        }
     70        if (masks[i].isBad) {
     71            maskValue |= value;
     72        }
     73        allMasks |= value;
    9974    }
    10075
    10176    // search for an unset bit to use for MARK:
    102     psMaskType markValue = 0x80;
    103 
    104     int nBits = sizeof(psMaskType) * 8;
     77    psImageMaskType markValue = 0x00;
     78    psImageMaskType markTrial = 0x01;
     79
     80    int nBits = sizeof(psImageMaskType) * 8;
    10581    for (int i = 0; !markValue && (i < nBits); i++) {
    106         if (maskValue & markValue) {
    107             markValue >>= 1;
     82        if (allMasks & markTrial) {
     83            markTrial <<= 1;
    10884        } else {
    109             markValue = markValue;
     85            markValue = markTrial;
    11086        }
    11187    }
    … …  
    11692
    11793    // update the list with the results
    118     psMetadataAddU8(source, PS_LIST_TAIL, "MASK.VALUE", PS_META_REPLACE, NULL, maskValue);
    119     psMetadataAddU8(source, PS_LIST_TAIL, "MARK.VALUE", PS_META_REPLACE, NULL, markValue);
     94    psMetadataAddImageMask(source, PS_LIST_TAIL, "MASK.VALUE", PS_META_REPLACE, NULL, maskValue);
     95    psMetadataAddImageMask(source, PS_LIST_TAIL, "MARK.VALUE", PS_META_REPLACE, NULL, markValue);
    12096
    12197    if (outMaskValue) {
    … …  
    130106
    131107// Get a mask value by name(s)
    132 static psMaskType maskGet(psMetadata *source, // Source of masks
    133                           const char *masks // Mask values to get
    134                           )
    135 {
    136     psMaskType mask = 0;                // Mask value, to return
     108psImageMaskType pmConfigMaskGetFromMetadata(psMetadata *source, // Source of masks
     109                                            const char *masks // Mask values to get
     110    )
     111{
     112    psImageMaskType mask = 0;                // Mask value, to return
    137113
    138114    psArray *names = psStringSplitArray(masks, " ,;", false); // Array of symbolic names
    … …  
    140116        const char *name = names->data[i]; // Symbolic name of interest
    141117        bool mdok;                      // Status of MD lookup
    142         psMaskType value = psMetadataLookupU8(&mdok, source, name);
     118        psImageMaskType value = psMetadataLookupImageMaskFromGeneric(&mdok, source, name);
    143119        if (!mdok) {
    144120            // Try and generate the value if we can
    145121            if (strcmp(name, "MASK.VALUE") == 0 || strcmp(name, "MARK.VALUE") == 0) {
    146                 if (!maskSetValues(NULL, NULL, source)) {
     122                if (!pmConfigMaskSetInMetadata(NULL, NULL, source)) {
    147123                    psError(PS_ERR_UNKNOWN, false, "Unable to set mask bits.");
    148124                    return 0;
    149125                }
    150                 value = psMetadataLookupU8(&mdok, source, name);
     126                value = psMetadataLookupImageMaskFromGeneric(&mdok, source, name);
    151127                psAssert(mdok, "Should have generated mask value");
    152128            } else {
    … …  
    163139}
    164140
     141// lookup an image mask value by name from a psMetadata, without requiring the entry to
     142// be of type psImageMaskType, but verifying that it will fit in psImageMaskType
     143psImageMaskType psMetadataLookupImageMaskFromGeneric (bool *status, const psMetadata *md, const char *name) {
     144
     145    *status = true;
     146
     147        // select the mask bit name from the header
     148        psMetadataItem *item = psMetadataLookup (md, name);
     149        if (!item) {
     150            psWarning("Unable to find header keyword %s when parsing mask", name);
     151            *status = false;
     152            return 0;
     153        }
     154
     155        // the value may be any of the U8, U16, U32, U64 types : accept the value regardless of type size
     156        psU64 fullValue = 0;
     157        switch (item->type) {
     158          case PS_DATA_U8:
     159            fullValue = item->data.U8;
     160            break;
     161          case PS_DATA_U16:
     162            fullValue = item->data.U16;
     163            break;
     164          case PS_DATA_U32:
     165            fullValue = item->data.U32;
     166            break;
     167          case PS_DATA_U64:
     168            fullValue = item->data.U64;
     169            break;
     170          case PS_DATA_S8:
     171            fullValue = item->data.S8;
     172            break;
     173          case PS_DATA_S16:
     174            fullValue = item->data.S16;
     175            break;
     176          case PS_DATA_S32:
     177            fullValue = item->data.S32;
     178            break;
     179          case PS_DATA_S64:
     180            fullValue = item->data.S64;
     181            break;
     182          default:
     183            psWarning("Mask entry %s in metadata is not of a mask type", name);
     184            *status = false;
     185            return 0;
     186        }
     187
     188        // will the incoming value fit within the current image mask type?
     189        if (fullValue > PS_MAX_IMAGE_MASK_TYPE) {
     190            psWarning("Mask entry %s in metadata is larger than allowed by the psImageMaskType", name);
     191            *status = false;
     192            return 0;
     193        }
     194        psImageMaskType value = fullValue;
     195        // XXX validate that value is a 2^n value?
     196
     197        return value;
     198}
     199
    165200// Remove from the header keywords starting with the provided string
    166 static int maskRemoveHeader(psMetadata *header, // Header from which to remove keywords
    167                             const char *start // Remove keywords that start with this string
    168                             )
     201int pmConfigMaskRemoveHeaderKeywords(psMetadata *header, // Header from which to remove keywords
     202                                     const char *start // Remove keywords that start with this string
     203    )
    169204{
    170205    psString regex = NULL;              // Regular expression for keywords
    … …  
    182217}
    183218
     219// look up the named mask value(s) from the MASKS recipe in the config system
     220psImageMaskType pmConfigMaskGet(const char *masks, const pmConfig *config)
     221{
     222    psAssert(config, "Require configuration");
     223    PS_ASSERT_STRING_NON_EMPTY(masks, 0);
     224
     225    bool mdok;                          // Status of MD lookup
     226    psMetadata *recipe = psMetadataLookupMetadata(&mdok, config->recipes, "MASKS"); // The recipe
     227    if (!recipe) {
     228        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
     229        return 0;
     230    }
     231   
     232    psImageMaskType mask = pmConfigMaskGetFromMetadata (recipe, masks);
     233    return mask;
     234}
     235
     236bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psImageMaskType maskValue)
     237{
     238    psAssert(config, "Require configuration");
     239    PS_ASSERT_STRING_NON_EMPTY(maskName, false);
     240
     241    psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
     242    if (!recipe) {
     243        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
     244        return false;
     245    }
     246
     247    bool status = psMetadataAddImageMask(recipe, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue);
     248    return status;
     249}
     250
     251
     252// replace the named masks in the recipe with values in the header:
     253// replace only the names in the header in the recipe
     254bool pmConfigMaskReadHeader(pmConfig *config, const psMetadata *header)
     255{
     256    PS_ASSERT_PTR_NON_NULL(config, false);
     257    PS_ASSERT_METADATA_NON_NULL(header, false);
     258
     259    bool status = false;
     260
     261    psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
     262    if (!recipe) {
     263        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
     264        return false;
     265    }
     266
     267    // MASK.VALUE and MARK.VALUE aren't usually set in the recipe, but may be set in the header: create fake
     268    // versions so that it won't complain later
     269    if (!psMetadataLookup(recipe, "MASK.VALUE")) {
     270        psMetadataAddImageMask(recipe, PS_LIST_TAIL, "MASK.VALUE", 0, "Bits to mask", 0);
     271    }
     272    if (!psMetadataLookup(recipe, "MARK.VALUE")) {
     273        psMetadataAddImageMask(recipe, PS_LIST_TAIL, "MARK.VALUE", 0, "Bits for marking", 0);
     274    }
     275
     276    // How many mask values do we need to read?  We raise an error if this is not found,
     277    // unless the MASK.FORCE is set to true in the camera config
     278    int nMask = psMetadataLookupS32(&status, header, "MSKNUM");
     279    if (!status) {
     280        if (psMetadataLookupBool(&status, config->camera, "MASK.FORCE")) {
     281            psWarning("No mask values in header.  Assuming MASKS recipe is accurate because of MASK.FORCE");
     282            return true;
     283        }
     284        psError(PS_ERR_UNKNOWN, true, "Unable to find MSKNUM in header.");
     285        return false;
     286    }
     287
     288    // Loop over the expected number of header mask names.  For each named mask value, there
     289    // should be a pair of header keywords, one for the name and one for the value
     290    char namekey[80];                   // Keyword name for symbolic name of mask entry
     291    char valuekey[80];                  // Keyword name for value of mask entry
     292    for (int i = 0; i < nMask; i++) {
     293        snprintf(namekey,  64, "MSKNAM%02d", i);
     294        snprintf(valuekey, 64, "MSKVAL%02d", i);
     295
     296        char *name = psMetadataLookupStr(&status, header, namekey);
     297        if (!status || !name) {
     298            psWarning("Unable to find header keyword %s when parsing mask", namekey);
     299            continue;
     300        }
     301
     302        psImageMaskType headerValue = psMetadataLookupImageMaskFromGeneric (&status, header, valuekey);
     303        if (!status) {
     304            psWarning("Failed to get mask value %s from header, skipping", valuekey);
     305            continue;
     306        }           
     307
     308        // since we may read multiple mask files, we need to warn (or error?) if any of the
     309        // header mask values conflict with other header mask values; However, the original
     310        // mask values from the recipe do not need to match the header values.
     311
     312        // when we add a header mask value, we will also add the NAME.ALREADY entry; check for
     313        // the NAME.ALREADY entry to see if we have previously added this mask value from a
     314        // header.
     315
     316        psString nameAlready = NULL;    // Name of key with ".ALREADY" added
     317        psStringAppend(&nameAlready, "%s.ALREADY", name);
     318        bool already = psMetadataLookupBool(&status, recipe, nameAlready); // Already read this one?
     319
     320        bool inRecipe = false;
     321        psImageMaskType recipeValue = psMetadataLookupImageMaskFromGeneric (&inRecipe, recipe, name);
     322        if (!inRecipe) {
     323            psWarning("Mask value %s is not defined in the recipe", name);
     324        }           
     325
     326        if (already) {
     327            assert (inRecipe); // XXX makes no sense for NAME.ALREADY to be in without NAME
     328            if (recipeValue != headerValue) {
     329                psWarning("New mask header value does not match previously loaded entry: %x vs %x", headerValue, recipeValue);
     330                psMetadataAddImageMask(recipe, PS_LIST_TAIL, name, PS_META_REPLACE, "Bitmask bit value", headerValue);
     331                // XXX alternatively, error here
     332            }
     333        } else {
     334            psMetadataAddBool(recipe, PS_LIST_TAIL, nameAlready, 0, "Already read this mask value", true);
     335            psMetadataAddImageMask(recipe, PS_LIST_TAIL, name, PS_META_REPLACE, "Bitmask bit value", headerValue);
     336        }
     337
     338        psFree(nameAlready);
     339    }
     340
     341    return true;
     342}
     343
     344// write the named mask bits to the header
     345bool pmConfigMaskWriteHeader(const pmConfig *config, psMetadata *header)
     346{
     347    PS_ASSERT_PTR_NON_NULL(config, false);
     348    PS_ASSERT_METADATA_NON_NULL(header, false);
     349
     350    pmConfigMaskRemoveHeaderKeywords(header, "MSKNAM");
     351    pmConfigMaskRemoveHeaderKeywords(header, "MSKVAL");
     352    if (psMetadataLookup(header, "MSKNUM")) {
     353        psMetadataRemoveKey(header, "MSKNUM");
     354    }
     355
     356    char namekey[80];
     357    char valuekey[80];
     358
     359    psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
     360    if (!recipe) {
     361        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
     362        return false;
     363    }
     364
     365    int nMask = 0;
     366
     367    psMetadataIterator *iter = psMetadataIteratorAlloc(recipe, PS_LIST_HEAD, NULL); // Iterator
     368    psMetadataItem *item;               // Item from iteration
     369    while ((item = psMetadataGetAndIncrement(iter))) {
     370
     371        // XXX this would give a false positive for mask which include '.ALREADY' in their names
     372        char *ptr = strstr (item->name, ".ALREADY");
     373        if (ptr) continue;
     374
     375        psU64 fullValue = 0;
     376        switch (item->type) {
     377          case PS_DATA_U8:
     378            fullValue = item->data.U8;
     379            break;
     380          case PS_DATA_U16:
     381            fullValue = item->data.U16;
     382            break;
     383          case PS_DATA_U32:
     384            fullValue = item->data.U32;
     385            break;
     386          case PS_DATA_U64:
     387            fullValue = item->data.U64;
     388            break;
     389          default:
     390            psWarning("mask recipe entry %s is not a bit value\n", item->name);
     391            continue;
     392        }
     393        assert (fullValue <= PS_MAX_IMAGE_MASK_TYPE); // this should have been asserted on read...
     394
     395        snprintf(namekey,  64, "MSKNAM%02d", nMask);
     396        snprintf(valuekey, 64, "MSKVAL%02d", nMask);
     397
     398        psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name);
     399        psMetadataAddImageMask(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", fullValue);
     400        nMask++;
     401    }
     402    psFree(iter);
     403
     404    psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Bitmask bit count", nMask);
     405    return true;
     406}
     407
     408
     409bool pmConfigMaskSetBits(psImageMaskType *outMaskValue, psImageMaskType *outMarkValue, const pmConfig *config)
     410{
     411    PS_ASSERT_PTR_NON_NULL(config, false);
     412
     413    psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
     414    if (!recipe) {
     415        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
     416        return false;
     417    }
     418
     419    bool status = pmConfigMaskSetInMetadata(outMaskValue, outMarkValue, recipe);
     420    return status;
     421}
     422
    184423//////////////////////////////////////////////////////////////////////////////////////////////////////////////
    185424// FPA version of mask functions.  These are not ready to go yet.
    … …  
    187426
    188427#if 0
    189 bool pmFPAMaskSetValues(psMaskType *outMaskValue, psMaskType *outMarkValue, pmFPA *fpa)
    190 {
     428
     429bool pmFPAMaskWriteHeader(psMetadata *header, const pmFPA *fpa)
     430{
     431    PS_ASSERT_METADATA_NON_NULL(header, false);
    191432    PS_ASSERT_PTR_NON_NULL(fpa, false);
    192433
     434    // clear out the header of the associated keywords:
     435    pmConfigMaskRemoveHeaderKeywords(header, "MSKNAM");
     436    pmConfigMaskRemoveHeaderKeywords(header, "MSKVAL");
     437    if (psMetadataLookup(header, "MSKNUM")) {
     438        psMetadataRemoveKey(header, "MSKNUM");
     439    }
     440
     441    char namekey[80], valuekey[80];     // Mask name and mask value header keywords
     442    int numMask = 0;                    // Number of mask entries
     443
     444    psMetadataIterator *iter = psMetadataIteratorAlloc(fpa->masks, PS_LIST_HEAD, NULL); // Iterator
     445    psMetadataItem *item;               // Item from iteration
     446    while ((item = psMetadataGetAndIncrement(iter))) {
     447        if (item->type != PS_TYPE_IMAGE_MASK) {
     448            psWarning("mask recipe entry %s is not of a mask type (%x)", item->name, item->type);
     449            continue;
     450        }
     451
     452        snprintf(namekey,  64, "MSKNAM%02d", numMask);
     453        snprintf(valuekey, 64, "MSKVAL%02d", numMask);
     454
     455        psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name);
     456        psMetadataAddImageMask(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", item->data.PS_TYPE_IMAGE_MASK_DATA);
     457        numMask++;
     458    }
     459    psFree(iter);
     460
     461    return psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Number of named mask entries", numMask);
     462}
     463
     464bool pmFPAMaskSetValues(psImageMaskType *outMaskValue, psImageMaskType *outMarkValue, pmFPA *fpa)
     465{
     466    PS_ASSERT_PTR_NON_NULL(fpa, false);
     467
    193468    return maskSetValues(outMaskValue, outMarkValue, fpa->masks);
    194469}
    195470
    196 psMaskType pmFPAMaskGet(const pmFPA *fpa, const char *masks, const pmConfig *config)
     471psImageMaskType pmFPAMaskGet(const pmFPA *fpa, const char *masks, const pmConfig *config)
    197472{
    198473    PS_ASSERT_PTR_NON_NULL(fpa, 0);
    … …  
    201476
    202477    if (fpa->masks) {
    203         return maskGet(fpa->masks, masks);
     478        return pmConfigMaskGetFromMetadata(fpa->masks, masks);
    204479    }
    205480    return pmConfigMaskGet(masks, config);
    206481}
    207482
    208 bool pmFPAMaskSet(pmFPA *fpa, const char *maskName, psMaskType maskValue)
     483bool pmFPAMaskSet(pmFPA *fpa, const char *maskName, psImageMaskType maskValue)
    209484{
    210485    PS_ASSERT_PTR_NON_NULL(fpa, 0);
    … …  
    214489        fpa->masks = psMetadataAlloc();
    215490    }
    216     return psMetadataAddU8(fpa->masks, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue);
     491    return psMetadataAddImageMask(fpa->masks, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue);
    217492}
    218493
    … …  
    250525            continue;
    251526        }
    252         psU8 bit = psMetadataLookupU8(&mdok, header, valuekey);
     527        psImageMaskType bit = psMetadataLookupImageMask(&mdok, header, valuekey);
    253528        if (!mdok) {
    254529            psWarning("Unable to find header keyword %s when parsing mask", namekey);
    … …  
    260535        psMetadataItem *item = psMetadataLookup(fpa->masks, name); // Item in recipe with current value
    261536        if (item) {
    262             psAssert(item->type == PS_TYPE_MASK, "Mask entry %s is not of a mask type (%x)",
     537            psAssert(item->type == PS_TYPE_IMAGE_MASK, "Mask entry %s is not of a mask type (%x)",
    263538                     name, item->type);
    264             if (item->data.PS_TYPE_MASK_DATA != bit) {
     539            if (item->data.PS_TYPE_IMAGE_MASK_DATA != bit) {
    265540                psWarning("New mask entry %s doesn't match previously loaded entry: %x vs %x",
    266                           name, bit, item->data.PS_TYPE_MASK_DATA);
     541                          name, bit, item->data.PS_TYPE_IMAGE_MASK_DATA);
    267542            }
    268543        } else {
    269             psMetadataAddU8(fpa->masks, PS_LIST_TAIL, name, 0, NULL, bit);
     544            psMetadataAddImageMask(fpa->masks, PS_LIST_TAIL, name, 0, NULL, bit);
    270545        }
    271546    }
    … …  
    281556    psMetadataItem *item;               // Item from iteration
    282557    while ((item = psMetadataGetAndIncrement(iter))) {
    283         if (item->type != PS_TYPE_MASK) {
     558        if (item->type != PS_TYPE_IMAGE_MASK) {
    284559            psWarning("Recipe mask entry %s is not of a mask type (%x)", item->name, item->type);
    285560            continue;
    286561        }
    287562        if (!psMetadataLookup(fpa->masks, item->name)) {
    288             psMetadataAddU8(fpa->masks, PS_LIST_TAIL, item->name, 0, item->comment,
    289                             item->data.PS_TYPE_MASK_DATA);
     563            psMetadataAddImageMask(fpa->masks, PS_LIST_TAIL, item->name, 0, item->comment,
     564                            item->data.PS_TYPE_IMAGE_MASK_DATA);
    290565        }
    291566    }
    … …  
    294569    return true;
    295570}
    296 
    297 
    298 bool pmFPAMaskWriteHeader(psMetadata *header, const pmFPA *fpa)
    299 {
    300     PS_ASSERT_METADATA_NON_NULL(header, false);
    301     PS_ASSERT_PTR_NON_NULL(fpa, false);
    302 
    303     maskRemoveHeader(header, "MSKNAM");
    304     maskRemoveHeader(header, "MSKVAL");
    305     if (psMetadataLookup(header, "MSKNUM")) {
    306         psMetadataRemoveKey(header, "MSKNUM");
    307     }
    308 
    309     char namekey[80], valuekey[80];     // Mask name and mask value header keywords
    310     int numMask = 0;                    // Number of mask entries
    311 
    312     psMetadataIterator *iter = psMetadataIteratorAlloc(fpa->masks, PS_LIST_HEAD, NULL); // Iterator
    313     psMetadataItem *item;               // Item from iteration
    314     while ((item = psMetadataGetAndIncrement(iter))) {
    315         if (item->type != PS_TYPE_MASK) {
    316             psWarning("mask recipe entry %s is not of a mask type (%x)", item->name, item->type);
    317             continue;
    318         }
    319 
    320         snprintf(namekey,  64, "MSKNAM%02d", numMask);
    321         snprintf(valuekey, 64, "MSKVAL%02d", numMask);
    322 
    323         psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name);
    324         psMetadataAddU8(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", item->data.PS_TYPE_MASK_DATA);
    325         numMask++;
    326     }
    327     psFree(iter);
    328 
    329     return psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Number of named mask entries", numMask);
    330 }
    331 
    332571#endif
    333 
    334 
    335 psMaskType pmConfigMaskGet(const char *masks, const pmConfig *config)
    336 {
    337     psAssert(config, "Require configuration");
    338     PS_ASSERT_STRING_NON_EMPTY(masks, 0);
    339 
    340     bool mdok;                          // Status of MD lookup
    341     psMetadata *recipe = psMetadataLookupMetadata(&mdok, config->recipes, "MASKS"); // The recipe
    342     if (!recipe) {
    343         psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
    344         return 0;
    345     }
    346     return maskGet(recipe, masks);
    347 }
    348 
    349 
    350 bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psMaskType maskValue)
    351 {
    352     psAssert(config, "Require configuration");
    353     PS_ASSERT_STRING_NON_EMPTY(maskName, false);
    354 
    355     psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
    356     if (!recipe) {
    357         psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
    358         return false;
    359     }
    360 
    361     return psMetadataAddU8(recipe, PS_LIST_TAIL, maskName, PS_META_REPLACE, NULL, maskValue);
    362 }
    363 
    364 
    365 // replace the named masks in the recipe with values in the header:
    366 // replace only the names in the header in the recipe
    367 bool pmConfigMaskReadHeader(pmConfig *config, const psMetadata *header)
    368 {
    369     PS_ASSERT_PTR_NON_NULL(config, false);
    370     PS_ASSERT_METADATA_NON_NULL(header, false);
    371 
    372     bool status = false;
    373 
    374     psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
    375     if (!recipe) {
    376         psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
    377         return false;
    378     }
    379 
    380     // MASK.VALUE and MARK.VALUE aren't usually set in the recipe, but may be set in the header: create fake
    381     // versions so that it won't complain later
    382     if (!psMetadataLookup(recipe, "MASK.VALUE")) {
    383         psMetadataAddU8(recipe, PS_LIST_TAIL, "MASK.VALUE", 0, "Bits to mask", 0);
    384     }
    385     if (!psMetadataLookup(recipe, "MARK.VALUE")) {
    386         psMetadataAddU8(recipe, PS_LIST_TAIL, "MARK.VALUE", 0, "Bits for marking", 0);
    387     }
    388 
    389     int nMask = psMetadataLookupS32(&status, header, "MSKNUM");
    390     if (!status) {
    391         if (psMetadataLookupBool(&status, config->camera, "MASK.FORCE")) {
    392             psWarning("No mask values in header.  Assuming MASKS recipe is accurate because of MASK.FORCE");
    393             return true;
    394         }
    395         psError(PS_ERR_UNKNOWN, true, "Unable to find MSKNUM in header.");
    396         return false;
    397     }
    398 
    399     char namekey[80];                   // Keyword name for symbolic name of mask entry
    400     char valuekey[80];                  // Keyword name for value of mask entry
    401     for (int i = 0; i < nMask; i++) {
    402         snprintf(namekey,  64, "MSKNAM%02d", i);
    403         snprintf(valuekey, 64, "MSKVAL%02d", i);
    404 
    405         char *name = psMetadataLookupStr(&status, header, namekey);
    406         if (!status || !name) {
    407             psWarning("Unable to find header keyword %s when parsing mask", namekey);
    408             continue;
    409         }
    410         psU8 bit = psMetadataLookupU8(&status, header, valuekey);
    411         if (!status) {
    412             psWarning("Unable to find header keyword %s when parsing mask", namekey);
    413             continue;
    414         }
    415 
    416         // XXX validate that bit is a 2^n value?
    417 
    418         psString nameAlready = NULL;    // Name of key with ".ALREADY" added
    419         psStringAppend(&nameAlready, "%s.ALREADY", name);
    420         bool already = psMetadataLookupBool(&status, recipe, nameAlready); // Already read this one?
    421 
    422         psMetadataItem *item = psMetadataLookup(recipe, name); // Item in recipe with current value
    423         if (item && item->type != PS_TYPE_MASK) {
    424             psWarning("Mask recipe entry is not of a mask type (%x)", item->type);
    425             item->type = PS_TYPE_MASK;
    426         }
    427 
    428         if (already) {
    429             if (item && item->data.U8 != bit) {
    430                 psWarning("New mask recipe entry doesn't match previously loaded entry: %x vs %x",
    431                           bit, item->data.U8);
    432             }
    433         } else {
    434             psMetadataAddBool(recipe, PS_LIST_TAIL, nameAlready, 0, "Already read this mask value", true);
    435         }
    436 
    437         if (!item) {
    438             psWarning("Mask recipe entry %s not in recipe\n", name);
    439             psMetadataAddU8(recipe, PS_LIST_TAIL, name, 0, "Bitmask bit value", bit);
    440         } else {
    441             item->data.U8 = bit;
    442         }
    443 
    444         psFree(nameAlready);
    445     }
    446 
    447 
    448     return true;
    449 }
    450 
    451 
    452 
    453 // write the named mask bits to the header
    454 bool pmConfigMaskWriteHeader(const pmConfig *config, psMetadata *header)
    455 {
    456     PS_ASSERT_PTR_NON_NULL(config, false);
    457     PS_ASSERT_METADATA_NON_NULL(header, false);
    458 
    459     maskRemoveHeader(header, "MSKNAM");
    460     maskRemoveHeader(header, "MSKVAL");
    461     if (psMetadataLookup(header, "MSKNUM")) {
    462         psMetadataRemoveKey(header, "MSKNUM");
    463     }
    464 
    465     char namekey[80];
    466     char valuekey[80];
    467 
    468     psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
    469     if (!recipe) {
    470         psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
    471         return false;
    472     }
    473 
    474     int nMask = 0;
    475 
    476     psMetadataIterator *iter = psMetadataIteratorAlloc(recipe, PS_LIST_HEAD, NULL); // Iterator
    477     psMetadataItem *item;               // Item from iteration
    478     while ((item = psMetadataGetAndIncrement(iter))) {
    479         if (strcmp(item->name + strlen(item->name) - strlen(".ALREADY"), ".ALREADY") == 0) {
    480             continue;
    481         }
    482 
    483         if (item->type != PS_DATA_U8) {
    484             psWarning("mask recipe entry %s is not a bit value\n", item->name);
    485             continue;
    486         }
    487 
    488         snprintf(namekey,  64, "MSKNAM%02d", nMask);
    489         snprintf(valuekey, 64, "MSKVAL%02d", nMask);
    490 
    491         psMetadataAddStr(header, PS_LIST_TAIL, namekey, 0, "Bitmask bit name", item->name);
    492         psMetadataAddU8(header, PS_LIST_TAIL, valuekey, 0, "Bitmask bit value", item->data.U8);
    493         nMask++;
    494     }
    495     psFree(iter);
    496 
    497     psMetadataAddS32(header, PS_LIST_TAIL, "MSKNUM", 0, "Bitmask bit count", nMask);
    498     return true;
    499 }
    500 
    501 
    502 bool pmConfigMaskSetBits(psMaskType *outMaskValue, psMaskType *outMarkValue, const pmConfig *config)
    503 {
    504     PS_ASSERT_PTR_NON_NULL(config, false);
    505 
    506     psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, "MASKS"); // The recipe
    507     if (!recipe) {
    508         psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find MASKS recipe.");
    509         return false;
    510     }
    511 
    512     return maskSetValues(outMaskValue, outMarkValue, recipe);
    513 }

  • trunk/psModules/src/config/pmConfigMask.h

    r18598 r21183  
    44 *  @author Paul Price, IfA
    55 *
    6  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    7  *  @date $Date: 2008-07-17 20:37:20 $
     6 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     7 *  @date $Date: 2009-01-27 06:39:38 $
    88 *  Copyright 2007 Institute for Astronomy, University of Hawaii
    99 */
    … …  
    2020/// @{
    2121
     22// structure to hold the properties of a mask value
     23typedef struct {
     24    char *badMaskName;                  // name for "bad" (i.e., mask me please) pixels
     25    char *fallbackName;                 // Fallback name in case a bad mask name is not defined
     26    psImageMaskType defaultMaskValue;   // Default value in case a bad mask name and its fallback are not defined
     27    bool isBad; // include this value as part of the MASK.VALUE entry (generically bad)
     28} pmConfigMaskInfo;
     29
     30// pmConfigMaskSetInMetadata examines named mask values and set the bits for maskValue and
     31// markValue.  Ensures that the below-named mask values are set, and calculates the mask value
     32// to catch all of the mask values marked as 'bad'.  Supplies the fallback name if the primary
     33// name is not found, or the default values if the fallback name is not found.
     34bool pmConfigMaskSetInMetadata(psImageMaskType *outMaskValue, // Value of MASK.VALUE, returned
     35                               psImageMaskType *outMarkValue, // Value of MARK.VALUE, returned
     36                               psMetadata *source  // Source of mask bits
     37  );
     38
     39
     40// Get a mask value by name(s)
     41psImageMaskType pmConfigMaskGetFromMetadata(psMetadata *source, // Source of masks
     42                                            const char *masks // Mask values to get
     43  );
     44
     45
     46// lookup an image mask value by name from a psMetadata, without requiring the entry to
     47// be of type psImageMaskType, but verifying that it will fit in psImageMaskType
     48psImageMaskType psMetadataLookupImageMaskFromGeneric (bool *status, const psMetadata *md, const char *name);
     49
     50// Remove from the header keywords starting with the provided string
     51int pmConfigMaskRemoveHeaderKeywords(psMetadata *header, // Header from which to remove keywords
     52                                     const char *start // Remove keywords that start with this string
     53  );
     54
    2255/// Return a mask value given a list of symbolic names
    2356///
    2457/// The mask values are derived from the MASKS recipe
    25 psMaskType pmConfigMaskGet(const char *masks, ///< List of symbolic names, space/comma delimited
     58psImageMaskType pmConfigMaskGet(const char *masks, ///< List of symbolic names, space/comma delimited
    2659                           const pmConfig *config ///< Configuration
    2760    );
    2861
    29 bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psMaskType maskValue);
     62bool pmConfigMaskSet(const pmConfig *config, const char *maskName, psImageMaskType maskValue);
    3063
    3164// replace the named masks in the recipe with values in the header:
    … …  
    3669bool pmConfigMaskWriteHeader(const pmConfig *config, psMetadata *header);
    3770
    38 bool pmConfigMaskSetBits(psMaskType *outMaskValue, psMaskType *outMarkValue, const pmConfig *config);
     71bool pmConfigMaskSetBits(psImageMaskType *outMaskValue, psImageMaskType *outMarkValue, const pmConfig *config);
    3972
    4073#endif

  • trunk/psModules/src/detrend/pmBias.c

    r19432 r21183  
    4545                inImage->data.F32[i][j] -= subImage->data.F32[i+yOffset][j+xOffset];
    4646                if (inMask && subMask) {
    47                     inMask->data.U8[i][j] |= subMask->data.U8[i+yOffset][j+xOffset];
     47                    inMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] |= subMask->data.PS_TYPE_IMAGE_MASK_DATA[i+yOffset][j+xOffset];
    4848                }
    4949            }
    … …  
    5454                inImage->data.F32[i][j] -= subImage->data.F32[i+yOffset][j+xOffset] * scale;
    5555                if (inMask && subMask) {
    56                     inMask->data.U8[i][j] |= subMask->data.U8[i+yOffset][j+xOffset];
     56                    inMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] |= subMask->data.PS_TYPE_IMAGE_MASK_DATA[i+yOffset][j+xOffset];
    5757                }
    5858            }

  • trunk/psModules/src/detrend/pmDark.c

    r19432 r21183  
    103103{
    104104    psArray *values = psArrayAlloc(inputs->n);
    105     psVector *roMask = psVectorAlloc(inputs->n, PS_TYPE_U8); // Mask for bad readouts
     105    psVector *roMask = psVectorAlloc(inputs->n, PS_TYPE_VECTOR_MASK); // Mask for bad readouts
    106106    psVector *norm = normConcept ? psVectorAlloc(inputs->n, PS_TYPE_F32) : NULL; // Normalizations for each
    107107    psVector *orders = psVectorAlloc(ordinates->n, PS_TYPE_U8); // Orders for each concept
    … …  
    121121        if (!ordinateLookup(&normValue, &inRange, normConcept, false, NAN, NAN, readout)) {
    122122            psWarning("Unable to find value of %s for readout %d", normConcept, i);
    123             roMask->data.U8[i] = 0xff;
     123            roMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    124124            norm->data.F32[i] = NAN;
    125125            numBadInputs++;
    … …  
    128128        if (normValue == 0.0) {
    129129            psWarning("Normalisation value (%s) for readout %d is zero", normConcept, i);
    130             roMask->data.U8[i] = 0xff;
     130            roMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    131131            norm->data.F32[i] = NAN;
    132132            numBadInputs++;
    … …  
    151151        for (int j = 0; j < inputs->n; j++) {
    152152            psVector *val = values->data[j]; // Value vector for readout
    153             if (roMask->data.U8[j]) {
     153            if (roMask->data.PS_TYPE_VECTOR_MASK_DATA[j]) {
    154154                val->data.F32[i] = NAN;
    155155                continue;
    … …  
    159159            float value = NAN;          // Value of ordinate
    160160            if (!ordinateLookup(&value, &inRange, ord->name, ord->scale, ord->min, ord->max, readout)) {
    161                 roMask->data.U8[j] = 0xff;
     161                roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
    162162                val->data.F32[i] = NAN;
    163163                numBadInputs++;
    … …  
    165165            }
    166166            if (!inRange) {
    167                 roMask->data.U8[j] = 0xff;
     167                roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
    168168                val->data.F32[i] = NAN;
    169169                numBadInputs++;
    … …  
    263263
    264264// do the combine work for this portion of the output (range is set by input data)
    265 bool pmDarkCombine(pmCell *output, const psArray *inputs, int iter, float rej, psMaskType maskVal)
     265bool pmDarkCombine(pmCell *output, const psArray *inputs, int iter, float rej, psImageMaskType maskVal)
    266266{
    267267    PS_ASSERT_PTR_NON_NULL(output, false);
    … …  
    314314    // Iterate over pixels, fitting polynomial
    315315    psVector *pixels = psVectorAlloc(inputs->n, PS_TYPE_F32); // Stack of pixels
    316     psVector *mask   = psVectorAlloc(inputs->n, PS_TYPE_MASK); // Mask for stack
     316    psVector *mask   = psVectorAlloc(inputs->n, PS_TYPE_VECTOR_MASK); // Mask for stack
    317317    for (int i = minInputRows; i < maxInputRows; i++) {
    318318        int yOut = i - outReadout->row0; // y position on output readout
    … …  
    330330            psVectorInit(mask, 0);
    331331            for (int r = 0; r < inputs->n; r++) {
    332                 if (roMask->data.U8[r]) {
    333                     mask->data.PS_TYPE_MASK_DATA[r] = 0xff;
     332                if (roMask->data.PS_TYPE_VECTOR_MASK_DATA[r]) {
     333                    mask->data.PS_TYPE_VECTOR_MASK_DATA[r] = 0xff;
    334334                    continue;
    335335                }
    … …  
    343343                }
    344344                if (readout->mask) {
    345                     mask->data.PS_TYPE_MASK_DATA[r] = readout->mask->data.PS_TYPE_MASK_DATA[yIn][xIn];
     345                    mask->data.PS_TYPE_VECTOR_MASK_DATA[r] = (readout->mask->data.PS_TYPE_IMAGE_MASK_DATA[yIn][xIn] & maskVal);
    346346                }
    347347
    348348            }
    349349
    350             if (!psPolynomialMDClipFit(poly, pixels, NULL, mask, maskVal, values, iter, rej)) {
     350            if (!psPolynomialMDClipFit(poly, pixels, NULL, mask, 0xff, values, iter, rej)) {
    351351                psErrorClear();         // Nothing we can do about it
    352352                psVectorInit(poly->coeff, NAN);
    … …  
    376376    const psVector *values = job->args->data[3]; // Values for each ordinate
    377377
    378     psMaskType bad = PS_SCALAR_VALUE(job->args->data[4], U8); // Mask value to give bad pixels
     378    psImageMaskType bad = PS_SCALAR_VALUE(job->args->data[4], PS_TYPE_IMAGE_MASK_DATA); // Mask value to give bad pixels
    379379    bool doNorm    = PS_SCALAR_VALUE(job->args->data[5], U8); // Normalise values?
    380380    float norm     = PS_SCALAR_VALUE(job->args->data[6], F32); // Value by which to normalise
    … …  
    386386
    387387bool pmDarkApplyScan(pmReadout *readout, const pmCell *dark, const psVector *orders, const psVector *values,
    388                      psMaskType bad, bool doNorm, float norm, int rowStart, int rowStop)
     388                     psImageMaskType bad, bool doNorm, float norm, int rowStart, int rowStop)
    389389{
    390390    int numCols = readout->image->numCols;
    … …  
    405405            readout->image->data.F32[y][x] -= value;
    406406            if (readout->mask && !isfinite(value)) {
    407                 readout->mask->data.PS_TYPE_MASK_DATA[y][x] = bad;
     407                readout->mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = bad;
    408408            }
    409409        }
    … …  
    414414}
    415415
    416 bool pmDarkApply(pmReadout *readout, pmCell *dark, psMaskType bad)
     416bool pmDarkApply(pmReadout *readout, pmCell *dark, psImageMaskType bad)
    417417{
    418418    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    424424        PS_ASSERT_IMAGE_NON_NULL(readout->mask, false);
    425425        PS_ASSERT_IMAGES_SIZE_EQUAL(readout->mask, readout->image, false);
    426         PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_MASK, false);
     426        PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_IMAGE_MASK, false);
    427427    }
    428428    int numTerms = dark->readouts->n;   // Number of polynomial terms
    … …  
    496496            psArrayAdd(job->args, 1, orders);
    497497            psArrayAdd(job->args, 1, values);
    498             PS_ARRAY_ADD_SCALAR(job->args, bad, PS_TYPE_MASK);
     498            PS_ARRAY_ADD_SCALAR(job->args, bad, PS_TYPE_IMAGE_MASK);
    499499            PS_ARRAY_ADD_SCALAR(job->args, doNorm, PS_TYPE_U8);
    500500            PS_ARRAY_ADD_SCALAR(job->args, norm, PS_TYPE_F32);

  • trunk/psModules/src/detrend/pmDark.h

    r19432 r21183  
    3737                   int iter,            // Number of rejection iterations
    3838                   float rej,           // Rejection threshold (standard deviations)
    39                    psMaskType maskVal   // Value to mask
     39                   psImageMaskType maskVal   // Value to mask
    4040    );
    4141
    … …  
    4949                     const psVector *orders, // Polynomial orders for each ordinate
    5050                     const psVector *values, // Values for each ordinate
    51                      psMaskType bad,    // Value to give bad pixels
     51                     psImageMaskType bad,    // Value to give bad pixels
    5252                     bool doNorm,       // Normalise values?
    5353                     float norm,        // Value by which to normalise
    … …  
    5858bool pmDarkApply(pmReadout *readout,    // Readout to which to apply dark
    5959                 pmCell *dark,    // Dark to apply
    60                  psMaskType bad         // Mask value to give bad pixels
     60                 psImageMaskType bad         // Mask value to give bad pixels
    6161    );
    6262

  • trunk/psModules/src/detrend/pmFlatField.c

    r19432 r21183  
    2222    const psImage *flatMask  = job->args->data[3]; // Flat-field mask
    2323
    24     psMaskType badFlat = PS_SCALAR_VALUE(job->args->data[4],U8);
     24    psImageMaskType badFlat = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA);
    2525    int xOffset        = PS_SCALAR_VALUE(job->args->data[5],S32);
    2626    int yOffset        = PS_SCALAR_VALUE(job->args->data[6],S32);
    … …  
    3838            ps##TYPE flatValue = flatImage->data.TYPE[j + yOffset][i + xOffset]; \
    3939            if (!isfinite(flatValue) || flatValue <= 0.0 || \
    40                 (flatMask && flatMask->data.U8[j + yOffset][i + xOffset])) { \
     40                (flatMask && flatMask->data.PS_TYPE_IMAGE_MASK_DATA[j + yOffset][i + xOffset])) { \
    4141                if (inMask) { \
    42                     inMask->data.PS_TYPE_MASK_DATA[j][i] |= badFlat; \
     42                    inMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= badFlat; \
    4343                } \
    4444                inImage->data.TYPE[j][i] = SPECIAL; \
    … …  
    5151
    5252bool pmFlatFieldScan(psImage *inImage, psImage *inMask, const psImage *flatImage, const psImage *flatMask,
    53                      psMaskType badFlat, int xOffset, int yOffset, int rowStart, int rowStop)
     53                     psImageMaskType badFlat, int xOffset, int yOffset, int rowStart, int rowStop)
    5454{
    5555    switch (inImage->type.type) {
    … …  
    7272}
    7373
    74 bool pmFlatField(pmReadout *in, const pmReadout *flat, psMaskType badFlat)
     74bool pmFlatField(pmReadout *in, const pmReadout *flat, psImageMaskType badFlat)
    7575{
    7676    PS_ASSERT_PTR_NON_NULL(in, false);
    … …  
    8181    PS_ASSERT_IMAGE_NON_EMPTY(flat->image, false);
    8282    if (in->mask) {
    83         PS_ASSERT_IMAGE_TYPE(in->mask, PS_TYPE_MASK, false);
     83        PS_ASSERT_IMAGE_TYPE(in->mask, PS_TYPE_IMAGE_MASK, false);
    8484        PS_ASSERT_IMAGES_SIZE_EQUAL(in->mask, in->image, false);
    8585    }
    8686    PS_ASSERT_IMAGE_TYPE(flat->image, in->image->type.type, false);
    8787    if (flat->mask) {
    88         PS_ASSERT_IMAGE_TYPE(flat->mask, PS_TYPE_MASK, false);
     88        PS_ASSERT_IMAGE_TYPE(flat->mask, PS_TYPE_IMAGE_MASK, false);
    8989        PS_ASSERT_IMAGES_SIZE_EQUAL(flat->mask, flat->image, false);
    9090    }
    … …  
    148148          psArrayAdd(job->args, 1, flatImage);
    149149          psArrayAdd(job->args, 1, flatMask);
    150           PS_ARRAY_ADD_SCALAR(job->args, badFlat, PS_TYPE_U8);
     150          PS_ARRAY_ADD_SCALAR(job->args, badFlat, PS_TYPE_IMAGE_MASK);
    151151          PS_ARRAY_ADD_SCALAR(job->args, xOffset, PS_TYPE_S32);
    152152          PS_ARRAY_ADD_SCALAR(job->args, yOffset, PS_TYPE_S32);

  • trunk/psModules/src/detrend/pmFlatField.h

    r19432 r21183  
    55 * @author Paul Price, IfA
    66 *
    7  * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-09-09 04:10:14 $
     7 * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 * Copyright 2004-2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    2525bool pmFlatField(pmReadout *in,         ///< Readout with input image
    2626                 const pmReadout *flat,  ///< Readout with flat image
    27                  psMaskType badFlat     ///< Mask value to give bad flat pixels
     27                 psImageMaskType badFlat     ///< Mask value to give bad flat pixels
    2828                );
    2929
    … …  
    3838    const psImage *flatImage,           ///< Flat-field image
    3939    const psImage *flatMask,            ///< Flat-field mask
    40     psMaskType badFlag,                 ///< Mask value to give bad pixels
     40    psImageMaskType badFlag,                 ///< Mask value to give bad pixels
    4141    int xOffset, int yOffset,           ///< Offset between input and flat-field
    4242    int rowStart, int rowStop           ///< Scan range

  • trunk/psModules/src/detrend/pmFlatNormalize.c

    r9730 r21183  
    99
    1010#include "pmFlatNormalize.h"
     11
     12// XXX this function should take the abstract mask names and set bad values in a more precise way
    1113
    1214// I'm not sure that many many iterations are required, but rather suspect that the system converges within a
    … …  
    5557    // Take the logarithms
    5658    psImage *flux = psImageCopy(NULL, bgMatrix, PS_TYPE_F32); // Copy of the input flux levels matrix
    57     psImage *fluxMask = psImageAlloc(numChips, numExps, PS_TYPE_U8); // Mask for bad measurements
     59    psImage *fluxMask = psImageAlloc(numChips, numExps, PS_TYPE_IMAGE_MASK); // Mask for bad measurements
    5860    psImageInit(fluxMask, 0);
    59     psVector *gainMask = psVectorAlloc(numChips, PS_TYPE_U8); // Mask for bad gains
     61    psVector *gainMask = psVectorAlloc(numChips, PS_TYPE_VECTOR_MASK); // Mask for bad gains
    6062    psVectorInit(gainMask, 0);
    61     psVector *expMask = psVectorAlloc(numExps, PS_TYPE_U8); // Mask for bad exposures
     63    psVector *expMask = psVectorAlloc(numExps, PS_TYPE_VECTOR_MASK); // Mask for bad exposures
    6264    psVectorInit(expMask, 0);
    6365    for (int i = 0; i < numChips; i++) {
    … …  
    7577            } else {
    7678                // Blank out this measurement
    77                 fluxMask->data.U8[j][i] = 1;
     79                fluxMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] = 1;
    7880                flux->data.F32[j][i] = NAN;
    7981            }
    … …  
    9092        int numFluxes = 0;              // Number of fluxes
    9193        for (int i = 0; i < numExps; i++) {
    92             if (expMask->data.U8[i]) {
     94            if (expMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    9395                psTrace("psModules.detrend", 7, "Flux for exposure %d is masked.\n", i);
    9496                continue;
    … …  
    98100            int number = 0;             // Number of chips contributing
    99101            for (int j = 0; j < numChips; j++) {
    100                 if (!gainMask->data.U8[j] && !fluxMask->data.U8[i][j]) {
     102                if (!gainMask->data.PS_TYPE_VECTOR_MASK_DATA[j] && !fluxMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
    101103                    sum += flux->data.F32[i][j] - chipGains->data.F32[j];
    102104                    number++;
    … …  
    106108                expFluxes->data.F32[i] = sum / (float)number;
    107109            } else {
    108                 expMask->data.U8[i] = 1;
     110                expMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1;
    109111                expFluxes->data.F32[i] = NAN;
    110112            }
    … …  
    116118        int numGains = 0;               // Number of gains
    117119        for (int i = 0; i < numChips; i++) {
    118             if (gainMask->data.U8[i]) {
     120            if (gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    119121                continue;
    120122            }
    … …  
    122124            int number = 0;             // Numer of sources contributing
    123125            for (int j = 0; j < numExps; j++) {
    124                 if (!fluxMask->data.U8[j][i]) {
     126                if (!fluxMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i]) {
    125127                    sum += flux->data.F32[j][i] - expFluxes->data.F32[j];
    126128                    number++;
    … …  
    130132                chipGains->data.F32[i] = sum / (float)number;
    131133            } else {
    132                 gainMask->data.U8[i] = 1;
     134                gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1;
    133135                chipGains->data.F32[i] = NAN;
    134136            }
    … …  
    144146            diff = 0.0;
    145147            for (int i = 0; i < numChips; i++) {
    146                 if (gainMask->data.U8[i]) {
     148                if (gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    147149                    continue;
    148150                }
    … …  
    151153            }
    152154            for (int i = 0; i < numExps; i++) {
    153                 if (expMask->data.U8[i]) {
     155                if (expMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    154156                    continue;
    155157                }
    … …  
    171173    // Un-log the vectors
    172174    for (int i = 0; i < numChips; i++) {
    173         if (!gainMask->data.U8[i]) {
     175        if (!gainMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    174176            chipGains->data.F32[i] = expf(chipGains->data.F32[i]);
    175177        }
    176178    }
    177179    for (int i = 0; i < numExps; i++) {
    178         if (!expMask->data.U8[i]) {
     180        if (!expMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    179181            expFluxes->data.F32[i] = expf(expFluxes->data.F32[i]);
    180182        }

  • trunk/psModules/src/detrend/pmFringeStats.c

    r13776 r21183  
    7070    fringe->x = psVectorRecycle(fringe->x, fringe->nRequested, PS_TYPE_F32);
    7171    fringe->y = psVectorRecycle(fringe->y, fringe->nRequested, PS_TYPE_F32);
    72     fringe->mask = psVectorRecycle(fringe->mask, fringe->nRequested, PS_TYPE_U8);
     72    fringe->mask = psVectorRecycle(fringe->mask, fringe->nRequested, PS_TYPE_VECTOR_MASK);
    7373    fringe->x->n = fringe->y->n = fringe->mask->n = fringe->nRequested;
    7474    psVectorInit(fringe->mask, 0);
    … …  
    115115    if (mask) {
    116116        PS_ASSERT_VECTOR_NON_NULL(mask, false);
    117         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     117        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    118118        PS_ASSERT_VECTOR_SIZE(mask, (long)numRows, false);
    119119    }
    … …  
    142142        psMetadataAddF32(row, PS_LIST_TAIL, "x", PS_META_REPLACE, "Fringe position in x", x->data.F32[i]);
    143143        psMetadataAddF32(row, PS_LIST_TAIL, "y", PS_META_REPLACE, "Fringe position in y", y->data.F32[i]);
    144         psU8 maskValue = 0;
    145         if (mask && mask->data.U8[i]) {
     144        psVectorMaskType maskValue = 0;
     145        if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    146146            maskValue = 0xff;
    147147        }
    148         psMetadataAddU8(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue);
     148        psMetadataAddVectorMask(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue);
    149149        table->data[i] = row;
    150150    }
    … …  
    207207    psVector *x = psVectorAlloc(numRows, PS_TYPE_F32); // x position
    208208    psVector *y = psVectorAlloc(numRows, PS_TYPE_F32); // y position
    209     psVector *mask = psVectorAlloc(numRows, PS_TYPE_U8); // mask
     209    psVector *mask = psVectorAlloc(numRows, PS_TYPE_VECTOR_MASK); // mask
    210210    regions->x = x;
    211211    regions->y = y;
    212212    regions->mask = mask;
    213213
    214     #define READ_REGIONS_ROW(VECTOR, TYPE, NAME, DESCRIPTION) \
    215     VECTOR->data.TYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \
     214    #define READ_REGIONS_ROW(VECTOR, TYPE, DATATYPE, NAME, DESCRIPTION) \
     215    VECTOR->data.DATATYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \
    216216    if (!mdok) { \
    217217        psError(PS_ERR_IO, true, "Unable to find " #DESCRIPTION " .\n"); \
    … …  
    224224    for (long i = 0; i < numRows; i++) {
    225225        psMetadata *row = table->data[i]; // Table row
    226         READ_REGIONS_ROW(x, F32, "x", "x position");
    227         READ_REGIONS_ROW(y, F32, "y", "y position");
    228         READ_REGIONS_ROW(mask, U8, "mask", "mask");
     226        READ_REGIONS_ROW(x, F32, F32, "x", "x position");
     227        READ_REGIONS_ROW(y, F32, F32, "y", "y position");
     228        READ_REGIONS_ROW(mask, VectorMask, PS_TYPE_VECTOR_MASK_DATA, "mask", "mask");
    229229    }
    230230    psFree(table);
    … …  
    259259}
    260260
    261 pmFringeStats *pmFringeStatsMeasure(pmFringeRegions *fringe, const pmReadout *readout, psMaskType maskVal)
     261pmFringeStats *pmFringeStatsMeasure(pmFringeRegions *fringe, const pmReadout *readout, psImageMaskType maskVal)
    262262{
    263263    PS_ASSERT_PTR_NON_NULL(fringe, NULL);
    … …  
    490490    newRegions->x = psVectorAlloc(numPoints, PS_TYPE_F32);
    491491    newRegions->y = psVectorAlloc(numPoints, PS_TYPE_F32);
    492     newRegions->mask = psVectorAlloc(numPoints, PS_TYPE_U8);
     492    newRegions->mask = psVectorAlloc(numPoints, PS_TYPE_VECTOR_MASK);
    493493    pmFringeStats *newStats = pmFringeStatsAlloc(newRegions); // The new list of statistics
    494494
    … …  
    500500        memcpy(&newRegions->x->data.F32[offset], regions->x->data.F32, regions->x->n * sizeof(psF32));
    501501        memcpy(&newRegions->y->data.F32[offset], regions->y->data.F32, regions->y->n * sizeof(psF32));
    502         memcpy(&newRegions->mask->data.U8[offset], regions->mask->data.U8, regions->mask->n * sizeof(psU8));
     502        memcpy(&newRegions->mask->data.PS_TYPE_VECTOR_MASK_DATA[offset], regions->mask->data.PS_TYPE_VECTOR_MASK_DATA, regions->mask->n * sizeof(psVectorMaskType));
    503503        memcpy(&newStats->f->data.F32[offset], fringe->f->data.F32, fringe->f->n * sizeof(psF32));
    504504        memcpy(&newStats->df->data.F32[offset], fringe->df->data.F32, fringe->df->n * sizeof(psF32));
    … …  
    549549    if (mask) {
    550550        PS_ASSERT_VECTOR_NON_NULL(mask, false);
    551         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     551        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    552552        PS_ASSERT_VECTOR_SIZE(mask, (long)numRows, false);
    553553    }
    … …  
    580580        psMetadataAddF32(row, PS_LIST_TAIL, "x", PS_META_REPLACE, "Fringe position in x", x->data.F32[i]);
    581581        psMetadataAddF32(row, PS_LIST_TAIL, "y", PS_META_REPLACE, "Fringe position in y", y->data.F32[i]);
    582         psU8 maskValue = 0;             // Mask value
    583         if (mask && mask->data.U8[i]) {
     582        psVectorMaskType maskValue = 0;             // Mask value
     583        if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    584584            maskValue = 0xff;
    585585        }
    … …  
    601601        psFree(df);
    602602
    603         psMetadataAddU8(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue);
     603        psMetadataAddVectorMask(row, PS_LIST_TAIL, "mask", PS_META_REPLACE, "Mask", maskValue);
    604604        table->data[i] = row;
    605605    }
    … …  
    648648    psVector *x = psVectorAlloc(numRows, PS_TYPE_F32); // x position
    649649    psVector *y = psVectorAlloc(numRows, PS_TYPE_F32); // y position
    650     psVector *mask = psVectorAlloc(numRows, PS_TYPE_U8); // mask
     650    psVector *mask = psVectorAlloc(numRows, PS_TYPE_VECTOR_MASK); // mask
    651651    regions->x = x;
    652652    regions->y = y;
    … …  
    656656    psArray *fringes = NULL; // Array of fringes, to return
    657657
    658     #define READ_FRINGES_VECTOR_ROW(VECTOR, TYPE, NAME, DESCRIPTION) \
     658    #define READ_FRINGES_VECTOR_ROW(VECTOR, TYPE, DATATYPE, NAME, DESCRIPTION) \
    659659    { \
    660         VECTOR->data.TYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \
     660        VECTOR->data.DATATYPE[i] = psMetadataLookup##TYPE(&mdok, row, NAME); \
    661661        if (!mdok) { \
    662662            psError(PS_ERR_IO, true, "Unable to find " #DESCRIPTION " for row %ld.\n", i); \
    … …  
    686686    }
    687687
     688    // XXX : need to extend this to support arbitrary types for the vectors on disk
    688689    // Translate the table into vectors
    689690    for (long i = 0; i < numRows; i++) {
    690691        psMetadata *row = table->data[i]; // Table row
    691         READ_FRINGES_VECTOR_ROW(x, F32, "x", "x position");
    692         READ_FRINGES_VECTOR_ROW(y, F32, "y", "y position");
    693         READ_FRINGES_VECTOR_ROW(mask, U8, "mask", "mask");
     692        READ_FRINGES_VECTOR_ROW(x, F32, F32, "x", "x position");
     693        READ_FRINGES_VECTOR_ROW(y, F32, F32, "y", "y position");
     694        READ_FRINGES_VECTOR_ROW(mask, VectorMask, PS_TYPE_VECTOR_MASK_DATA, "mask", "mask");
    694695        READ_FRINGES_ARRAY_ROW(f, F32, "f", "fringe measurement");
    695696        READ_FRINGES_ARRAY_ROW(df, F32, "df", "fringe error");
    … …  
    782783            double matrix = 0.0;        // The matrix sum
    783784            for (int k = 0; k < numPoints; k++) {
    784                 if (!mask->data.U8[k]) {
     785                if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[k]) {
    785786                    psF32 f1 = (fringe1) ? fringe1->data.F32[k] : 1.0; // Contribution from i fringe
    786787                    psF32 f2 = (fringe2) ? fringe2->data.F32[k] : 1.0; // Contribution from j fringe
    … …  
    799800        double vector = 0.0;            // The vector sum
    800801        for (int k = 0; k < numPoints; k++) {
    801             if (!mask->data.U8[k]) {
     802            if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[k]) {
    802803                psF32 f1 = (fringe1) ? fringe1->data.F32[k] : 1.0; // Contribution from fringe 1
    803804                psF32 s = science->f->data.F32[k]; // Contribution from science measurement
    … …  
    855856
    856857    for (int i = 0; i < diff->n; i++) {
    857         if (!mask->data.U8[i]) {
     858        if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    858859            float difference = science->f->data.F32[i] - scale->coeff->data.F32[0];
    859860            for (int j = 0; j < fringes->n; j++) {
    … …  
    877878    assert(diffs->type.type == PS_TYPE_F32);
    878879    assert(mask);
    879     assert(mask->type.type == PS_TYPE_U8);
     880    assert(mask->type.type == PS_TYPE_VECTOR_MASK);
    880881    assert(diffs->n == mask->n);
    881882
    … …  
    888889    int numClipped = 0;                 // Number clipped
    889890    for (int i = 0; i < diffs->n; i++) {
    890         psTrace("psModules.detrend", 10, "Region %d (%d): %f\n", i, mask->data.U8[i], diffs->data.F32[i]);
    891         if (!mask->data.U8[i] && fabs(diffs->data.F32[i]) > middle + thresh) {
     891        psTrace("psModules.detrend", 10, "Region %d (%d): %f\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i], diffs->data.F32[i]);
     892        if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[i] && fabs(diffs->data.F32[i]) > middle + thresh) {
    892893            psTrace("psModules.detrend", 5, "Masking %d: %f\n", i, diffs->data.F32[i]);
    893             mask->data.U8[i] = 1;
     894            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1;
    894895            numClipped++;
    895896        }
    … …  
    931932    // Set up the mask
    932933    if (!regions->mask) {
    933         regions->mask = psVectorAlloc(numRegions, PS_TYPE_U8);
     934        regions->mask = psVectorAlloc(numRegions, PS_TYPE_VECTOR_MASK);
    934935        psVectorInit(regions->mask, 0);
    935936    }
    … …  
    946947        for (int j = 0; j < numRegions; j++) {
    947948            if (!isfinite(fringe->f->data.F32[j])) {
    948                 mask->data.U8[j] = 1;
     949                mask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 1;
    949950                psTrace("psModules.detrend", 9, "Masking region %d because not finite in fringe %d.\n", j, i);
    950951            }
    … …  
    956957    FILE *f = fopen ("fringe.dat", "w");
    957958    for (int j = 0; j < numRegions; j++) {
    958         if (mask->data.U8[j]) continue;
     959        if (mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) continue;
    959960        fprintf (f, "%d %f %f ", j, science->f->data.F32[j], science->df->data.F32[j]);
    960961        for (int i = 0; i < fringes->n; i++) {
    … …  
    10141015// XXX note that this modifies the input fringe images
    10151016psImage *pmFringeCorrect(pmReadout *readout, pmFringeRegions *fringes, psArray *fringeImages,
    1016                          psArray *fringeStats, psMaskType maskVal, float rej,
     1017                         psArray *fringeStats, psImageMaskType maskVal, float rej,
    10171018                         unsigned int nIter, float keepFrac)
    10181019{

  • trunk/psModules/src/detrend/pmFringeStats.h

    r11253 r21183  
    55 * @author Paul Price, IfA
    66 *
    7  * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2007-01-24 02:54:15 $
     7 * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 * Copyright 2004-2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    102102pmFringeStats *pmFringeStatsMeasure(pmFringeRegions *fringe, ///< Fringe regions at which to measure
    103103                                    const pmReadout *readout, ///< Readout for which to measure
    104                                     psMaskType maskVal ///< Mask value for image
     104                                    psImageMaskType maskVal ///< Mask value for image
    105105                                   );
    106106
    … …  
    206206                         psArray *fringeImages, ///< Fringe template images to use in correction
    207207                         psArray *fringeStats, ///< Fringe stats (for templates) to use in correction
    208                          psMaskType maskVal, ///< Value to mask for science image
     208                         psImageMaskType maskVal, ///< Value to mask for science image
    209209                         float rej,     ///< Rejection threshold, for pmFringeScaleMeasure
    210210                         unsigned int nIter, ///< Maximum number of iterations, for pmFringeScaleMeasure

  • trunk/psModules/src/detrend/pmMaskBadPixels.c

    r18554 r21183  
    1414#include "pmMaskBadPixels.h"
    1515
    16 bool pmMaskBadPixels(pmReadout *input, const pmReadout *mask, psMaskType maskVal)
     16bool pmMaskBadPixels(pmReadout *input, const pmReadout *mask, psImageMaskType maskVal)
    1717{
    1818    PS_ASSERT_PTR_NON_NULL(input, false);
    1919    PS_ASSERT_PTR_NON_NULL(input->mask, false);
    20     PS_ASSERT_IMAGE_TYPE(input->mask, PS_TYPE_MASK, false);
     20    PS_ASSERT_IMAGE_TYPE(input->mask, PS_TYPE_IMAGE_MASK, false);
    2121
    2222    PS_ASSERT_PTR_NON_NULL(mask, false);
    2323    PS_ASSERT_PTR_NON_NULL(mask->mask, false);
    24     PS_ASSERT_IMAGE_TYPE(mask->mask, PS_TYPE_MASK, false);
     24    PS_ASSERT_IMAGE_TYPE(mask->mask, PS_TYPE_IMAGE_MASK, false);
    2525
    2626    psImage *inMask = input->mask;
    … …  
    5353    int offRow = input->row0 - mask->row0;
    5454
    55     // masks are both of type PS_TYPE_MASK
    56     psMaskType **exVal = exMask->data.U8;
    57     psMaskType **inVal = inMask->data.U8;
     55    // masks are both of type PS_TYPE_IMAGE_MASK
     56    psImageMaskType **exVal = exMask->data.PS_TYPE_IMAGE_MASK_DATA;
     57    psImageMaskType **inVal = inMask->data.PS_TYPE_IMAGE_MASK_DATA;
    5858
    5959    // apply exMask values
    … …  
    8282
    8383bool pmMaskFlagSuspectPixels(pmReadout *output, const pmReadout *readout, float median, float stdev,
    84                              float rej, psMaskType maskVal)
     84                             float rej, psImageMaskType maskVal)
    8585{
    8686    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    9292        PS_ASSERT_IMAGE_NON_EMPTY(readout->mask, false);
    9393        PS_ASSERT_IMAGES_SIZE_EQUAL(readout->image, readout->mask, false);
    94         PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_MASK, false);
     94        PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_IMAGE_MASK, false);
    9595    }
    9696    PS_ASSERT_PTR_NON_NULL(output, false);
    … …  
    128128        for (int x = 0; x < image->numCols; x++) {
    129129            if (fabs((image->data.F32[y][x] - median) / stdev) < rej) continue;
    130             if (mask && (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal)) continue;
     130            if (mask && (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal)) continue;
    131131            suspect->data.F32[y][x] += 1.0;
    132132        }
    … …  
    142142
    143143// the maskVal supplied here is the value SET for this mask (ie, it is not used to avoid pixels)
    144 bool pmMaskIdentifyBadPixels(pmReadout *output, psMaskType maskVal, float thresh, pmMaskIdentifyMode mode)
     144bool pmMaskIdentifyBadPixels(pmReadout *output, psImageMaskType maskVal, float thresh, pmMaskIdentifyMode mode)
    145145{
    146146    PS_ASSERT_PTR_NON_NULL(output, false);
    … …  
    155155        PS_ASSERT_IMAGE_NON_EMPTY(output->mask, false);
    156156        PS_ASSERT_IMAGES_SIZE_EQUAL(output->mask, suspects, false);
    157         PS_ASSERT_IMAGE_TYPE(output->mask, PS_TYPE_MASK, false);
     157        PS_ASSERT_IMAGE_TYPE(output->mask, PS_TYPE_IMAGE_MASK, false);
    158158    } else {
    159         output->mask = psImageAlloc(suspects->numCols, suspects->numRows, PS_TYPE_MASK);
     159        output->mask = psImageAlloc(suspects->numCols, suspects->numRows, PS_TYPE_IMAGE_MASK);
    160160    }
    161161    int num = psMetadataLookupS32(NULL, output->analysis, PM_MASK_ANALYSIS_NUM); // Number of inputs
    … …  
    246246        for (int x = 0; x < suspects->numCols; x++) {
    247247            if (suspects->data.F32[y][x] >= limit) {
    248                 badpix->data.PS_TYPE_MASK_DATA[y][x] = maskVal;
     248                badpix->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = maskVal;
    249249            }
    250250        }

  • trunk/psModules/src/detrend/pmMaskBadPixels.h

    r17228 r21183  
    55 * @author Eugene Magnier, IfA
    66 *
    7  * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-03-29 03:10:17 $
     7 * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 * Copyright 2004 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    4040bool pmMaskBadPixels(pmReadout *input,  ///< Input science image
    4141                     const pmReadout *mask, ///< Mask image to apply
    42                      psMaskType maskVal ///< Mask value to apply
     42                     psImageMaskType maskVal ///< Mask value to apply
    4343                    );
    4444
    … …  
    5656                             float stdev, ///< Image standard deviation
    5757                             float rej, ///< Rejection threshold (standard deviations)
    58                              psMaskType maskVal ///< Mask value for statistics
     58                             psImageMaskType maskVal ///< Mask value for statistics
    5959    );
    6060
    … …  
    6464/// according to the chosen mode.
    6565bool pmMaskIdentifyBadPixels(pmReadout *output, ///< Output readout, with suspect pixels imageOut
    66                              psMaskType maskVal, ///< Value to set for bad pixels
     66                             psImageMaskType maskVal, ///< Value to set for bad pixels
    6767                             float thresh, ///< Threshold for bad pixel
    6868                             pmMaskIdentifyMode mode ///< Mode for identifying bad pixels

  • trunk/psModules/src/detrend/pmOverscan.c

    r19846 r21183  
    6767    psVector *reduced = psVectorAlloc(pixels->n, PS_TYPE_F32); // Overscan for each row
    6868    psVector *ordinate = psVectorAlloc(pixels->n, PS_TYPE_F32); // Ordinate
    69     psVector *mask = psVectorAlloc(pixels->n, PS_TYPE_U8); // Mask for fitting
     69    psVector *mask = psVectorAlloc(pixels->n, PS_TYPE_VECTOR_MASK); // Mask for fitting
    7070
    7171    for (int i = 0; i < pixels->n; i++) {
    7272        psVector *values = pixels->data[i]; // Vector with overscan values
    7373        if (values->n > 0) {
    74             mask->data.U8[i] = 0;
     74            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0;
    7575            ordinate->data.F32[i] = 2.0*(float)i/(float)pixels->n - 1.0; // Scale to [-1,1]
    7676            psVectorStats(myStats, values, NULL, NULL, 0);
    … …  
    8282        } else {
    8383            // We'll fit this one out
    84             mask->data.U8[i] = 1;
     84            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 1;
    8585        }
    8686    }

  • trunk/psModules/src/detrend/pmRemnance.c

    r20669 r21183  
    1313
    1414bool pmRemnance(pmReadout *ro,           ///< Readout with input image
    15                 psMaskType maskVal,      ///< Value of mask
    16                 psMaskType maskRem,       ///< Value to give remance
     15                psImageMaskType maskVal,      ///< Value of mask
     16                psImageMaskType maskRem,       ///< Value to give remance
    1717                int size,               ///< Size of accumulation patches
    1818                float threshold         ///< Threshold for masking
    … …  
    2323    PM_ASSERT_READOUT_MASK(ro, false);
    2424
    25     psImage *image = ro->image, *mask = ro->mask; // Mask and image from readout
     25    psImage *image = ro->image;
     26    psImage *mask = ro->mask; // Mask and image from readout
     27
    2628    int numCols = image->numCols, numRows = image->numRows; // Size of image
    2729
    … …  
    3335        psErrorClear();
    3436        psWarning("Unable to calculate image statistics: masking entire readout.");
    35         psBinaryOp(mask, mask, "|", psScalarAlloc(maskRem, PS_TYPE_MASK));
     37        psBinaryOp(mask, mask, "|", psScalarAlloc(maskRem, PS_TYPE_IMAGE_MASK));
    3638        psFree(stats);
    3739        psFree(rng);
    … …  
    5759            }
    5860            for (int y = min; y < max; y++) {
    59                 if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
     61                if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
    6062                    continue;
    6163                }
    … …  
    8486            }
    8587            for (int y = 0; y < maxMask; y++) {
    86                 mask->data.PS_TYPE_MASK_DATA[y][x] |= maskRem;
     88                mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= maskRem;
    8789            }
    8890            numMasked += maxMask;

  • trunk/psModules/src/detrend/pmRemnance.h

    r20622 r21183  
    1313// GPC1 leaves remnance that flows down from where the annoyed pixels are.
    1414bool pmRemnance(pmReadout *ro,           ///< Readout with input image
    15                 psMaskType maskVal,      ///< Value of mask
    16                 psMaskType maskRem,       ///< Value to give remance
     15                psImageMaskType maskVal,      ///< Value of mask
     16                psImageMaskType maskRem,       ///< Value to give remance
    1717                int size,               ///< Size of accumulation patches
    1818                float threshold         ///< Threshold for masking

  • trunk/psModules/src/detrend/pmShifts.c

    r15322 r21183  
    412412}
    413413
    414 bool pmShiftsConvolve(pmReadout *detrend, const pmCell *source, psMaskType maskVal)
     414bool pmShiftsConvolve(pmReadout *detrend, const pmCell *source, psImageMaskType maskVal)
    415415{
    416416    PS_ASSERT_PTR(detrend, false);

  • trunk/psModules/src/detrend/pmShifts.h

    r12696 r21183  
    4646bool pmShiftsConvolve(pmReadout *detrend, ///< Detrend readout to convolve
    4747                      const pmCell *source, ///< Science exposure, containing a shifts kernel
    48                       psMaskType maskVal ///< Mask value to smear
     48                      psImageMaskType maskVal ///< Mask value to smear
    4949                      );
    5050

  • trunk/psModules/src/detrend/pmShutterCorrection.c

    r19432 r21183  
    198198pmShutterCorrection *pmShutterCorrectionLinFit(const psVector *exptime, const psVector *counts,
    199199                                               const psVector *cntError, const psVector *mask, float offref,
    200                                                int nIter, float rej, psMaskType maskVal)
     200                                               int nIter, float rej)
    201201{
    202202    PS_ASSERT_VECTOR_NON_NULL(exptime, NULL);
    … …  
    241241    stats->clipIter = nIter;
    242242
    243     if (!psVectorClipFitPolynomial2D(line, stats, mask, maskVal, counts, cntError, x, y)) {
     243    if (!psVectorClipFitPolynomial2D(line, stats, mask, 0xff, counts, cntError, x, y)) {
    244244        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to fit shutter correction.\n");
    245245        psFree(stats);
    … …  
    371371
    372372bool pmShutterCorrectionMeasure(pmReadout *output, const psArray *readouts, int size, psStatsOptions meanStat,
    373                                 psStatsOptions stdevStat, int nIter, float rej, psMaskType maskVal)
     373                                psStatsOptions stdevStat, int nIter, float rej, psImageMaskType maskVal)
    374374{
    375375    PS_ASSERT_ARRAY_NON_NULL(readouts, NULL);
    … …  
    457457            masks->data[i] = psMemIncrRefCounter(mask);
    458458
    459             if (mask->type.type != PS_TYPE_U8) {
     459            if (mask->type.type != PS_TYPE_IMAGE_MASK) {
    460460                psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Bad type for mask: %x\n", mask->type.type);
    461461                goto MEASURE_ERROR;
    … …  
    582582    psImage *shutter = psImageAlloc(numCols, numRows, PS_TYPE_F32); // Shutter correction image
    583583    psImage *pattern = psImageAlloc(numCols, numRows, PS_TYPE_F32); // Illumination pattern
    584     psVector *mask = psVectorAlloc(num, PS_TYPE_U8); // Mask for each image
     584    psVector *mask = psVectorAlloc(num, PS_TYPE_VECTOR_MASK); // Mask for each image
    585585    psVectorInit(mask, 0);
    586586    psTrace("psModules.detrend", 2, "Performing linear fit on individual pixels...\n");
    … …  
    592592                psImage *maskImage;     // Mask image
    593593                if (masks && (maskImage = masks->data[i])) {
    594                     mask->data.U8[i] = maskImage->data.U8[y][x];
     594                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (maskImage->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal);
    595595                }
    596596                psImage *weight;        // Weight image
    … …  
    602602            }
    603603
    604             pmShutterCorrection *corr = pmShutterCorrectionLinFit(exptimes, counts, errors, mask, meanRef,
    605                                         nIter, rej, maskVal);
     604            pmShutterCorrection *corr = pmShutterCorrectionLinFit(exptimes, counts, errors, mask, meanRef, nIter, rej);
    606605            shutter->data.F32[y][x] = corr->offset;
    607606            pattern->data.F32[y][x] = corr->scale;
    … …  
    665664
    666665    float exptime    = PS_SCALAR_VALUE(job->args->data[3],F32);
    667     psMaskType blank = PS_SCALAR_VALUE(job->args->data[4],U8);
     666    psImageMaskType blank = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA);
    668667    int rowStart     = PS_SCALAR_VALUE(job->args->data[5],S32);
    669668    int rowStop      = PS_SCALAR_VALUE(job->args->data[6],S32);
    … …  
    672671
    673672bool pmShutterCorrectionApplyScan(psImage *image, const psImage *shutterImage, psImage *mask, float exptime,
    674                                   psMaskType blank, int rowStart, int rowStop)
     673                                  psImageMaskType blank, int rowStart, int rowStop)
    675674{
    676675    for (int y = rowStart; y < rowStop; y++) {
    677676        for (int x = 0; x < image->numCols; x++) {
    678677            if (mask && !isfinite(shutterImage->data.F32[y][x])) {
    679                 mask->data.PS_TYPE_MASK_DATA[y][x] |= blank;
     678                mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= blank;
    680679                image->data.F32[y][x] = NAN;
    681680                continue;
    … …  
    687686}
    688687
    689 bool pmShutterCorrectionApply(pmReadout *readout, const pmReadout *shutter, psMaskType blank)
     688bool pmShutterCorrectionApply(pmReadout *readout, const pmReadout *shutter, psImageMaskType blank)
    690689{
    691690    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    746745            for (int x = 0; x < image->numCols; x++) {
    747746                if (mask && !isfinite(shutterImage->data.F32[y][x])) {
    748                     mask->data.PS_TYPE_MASK_DATA[y][x] |= blank;
     747                    mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= blank;
    749748                    image->data.F32[y][x] = NAN;
    750749                    continue;
    … …  
    770769                psArrayAdd(job->args, 1, mask);
    771770                PS_ARRAY_ADD_SCALAR(job->args, exptime, PS_TYPE_F32);
    772                 PS_ARRAY_ADD_SCALAR(job->args, blank, PS_TYPE_MASK);
     771                PS_ARRAY_ADD_SCALAR(job->args, blank, PS_TYPE_IMAGE_MASK);
    773772                PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
    774773                PS_ARRAY_ADD_SCALAR(job->args, rowStop, PS_TYPE_S32);
    … …  
    860859                                   psStatsOptions meanStat, ///< Statistic to use for mean
    861860                                   psStatsOptions stdevStat, ///< Statistic to use for stdev
    862                                    psMaskType maskVal, ///< Mask value
     861                                   psImageMaskType maskVal, ///< Mask value
    863862                                   psRandom *rng ///< Random number generator
    864863    )
    … …  
    876875    if (readout->mask) {
    877876        PS_ASSERT_IMAGE_NON_NULL(readout->mask, NULL);
    878         PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_MASK, NULL);
     877        PS_ASSERT_IMAGE_TYPE(readout->mask, PS_TYPE_IMAGE_MASK, NULL);
    879878        PS_ASSERT_IMAGE_SIZE(readout->mask, data->numCols, data->numRows, NULL);
    880879    }
    … …  
    10221021
    10231022bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs,
    1024                                         psMaskType maskVal)
     1023                                        psImageMaskType maskVal)
    10251024{
    10261025    PS_ASSERT_PTR_NON_NULL(shutter, false);
    … …  
    10841083bool pmShutterCorrectionGenerate(pmReadout *shutter, pmReadout *pattern, const psArray *inputs,
    10851084                                 float reference, const pmShutterCorrectionData *data,
    1086                                  int nIter, float rej, psMaskType maskVal)
     1085                                 int nIter, float rej, psImageMaskType maskVal)
    10871086{
    10881087    PS_ASSERT_PTR_NON_NULL(shutter, false);
    … …  
    11161115    psVector *counts = psVectorAlloc(num, PS_TYPE_F32); // Counts in each image
    11171116    psVector *errors = psVectorAlloc(num, PS_TYPE_F32); // Counts in each image
    1118     psVector *mask = psVectorAlloc(num, PS_TYPE_MASK); // Mask for each image
     1117    psVector *mask = psVectorAlloc(num, PS_TYPE_VECTOR_MASK); // Mask for each image
    11191118    psTrace("psModules.detrend", 2, "Performing linear fit on individual pixels...\n");
    11201119    for (int i = minInputRows; i < maxInputRows; i++) {
    … …  
    11321131                counts->data.F32[r] = image->data.F32[yIn][xIn] * ref;
    11331132                if (readout->mask) {
    1134                     mask->data.PS_TYPE_MASK_DATA[r] = readout->mask->data.PS_TYPE_MASK_DATA[yIn][xIn];
     1133                    mask->data.PS_TYPE_VECTOR_MASK_DATA[r] = (readout->mask->data.PS_TYPE_IMAGE_MASK_DATA[yIn][xIn] & maskVal);
    11351134                }
    11361135                if (readout->weight) {
    … …  
    11421141            }
    11431142
    1144             pmShutterCorrection *corr = pmShutterCorrectionLinFit(data->exptimes, counts, errors, mask,
    1145                                                                   reference, nIter, rej, maskVal);
     1143            pmShutterCorrection *corr = pmShutterCorrectionLinFit(data->exptimes, counts, errors, mask, reference, nIter, rej);
    11461144            if (!corr) {
    11471145                // Nothing we can do about it

  • trunk/psModules/src/detrend/pmShutterCorrection.h

    r19432 r21183  
    55 * @author Paul Price, IfA
    66 *
    7  * @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-09-09 04:10:14 $
     7 * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 * Copyright 2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    9191    float offref,                       ///< Reference time offset
    9292    int nIter,                          ///< Number of iterations
    93     float rej,                          ///< Rejection threshold (sigma)
    94     psMaskType maskVal                  ///< Mask value
     93    float rej                           ///< Rejection threshold (sigma)
    9594    );
    9695
    … …  
    121120    int nIter,                          ///< Number of iterations
    122121    float rej,                          ///< Rejection threshold (sigma)
    123     psMaskType maskVal                  ///< Mask value
     122    psImageMaskType maskVal                  ///< Mask value
    124123    );
    125124
    … …  
    135134    psImage *mask,                      ///< Input mask image
    136135    float exptime,                      ///< Exposure time to which to correct
    137     psMaskType blank,                   ///< Mask value to give blank pixels
     136    psImageMaskType blank,                   ///< Mask value to give blank pixels
    138137    int rowStart, int rowStop           ///< Range of scan
    139138    );
    … …  
    145144    pmReadout *readout,                 ///< Readout to which to apply shutter correction
    146145    const pmReadout *shutter,           ///< Shutter correction readout, with dT for each pixel
    147     psMaskType blank                    ///< Value to give blank pixels
     146    psImageMaskType blank                    ///< Value to give blank pixels
    148147    );
    149148
    … …  
    181180    psStatsOptions meanStat,            ///< Statistic to use for mean
    182181    psStatsOptions stdevStat,           ///< Statistic to use for stdev
    183     psMaskType maskVal,                 ///< Mask value
     182    psImageMaskType maskVal,                 ///< Mask value
    184183    psRandom *rng                       ///< Random number generator
    185184    );
    … …  
    201200    int nIter,                          ///< Number of iterations
    202201    float rej,                          ///< Rejection threshold (sigma)
    203     psMaskType maskVal                  ///< Mask value
     202    psImageMaskType maskVal                  ///< Mask value
    204203    );
    205204
    206205// prepare outputs for shutter correction
    207206bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs,
    208                                         psMaskType maskVal);
     207                                        psImageMaskType maskVal);
    209208
    210209/// @}

  • trunk/psModules/src/detrend/pmSkySubtract.c

    r12742 r21183  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2007-04-04 22:42:48 $
     8 *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    114114
    115115    psVector *binVector = psVectorAlloc(binFactor * binFactor, PS_TYPE_F32);
    116     psVector *binMask = psVectorAlloc(binFactor * binFactor, PS_TYPE_U8);
     116    psVector *binMask = psVectorAlloc(binFactor * binFactor, PS_TYPE_VECTOR_MASK);
    117117    psStats *myStats = psStatsAlloc(statOptions);
    118118
    … …  
    126126                        binVector->data.F32[count] =
    127127                            origImage->data.F32[row + binRow][col + binCol];
    128                         binMask->data.U8[count] = 0;
     128                        binMask->data.PS_TYPE_VECTOR_MASK_DATA[count] = 0;
    129129                    } else {
    130130                        binVector->data.F32[count] = 0.0;
    131                         binMask->data.U8[count] = 1;
     131                        binMask->data.PS_TYPE_VECTOR_MASK_DATA[count] = 1;
    132132                    }
    133133                    count++;
    … …  
    313313    PS_ASSERT_IMAGE_NON_NULL(maskImage, NULL);
    314314    PS_ASSERT_IMAGE_NON_EMPTY(maskImage, NULL);
    315     PS_ASSERT_IMAGE_TYPE(maskImage, PS_TYPE_U8, NULL);
     315    PS_ASSERT_IMAGE_TYPE(maskImage, PS_TYPE_IMAGE_MASK, NULL);
    316316    PS_ASSERT_IMAGES_SIZE_EQUAL(dataImage, maskImage, NULL);
    317317    psS32 oldPolyX = -1;
    … …  
    361361    for (x=0;x<dataImage->numRows;x++) {
    362362        for (y=0;y<dataImage->numCols;y++) {
    363             if (maskImage->data.U8[x][y] == 0) {
     363            if (maskImage->data.PS_TYPE_IMAGE_MASK_DATA[x][y] == 0) {
    364364                buildSums((psF64) x, (psF64) y, myPoly->nX, myPoly->nY);
    365365
    … …  
    572572
    573573        if (in->mask != NULL) {
    574             binnedMaskImage = psImageCopy(binnedMaskImage, in->mask, PS_TYPE_U8);
     574            binnedMaskImage = psImageCopy(binnedMaskImage, in->mask, PS_TYPE_IMAGE_MASK);
    575575            if (binnedMaskImage == NULL) {
    576576                psError(PS_ERR_UNKNOWN, false, "psImageCopy() returned NULL.  Returning in image.\n");
    … …  
    581581            binnedMaskImage = psImageAlloc(binnedImage->numCols,
    582582                                           binnedImage->numRows,
    583                                            PS_TYPE_U8);
     583                                           PS_TYPE_IMAGE_MASK);
    584584            psImageInit(binnedMaskImage, 0);
    585585        }
    … …  
    592592        binnedMaskImage = psImageAlloc(binnedImage->numCols,
    593593                                       binnedImage->numRows,
    594                                        PS_TYPE_U8);
     594                                       PS_TYPE_IMAGE_MASK);
    595595        psImageInit(binnedMaskImage, 0);
    596596    }
    … …  
    625625                if (fabs(binnedImage->data.F32[row][col] - binnedMean) >
    626626                        (clipSD * binnedStdev)) {
    627                     binnedMaskImage->data.U8[row][col] = 1;
     627                    binnedMaskImage->data.PS_TYPE_IMAGE_MASK_DATA[row][col] = 1;
    628628                }
    629629            }

  • trunk/psModules/src/imcombine/pmImageCombine.c

    r12742 r21183  
    88 *  @author GLG, MHPCC
    99 *
    10  *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2007-04-04 22:42:48 $
     10 *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2009-01-27 06:39:38 $
    1212 *
    1313 *  XXX: pmRejectPixels() has a known bug with the pmImageTransform() call.
    … …  
    1717 */
    1818
     19// XXX this is somewhat messy and unclear on the masking.
     20
    1921#ifdef HAVE_CONFIG_H
    2022#include <config.h>
    … …  
    5355
    5456    buffer->pixels = psVectorAlloc(numImages, PS_TYPE_F32);
    55     buffer->masks = psVectorAlloc(numImages, PS_TYPE_MASK);
     57    buffer->masks = psVectorAlloc(numImages, PS_TYPE_VECTOR_MASK);
    5658    buffer->errors = psVectorAlloc(numImages, PS_TYPE_F32);
    5759    buffer->stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
    … …  
    6769                          const psArray *errors, // Array of input error images
    6870                          const psArray *masks, // Array of input masks
    69                           psU32 maskVal, // Mask value
     71                          psImageMaskType maskVal, // Mask value
    7072                          psS32 numIter, // Number of rejection iterations
    7173                          psF32 sigmaClip, // Number of standard deviations at which to reject
    … …  
    115117        if (masks) {
    116118            psImage *mask = masks->data[i]; // Mask of interest
    117             pixelMasks->data.U8[i] = mask->data.U8[y][x];
    118         }        // Set the pixel error data, if necessary
     119            pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal);
     120        }       
     121        // Set the pixel error data, if necessary
    119122        if (errors) {
    120123            psImage *error = errors->data[i]; // Error image of interest
    … …  
    128131    for (int iter = 0; iter < numIter; iter++) {
    129132        // Combine all the pixels, using the specified stat.
    130         if (!psVectorStats(stats, pixelData, pixelErrors, pixelMasks, maskVal)) {
     133        if (!psVectorStats(stats, pixelData, pixelErrors, pixelMasks, 0xff)) {
    131134            combine->data.F32[y][x] = NAN;
    132135            psFree(buffer);
    … …  
    148151        float stdev = stats->sampleStdev;
    149152        for (int i = 0; i < numImages; i++) {
    150             if (!(pixelMasks->data.U8[i] & maskVal) &&
     153            if (!(pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[i] & 0xff) &&
    151154                    fabs(pixelData->data.F32[i] - combinedPixel) > sigmaClip * stdev) {
    152155                // Reject pixel as questionable
    153156                numRejects++;
    154                 pixelMasks->data.U8[i] = maskVal;
     157                pixelMasks->data.PS_TYPE_IMAGE_MASK_DATA[i] = 0xff;
    155158                if (questionablePixels) {
    156159                    // Mark the pixel as questionable
    … …  
    191194    const psArray *errors,              ///< Array of input error images
    192195    const psArray *masks,               ///< Array of input masks
    193     psU32 maskVal,                      ///< Mask value
     196    psImageMaskType maskVal,                      ///< Mask value
    194197    const psPixels *pixels,             ///< Pixels to combine
    195198    psS32 numIter,                      ///< Number of rejection iterations
    … …  
    231234            psImage *mask  = masks->data[i];
    232235            PS_ASSERT_IMAGE_SIZE(mask, numCols, numRows, NULL);
    233             PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     236            PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    234237        }
    235238    }
    … …  
    319322    int num = 0;
    320323    psVector *pixels = psVectorAlloc(8, PS_TYPE_F32); // Array of pixels
    321     psVector *mask = psVectorAlloc(8, PS_TYPE_U8); // Corresponding mask
     324    psVector *mask = psVectorAlloc(8, PS_TYPE_VECTOR_MASK); // Corresponding mask
    322325
    323326    // Get limits
    … …  
    329332        for (int j = yMin; j <= yMax; j++) {
    330333            for (int i = xMin; i <= xMax; i++) {
    331                 if ((i != x) && (j != y) && (0 == imageMask->data.U8[j][i])) {
     334                if ((i != x) && (j != y) && (0 == imageMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i])) {
    332335                    pixels->data.F32[num] = image->data.F32[j][i];
    333                     mask->data.U8[num] = 0;
     336                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0;
    334337                    num++;
    335338                } else {
    336                     mask->data.U8[num] = 1;
     339                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 1;
    337340                }
    338341            }
    … …  
    347350                if ((i != x) && (j != y)) {
    348351                    pixels->data.F32[num] = image->data.F32[j][i];
    349                     mask->data.U8[num] = 0;
     352                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0;
    350353                    num++;
    351354                } else {
    352                     mask->data.U8[num] = 1;
     355                    mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 1;
    353356                }
    354357            }
    … …  
    473476    for (psS32 i = 0 ; i < image->numRows ; i++) {
    474477        for (psS32 j = 0 ; j < image->numCols ; j++) {
    475             imgF32->data.F32[i][j] = (psF32) image->data.U8[i][j];
     478            imgF32->data.F32[i][j] = (psF32) image->data.PS_TYPE_IMAGE_MASK_DATA[i][j];
    476479        }
    477480    }
    … …  
    518521            PS_ASSERT_IMAGE_NON_NULL(tmpMask, NULL);
    519522            PS_ASSERT_IMAGE_NON_EMPTY(tmpMask, NULL);
    520             PS_ASSERT_IMAGE_TYPE(tmpMask, PS_TYPE_F32, NULL);
     523            PS_ASSERT_IMAGE_TYPE(tmpMask, PS_TYPE_F32, NULL); // XXX really F32??
    521524            PS_ASSERT_IMAGES_SIZE_EQUAL(tmpImage, tmpMask, NULL);
    522525        }
    … …  
    571574
    572575        //
    573         // Create a psU8 mask image from the list of cosmic pixels.
     576        // Create a psImageMaskType mask image from the list of cosmic pixels.
    574577        //
    575578        psImage *maskImage = NULL;

  • trunk/psModules/src/imcombine/pmPSFEnvelope.c

    r20999 r21183  
    223223    // *** readout->weight = (psImage*)psBinaryOp(NULL, readout->image, "*", psScalarAlloc(WEIGHT_FACTOR, PS_TYPE_F32));
    224224    readout->weight = (psImage*)psBinaryOp(NULL, readout->image, "+", psScalarAlloc(WEIGHT_VAL, PS_TYPE_F32));
    225     readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     225    readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    226226    psImageInit(readout->mask, 0);
    227227

  • trunk/psModules/src/imcombine/pmReadoutCombine.c

    r19086 r21183  
    105105
    106106    // note the mask value actually used
    107     psMaskType maskVal = params->maskVal; // The mask value
     107    psImageMaskType maskVal = params->maskVal; // The mask value
    108108    if (maskVal) {
    109109        psString comment = NULL;        // Comment to add to header
    … …  
    247247    psF32 *pixelsData = pixels->data.F32; // Dereference pixels
    248248
    249     psVector *mask   = psVectorAlloc(inputs->n, PS_TYPE_U8); // Mask for stack
    250     psU8 *maskData = mask->data.U8;     // Dereference mask
     249    psVector *mask   = psVectorAlloc(inputs->n, PS_TYPE_VECTOR_MASK); // Mask for stack
     250    psVectorMaskType *maskData = mask->data.PS_TYPE_VECTOR_MASK_DATA;     // Dereference mask
    251251
    252252    psVector *weights = NULL;           // Stack of weights
    … …  
    260260
    261261    float keepFrac = 1.0 - params->fracLow - params->fracHigh; // Fraction of pixels to keep
    262     psMaskType maskVal = params->maskVal; // The mask value
     262    psImageMaskType maskVal = params->maskVal; // The mask value
    263263
    264264    #ifndef PS_NO_TRACE
    … …  
    278278    // Dereference output products
    279279    psF32 **outputImage  = output->image->data.F32; // Output image
    280     psU8  **outputMask   = output->mask->data.U8; // Output mask
     280    psImageMaskType **outputMask   = output->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Output mask
    281281    psF32 **outputWeight = NULL; // Output weight map
    282282    if (output->weight) {
    … …  
    303303
    304304            int numValid = 0;           // Number of valid pixels in the stack
    305             memset(maskData, 0, mask->n * sizeof(psU8)); // Reset the mask
     305            memset(maskData, 0, mask->n * sizeof(psVectorMaskType)); // Reset the mask
    306306            for (int r = 0; r < inputs->n; r++) {
    307307                pmReadout *readout = inputs->data[r]; // Input readout
    … …  
    318318                // Check mask
    319319                psImage *roMask = readout->mask; // The mask image
    320                 if (roMask && roMask->data.U8[yIn][xIn] & maskVal) {
     320                if (roMask && roMask->data.PS_TYPE_IMAGE_MASK_DATA[yIn][xIn] & maskVal) {
    321321                    maskData[r] = 1;
    322322                    continue;

  • trunk/psModules/src/imcombine/pmReadoutCombine.h

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

  • trunk/psModules/src/imcombine/pmStack.c

    r20712 r21183  
    88 *  @author GLG, MHPCC
    99 *
    10  *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2008-11-13 03:50:30 $
     10 *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2009-01-27 06:39:38 $
    1212 *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    1313 *
    … …  
    6363
    6464    buffer->pixels = psVectorAlloc(numImages, PS_TYPE_F32);
    65     buffer->masks = psVectorAlloc(numImages, PS_TYPE_MASK);
     65    buffer->masks = psVectorAlloc(numImages, PS_TYPE_VECTOR_MASK);
    6666    buffer->variances = psVectorAlloc(numImages, PS_TYPE_F32);
    6767    buffer->weights = psVectorAlloc(numImages, PS_TYPE_F32);
    … …  
    143143    assert(!masks || values->n == masks->n);
    144144    assert(values->type.type == PS_TYPE_F32);
    145     assert(!masks || masks->type.type == PS_TYPE_MASK);
     145    assert(!masks || masks->type.type == PS_TYPE_VECTOR_MASK);
    146146    assert(sortBuffer && sortBuffer->nalloc >= values->n && sortBuffer->type.type == PS_TYPE_F32);
    147147
    … …  
    149149    int num = 0;            // Number of valid values
    150150    for (int i = 0; i < values->n; i++) {
    151         if (!masks || !masks->data.PS_TYPE_MASK_DATA[i]) {
     151        if (!masks || !masks->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    152152            sortBuffer->data.F32[num++] = values->data.F32[i];
    153153        }
    … …  
    215215                          const psVector *reject, // Indices of pixels to reject, or NULL
    216216                          int x, int y, // Coordinates of interest; frame of output image
    217                           psMaskType maskVal, // Value to mask
    218                           psMaskType bad, // Value to give bad pixels
     217                          psImageMaskType maskVal, // Value to mask
     218                          psImageMaskType bad, // Value to give bad pixels
    219219                          int numIter, // Number of rejection iterations
    220220                          float rej, // Number of standard deviations at which to reject
    … …  
    258258        int xIn = x - data->readout->col0, yIn = y - data->readout->row0; // Coordinates on input readout
    259259        psImage *mask = data->readout->mask; // Mask of interest
    260         if (mask->data.PS_TYPE_MASK_DATA[yIn][xIn] & maskVal) {
     260        if (mask->data.PS_TYPE_IMAGE_MASK_DATA[yIn][xIn] & maskVal) {
    261261            continue;
    262262        }
    … …  
    283283    // Default option is that the pixel is bad
    284284    float imageValue = NAN, varianceValue = NAN; // Value for combined image and variance map
    285     psMaskType maskValue = bad;         // Value for combined mask
     285    psImageMaskType maskValue = bad;         // Value for combined mask
    286286    switch (num) {
    287287      case 0:
    … …  
    382382// Mask a pixel for inspection
    383383#define MASK_PIXEL_FOR_INSPECTION() \
    384     pixelMasks->data.PS_TYPE_MASK_DATA[j] = 0xff; \
     384    pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff; \
    385385    combineInspect(inputs, x, y, pixelSources->data.U16[j]); \
    386386    numClipped++; \
    … …  
    388388
    389389              for (int j = 0; j < num; j++) {
    390                   if (pixelMasks->data.PS_TYPE_MASK_DATA[j]) {
     390                  if (pixelMasks->data.PS_TYPE_VECTOR_MASK_DATA[j]) {
    391391                      continue;
    392392                  }
    … …  
    408408
    409409    image->data.F32[y][x] = imageValue;
    410     mask->data.PS_TYPE_MASK_DATA[y][x] = maskValue;
     410    mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = maskValue;
    411411    if (variance) {
    412412        variance->data.F32[y][x] = varianceValue;
    … …  
    438438    PS_ASSERT_IMAGE_TYPE(data->readout->image, PS_TYPE_F32, false);
    439439    PS_ASSERT_IMAGE_NON_NULL(data->readout->mask, false);
    440     PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_MASK, false);
     440    PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_IMAGE_MASK, false);
    441441    PS_ASSERT_IMAGES_SIZE_EQUAL(data->readout->image, data->readout->mask, false);
    442442    *numCols = data->readout->image->numCols;
    … …  
    469469        PS_ASSERT_IMAGE_NON_NULL(data->readout->mask, false);
    470470        PS_ASSERT_IMAGE_TYPE(data->readout->image, PS_TYPE_F32, false);
    471         PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_MASK, false);
     471        PS_ASSERT_IMAGE_TYPE(data->readout->mask, PS_TYPE_IMAGE_MASK, false);
    472472        PS_ASSERT_IMAGE_SIZE(data->readout->image, *numCols, *numRows, false);
    473473        PS_ASSERT_IMAGES_SIZE_EQUAL(data->readout->image, data->readout->mask, false);
    … …  
    562562
    563563/// Stack input images
    564 bool pmStackCombine(pmReadout *combined, psArray *input, psMaskType maskVal, psMaskType bad,
     564bool pmStackCombine(pmReadout *combined, psArray *input, psImageMaskType maskVal, psImageMaskType bad,
    565565                    int kernelSize, int numIter, float rej, float sys,
    566566                    bool entire, bool useVariance, bool safe)
    … …  
    587587        PS_ASSERT_IMAGE_TYPE(combined->image, PS_TYPE_F32, false);
    588588        PS_ASSERT_IMAGE_NON_NULL(combined->mask, false);
    589         PS_ASSERT_IMAGE_TYPE(combined->mask, PS_TYPE_MASK, false);
     589        PS_ASSERT_IMAGE_TYPE(combined->mask, PS_TYPE_IMAGE_MASK, false);
    590590        PS_ASSERT_IMAGES_SIZE_EQUAL(combined->image, combined->mask, false);
    591591    }
    … …  
    698698        psImage *combinedMask = combined->mask; // Combined mask
    699699        if (!combinedMask) {
    700             combined->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     700            combined->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    701701            combinedMask = combined->mask;
    702702        }

  • trunk/psModules/src/imcombine/pmStack.h

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

  • trunk/psModules/src/imcombine/pmStackReject.c

    r20838 r21183  
    6161        }
    6262
    63         int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK); // Number of bytes to copy
     63        int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK); // Number of bytes to copy
    6464        psAssert(convolved->numCols - 2 * box == xMax - xMin, "Bad number of columns");
    6565        psAssert(convolved->numRows - 2 * box == yMax - yMin, "Bad number of rows");
    6666
    6767        for (int yTarget = yMin, ySource = box; yTarget < yMax; yTarget++, ySource++) {
    68             memcpy(&target->data.PS_TYPE_MASK_DATA[yTarget][xMin],
    69                    &convolved->data.PS_TYPE_MASK_DATA[ySource][box], numBytes);
     68            memcpy(&target->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin],
     69                   &convolved->data.PS_TYPE_IMAGE_MASK_DATA[ySource][box], numBytes);
    7070        }
    7171        psFree(convolved);
    7272    } else {
    7373        // Just copy over
    74         int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK); // Number of bytes to copy
     74        int numBytes = (xMax - xMin) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK); // Number of bytes to copy
    7575        for (int yTarget = yMin; yTarget < yMax; yTarget++) {
    76             memcpy(&target->data.PS_TYPE_MASK_DATA[yTarget][xMin],
    77                    &source->data.PS_TYPE_MASK_DATA[yTarget][xMin], numBytes);
     76            memcpy(&target->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin],
     77                   &source->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][xMin], numBytes);
    7878        }
    7979    }
    … …  
    262262    bool oldThreads = psImageConvolveSetThreads(false); // Old value of threading for psImageColvolve
    263263
    264     psImage *target = psImageRecycle(convolved, numCols, numRows, PS_TYPE_MASK); // Grown image
     264    psImage *target = psImageRecycle(convolved, numCols, numRows, PS_TYPE_IMAGE_MASK); // Grown image
    265265    psImageInit(target, 0);
    266266    if (threaded) {

  • trunk/psModules/src/imcombine/pmSubtraction.c

    r20838 r21183  
    246246                        psImage *image, // Image to convolve
    247247                        psImage *mask, // Mask image
    248                         psMaskType maskVal, // Value to mask
     248                        psImageMaskType maskVal, // Value to mask
    249249                        const psKernel *kernel, // Kernel by which to convolve
    250250                        psRegion region,// Region of interest
    … …  
    291291                              psImage *sys, // Systematic error image
    292292                              psImage *mask, // Mask image
    293                               psMaskType maskVal, // Value to mask
     293                              psImageMaskType maskVal, // Value to mask
    294294                              const psKernel *kernel, // Kernel by which to convolve
    295295                              psRegion region,// Region of interest
    … …  
    373373                                  float background, // Background value to apply
    374374                                  psRegion region, // Region to convolve
    375                                   psMaskType maskBad, // Value to give bad pixels
    376                                   psMaskType maskPoor, // Value to give poor pixels
     375                                  psImageMaskType maskBad, // Value to give bad pixels
     376                                  psImageMaskType maskPoor, // Value to give poor pixels
    377377                                  float poorFrac, // Fraction for "poor"
    378378                                  bool useFFT,  // Use FFT to convolve?
    … …  
    385385    }
    386386
    387     psMaskType subBad;                  // Bad pixels in subtraction mask
    388     psMaskType subConvBad;              // Bad pixels in subtraction mask when convolving
    389     psMaskType subConvPoor;             // Poor pixels in subtraction mask when convolving
     387    psImageMaskType subBad;                  // Bad pixels in subtraction mask
     388    psImageMaskType subConvBad;              // Bad pixels in subtraction mask when convolving
     389    psImageMaskType subConvPoor;             // Poor pixels in subtraction mask when convolving
    390390    if (kernels->mode == PM_SUBTRACTION_MODE_1 || (kernels->mode == PM_SUBTRACTION_MODE_DUAL && !wantDual)) {
    391391        subBad = PM_SUBTRACTION_MASK_BAD_1;
    … …  
    437437            for (int yTarget = rowMin, ySource = box; yTarget < rowMax; yTarget++, ySource++) {
    438438                // Dereference images
    439                 psMaskType *target = &convMask->data.PS_TYPE_MASK_DATA[yTarget][colMin]; // Target values
    440                 psMaskType *source = &convolved->data.PS_TYPE_MASK_DATA[ySource][box]; // Source values
     439                psImageMaskType *target = &convMask->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][colMin]; // Target values
     440                psImageMaskType *source = &convolved->data.PS_TYPE_IMAGE_MASK_DATA[ySource][box]; // Source values
    441441                for (int xTarget = colMin; xTarget < colMax; xTarget++, target++, source++) {
    442442                    if (*source & subConvBad) {
    … …  
    783783    PS_ASSERT_VECTOR_TYPE(deviations, PS_TYPE_F32, -1);
    784784    PS_ASSERT_IMAGE_NON_EMPTY(subMask, -1);
    785     PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, -1);
     785    PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, -1);
    786786
    787787    // I used to measure the rms deviation about zero, and use that as the sigma against which to clip, but
    … …  
    794794
    795795    int numStamps = 0;                  // Number of used stamps
    796     psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_MASK); // Mask, for statistics
     796    psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_VECTOR_MASK); // Mask, for statistics
    797797    psVectorInit(mask, 0);
    798798    for (int i = 0; i < stamps->num; i++) {
    799799        pmSubtractionStamp *stamp = stamps->stamps->data[i]; // Stamp of interest
    800800        if (stamp->status != PM_SUBTRACTION_STAMP_USED) {
    801             mask->data.PS_TYPE_MASK_DATA[i] = 0xff;
     801            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    802802            continue;
    803803        }
    … …  
    869869                for (int y = stamp->y - footprint; y <= stamp->y + footprint; y++) {
    870870                    for (int x = stamp->x - footprint; x <= stamp->x + footprint; x++) {
    871                         subMask->data.PS_TYPE_MASK_DATA[y][x] |= PM_SUBTRACTION_MASK_REJ;
     871                        subMask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= PM_SUBTRACTION_MASK_REJ;
    872872                    }
    873873                }
    … …  
    997997                                     psImage *sys1, psImage *sys2, // Systematic error images
    998998                                     psImage *subMask, // Input subtraction mask
    999                                      psMaskType maskBad, // Mask value to give bad pixels
    1000                                      psMaskType maskPoor, // Mask value to give poor pixels
     999                                     psImageMaskType maskBad, // Mask value to give bad pixels
     1000                                     psImageMaskType maskPoor, // Mask value to give poor pixels
    10011001                                     float poorFrac, // Fraction for "poor"
    10021002                                     const psRegion *region, // Patch to convolve
    … …  
    10351035
    10361036    if ((kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro1->mask) {
    1037         psMaskType **target = convMask->data.PS_TYPE_MASK_DATA; // Target mask
    1038         psMaskType **source = ro1->mask->data.PS_TYPE_MASK_DATA; // Source mask
     1037        psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
     1038        psImageMaskType **source = ro1->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask
    10391039
    10401040        for (int y = yMin; y < yMax; y++) {
    … …  
    10451045    }
    10461046    if ((kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro2->mask) {
    1047         psMaskType **target = convMask->data.PS_TYPE_MASK_DATA; // Target mask
    1048         psMaskType **source = ro2->mask->data.PS_TYPE_MASK_DATA; // Source mask
     1047        psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
     1048        psImageMaskType **source = ro2->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask
    10491049
    10501050        for (int y = yMin; y < yMax; y++) {
    … …  
    10751075    psImage *sys2 = args->data[10]; // Systematic error image 2
    10761076    psImage *subMask = args->data[11]; // Subtraction mask
    1077     psMaskType maskBad = PS_SCALAR_VALUE(args->data[12], U8); // Output mask value for bad pixels
    1078     psMaskType maskPoor = PS_SCALAR_VALUE(args->data[13], U8); // Output mask value for poor pixels
     1077    psImageMaskType maskBad = PS_SCALAR_VALUE(args->data[12], PS_TYPE_IMAGE_MASK_DATA); // Output mask value for bad pixels
     1078    psImageMaskType maskPoor = PS_SCALAR_VALUE(args->data[13], PS_TYPE_IMAGE_MASK_DATA); // Output mask value for poor pixels
    10791079    float poorFrac = PS_SCALAR_VALUE(args->data[14], F32); // Fraction for "poor"
    10801080    const psRegion *region = args->data[15]; // Region to convolve
    10811081    const pmSubtractionKernels *kernels = args->data[16]; // Kernels
    1082     bool doBG = PS_SCALAR_VALUE(args->data[17], U8); // Do background subtraction?
    1083     bool useFFT = PS_SCALAR_VALUE(args->data[18], U8); // Use FFT for convolution?
     1082    bool doBG = PS_SCALAR_VALUE(args->data[17], PS_TYPE_IMAGE_MASK_DATA); // Do background subtraction?
     1083    bool useFFT = PS_SCALAR_VALUE(args->data[18], PS_TYPE_IMAGE_MASK_DATA); // Use FFT for convolution?
    10841084
    10851085    return subtractionConvolvePatch(numCols, numRows, x0, y0, out1, out2, convMask, ro1, ro2, sys1, sys2,
    … …  
    10881088
    10891089bool pmSubtractionConvolve(pmReadout *out1, pmReadout *out2, const pmReadout *ro1, const pmReadout *ro2,
    1090                            psImage *subMask, int stride, psMaskType maskBad, psMaskType maskPoor,
     1090                           psImage *subMask, int stride, psImageMaskType maskBad, psImageMaskType maskPoor,
    10911091                           float poorFrac, float sysError, const psRegion *region,
    10921092                           const pmSubtractionKernels *kernels, bool doBG, bool useFFT)
    … …  
    11211121    if (subMask) {
    11221122        PS_ASSERT_IMAGE_NON_NULL(subMask, false);
    1123         PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, false);
     1123        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, false);
    11241124        PS_ASSERT_IMAGE_SIZE(subMask, numCols, numRows, false);
    11251125    }
    … …  
    11821182        if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    11831183            if (!out1->mask) {
    1184                 out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     1184                out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    11851185            }
    11861186            convMask = out1->mask;
    … …  
    11941194            } else {
    11951195                if (!out2->mask) {
    1196                     out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     1196                    out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    11971197                }
    11981198                convMask = out2->mask;
    … …  
    12851285                    psMutexUnlock(subMask);
    12861286                }
    1287                 PS_ARRAY_ADD_SCALAR(args, maskBad, PS_TYPE_U8);
    1288                 PS_ARRAY_ADD_SCALAR(args, maskPoor, PS_TYPE_U8);
     1287                PS_ARRAY_ADD_SCALAR(args, maskBad, PS_TYPE_IMAGE_MASK);
     1288                PS_ARRAY_ADD_SCALAR(args, maskPoor, PS_TYPE_IMAGE_MASK);
    12891289                PS_ARRAY_ADD_SCALAR(args, poorFrac, PS_TYPE_F32);
    12901290                psArrayAdd(args, 1, subRegion);

  • trunk/psModules/src/imcombine/pmSubtraction.h

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

  • trunk/psModules/src/imcombine/pmSubtractionMask.c

    r20832 r21183  
    2020                             psImage *weight, // Weight map to mark as blank (or NULL)
    2121                             int x, int y, // Coordinates to mark blank
    22                              psMaskType blank // Blank mask value
     22                             psImageMaskType blank // Blank mask value
    2323    )
    2424{
    2525    image->data.F32[y][x] = NAN;
    2626    if (mask) {
    27         mask->data.PS_TYPE_MASK_DATA[y][x] |= blank;
     27        mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= blank;
    2828    }
    2929    if (weight) {
    … …  
    3737//////////////////////////////////////////////////////////////////////////////////////////////////////////////
    3838
    39 psImage *pmSubtractionMask(const psImage *mask1, const psImage *mask2, psMaskType maskVal,
     39psImage *pmSubtractionMask(const psImage *mask1, const psImage *mask2, psImageMaskType maskVal,
    4040                           int size, int footprint, float badFrac, bool useFFT)
    4141{
    4242    PS_ASSERT_IMAGE_NON_NULL(mask1, NULL);
    43     PS_ASSERT_IMAGE_TYPE(mask1, PS_TYPE_MASK, NULL);
     43    PS_ASSERT_IMAGE_TYPE(mask1, PS_TYPE_IMAGE_MASK, NULL);
    4444    if (mask2) {
    4545        PS_ASSERT_IMAGE_NON_NULL(mask2, NULL);
    46         PS_ASSERT_IMAGE_TYPE(mask2, PS_TYPE_MASK, NULL);
     46        PS_ASSERT_IMAGE_TYPE(mask2, PS_TYPE_IMAGE_MASK, NULL);
    4747        PS_ASSERT_IMAGES_SIZE_EQUAL(mask2, mask1, NULL);
    4848    }
    … …  
    5757
    5858    // Dereference inputs for convenience
    59     psMaskType **data1 = mask1->data.PS_TYPE_MASK_DATA;
    60     psMaskType **data2 = NULL;
     59    psImageMaskType **data1 = mask1->data.PS_TYPE_IMAGE_MASK_DATA;
     60    psImageMaskType **data2 = NULL;
    6161    if (mask2) {
    62         data2 = mask2->data.PS_TYPE_MASK_DATA;
     62        data2 = mask2->data.PS_TYPE_IMAGE_MASK_DATA;
    6363    }
    6464
    … …  
    8686
    8787    // Worried about the masks for bad pixels and bad stamps colliding, so make our own mask
    88     psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); // The global mask
     88    psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); // The global mask
    8989    psImageInit(mask, 0);
    90     psMaskType **maskData = mask->data.PS_TYPE_MASK_DATA; // Dereference for convenience
     90    psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA; // Dereference for convenience
    9191
    9292    // Block out a border around the edge of the image
    … …  
    161161
    162162bool pmSubtractionBorder(psImage *image, psImage *weight, psImage *mask,
    163                          int size, psMaskType blank)
     163                         int size, psImageMaskType blank)
    164164{
    165165    PS_ASSERT_IMAGE_NON_NULL(image, false);
    … …  
    168168        PS_ASSERT_IMAGE_NON_NULL(mask, false);
    169169        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
    170         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
     170        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
    171171    }
    172172    if (weight) {
    … …  
    211211    }
    212212    PS_ASSERT_IMAGE_NON_NULL(mask, false);
    213     PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
     213    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
    214214    PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
    215215
    … …  
    233233
    234234    int numCols = image->numCols, numRows = image->numRows; // Size of image
    235     psMaskType **maskData = mask->data.PS_TYPE_MASK_DATA; // Dereference mask
     235    psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA; // Dereference mask
    236236
    237237    for (int y = 0; y < numRows; y++) {

  • trunk/psModules/src/imcombine/pmSubtractionMask.h

    r17729 r21183  
    77psImage *pmSubtractionMask(const psImage *refMask, ///< Mask for the reference image (will be convolved)
    88                           const psImage *inMask, ///< Mask for the input image, or NULL
    9                            psMaskType maskVal, ///< Value to mask out
     9                           psImageMaskType maskVal, ///< Value to mask out
    1010                           int size, ///< Half-size of the kernel (pmSubtractionKernels.size)
    1111                           int footprint, ///< Half-size of the kernel footprint
    … …  
    1919                         psImage *mask, ///< Mask (or NULL)
    2020                         int size,      ///< Kernel half-size
    21                          psMaskType blank ///< Mask value for blank regions
     21                         psImageMaskType blank ///< Mask value for blank regions
    2222    );
    2323

  • trunk/psModules/src/imcombine/pmSubtractionMatch.c

    r21149 r21183  
    9898                        int inner, int ringsOrder, int binning, float penalty,
    9999                        bool optimum, const psVector *optFWHMs, int optOrder, float optThreshold,
    100                         int iter, float rej, float sysError, psMaskType maskVal, psMaskType maskBad,
    101                         psMaskType maskPoor, float poorFrac, float badFrac, pmSubtractionMode subMode)
     100                        int iter, float rej, float sysError, psImageMaskType maskVal, psImageMaskType maskBad,
     101                        psImageMaskType maskPoor, float poorFrac, float badFrac, pmSubtractionMode subMode)
    102102{
    103103    if (subMode != PM_SUBTRACTION_MODE_2) {
    … …  
    565565    if (width1 == 0 || width2 == 0) {
    566566        ratios->data.F32[index] = NAN;
    567         mask->data.PS_TYPE_MASK_DATA[index] = 0xff;
     567        mask->data.PS_TYPE_IMAGE_MASK_DATA[index] = 0xff;
    568568    } else {
    569569        ratios->data.F32[index] = (float)width1 / (float)width2;
    570         mask->data.PS_TYPE_MASK_DATA[index] = 0;
     570        mask->data.PS_TYPE_IMAGE_MASK_DATA[index] = 0;
    571571        psTrace("psModules.imcombine", 3, "Stamp %d (%.1f,%.1f) widths: %d, %d --> %f\n",
    572572                index, stamp->x, stamp->y, width1, width2, ratios->data.F32[index]);
    … …  
    596596    PM_ASSERT_SUBTRACTION_STAMP_LIST_NON_NULL(stamps, PM_SUBTRACTION_MODE_ERR);
    597597
    598     psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_MASK); // Mask for stamps
     598    psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_VECTOR_MASK); // Mask for stamps
    599599    psVector *ratios = psVectorAlloc(stamps->num, PS_TYPE_F32); // Ratios of widths
    600600
    … …  
    624624        pmSubtractionStamp *stamp = stamps->stamps->data[i]; // Stamp of interest
    625625        if (stamp->status != PM_SUBTRACTION_STAMP_CALCULATE && stamp->status != PM_SUBTRACTION_STAMP_USED) {
    626             mask->data.PS_TYPE_MASK_DATA[i] = 0xff;
     626            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    627627            continue;
    628628        }

  • trunk/psModules/src/imcombine/pmSubtractionMatch.h

    r20568 r21183  
    4040                        float rej,      ///< Rejection threshold
    4141                        float sysError, ///< Relative systematic error
    42                         psMaskType maskVal, ///< Value to mask for input
    43                         psMaskType maskBad, ///< Mask for output bad pixels
    44                         psMaskType maskPoor, ///< Mask for output poor pixels
     42                        psImageMaskType maskVal, ///< Value to mask for input
     43                        psImageMaskType maskBad, ///< Mask for output bad pixels
     44                        psImageMaskType maskPoor, ///< Mask for output poor pixels
    4545                        float poorFrac, ///< Fraction for "poor"
    4646                        float badFrac,   ///< Maximum fraction of bad input pixels to accept

  • trunk/psModules/src/imcombine/pmSubtractionStamps.c

    r20937 r21183  
    9898
    9999    // Determine mask value
    100     psMaskType maskVal = PM_SUBTRACTION_MASK_BORDER | PM_SUBTRACTION_MASK_BAD_1 | PM_SUBTRACTION_MASK_BAD_2;
     100    psImageMaskType maskVal = PM_SUBTRACTION_MASK_BORDER | PM_SUBTRACTION_MASK_BAD_1 | PM_SUBTRACTION_MASK_BAD_2;
    101101    switch (mode) {
    102102      case PM_SUBTRACTION_MODE_1:
    … …  
    115115
    116116    // Check the immediate pixel
    117     if (clean && (mask->data.PS_TYPE_MASK_DATA[y][x] & (maskVal | PM_SUBTRACTION_MASK_REJ))) {
     117    if (clean && (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & (maskVal | PM_SUBTRACTION_MASK_REJ))) {
    118118        clean = false;
    119119    }
    … …  
    126126        for (int j = yMin; j <= yMax; j++) {
    127127            for (int i = xMin; i <= xMax; i++) {
    128                 if (mask->data.PS_TYPE_MASK_DATA[j][i] & maskVal) {
     128                if (mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] & maskVal) {
    129129                    clean = false;
    130130                    goto CHECK_STAMP_MASK_DONE;
    … …  
    139139        for (int j = yMin; j <= yMax; j++) {
    140140            for (int i = xMin; i <= xMax; i++) {
    141                 mask->data.PS_TYPE_MASK_DATA[j][i] |= PM_SUBTRACTION_MASK_REJ;
     141                mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= PM_SUBTRACTION_MASK_REJ;
    142142            }
    143143        }
    … …  
    235235        PS_ASSERT_IMAGE_NON_NULL(subMask, NULL);
    236236        PS_ASSERT_IMAGES_SIZE_EQUAL(image, subMask, NULL);
    237         PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, NULL);
     237        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, NULL);
    238238    }
    239239    PS_ASSERT_INT_NONNEGATIVE(footprint, NULL);
    … …  
    377377    if (subMask) {
    378378        PS_ASSERT_IMAGE_NON_NULL(subMask, NULL);
    379         PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, NULL);
     379        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, NULL);
    380380        if (image) {
    381381            PS_ASSERT_IMAGE_NON_NULL(image, NULL);

  • trunk/psModules/src/objects/pmFootprintArrayGrow.c

    r20937 r21183  
    33 * @author RHL, Princeton & IfA; EAM, IfA
    44 *
    5  * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    6  * @date $Date: 2008-12-08 02:51:14 $
     5 * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     6 * @date $Date: 2009-01-27 06:39:38 $
    77 * Copyright 2006 Institute for Astronomy, University of Hawaii
    88 */
    … …  
    4545    // Use a separable convolution: should be faster
    4646    idImage = (psImage*)psBinaryOp(idImage, idImage, "MIN", psScalarAlloc(1, PS_TYPE_S32));
    47     psImage *idImageMask = psImageCopy(NULL, idImage, PS_TYPE_MASK); // Image with 1 = object
     47    psImage *idImageMask = psImageCopy(NULL, idImage, PS_TYPE_IMAGE_MASK); // Image with 1 = object
    4848    psImage *grownIdImage = psImageConvolveMask(NULL, idImageMask, 0x01, 0x01, -r, r, -r, r); // Grown mask
    4949    if (!grownIdImage) {

  • trunk/psModules/src/objects/pmFootprintFindAtPoint.c

    r20937 r21183  
    44 * @author RHL, Princeton & IfA; EAM, IfA
    55 *
    6  * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    7  * @date $Date: 2008-12-08 02:51:14 $
     6 * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2009-01-27 06:39:38 $
    88 * Copyright 2006 Institute for Astronomy, University of Hawaii
    99 */
    … …  
    7777   
    7878    if (mask != NULL) {                 // remember that we've detected these pixels
    79         psMaskType *mpix = &mask->data.PS_TYPE_MASK_DATA[span->y - mask->row0][span->x0 - mask->col0];
     79        psImageMaskType *mpix = &mask->data.PS_TYPE_IMAGE_MASK_DATA[span->y - mask->row0][span->x0 - mask->col0];
    8080
    8181        for (int i = 0; i <= span->x1 - span->x0; i++) {
    … …  
    143143    psF32 *imgRowF32 = NULL;            // row pointer if F32
    144144    psS32 *imgRowS32 = NULL;            //  "   "   "  "  !F32
    145     psMaskType *maskRow = NULL;         //  masks's row pointer
     145    psImageMaskType *maskRow = NULL;            //  masks's row pointer
    146146   
    147147    const int row0 = img->row0;
    … …  
    186186        imgRowF32 = img->data.F32[i];   // only one of
    187187        imgRowS32 = img->data.S32[i];   //      these is valid!
    188         maskRow = mask->data.PS_TYPE_MASK_DATA[i];
     188        maskRow = mask->data.PS_TYPE_IMAGE_MASK_DATA[i];
    189189        //
    190190        // Search left from the pixel diagonally to the left of (i - di, x0). If there's
    … …  
    354354 * looking for the rest of the pmFootprint.  These are generally set from peaks.
    355355 */
    356    psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     356   psImage *mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    357357   P_PSIMAGE_SET_ROW0(mask, row0);
    358358   P_PSIMAGE_SET_COL0(mask, col0);
    … …  
    365365       for (int i = 0; i < peaks->n; i++) {
    366366           pmPeak *peak = peaks->data[i];
    367            mask->data.PS_TYPE_MASK_DATA[peak->y - mask->row0][peak->x - mask->col0] |= PM_SSPAN_STOP;
     367           mask->data.PS_TYPE_IMAGE_MASK_DATA[peak->y - mask->row0][peak->x - mask->col0] |= PM_SSPAN_STOP;
    368368       }
    369369   }
    … …  
    375375   imgRowF32 = img->data.F32[row];      // only one of
    376376   imgRowS32 = img->data.S32[row];      //      these is valid!
    377    psMaskType *maskRow = mask->data.PS_TYPE_MASK_DATA[row];
     377   psImageMaskType *maskRow = mask->data.PS_TYPE_IMAGE_MASK_DATA[row];
    378378   {
    379379       int i;

  • trunk/psModules/src/objects/pmGrowthCurveGenerate.c

    r20937 r21183  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2008-12-08 02:51:14 $
     7 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2009-01-27 06:39:38 $
    99 *
    1010 *  Copyright 2004 Institute for Astronomy, University of Hawaii
    … …  
    4141#include "pmErrorCodes.h"
    4242
    43 pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType markVal, float xc, float yc);
     43pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType markVal, float xc, float yc);
    4444
    4545/*****************************************************************************/
    … …  
    4848
    4949// we generate the growth curve for the center of the image with the specified psf model
    50 bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType markVal)
     50bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType markVal)
    5151{
    5252    PS_ASSERT_PTR_NON_NULL(readout, false);
    … …  
    119119}
    120120
    121 pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType markVal, float xc, float yc) {
     121pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType markVal, float xc, float yc) {
    122122
    123123    float fitMag, apMag;
    … …  
    162162    psImage *view = psImageSubset (image, region);
    163163    psImage *pixels = psImageCopy (NULL, view, PS_TYPE_F32);
    164     psImage *mask = psImageCopy (NULL, view, PS_TYPE_U8);
     164    psImage *mask = psImageCopy (NULL, view, PS_TYPE_IMAGE_MASK);
    165165
    166166    psImageInit (pixels, 0.0);
    … …  
    189189            return NULL;
    190190        }
    191         psImageKeepCircle (mask, xc, yc, radius, "AND", PS_NOT_U8(markVal));
     191        psImageKeepCircle (mask, xc, yc, radius, "AND", PS_NOT_IMAGE_MASK(markVal));
    192192
    193193        // the 'ignore' mode is for testing

  • trunk/psModules/src/objects/pmModel.c

    r20592 r21183  
    66 *  @author EAM, IfA
    77 *
    8  *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-11-09 00:28:18 $
     8 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    172172                          pmModelOpMode mode,
    173173                          bool add,
    174                           psMaskType maskVal,
     174                          psImageMaskType maskVal,
    175175                          int dx,
    176176                          int dy
    … …  
    229229    psF32 **Rx = NULL;
    230230    psF32 **Ry = NULL;
    231     psU8 **Rm = NULL;
     231    psImageMaskType **Rm = NULL;
    232232
    233233    if (model->residuals) {
    … …  
    237237        Rx = (model->residuals->Rx)   ? model->residuals->Rx->data.F32 : NULL;
    238238        Ry = (model->residuals->Ry)   ? model->residuals->Ry->data.F32 : NULL;
    239         Rm = (model->residuals->mask) ? model->residuals->mask->data.U8 : NULL;
     239        Rm = (model->residuals->mask) ? model->residuals->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
    240240        if (Ro) {
    241241            NX = model->residuals->Ro->numCols;
    … …  
    249249    for (psS32 iy = 0; iy < image->numRows; iy++) {
    250250        for (psS32 ix = 0; ix < image->numCols; ix++) {
    251             if ((mask != NULL) && (mask->data.U8[iy][ix] & maskVal))
     251            if ((mask != NULL) && (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] & maskVal))
    252252                continue;
    253253
    … …  
    351351                pmModel *model,
    352352                pmModelOpMode mode,
    353                 psMaskType maskVal)
     353                psImageMaskType maskVal)
    354354{
    355355    psTrace("psModules.objects", 3, "---- %s() begin ----\n", __func__);
    … …  
    365365                pmModel *model,
    366366                pmModelOpMode mode,
    367                 psMaskType maskVal)
     367                psImageMaskType maskVal)
    368368{
    369369    psTrace("psModules.objects", 3, "---- %s() begin ----\n", __func__);
    … …  
    379379                          pmModel *model,
    380380                          pmModelOpMode mode,
    381                           psMaskType maskVal,
     381                          psImageMaskType maskVal,
    382382                          int dx,
    383383                          int dy)
    … …  
    395395                          pmModel *model,
    396396                          pmModelOpMode mode,
    397                           psMaskType maskVal,
     397                          psImageMaskType maskVal,
    398398                          int dx,
    399399                          int dy)

  • trunk/psModules/src/objects/pmModel.h

    r20945 r21183  
    55 * @author EAM, IfA
    66 *
    7  * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-12-09 21:16:09 $
     7 * @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 *
    1010 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    150150    pmModel *model,                     ///< The input pmModel
    151151    pmModelOpMode mode,                 ///< mode to control how the model is added into the image
    152     psMaskType maskVal                  ///< Value to mask
     152    psImageMaskType maskVal             ///< Value to mask
    153153);
    154154
    … …  
    168168    pmModel *model,                     ///< The input pmModel
    169169    pmModelOpMode mode,                 ///< mode to control how the model is added into the image
    170     psMaskType maskVal                  ///< Value to mask
     170    psImageMaskType maskVal             ///< Value to mask
    171171);
    172172
    … …  
    175175                          pmModel *model,
    176176                          pmModelOpMode mode,
    177                           psMaskType maskVal,
     177                          psImageMaskType maskVal,
    178178                          int dx,
    179179                          int dy);
    … …  
    183183                          pmModel *model,
    184184                          pmModelOpMode mode,
    185                           psMaskType maskVal,
     185                          psImageMaskType maskVal,
    186186                          int dx,
    187187                          int dy);

  • trunk/psModules/src/objects/pmPSF.h

    r20945 r21183  
    66 * @author EAM, IfA
    77 *
    8  * @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2008-12-09 21:16:09 $
     8 * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2009-01-27 06:39:38 $
    1010 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1111 */
    … …  
    102102double pmPSF_SXYtoModel (psF32 *fittedPar);
    103103
    104 bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psMaskType maskVal, psMaskType mark);
     104bool pmGrowthCurveGenerate (pmReadout *readout, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType mark);
    105105pmPSF *pmPSFBuildSimple (char *typeName, float sxx, float syy, float sxy, ...);
    106106

  • trunk/psModules/src/objects/pmPSF_IO.c

    r20937 r21183  
    66 *  @author EAM, IfA
    77 *
    8  *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-12-08 02:51:14 $
     8 *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    871871            psFitsReadImageBuffer(psf->residuals->Ry, file->fits, fullImage, 2); // Desired pixels
    872872        }
     873        // XXX notice that we are not saving the resid->mask
    873874    }
    874875

  • trunk/psModules/src/objects/pmPSFtry.c

    r21173 r21183  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.68 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2009-01-27 00:01:33 $
    9  *
     7 *  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2009-01-27 06:39:38 $
    109 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1110 *
    … …  
    115114    test->metricErr = psVectorAlloc (sources->n, PS_TYPE_F32);
    116115    test->fitMag    = psVectorAlloc (sources->n, PS_TYPE_F32);
    117     test->mask      = psVectorAlloc (sources->n, PS_TYPE_U8);
     116    test->mask      = psVectorAlloc (sources->n, PS_TYPE_VECTOR_MASK);
    118117
    119118    psVectorInit (test->mask,        0);
    … …  
    148147
    149148// generate a pmPSFtry with a copy of the test PSF sources
    150 pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psMaskType maskVal, psMaskType markVal)
     149pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psImageMaskType maskVal, psImageMaskType markVal)
    151150{
    152151    bool status;
    … …  
    176175        pmSource *source = psfTry->sources->data[i];
    177176        if (!source->moments) {
    178             psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL;
     177            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL;
    179178            continue;
    180179        }
    181180        if (!source->moments->nPixels) {
    182             psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL;
     181            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL;
    183182            continue;
    184183        }
    … …  
    186185        source->modelEXT = pmSourceModelGuess (source, psfTry->psf->type);
    187186        if (source->modelEXT == NULL) {
    188             psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL;
     187            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL;
    189188            psTrace ("psModules.objects", 4, "masking %d (%d,%d) : failed to generate model guess\n", i, source->peak->x, source->peak->y);
    190189            continue;
    … …  
    198197
    199198        // clear object mask to define valid pixels
    200         psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
     199        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
    201200
    202201        // exclude the poor fits
    203202        if (!status) {
    204             psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL;
     203            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL;
    205204            psTrace ("psModules.objects", 4, "masking %d (%d,%d) : status is poor\n", i, source->peak->x, source->peak->y);
    206205            continue;
    … …  
    231230
    232231        // masked for: bad model fit, outlier in parameters
    233         if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL) {
     232        if (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL) {
    234233            psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : source is masked\n", i, source->peak->x, source->peak->y);
    235234            continue;
    … …  
    239238        source->modelPSF = pmModelFromPSF (source->modelEXT, psfTry->psf);
    240239        if (source->modelPSF == NULL) {
    241             psfTry->mask->data.U8[i] = PSFTRY_MASK_BAD_MODEL;
     240            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_BAD_MODEL;
    242241            abort();
    243242            continue;
    … …  
    253252        // skip poor fits
    254253        if (!status) {
    255             psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
    256             psfTry->mask->data.U8[i] = PSFTRY_MASK_PSF_FAIL;
     254            psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
     255            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_PSF_FAIL;
    257256            psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : failed PSF fit\n", i, source->peak->x, source->peak->y);
    258257            continue;
    … …  
    261260        status = pmSourceMagnitudes (source, psfTry->psf, PM_SOURCE_PHOT_INTERP, maskVal);
    262261        if (!status || isnan(source->apMag)) {
    263             psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
    264             psfTry->mask->data.U8[i] = PSFTRY_MASK_BAD_PHOT;
     262            psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
     263            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_BAD_PHOT;
    265264            psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : poor photometry\n", i, source->peak->x, source->peak->y);
    266265            continue;
    … …  
    268267
    269268        // clear object mask to define valid pixels
    270         psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
     269        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
    271270
    272271        psfTry->fitMag->data.F32[i] = source->psfMag;
    … …  
    292291    psVector *flux  = psVectorAlloc (psfTry->sources->n, PS_TYPE_F32);
    293292    psVector *chisq = psVectorAlloc (psfTry->sources->n, PS_TYPE_F32);
    294     psVector *mask  = psVectorAlloc (psfTry->sources->n, PS_TYPE_MASK);
     293    psVector *mask  = psVectorAlloc (psfTry->sources->n, PS_TYPE_VECTOR_MASK);
    295294
    296295    // generate the x and y vectors, and mask missing models
    … …  
    300299            flux->data.F32[i] = 0.0;
    301300            chisq->data.F32[i] = 0.0;
    302             mask->data.U8[i] = 0xff;
     301            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    303302        } else {
    304303            flux->data.F32[i] = source->modelPSF->params->data.F32[PM_PAR_I0];
    305304            chisq->data.F32[i] = source->modelPSF->chisq / source->modelPSF->nDOF;
    306             mask->data.U8[i] = 0;
     305            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0;
    307306        }
    308307    }
    … …  
    312311
    313312    // linear clipped fit of chisq trend vs flux
    314     bool result = psVectorClipFitPolynomial1D(psfTry->psf->ChiTrend, options->stats, mask,
    315                                               0xff, chisq, NULL, flux);
     313    bool result = psVectorClipFitPolynomial1D(psfTry->psf->ChiTrend, options->stats, mask, 0xff, chisq, NULL, flux);
    316314    psStatsOptions meanStat = psStatsMeanOption(options->stats->options); // Statistic for mean
    317315    psStatsOptions stdevStat = psStatsStdevOption(options->stats->options); // Statistic for stdev
    … …  
    370368
    371369    for (int i = 0; i < psfTry->sources->n; i++) {
    372         if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL)
     370        if (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL)
    373371            continue;
    374372        r2rflux->data.F32[i] = PS_SQR(RADIUS) * pow(10.0, 0.4*psfTry->fitMag->data.F32[i]);
    … …  
    379377        FILE *f = fopen ("apresid.dat", "w");
    380378        for (int i = 0; i < psfTry->sources->n; i++) {
    381             int keep = (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL);
     379            int keep = (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL);
    382380
    383381            pmSource *source = psfTry->sources->data[i];
    … …  
    427425        psVector *apfit = psPolynomial1DEvalVector (poly, r2rflux);
    428426        for (int i = 0; i < psfTry->sources->n; i++) {
    429             int keep = (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL);
     427            int keep = (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL);
    430428
    431429            pmSource *source = psfTry->sources->data[i];
    … …  
    603601    for (int i = 0; i < sources->n; i++) {
    604602        // skip any masked sources (failed to fit one of the model steps or get a magnitude)
    605         if (srcMask->data.U8[i]) continue;
     603        if (srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
    606604       
    607605        pmSource *source = sources->data[i];
    … …  
    624622
    625623        psVector *dz = NULL;
    626         psVector *mask = psVectorAlloc (sources->n, PS_TYPE_U8);
     624        psVector *mask = psVectorAlloc (sources->n, PS_TYPE_VECTOR_MASK);
    627625
    628626        // check the fit residuals and increase Nx,Ny until the error is minimized
    … …  
    632630            // copy srcMask to mask (we do not want the mask values set in pmPSFFitShapeParamsMap to be sticky)
    633631            for (int i = 0; i < mask->n; i++) {
    634                 mask->data.U8[i] = srcMask->data.U8[i];
     632                mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i];
    635633            }
    636634            if (!pmPSFFitShapeParamsMap (psf, i, &scatterTotal, mask, x, y, mag, e0, e1, e2, dz)) {
    … …  
    651649        // copy srcMask to mask (we do not want the mask values set in pmPSFFitShapeParamsMap to be sticky)
    652650        for (int i = 0; i < mask->n; i++) {
    653             mask->data.U8[i] = srcMask->data.U8[i];
     651            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i];
    654652        }
    655653        if (!pmPSFFitShapeParamsMap (psf, entryMin, &scatterTotal, mask, x, y, mag, e0, e1, e2, dz)) {
    … …  
    663661        // copy mask back to srcMask
    664662        for (int i = 0; i < mask->n; i++) {
    665             srcMask->data.U8[i] = mask->data.U8[i];
     663            srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = mask->data.PS_TYPE_VECTOR_MASK_DATA[i];
    666664        }
    667665
    … …  
    736734                     pmTrend2DEval (psf->params->data[PM_PAR_E1], x->data.F32[i], y->data.F32[i]),
    737735                     pmTrend2DEval (psf->params->data[PM_PAR_E2], x->data.F32[i], y->data.F32[i]),
    738                      srcMask->data.U8[i]);
     736                     srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    739737        }
    740738        fclose (f);
    … …  
    851849
    852850    // the mask marks the values not used to calculate the ApTrend
    853     psVector *fitMask = psVectorAlloc (x_fit->n, PS_TYPE_U8);
     851    psVector *fitMask = psVectorAlloc (x_fit->n, PS_TYPE_VECTOR_MASK);
    854852    // copy mask values to fitMask as a starting point
    855853    for (int i = 0; i < fitMask->n; i++) {
    856         fitMask->data.U8[i] = mask->data.U8[i];
     854        fitMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = mask->data.PS_TYPE_VECTOR_MASK_DATA[i];
    857855    }
    858856
    … …  
    943941    // XXX copy fitMask values back to mask
    944942    for (int i = 0; i < fitMask->n; i++) {
    945         mask->data.U8[i] = fitMask->data.U8[i];
     943        mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = fitMask->data.PS_TYPE_VECTOR_MASK_DATA[i];
    946944    }
    947945    psFree (fitMask);
    … …  
    951949
    952950// calculate the scatter of the parameters
    953 bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psMaskType maskValue, psStatsOptions stdevOpt)
     951bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psVectorMaskType maskValue, psStatsOptions stdevOpt)
    954952{
    955953
    … …  
    994992    psVector *dE1subset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
    995993    psVector *dE2subset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
    996     psVector *mkSubset  = psVectorAllocEmpty (nGroup, PS_TYPE_U8);
     994    psVector *mkSubset  = psVectorAllocEmpty (nGroup, PS_TYPE_VECTOR_MASK);
    997995
    998996    int n = 0;
    … …  
    10071005            dE2subset->data.F32[j] = e2res->data.F32[N];
    10081006
    1009             mkSubset->data.U8[j]   = mask->data.U8[N];
    1010             if (!mask->data.U8[N]) nValid ++;
     1007            mkSubset->data.PS_TYPE_VECTOR_MASK_DATA[j]   = mask->data.PS_TYPE_VECTOR_MASK_DATA[N];
     1008            if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[N]) nValid ++;
    10111009        }
    10121010        if (nValid < 3) continue;

  • trunk/psModules/src/objects/pmPSFtry.h

    r21174 r21183  
    66 * @author EAM, IfA
    77 *
    8  * @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2009-01-27 00:02:16 $
     8 * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2009-01-27 06:39:38 $
    1010 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1111 */
    … …  
    4848    pmPSF      *psf;                    ///< Add comment.
    4949    psArray    *sources;                ///< pointers to the original sources
    50     psVector   *mask;                   ///< Add comment.
     50    psVector   *mask;                   ///< PS_TYPE_VECTOR_MASK to flag good and bad sources
    5151    psVector   *metric;                 ///< Add comment.
    5252    psVector   *metricErr;              ///< Add comment.
    … …  
    8989 *
    9090 */
    91 pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psMaskType maskVal, psMaskType mark);
     91pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psImageMaskType maskVal, psImageMaskType mark);
    9292
    9393/** pmPSFtryMetric()
    … …  
    129129bool pmPSFFitShapeParams (pmPSF *psf, psArray *sources, psVector *x, psVector *y, psVector *srcMask);
    130130bool pmPSFFitShapeParamsMap (pmPSF *psf, int scale, float *scatterTotal, psVector *mask, psVector *x, psVector *y, psVector *mag, psVector *e0obs, psVector *e1obs, psVector *e2obs, psVector *dz);
    131 bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psMaskType maskValue, psStatsOptions stdevOpt);
     131bool pmPSFShapeParamsScatter(float *scatterTotal, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, psVectorMaskType maskValue, psStatsOptions stdevOpt);
    132132bool pmPSFShapeParamsErrors (float *errorFloor, psVector *mag, psVector *e0res, psVector *e1res, psVector *e2res, psVector *mask, int nGroup, psStatsOptions stdevOpt);
    133133

  • trunk/psModules/src/objects/pmResiduals.c

    r15562 r21183  
    44 *
    55 * @author EAM, IfA
    6  * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    7  * @date $Date: 2007-11-10 01:09:20 $
     6 * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2009-01-27 06:39:38 $
    88 * Copyright 2004 IfA, University of Hawaii
    99 */
    … …  
    4343    resid->Ry  = psImageAlloc (nX, nY, PS_TYPE_F32);
    4444    resid->weight = psImageAlloc (nX, nY, PS_TYPE_F32);
    45     resid->mask   = psImageAlloc (nX, nY, PS_TYPE_U8);
     45    resid->mask   = psImageAlloc (nX, nY, PM_TYPE_RESID_MASK);
     46
     47    // NOTE : the residual mask is internal only : 1 byte is sufficient
    4648
    4749    resid->xBin = xBin;

  • trunk/psModules/src/objects/pmResiduals.h

    r15562 r21183  
    44 *
    55 * @author EAM, IfA
    6  * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    7  * @date $Date: 2007-11-10 01:09:20 $
     6 * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2009-01-27 06:39:38 $
    88 * Copyright 2004 IfA, University of Hawaii
    99 */
    … …  
    3131bool psMemCheckResiduals(psPtr ptr);
    3232
     33// macros to abstract the resid mask type : these values must be consistent
     34#define PM_TYPE_RESID_MASK PS_TYPE_U8        /**< the psElemType to use for mask image */
     35#define PM_TYPE_RESID_MASK_DATA U8           /**< the data member to use for mask image */
     36#define PM_TYPE_RESID_MASK_NAME "psU8"       /**< the data type for mask as a string */
     37typedef psU8 pmResidMaskType;               ///< the C datatype for a mask image
     38#define PM_NOT_RESID_MASK(A)(UINT8_MAX-(A))
     39
    3340/// @}
    3441# endif

  • trunk/psModules/src/objects/pmSource.c

    r20937 r21183  
    66 *  @author EAM, IfA: significant modifications.
    77 *
    8  *  @version $Revision: 1.66 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-12-08 02:51:14 $
     8 *  @version $Revision: 1.67 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    171171
    172172    // the maskObj is a unique mask array; create a new mask image
    173     source->maskObj = in->maskObj ? psImageCopy (NULL, in->maskObj, PS_TYPE_MASK) : NULL;
     173    source->maskObj = in->maskObj ? psImageCopy (NULL, in->maskObj, PS_TYPE_IMAGE_MASK) : NULL;
    174174
    175175    source->type = in->type;
    … …  
    205205        mySource->maskView = psImageSubset(readout->mask,  srcRegion);
    206206        // the object mask is a copy, and used to define the source pixels
    207         mySource->maskObj = psImageCopy(NULL, mySource->maskView, PS_TYPE_MASK);
     207        mySource->maskObj = psImageCopy(NULL, mySource->maskView, PS_TYPE_IMAGE_MASK);
    208208    }
    209209    mySource->region   = srcRegion;
    … …  
    255255        // re-copy the main mask pixels.  NOTE: the user will need to reset the object mask
    256256        // pixels (eg, with psImageKeepCircle)
    257         mySource->maskObj = psImageCopy (mySource->maskObj, mySource->maskView, PS_TYPE_MASK);
     257        mySource->maskObj = psImageCopy (mySource->maskObj, mySource->maskView, PS_TYPE_IMAGE_MASK);
    258258
    259259        // drop the old modelFlux pixels and force the user to re-create
    … …  
    505505*****************************************************************************/
    506506
    507 bool pmSourceRoughClass(psRegion *region, psArray *sources, psMetadata *recipe, pmPSFClump clump, psMaskType maskSat)
     507bool pmSourceRoughClass(psRegion *region, psArray *sources, psMetadata *recipe, pmPSFClump clump, psImageMaskType maskSat)
    508508{
    509509    psTrace("psModules.objects", 5, "---- begin ----");
    … …  
    738738        psF32 *vPix = source->pixels->data.F32[row];
    739739        psF32 *vWgt = source->weight->data.F32[row];
    740         psU8  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.U8[row];
     740        psImageMaskType *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
    741741
    742742        for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) {
    … …  
    848848# endif
    849849// construct a realization of the source model
    850 bool pmSourceCacheModel (pmSource *source, psMaskType maskVal) {
     850bool pmSourceCacheModel (pmSource *source, psImageMaskType maskVal) {
    851851    PS_ASSERT_PTR_NON_NULL(source, false);
    852852    // select appropriate model
    … …  
    867867// construct a realization of the source model
    868868// XXX this function should optionally save an existing psf image from modelFlux
    869 bool pmSourceCachePSF (pmSource *source, psMaskType maskVal) {
     869bool pmSourceCachePSF (pmSource *source, psImageMaskType maskVal) {
    870870    PS_ASSERT_PTR_NON_NULL(source, false);
    871871
    … …  
    885885
    886886// should we call pmSourceCacheModel if it does not exist?
    887 bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psMaskType maskVal, int dx, int dy)
     887bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psImageMaskType maskVal, int dx, int dy)
    888888{
    889889    PS_ASSERT_PTR_NON_NULL(source, false);
    … …  
    915915        }
    916916
    917         psU8 **mask = NULL;
     917        psImageMaskType **mask = NULL;
    918918        if (source->maskObj) {
    919             mask = source->maskObj->data.U8;
     919            mask = source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA;
    920920        }
    921921
    … …  
    957957}
    958958
    959 bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psMaskType maskVal) {
     959bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal) {
    960960    return pmSourceOp (source, mode, true, maskVal, 0, 0);
    961961}
    962962
    963 bool pmSourceSub (pmSource *source, pmModelOpMode mode, psMaskType maskVal) {
     963bool pmSourceSub (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal) {
    964964    return pmSourceOp (source, mode, false, maskVal, 0, 0);
    965965}
    966966
    967 bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy) {
     967bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy) {
    968968    return pmSourceOp (source, mode, true, maskVal, dx, dy);
    969969}
    970970
    971 bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy) {
     971bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy) {
    972972    return pmSourceOp (source, mode, false, maskVal, dx, dy);
    973973}

  • trunk/psModules/src/objects/pmSource.h

    r20945 r21183  
    33 * @author EAM, IfA; GLG, MHPCC
    44 *
    5  * @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
    6  * @date $Date: 2008-12-09 21:16:09 $
     5 * @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
     6 * @date $Date: 2009-01-27 06:39:38 $
    77 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    88 */
    … …  
    210210    psMetadata *metadata,               ///< Contains classification parameters
    211211    pmPSFClump clump,                   ///< Statistics about the PSF clump
    212     psMaskType maskSat                  ///< Mask value for saturated pixels
     212    psImageMaskType maskSat             ///< Mask value for saturated pixels
    213213);
    214214
    … …  
    231231pmModel *pmSourceGetModel (bool *isPSF, const pmSource *source);
    232232
    233 bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psMaskType maskVal);
    234 bool pmSourceSub (pmSource *source, pmModelOpMode mode, psMaskType maskVal);
    235 bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy);
    236 bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy);
    237 
    238 bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psMaskType maskVal, int dx, int dy);
    239 bool pmSourceCacheModel (pmSource *source, psMaskType maskVal);
    240 bool pmSourceCachePSF (pmSource *source, psMaskType maskVal);
     233bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal);
     234bool pmSourceSub (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal);
     235bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy);
     236bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy);
     237
     238bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psImageMaskType maskVal, int dx, int dy);
     239bool pmSourceCacheModel (pmSource *source, psImageMaskType maskVal);
     240bool pmSourceCachePSF (pmSource *source, psImageMaskType maskVal);
    241241
    242242int             pmSourceSortBySN (const void **a, const void **b);

  • trunk/psModules/src/objects/pmSourceFitModel.c

    r20937 r21183  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-12-08 02:51:14 $
     8 *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5656                       pmModel *model,
    5757                       pmSourceFitMode mode,
    58                        psMaskType maskVal)
     58                       psImageMaskType maskVal)
    5959{
    6060    psTrace("psModules.objects", 5, "---- %s begin ----\n", __func__);
    … …  
    8181        for (psS32 j = 0; j < source->pixels->numCols; j++) {
    8282            // skip masked points
    83             if (source->maskObj->data.U8[i][j] & maskVal) {
     83            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j] & maskVal) {
    8484                continue;
    8585            }
    … …  
    121121    // create the minimization constraints
    122122    psMinConstraint *constraint = psMinConstraintAlloc();
    123     constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_U8);
     123    constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
    124124    constraint->checkLimits = model->modelLimits;
    125125
    … …  
    131131        nParams = 1;
    132132        psVectorInit (constraint->paramMask, 1);
    133         constraint->paramMask->data.U8[PM_PAR_I0] = 0;
     133        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0;
    134134        break;
    135135    case PM_SOURCE_FIT_PSF:
    … …  
    137137        nParams = 3;
    138138        psVectorInit (constraint->paramMask, 1);
    139         constraint->paramMask->data.U8[PM_PAR_I0] = 0;
    140         constraint->paramMask->data.U8[PM_PAR_XPOS] = 0;
    141         constraint->paramMask->data.U8[PM_PAR_YPOS] = 0;
     139        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0;
     140        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_XPOS] = 0;
     141        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_YPOS] = 0;
    142142        break;
    143143    case PM_SOURCE_FIT_EXT:
    … …  
    145145        nParams = params->n - 1;
    146146        psVectorInit (constraint->paramMask, 0);
    147         constraint->paramMask->data.U8[PM_PAR_SKY] = 1;
     147        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1;
    148148        break;
    149149    default:
    … …  
    175175            fprintf (stderr, "%f ", params->data.F32[i]);
    176176        }
    177         if ((constraint->paramMask != NULL) && constraint->paramMask->data.U8[i])
     177        if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    178178            continue;
    179179        dparams->data.F32[i] = sqrt(covar->data.F32[i][i]);
    … …  
    192192    if (constraint->paramMask != NULL) {
    193193        psVector *delta = psVectorAlloc (params->n, PS_TYPE_F32);
    194         psVector *altmask = psVectorAlloc (params->n, PS_TYPE_U8);
    195         altmask->data.U8[0] = 1;
     194        psVector *altmask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
     195        altmask->data.PS_TYPE_VECTOR_MASK_DATA[0] = 1;
    196196        for (int i = 1; i < dparams->n; i++) {
    197             altmask->data.U8[i] = (constraint->paramMask->data.U8[i]) ? 0 : 1;
     197            altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1;
    198198        }
    199199        psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, model->modelFunc);
    200200
    201201        for (int i = 0; i < dparams->n; i++) {
    202             if (!constraint->paramMask->data.U8[i])
     202            if (!constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    203203                continue;
    204204            // note that delta is the value *subtracted* from the parameter

  • trunk/psModules/src/objects/pmSourceFitModel.h

    r13898 r21183  
    33 * @author EAM, IfA; GLG, MHPCC
    44 *
    5  * @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    6  * @date $Date: 2007-06-20 02:22:26 $
     5 * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     6 * @date $Date: 2009-01-27 06:39:38 $
    77 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    88 */
    … …  
    4141    pmModel *model,   ///< model to be fitted
    4242    pmSourceFitMode mode,  ///< define parameters to be fitted
    43     psMaskType maskVal                  ///< Value to mask
     43    psImageMaskType maskVal             ///< Value to mask
    4444);
    4545
    … …  
    7171    psArray *modelSet,   ///< model to be fitted
    7272    pmSourceFitMode mode,  ///< define parameters to be fitted
    73     psMaskType maskVal                  ///< Vale to mask
     73    psImageMaskType maskVal             ///< Vale to mask
    7474
    7575);

  • trunk/psModules/src/objects/pmSourceFitSet.c

    r21163 r21183  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2009-01-24 20:52:26 $
    10  *
     8 *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1110 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1211 *
    … …  
    394393            for (int j = 0; j < paramOne->n; j++) {
    395394                if (j == PM_PAR_I0) continue;
    396                 constraint->paramMask->data.U8[n + j] = 1;
     395                constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n + j] = 1;
    397396            }
    398397            break;
    … …  
    403402                if (j == PM_PAR_YPOS) continue;
    404403                if (j == PM_PAR_I0) continue;
    405                 constraint->paramMask->data.U8[n + j] = 1;
     404                constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n + j] = 1;
    406405            }
    407406            break;
    408407          case PM_SOURCE_FIT_EXT:
    409408            // EXT model fits all params (except sky)
    410             constraint->paramMask->data.U8[n + PM_PAR_SKY] = 1;
     409            constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n + PM_PAR_SKY] = 1;
    411410            break;
    412411          default:
    … …  
    445444                     psArray *modelSet,
    446445                     pmSourceFitMode mode,
    447                      psMaskType maskVal)
     446                     psImageMaskType maskVal)
    448447{
    449448    psTrace("psModules.objects", 3, "---- %s begin ----\n", __func__);
    … …  
    469468        for (psS32 j = 0; j < source->pixels->numCols; j++) {
    470469            // skip masked points
    471             if (source->maskObj->data.U8[i][j] & maskVal) {
     470            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j] & maskVal) {
    472471                continue;
    473472            }
    … …  
    515514    // create the minimization constraints
    516515    psMinConstraint *constraint = psMinConstraintAlloc();
    517     constraint->paramMask = psVectorAlloc (thisSet->nParamSet, PS_TYPE_U8);
     516    constraint->paramMask = psVectorAlloc (thisSet->nParamSet, PS_TYPE_VECTOR_MASK);
    518517    constraint->checkLimits = pmSourceFitSetCheckLimits;
    519518
    … …  
    528527    if (psTraceGetLevel("psModules.objects") >= 5) {
    529528        for (int i = 0; i < params->n; i++) {
    530             fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.U8[i]);
     529            fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    531530        }
    532531    }
    … …  
    560559    psVector *dparams = psVectorAlloc (thisSet->nParamSet, PS_TYPE_F32);
    561560    for (int i = 0; i < dparams->n; i++) {
    562         if ((constraint->paramMask != NULL) && constraint->paramMask->data.U8[i])
     561        if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    563562            continue;
    564563        dparams->data.F32[i] = sqrt(covar->data.F32[i][i]);
    … …  
    568567    if (constraint->paramMask != NULL) {
    569568        psVector *delta = psVectorAlloc (params->n, PS_TYPE_F32);
    570         psVector *altmask = psVectorAlloc (params->n, PS_TYPE_U8);
    571         altmask->data.U8[0] = 1;
     569        psVector *altmask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
     570        altmask->data.PS_TYPE_VECTOR_MASK_DATA[0] = 1;
    572571        for (int i = 1; i < dparams->n; i++) {
    573             altmask->data.U8[i] = (constraint->paramMask->data.U8[i]) ? 0 : 1;
     572            altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1;
    574573        }
    575574        psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, pmSourceFitSetFunction);
    576575
    577576        for (int i = 0; i < dparams->n; i++) {
    578             if (!constraint->paramMask->data.U8[i])
     577            if (!constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    579578                continue;
    580579            // note that delta is the value *subtracted* from the parameter

  • trunk/psModules/src/objects/pmSourceFitSet.h

    r21163 r21183  
    33 * @author EAM, IfA; GLG, MHPCC
    44 *
    5  * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    6  * @date $Date: 2009-01-24 20:52:26 $
     5 * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     6 * @date $Date: 2009-01-27 06:39:38 $
    77 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    88 */
    … …  
    5454 */
    5555bool pmSourceFitSet(
    56     pmSource *source,   ///< The input pmSource
    57     psArray *modelSet,   ///< model to be fitted
    58     pmSourceFitMode mode,  ///< define parameters to be fitted
    59     psMaskType maskVal                  ///< Vale to mask
     56    pmSource *source,                   ///< The input pmSource
     57    psArray *modelSet,                  ///< model to be fitted
     58    pmSourceFitMode mode,               ///< define parameters to be fitted
     59    psImageMaskType maskVal             ///< Vale to mask
    6060
    6161);

  • trunk/psModules/src/objects/pmSourceMatch.c

    r21105 r21183  
    122122    match->image = psVectorAllocEmpty(num, PS_TYPE_U32);
    123123    match->index = psVectorAllocEmpty(num, PS_TYPE_U32);
    124     match->mask = psVectorAllocEmpty(num, PS_TYPE_MASK);
     124    match->mask = psVectorAllocEmpty(num, PS_TYPE_VECTOR_MASK);
    125125
    126126    return match;
    … …  
    143143    match->image->data.S32[num] = image;
    144144    match->index->data.S32[num] = index;
    145     match->mask->data.PS_TYPE_MASK_DATA[num] = 0;
     145    match->mask->data.PS_TYPE_VECTOR_MASK_DATA[num] = 0;
    146146    match->num++;
    147147
    … …  
    316316        double star = 0.0, starErr = 0.0; // Accumulators for star
    317317        for (int j = 0; j < match->num; j++) {
    318             if (match->mask->data.PS_TYPE_MASK_DATA[j]) {
     318            if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) {
    319319                continue;
    320320            }
    … …  
    347347        pmSourceMatch *match = matches->data[i]; // Matched stars
    348348        for (int j = 0; j < match->num; j++) {
    349             if (match->mask->data.PS_TYPE_MASK_DATA[j]) {
     349            if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) {
    350350                continue;
    351351            }
    … …  
    373373        pmSourceMatch *match = matches->data[i]; // Matched stars
    374374        for (int j = 0; j < match->num; j++) {
    375             if (match->mask->data.PS_TYPE_MASK_DATA[j]) {
     375            if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) {
    376376                continue;
    377377            }
    … …  
    474474        pmSourceMatch *match = matches->data[i]; // Matched stars
    475475        for (int j = 0; j < match->num; j++) {
    476             if (match->mask->data.PS_TYPE_MASK_DATA[j]) {
     476            if (match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) {
    477477                continue;
    478478            }
    … …  
    488488            if (PS_SQR(dev) > starClip * (PS_SQR(magErr) + sysErr2)) {
    489489                numRejected++;
    490                 match->mask->data.PS_TYPE_MASK_DATA[j] = 0xFF;
     490                match->mask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xFF;
    491491            }
    492492        }

  • trunk/psModules/src/objects/pmSourceMoments.c

    r20937 r21183  
    66 *  @author EAM, IfA: significant modifications.
    77 *
    8  *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-12-08 02:51:14 $
     8 *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    100100        psF32 *vPix = source->pixels->data.F32[row];
    101101        psF32 *vWgt = source->weight->data.F32[row];
    102         psU8  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.U8[row];
     102        psImageMaskType *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
    103103
    104104        for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) {
    … …  
    190190        psF32 *vPix = source->pixels->data.F32[row];
    191191        psF32 *vWgt = source->weight->data.F32[row];
    192         psU8  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.U8[row];
     192        psImageMaskType  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
    193193
    194194        for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) {
    … …  
    342342        psF32 *vPix = source->pixels->data.F32[row];
    343343        psF32 *vWgt = source->weight->data.F32[row];
    344         psU8  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.U8[row];
     344        psImageMaskType  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
    345345
    346346        for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) {

  • trunk/psModules/src/objects/pmSourcePhotometry.c

    r20937 r21183  
    33 *  @author EAM, IfA; GLG, MHPCC
    44 *
    5  *  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2008-12-08 02:51:14 $
     5 *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2009-01-27 06:39:38 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    6666
    6767// XXX masked region should be (optionally) elliptical
    68 bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psMaskType maskVal)
     68bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal)
    6969{
    7070    PS_ASSERT_PTR_NON_NULL(source, false);
    … …  
    306306
    307307// return source aperture magnitude
    308 bool pmSourcePhotometryAper (float *apMag, pmModel *model, psImage *image, psImage *mask, psMaskType maskVal)
     308bool pmSourcePhotometryAper (float *apMag, pmModel *model, psImage *image, psImage *mask, psImageMaskType maskVal)
    309309{
    310310    PS_ASSERT_PTR_NON_NULL(apMag, false);
    … …  
    324324
    325325    psF32 **imData = image->data.F32;
    326     psU8 **mkData = mask->data.U8;
     326    psImageMaskType **mkData = mask->data.PS_TYPE_IMAGE_MASK_DATA;
    327327
    328328    // measure apMag
    … …  
    344344
    345345// return source aperture magnitude
    346 bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psMaskType maskVal)
     346bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psImageMaskType maskVal)
    347347{
    348348    PS_ASSERT_PTR_NON_NULL(pixWeight, false);
    … …  
    412412            if (my >= NY)
    413413                continue;
    414             if (mask->data.U8[my][mx] & maskVal)
     414            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[my][mx] & maskVal)
    415415                continue;
    416416
    … …  
    475475    for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
    476476        for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
    477             if (Ti->data.U8[yi][xi])
    478                 continue;
    479             if (Tj->data.U8[yj][xj])
     477            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
     478                continue;
     479            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
    480480                continue;
    481481
    … …  
    540540    for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
    541541        for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
    542             if (Ti->data.U8[yi][xi])
    543                 continue;
    544             if (Tj->data.U8[yj][xj])
     542            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
     543                continue;
     544            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
    545545                continue;
    546546
    … …  
    578578    for (int yi = 0; yi < Pi->numRows; yi++) {
    579579        for (int xi = 0; xi < Pi->numCols; xi++) {
    580             if (Ti->data.U8[yi][xi])
     580            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
    581581                continue;
    582582            if (!unweighted_sum) {
    … …  
    613613
    614614bool pmSourceChisq (pmModel *model, psImage *image, psImage *mask, psImage *weight,
    615                     psMaskType maskVal)
     615                    psImageMaskType maskVal)
    616616{
    617617    PS_ASSERT_PTR_NON_NULL(model, false);
    … …  
    624624    for (int j = 0; j < image->numRows; j++) {
    625625        for (int i = 0; i < image->numCols; i++) {
    626             if (mask->data.U8[j][i] & maskVal)
     626            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] & maskVal)
    627627                continue;
    628628            if (weight->data.F32[j][i] <= 0)
    … …  
    657657    for (int yi = 0; yi < Pi->numRows; yi++) {
    658658        for (int xi = 0; xi < Pi->numCols; xi++) {
    659             if (Ti->data.U8[yi][xi])
     659            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
    660660                continue;
    661661            if (!unweighted_sum) {
    … …  
    734734    for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
    735735        for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
    736             if (Ti->data.U8[yi][xi])
    737                 continue;
    738             if (Tj->data.U8[yj][xj])
     736            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
     737                continue;
     738            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
    739739                continue;
    740740
    … …  
    798798    for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
    799799        for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
    800             if (Ti->data.U8[yi][xi])
    801                 continue;
    802             if (Tj->data.U8[yj][xj])
     800            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi])
     801                continue;
     802            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj])
    803803                continue;
    804804

  • trunk/psModules/src/objects/pmSourcePhotometry.h

    r18554 r21183  
    44 * @author EAM, IfA; GLG, MHPCC
    55 *
    6  * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    7  * @date $Date: 2008-07-15 20:25:00 $
     6 * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2009-01-27 06:39:38 $
    88 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    99 */
    … …  
    4646    psImage *image,                     ///< image pixels to be used
    4747    psImage *mask,                      ///< mask of pixels to ignore
    48     psMaskType maskVal                  ///< Value to mask
     48    psImageMaskType maskVal             ///< Value to mask
    4949);
    5050
    5151bool pmSourceMagnitudesInit (psMetadata *config);
    52 bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psMaskType maskVal);
    53 bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psMaskType maskVal);
    54 bool pmSourceChisq (pmModel *model, psImage *image, psImage *mask, psImage *weight, psMaskType maskVal);
     52bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal);
     53bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *image, psImage *mask, psImageMaskType maskVal);
     54bool pmSourceChisq (pmModel *model, psImage *image, psImage *mask, psImage *weight, psImageMaskType maskVal);
    5555
    5656

  • trunk/psModules/src/objects/pmSourceSky.c

    r20937 r21183  
    66 *  @author EAM, IfA: significant modifications.
    77 *
    8  *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-12-08 02:51:14 $
     8 *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5252    psStatsOptions statsOptions,
    5353    psF32 Radius,
    54     psMaskType maskVal,
    55     psMaskType markVal)
     54    psImageMaskType maskVal,
     55    psImageMaskType markVal)
    5656{
    5757    psTrace("psModules.objects", 3, "---- %s() begin ----\n", __func__);
    … …  
    8686        return false;
    8787    }
    88     psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_U8(markVal));
     88    psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_IMAGE_MASK(markVal));
    8989    double value = psStatsGetValue(myStats, statistic);
    9090    psFree(myStats);
    … …  
    107107    psStatsOptions statsOptions,
    108108    psF32 Radius,
    109     psMaskType maskVal,
    110     psMaskType markVal
     109    psImageMaskType maskVal,
     110    psImageMaskType markVal
    111111)
    112112{
    … …  
    142142        return false;
    143143    }
    144     psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_U8(markVal));
     144    psImageMaskRegion(mask, srcRegion, "AND", PS_NOT_IMAGE_MASK(markVal));
    145145    double value = psStatsGetValue(myStats, statistic);
    146146    psFree(myStats);

  • trunk/psModules/src/objects/pmSourceSky.h

    r13898 r21183  
    22 * @author EAM, IfA; GLG, MHPCC
    33 *
    4  * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    5  * @date $Date: 2007-06-20 02:22:26 $
     4 * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     5 * @date $Date: 2009-01-27 06:39:38 $
    66 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    77 */
    … …  
    3030    psStatsOptions statsOptions, ///< The statistic used in calculating the background sky
    3131    float Radius,   ///< The inner radius of the square annulus to exclude
    32     psMaskType maskVal,                 ///< Value to mask
    33     psMaskType mark                     ///< Mask value for marking
     32    psImageMaskType maskVal,                 ///< Value to mask
     33    psImageMaskType mark                     ///< Mask value for marking
    3434);
    3535
    … …  
    4040    psStatsOptions statsOptions, ///< The statistic used in calculating the background sky
    4141    float Radius,   ///< The inner radius of the square annulus to exclude
    42     psMaskType maskVal,                 ///< Value to mask
    43     psMaskType mark                     ///< Mask value for marking
     42    psImageMaskType maskVal,                 ///< Value to mask
     43    psImageMaskType mark                     ///< Mask value for marking
    4444);
    4545

  • trunk/psModules/src/objects/pmSourceVisual.c

    r20582 r21183  
    5757        model->data.F32[i] = pmTrend2DEval (trend, x->data.F32[i], y->data.F32[i]);
    5858        resid->data.F32[i] = param->data.F32[i] - model->data.F32[i];
    59         if (mask->data.U8[i]) continue;
     59        if (mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
    6060        min = PS_MIN (min, resid->data.F32[i]);
    6161        max = PS_MAX (max, resid->data.F32[i]);

  • trunk/psModules/src/objects/pmTrend2D.c

    r21172 r21183  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2009-01-27 00:00:44 $
     5 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2009-01-27 06:39:38 $
    77 *  Copyright 2004 Institute for Astronomy, University of Hawaii
    88 *
    … …  
    179179}
    180180
    181 bool pmTrend2DFit(pmTrend2D *trend, psVector *mask, psMaskType maskVal, const psVector *x,
     181bool pmTrend2DFit(pmTrend2D *trend, psVector *mask, psVectorMaskType maskVal, const psVector *x,
    182182                  const psVector *y, const psVector *f, const psVector *df)
    183183{
    … …  
    234234}
    235235
    236 psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psMaskType maskValue, const psVector *x, const psVector *y)
     236psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psVectorMaskType maskValue, const psVector *x, const psVector *y)
    237237{
    238238    PM_ASSERT_TREND2D_NON_NULL(trend, NULL);

  • trunk/psModules/src/objects/pmTrend2D.h

    r21172 r21183  
    55 * @author EAM, IfA
    66 *
    7  * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2009-01-27 00:00:45 $
     7 * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1010 */
    … …  
    8080bool pmTrend2DFit(pmTrend2D *trend,
    8181                  psVector *mask,       // Warning: mask is modified!
    82                   psMaskType maskVal,
     82                  psVectorMaskType maskVal,
    8383                  const psVector *x,
    8484                  const psVector *y,
    … …  
    9090                     float x, float y
    9191    );
    92 psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psMaskType maskValue,
     92psVector *pmTrend2DEvalVector(const pmTrend2D *trend, psVector *mask, psVectorMaskType maskValue,
    9393                              const psVector *x, const psVector *y
    9494    );
Note: See TracChangeset for help on using the changeset viewer.