IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21075


Ignore:
Timestamp:
Dec 31, 2008, 10:31:29 AM (17 years ago)
Author:
eugene
Message:

conversion of psMaskType to psImageMaskType or psVectorMaskType as needed

Location:
branches/eam_branch_20081230/psModules/src
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20081230/psModules/src/detrend/pmShutterCorrection.c

    r21072 r21075  
    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

  • branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.c

    r19086 r21075  
    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(psImageMaskType)); // 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;

  • branches/eam_branch_20081230/psModules/src/imcombine/pmReadoutCombine.h

    r21072 r21075  
    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.14.24.1 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2008-12-31 20:31:28 $
    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

  • branches/eam_branch_20081230/psModules/src/imcombine/pmStack.c

    r20712 r21075  
    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.45.6.1 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2008-12-31 20:31:28 $
    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        }

  • branches/eam_branch_20081230/psModules/src/imcombine/pmSubtraction.c

    r20838 r21075  
    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);

  • branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMask.c

    r20832 r21075  
    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++) {

  • branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionMatch.c

    r20718 r21075  
    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    }
    572572
    … …  
    594594    PM_ASSERT_SUBTRACTION_STAMP_LIST_NON_NULL(stamps, PM_SUBTRACTION_MODE_ERR);
    595595
    596     psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_MASK); // Mask for stamps
     596    psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_IMAGE_MASK); // Mask for stamps
    597597    psVector *ratios = psVectorAlloc(stamps->num, PS_TYPE_F32); // Ratios of widths
    598598
    … …  
    622622        pmSubtractionStamp *stamp = stamps->stamps->data[i]; // Stamp of interest
    623623        if (stamp->status != PM_SUBTRACTION_STAMP_CALCULATE && stamp->status != PM_SUBTRACTION_STAMP_USED) {
    624             mask->data.PS_TYPE_MASK_DATA[i] = 0xff;
     624            mask->data.PS_TYPE_IMAGE_MASK_DATA[i] = 0xff;
    625625            continue;
    626626        }

  • branches/eam_branch_20081230/psModules/src/imcombine/pmSubtractionStamps.c

    r21072 r21075  
    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);

  • branches/eam_branch_20081230/psModules/src/objects/pmFootprintFindAtPoint.c

    r20937 r21075  
    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.3.4.1 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2008-12-31 20:31:29 $
    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;

  • branches/eam_branch_20081230/psModules/src/objects/pmGrowthCurveGenerate.c

    r20937 r21075  
    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.4.4.1 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2008-12-31 20:31:29 $
    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

  • branches/eam_branch_20081230/psModules/src/objects/pmModel.c

    r21072 r21075  
    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.25.6.1 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2008-12-31 20:31:29 $
    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)

  • branches/eam_branch_20081230/psModules/src/objects/pmPSFtry.c

    r20937 r21075  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.67 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2008-12-08 02:51:14 $
     7 *  @version $Revision: 1.67.4.1 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2008-12-31 20:31:29 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    115115    test->metricErr = psVectorAlloc (sources->n, PS_TYPE_F32);
    116116    test->fitMag    = psVectorAlloc (sources->n, PS_TYPE_F32);
    117     test->mask      = psVectorAlloc (sources->n, PS_TYPE_U8);
     117    test->mask      = psVectorAlloc (sources->n, PS_TYPE_VECTOR_MASK);
    118118
    119119    psVectorInit (test->mask,        0);
    … …  
    148148
    149149// 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)
     150pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psImageMaskType maskVal, psImageMaskType markVal)
    151151{
    152152    bool status;
    … …  
    189189
    190190        // clear object mask to define valid pixels
    191         psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
     191        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
    192192
    193193        // exclude the poor fits
    194194        if (!status) {
    195             psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL;
     195            psfTry->mask->data.PS_TYPE_IMAGE_MASK_DATA[i] = PSFTRY_MASK_EXT_FAIL;
    196196            psTrace ("psModules.objects", 4, "masking %d (%d,%d) : status is poor\n", i, source->peak->x, source->peak->y);
    197197            continue;
    … …  
    222222
    223223        // masked for: bad model fit, outlier in parameters
    224         if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL) {
     224        if (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL) {
    225225            psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : source is masked\n", i, source->peak->x, source->peak->y);
    226226            continue;
    … …  
    230230        source->modelPSF = pmModelFromPSF (source->modelEXT, psfTry->psf);
    231231        if (source->modelPSF == NULL) {
    232             psfTry->mask->data.U8[i] = PSFTRY_MASK_BAD_MODEL;
     232            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_BAD_MODEL;
    233233            abort();
    234234            continue;
    … …  
    244244        // skip poor fits
    245245        if (!status) {
    246             psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
    247             psfTry->mask->data.U8[i] = PSFTRY_MASK_PSF_FAIL;
     246            psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
     247            psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_PSF_FAIL;
    248248            psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : failed PSF fit\n", i, source->peak->x, source->peak->y);
    249249            continue;
    … …  
    252252        status = pmSourceMagnitudes (source, psfTry->psf, PM_SOURCE_PHOT_INTERP, maskVal);
    253253        if (!status || isnan(source->apMag)) {
    254             psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
    255             psfTry->mask->data.U8[i] = PSFTRY_MASK_BAD_PHOT;
     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_BAD_PHOT;
    256256            psTrace ("psModules.objects", 4, "dropping %d (%d,%d) : poor photometry\n", i, source->peak->x, source->peak->y);
    257257            continue;
    … …  
    259259
    260260        // clear object mask to define valid pixels
    261         psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_U8(markVal));
     261        psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, options->radius, "AND", PS_NOT_IMAGE_MASK(markVal));
    262262
    263263        psfTry->fitMag->data.F32[i] = source->psfMag;
    … …  
    291291            flux->data.F32[i] = 0.0;
    292292            chisq->data.F32[i] = 0.0;
    293             mask->data.U8[i] = 0xff;
     293            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    294294        } else {
    295295            flux->data.F32[i] = source->modelPSF->params->data.F32[PM_PAR_I0];
    296296            chisq->data.F32[i] = source->modelPSF->chisq / source->modelPSF->nDOF;
    297             mask->data.U8[i] = 0;
     297            mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0;
    298298        }
    299299    }
    … …  
    361361
    362362    for (int i = 0; i < psfTry->sources->n; i++) {
    363         if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL)
     363        if (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL)
    364364            continue;
    365365        r2rflux->data.F32[i] = PS_SQR(RADIUS) * pow(10.0, 0.4*psfTry->fitMag->data.F32[i]);
    … …  
    370370        FILE *f = fopen ("apresid.dat", "w");
    371371        for (int i = 0; i < psfTry->sources->n; i++) {
    372             int keep = (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL);
     372            int keep = (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL);
    373373
    374374            pmSource *source = psfTry->sources->data[i];
    … …  
    418418        psVector *apfit = psPolynomial1DEvalVector (poly, r2rflux);
    419419        for (int i = 0; i < psfTry->sources->n; i++) {
    420             int keep = (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL);
     420            int keep = (psfTry->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL);
    421421
    422422            pmSource *source = psfTry->sources->data[i];
    … …  
    613613
    614614        psVector *dz = NULL;
    615         psVector *mask = psVectorAlloc (sources->n, PS_TYPE_U8);
     615        psVector *mask = psVectorAlloc (sources->n, PS_TYPE_VECTOR_MASK);
    616616
    617617        // check the fit residuals and increase Nx,Ny until the error is minimized
    … …  
    647647        // copy mask back to srcMask
    648648        for (int i = 0; i < mask->n; i++) {
    649             srcMask->data.U8[i] = mask->data.U8[i];
     649            srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = mask->data.PS_TYPE_VECTOR_MASK_DATA[i];
    650650        }
    651651
    … …  
    720720                     pmTrend2DEval (psf->params->data[PM_PAR_E1], x->data.F32[i], y->data.F32[i]),
    721721                     pmTrend2DEval (psf->params->data[PM_PAR_E2], x->data.F32[i], y->data.F32[i]),
    722                      srcMask->data.U8[i]);
     722                     srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    723723        }
    724724        fclose (f);
    … …  
    835835
    836836    // the mask marks the values not used to calculate the ApTrend
    837     psVector *fitMask = psVectorAlloc (x_fit->n, PS_TYPE_U8);
     837    psVector *fitMask = psVectorAlloc (x_fit->n, PS_TYPE_VECTOR_MASK);
    838838    psVectorInit (fitMask, 0);
    839839
    … …  
    924924    // XXX copy fitMask values back to mask
    925925    for (int i = 0; i < fitMask->n; i++) {
    926         mask->data.U8[i] = fitMask->data.U8[i];
     926        mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = fitMask->data.PS_TYPE_VECTOR_MASK_DATA[i];
    927927    }
    928928    psFree (fitMask);
    … …  
    975975    psVector *dE1subset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
    976976    psVector *dE2subset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
    977     psVector *mkSubset  = psVectorAllocEmpty (nGroup, PS_TYPE_U8);
     977    psVector *mkSubset  = psVectorAllocEmpty (nGroup, PS_TYPE_VECTOR_MASK);
    978978
    979979    int n = 0;
    … …  
    988988            dE2subset->data.F32[j] = e2res->data.F32[N];
    989989
    990             mkSubset->data.U8[j]   = mask->data.U8[N];
    991             if (!mask->data.U8[N]) nValid ++;
     990            mkSubset->data.PS_TYPE_VECTOR_MASK_DATA[j]   = mask->data.PS_TYPE_VECTOR_MASK_DATA[N];
     991            if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[N]) nValid ++;
    992992        }
    993993        if (nValid < 3) continue;

  • branches/eam_branch_20081230/psModules/src/objects/pmSource.c

    r20937 r21075  
    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.66.4.1 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2008-12-31 20:31:29 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    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}

  • branches/eam_branch_20081230/psModules/src/objects/pmSourceFitModel.c

    r20937 r21075  
    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.28.4.1 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2008-12-31 20:31:29 $
    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_DATA);
    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

  • branches/eam_branch_20081230/psModules/src/objects/pmSourceFitSet.c

    r20937 r21075  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-12-08 02:51:14 $
     8 *  @version $Revision: 1.12.4.1 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2008-12-31 20:31:29 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    281281            for (int j = 0; j < paramOne->n; j++) {
    282282                if (j == PM_PAR_I0) continue;
    283                 constraint->paramMask->data.U8[n + j] = 1;
     283                constraint->paramMask->data.PS_TYPE_IMAGE_MASK_DATA[n + j] = 1;
    284284            }
    285285            break;
    … …  
    290290                if (j == PM_PAR_YPOS) continue;
    291291                if (j == PM_PAR_I0) continue;
    292                 constraint->paramMask->data.U8[n + j] = 1;
     292                constraint->paramMask->data.PS_TYPE_IMAGE_MASK_DATA[n + j] = 1;
    293293            }
    294294            break;
    295295          case PM_SOURCE_FIT_EXT:
    296296            // EXT model fits all params (except sky)
    297             constraint->paramMask->data.U8[n + PM_PAR_SKY] = 1;
     297            constraint->paramMask->data.PS_TYPE_IMAGE_MASK_DATA[n + PM_PAR_SKY] = 1;
    298298            break;
    299299          default:
    … …  
    332332                     psArray *modelSet,
    333333                     pmSourceFitMode mode,
    334                      psMaskType maskVal)
     334                     psImageMaskType maskVal)
    335335{
    336336    psTrace("psModules.objects", 3, "---- %s begin ----\n", __func__);
    … …  
    356356        for (psS32 j = 0; j < source->pixels->numCols; j++) {
    357357            // skip masked points
    358             if (source->maskObj->data.U8[i][j] & maskVal) {
     358            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j] & maskVal) {
    359359                continue;
    360360            }
    … …  
    402402    // create the minimization constraints
    403403    psMinConstraint *constraint = psMinConstraintAlloc();
    404     constraint->paramMask = psVectorAlloc (thisSet->nParamSet, PS_TYPE_U8);
     404    constraint->paramMask = psVectorAlloc (thisSet->nParamSet, PS_TYPE_VECTOR_MASK);
    405405    constraint->checkLimits = pmSourceFitSetCheckLimits;
    406406
    … …  
    415415    if (psTraceGetLevel("psModules.objects") >= 5) {
    416416        for (int i = 0; i < params->n; i++) {
    417             fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.U8[i]);
     417            fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    418418        }
    419419    }
    … …  
    448448    psVector *dparams = psVectorAlloc (thisSet->nParamSet, PS_TYPE_F32);
    449449    for (int i = 0; i < dparams->n; i++) {
    450         if ((constraint->paramMask != NULL) && constraint->paramMask->data.U8[i])
     450        if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    451451            continue;
    452452        dparams->data.F32[i] = sqrt(covar->data.F32[i][i]);
    … …  
    456456    if (constraint->paramMask != NULL) {
    457457        psVector *delta = psVectorAlloc (params->n, PS_TYPE_F32);
    458         psVector *altmask = psVectorAlloc (params->n, PS_TYPE_U8);
    459         altmask->data.U8[0] = 1;
     458        psVector *altmask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
     459        altmask->data.PS_TYPE_VECTOR_MASK_DATA[0] = 1;
    460460        for (int i = 1; i < dparams->n; i++) {
    461             altmask->data.U8[i] = (constraint->paramMask->data.U8[i]) ? 0 : 1;
     461            altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1;
    462462        }
    463463        psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, pmSourceFitSetFunction);
    464464
    465465        for (int i = 0; i < dparams->n; i++) {
    466             if (!constraint->paramMask->data.U8[i])
     466            if (!constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    467467                continue;
    468468            // note that delta is the value *subtracted* from the parameter

  • branches/eam_branch_20081230/psModules/src/objects/pmSourcePhotometry.c

    r20937 r21075  
    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.47.4.1 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2008-12-31 20:31:29 $
    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

  • branches/eam_branch_20081230/psModules/src/objects/pmSourceSky.c

    r20937 r21075  
    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.18.4.1 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2008-12-31 20:31:29 $
    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);

  • branches/eam_branch_20081230/psModules/src/objects/pmTrend2D.c

    r19961 r21075  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2008-10-07 22:47:04 $
     5 *  @version $Revision: 1.10.14.1 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2008-12-31 20:31:29 $
    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{
Note: See TracChangeset for help on using the changeset viewer.