IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21074


Ignore:
Timestamp:
Dec 30, 2008, 10:40:00 AM (17 years ago)
Author:
eugene
Message:

upgrades to the masking concepts: added psImageMaskType & psVectorMaskType and associated macros; replaced psMaskType where appropriate (see src/mask.notes.txt)

Location:
branches/eam_branch_20081230/psLib/src
Files:
45 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20081230/psLib/src/fft/psImageFFT.c

    r20566 r21074  
    66/// @author Robert DeSonia, MHPCC
    77///
    8 /// @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
    9 /// @date $Date: 2008-11-06 23:36:20 $
     8/// @version $Revision: 1.28.6.1 $ $Name: not supported by cvs2svn $
     9/// @date $Date: 2008-12-30 20:39:59 $
    1010///
    1111/// Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    318318
    319319
    320 psImage *psImageConvolveFFT(psImage *out, const psImage *in, const psImage *mask, psMaskType maskVal,
     320psImage *psImageConvolveFFT(psImage *out, const psImage *in, const psImage *mask, psImageMaskType maskVal,
    321321                            const psKernel *kernel)
    322322{
    … …  
    326326    if (mask) {
    327327        PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    328         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     328        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    329329        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, in, NULL);
    330330    }
    … …  
    464464        for (int y = 0; y < numRows; y++) {
    465465            for (int x = 0; x < numCols; x++) {
    466                 if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
     466                if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
    467467                    data[x + paddedCols * y] = 0;
    468468                }

  • branches/eam_branch_20081230/psLib/src/fft/psImageFFT.h

    r21072 r21074  
    55/// @author Robert DeSonia, MHPCC
    66///
    7 /// @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    8 /// @date $Date: 2008-04-04 22:44:56 $
     7/// @version $Revision: 1.10.36.1 $ $Name: not supported by cvs2svn $
     8/// @date $Date: 2008-12-30 20:39:59 $
    99/// Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1010///
    … …  
    7070    const psImage *in,                  ///< Image to convolve
    7171    const psImage *mask,                ///< Corresponding mask
    72     psMaskType maskVal,                 ///< Value to mask
     72    psImageMaskType maskVal,            ///< Value to mask
    7373    const psKernel *kernel              ///< kernel to colvolve with
    7474);

  • branches/eam_branch_20081230/psLib/src/fits/psFitsImage.c

    r21072 r21074  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2008-09-05 08:08:33 $
     9 *  @version $Revision: 1.40.14.1 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-12-30 20:39:59 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    251251                                          const psImage *image, // Image to convert
    252252                                          const psImage *mask, // Mask image, or NULL
    253                                           psMaskType maskVal, // Value to mask
     253                                          psImageMaskType maskVal, // Value to mask
    254254                                          psRandom *rng, // Random number generator
    255255                                          bool newScaleZero // Determine a new BSCALE and BZERO?
    … …  
    506506
    507507bool psFitsWriteImageWithMask(psFits *fits, psMetadata *header, const psImage *input,
    508                               const psImage *mask, psMaskType maskVal, int numZPlanes,
     508                              const psImage *mask, psImageMaskType maskVal, int numZPlanes,
    509509                              const char *extname)
    510510{
    … …  
    525525
    526526bool psFitsInsertImageWithMask(psFits *fits, psMetadata *header, const psImage *image,
    527                                const psImage *mask, psMaskType maskVal, int numZPlanes,
     527                               const psImage *mask, psImageMaskType maskVal, int numZPlanes,
    528528                               const char *extname, bool after)
    529529{
    … …  
    532532    PS_ASSERT_IMAGE_NON_NULL(image, false);
    533533    if (mask) {
    534         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
     534        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
    535535        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
    536536    }
    … …  
    706706}
    707707
    708 bool psFitsUpdateImageWithMask(psFits *fits, const psImage *input, const psImage *mask, psMaskType maskVal,
     708bool psFitsUpdateImageWithMask(psFits *fits, const psImage *input, const psImage *mask, psImageMaskType maskVal,
    709709                               int x0, int y0, int z)
    710710{
    … …  
    713713    PS_ASSERT_IMAGE_NON_NULL(input, false);
    714714    if (mask) {
    715         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
     715        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
    716716        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, input, false);
    717717    }
    … …  
    896896
    897897bool psFitsWriteImageCubeWithMask(psFits *fits, psMetadata *header, const psArray *input,
    898                                   const psArray *masks, psMaskType maskVal, const char *extname)
     898                                  const psArray *masks, psImageMaskType maskVal, const char *extname)
    899899{
    900900    PS_ASSERT_FITS_NON_NULL(fits, false);
    … …  
    976976
    977977bool psFitsUpdateImageCubeWithMask(psFits *fits, const psArray *input,
    978                                    const psArray *masks, psMaskType maskVal, int x0, int y0)
     978                                   const psArray *masks, psImageMaskType maskVal, int x0, int y0)
    979979{
    980980    PS_ASSERT_FITS_NON_NULL(fits, false);

  • branches/eam_branch_20081230/psLib/src/fits/psFitsImage.h

    r21072 r21074  
    44 * @author Robert DeSonia, MHPCC
    55 *
    6  * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    7  * @date $Date: 2008-09-05 08:08:33 $
     6 * @version $Revision: 1.10.14.1 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2008-12-30 20:39:59 $
    88 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    99 */
    … …  
    7474    const psImage *input,               ///< the image to output
    7575    const psImage *mask,                ///< the mask image
    76     psMaskType maskVal,                 ///< value to mask
     76    psImageMaskType maskVal,            ///< value to mask
    7777    int depth,                          ///< the number of z-planes of the FITS image data cube
    7878    const char *extname                 ///< FITS extension name
    … …  
    101101    const psImage *input,               ///< the image to output
    102102    const psImage *mask,                ///< the mask image
    103     psMaskType maskVal,                 ///< value to mask
     103    psImageMaskType maskVal,            ///< value to mask
    104104    int depth,                          ///< the number of z-planes of the FITS image data cube
    105105    const char *extname,                ///< FITS extension name
    … …  
    128128    const psImage *input,               ///< the image to output
    129129    const psImage *mask,                ///< the mask image
    130     psMaskType maskVal,                 ///< value to mask
     130    psImageMaskType maskVal,            ///< value to mask
    131131    int x0,                             ///< psImage's x-axis origin in FITS image coordinates
    132132    int y0,                             ///< psImage's y-axis origin in FITS image coordinates
    … …  
    157157    const psArray *input,               ///< Array of images
    158158    const psArray *masks,               ///< Array of masks
    159     psMaskType maskVal,                 ///< Value to mask
     159    psImageMaskType maskVal,            ///< Value to mask
    160160    const char *extname                 ///< Name of extension
    161161    );
    … …  
    175175    const psArray *input,               ///< Array of images
    176176    const psArray *masks,               ///< Array of masks
    177     psMaskType maskVal,                 ///< Value to mask
     177    psImageMaskType maskVal,            ///< Value to mask
    178178    int x0,                             ///< x origin of images in FITS image coordinates
    179179    int y0                              ///< y origin of images in FITS image coordinates

  • branches/eam_branch_20081230/psLib/src/fits/psFitsScale.c

    r21072 r21074  
    100100                       const psImage *image, // Image to scale
    101101                       const psImage *mask, // Mask image
    102                        psMaskType maskVal, // Value to mask
     102                       psImageMaskType maskVal, // Value to mask
    103103                       const psFitsOptions *options // FITS options
    104104    )
    … …  
    167167
    168168bool psFitsScaleDetermine(double *bscale, double *bzero, long *blank, const psImage *image,
    169                           const psImage *mask, psMaskType maskVal, const psFits *fits)
     169                          const psImage *mask, psImageMaskType maskVal, const psFits *fits)
    170170{
    171171    PS_ASSERT_PTR_NON_NULL(bscale, false);
    … …  
    174174    PS_ASSERT_IMAGE_NON_NULL(image, false);
    175175    if (mask) {
    176         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
     176        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
    177177        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
    178178    }

  • branches/eam_branch_20081230/psLib/src/fits/psFitsScale.h

    r21072 r21074  
    1313                          const psImage *image, ///< Image to scale
    1414                          const psImage *mask, ///< Mask image
    15                           psMaskType maskVal, ///< Value to mask
     15                          psImageMaskType maskVal, ///< Value to mask
    1616                          const psFits *fits ///< FITS options
    1717    );

  • branches/eam_branch_20081230/psLib/src/imageops/psImageBackground.c

    r20216 r21074  
    1818// XXX allow the user to choose the stats method?
    1919// (SAMPLE_MEAN, CLIPPED_MEAN, ROBUST_MEDIAN, FITTED_MEAN)
    20 bool psImageBackground(psStats *stats, psVector **sample, const psImage *image, const psImage *mask, psMaskType maskValue, psRandom *rng)
     20bool psImageBackground(psStats *stats, psVector **sample, const psImage *image, const psImage *mask, psImageMaskType maskValue, psRandom *rng)
    2121{
    2222    PS_ASSERT_IMAGE_NON_NULL(image, NULL);
    2323    if (mask) {
    2424        PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    25         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL);
     25        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    2626        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, NULL);
    2727    }
    … …  
    6363        int iy = pixel / nx;
    6464
    65         if (!isfinite(image->data.F32[iy][ix]) || (mask && mask->data.U8[iy][ix] & maskValue)) {
     65        if (!isfinite(image->data.F32[iy][ix]) || (mask && mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] & maskValue)) {
    6666            continue;
    6767        }

  • branches/eam_branch_20081230/psLib/src/imageops/psImageBackground.h

    r16115 r21074  
    55 *  @author EAM, IfA
    66 *
    7  *  $Revision: 1.6 $ $Name: not supported by cvs2svn $
    8  *  $Date: 2008-01-17 22:07:33 $
     7 *  $Revision: 1.6.38.1 $ $Name: not supported by cvs2svn $
     8 *  $Date: 2008-12-30 20:39:59 $
    99 *  Copyright 2004-2005 IfA, University of Hawaii
    1010 */
    … …  
    2727                       const psImage *image, // Image for which to get the background
    2828                       const psImage *mask, // Mask image
    29                        psMaskType maskValue, // Mask pixels which this mask value
     29                       psImageMaskType maskValue, // Mask pixels which this mask value
    3030                       psRandom *rng // Random number generator (for pixel selection)
    3131                      );

  • branches/eam_branch_20081230/psLib/src/imageops/psImageConvolve.c

    r21072 r21074  
    77/// @author Eugene Magnier, IfA
    88///
    9 /// @version $Revision: 1.81 $ $Name: not supported by cvs2svn $
    10 /// @date $Date: 2008-11-26 00:43:12 $
     9/// @version $Revision: 1.81.6.1 $ $Name: not supported by cvs2svn $
     10/// @date $Date: 2008-12-30 20:39:59 $
    1111///
    1212/// Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    … …  
    319319}
    320320
    321 psImage *psImageConvolveMaskDirect(psImage *out, const psImage *mask, psMaskType maskVal,
    322                                    psMaskType setVal, int xMin, int xMax, int yMin, int yMax)
     321psImage *psImageConvolveMaskDirect(psImage *out, const psImage *mask, psImageMaskType maskVal,
     322                                   psImageMaskType setVal, int xMin, int xMax, int yMin, int yMax)
    323323{
    324324    PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    325     PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     325    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    326326    if (out == mask && ((maskVal & setVal) || !setVal)) {
    327327        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    … …  
    352352    if (!out) {
    353353        // Propagate the non-masked values
    354         out = (psImage*)psBinaryOp(NULL, (const psPtr)mask, "&", psScalarAlloc(~maskVal, PS_TYPE_MASK));
     354        out = (psImage*)psBinaryOp(NULL, (const psPtr)mask, "&", psScalarAlloc(~maskVal, PS_TYPE_IMAGE_MASK));
    355355    }
    356356
    357357    // Dereference mask images
    358     psMaskType **maskData = mask->data.PS_TYPE_MASK_DATA;
    359     psMaskType **outData = out->data.PS_TYPE_MASK_DATA;
     358    psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA;
     359    psImageMaskType **outData = out->data.PS_TYPE_IMAGE_MASK_DATA;
    360360
    361361    if (setVal) {
    … …  
    376376        for (int row = 0; row < numRows; row++) {
    377377            for (int col = 0; col < numCols; col++) {
    378                 psMaskType pixel = outData[row][col]; // Pixel value to set
     378                psImageMaskType pixel = outData[row][col]; // Pixel value to set
    379379                if (pixel & maskVal) {
    380380                    // Already done this one
    … …  
    395395
    396396
    397 psImage *psImageConvolveMaskFFT(psImage *out, const psImage *mask, psMaskType maskVal,
    398                                 psMaskType setVal, int xMin, int xMax, int yMin, int yMax, float thresh)
     397psImage *psImageConvolveMaskFFT(psImage *out, const psImage *mask, psImageMaskType maskVal,
     398                                psImageMaskType setVal, int xMin, int xMax, int yMin, int yMax, float thresh)
    399399{
    400400    PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    401     PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     401    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    402402    PS_ASSERT_FLOAT_LARGER_THAN(thresh, 0.0, NULL);
    403403    PS_ASSERT_FLOAT_LESS_THAN(thresh, 1.0, NULL);
    … …  
    431431    for (int y = 0; y < numRows; y++) {
    432432        for (int x = 0; x < numCols; x++) {
    433             if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
     433            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
    434434                onoff->data.F32[y][x] = 1.0;
    435435            }
    … …  
    452452
    453453    if (!out) {
    454         out = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     454        out = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
    455455    }
    456456    for (int y = 0; y < numRows; y++) {
    457457        for (int x = 0; x < numCols; x++) {
    458             out->data.PS_TYPE_MASK_DATA[y][x] = (convolved->data.F32[y][x] >= thresh) ?
    459                 (mask->data.PS_TYPE_MASK_DATA[y][x] | setVal) : mask->data.PS_TYPE_MASK_DATA[y][x];
     458            out->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = (convolved->data.F32[y][x] >= thresh) ?
     459                (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] | setVal) : mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x];
    460460        }
    461461    }
    … …  
    651651case PS_TYPE_##TYPE: { \
    652652    psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_##TYPE); /* Calculation image; BW */ \
    653     psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */ \
     653    psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */ \
    654654    \
    655655    /** Smooth in X direction **/ \
    … …  
    658658            int xMin = PS_MAX(i - size, 0); \
    659659            int xMax = PS_MIN(i + size, xLast); \
    660             const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin]; \
     660            const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[j][xMin]; \
    661661            const ps##TYPE *imageData = &image->data.TYPE[j][xMin]; \
    662662            int uMin = - PS_MIN(i, size); /* Minimum kernel index */ \
    … …  
    673673                /* BW */ \
    674674                calculation->data.TYPE[i][j] = sumIG / sumG; \
    675                 calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0; \
     675                calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0; \
    676676            } else { \
    677677                /* BW */ \
    678                 calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF; \
     678                calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0xFF; \
    679679            } \
    680680        } \
    … …  
    688688            int yMin = PS_MAX(j - size, 0); \
    689689            int yMax = PS_MIN(j + size, yLast); \
    690             const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */ \
     690            const psImageMaskType *maskData = &calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][yMin]; /* BW */ \
    691691            const ps##TYPE *imageData = &calculation->data.TYPE[i][yMin]; /* BW */ \
    692692            int vMin = - PS_MIN(j, size); /* Minimum kernel index */ \
    … …  
    714714                           const psImage *image,
    715715                           const psImage *mask,
    716                            psMaskType maskVal,
     716                           psImageMaskType maskVal,
    717717                           float sigma,
    718718                           float numSigma,
    … …  
    721721    PS_ASSERT_IMAGE_NON_NULL(image, NULL);
    722722    PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    723     PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     723    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    724724    PS_ASSERT_IMAGES_SIZE_EQUAL(image, mask, NULL);
    725725
    … …  
    751751      case PS_TYPE_F32: {
    752752          psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */
    753           psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */
     753          psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */
    754754
    755755          /** Smooth in X direction **/
    … …  
    758758                  int xMin = PS_MAX(i - size, 0);
    759759                  int xMax = PS_MIN(i + size, xLast);
    760                   const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin];
     760                  const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[j][xMin];
    761761                  const psF32 *imageData = &image->data.F32[j][xMin];
    762762                  int uMin = - PS_MIN(i, size); /* Minimum kernel index */
    … …  
    776776                      /* BW */
    777777                      calculation->data.F32[i][j] = sumIG / sumG;
    778                       calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0;
     778                      calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0;
    779779                  } else {
    780780                      /* BW */
    781                       calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF;
     781                      calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0xFF;
    782782                  }
    783783              }
    … …  
    791791                  int yMin = PS_MAX(j - size, 0);
    792792                  int yMax = PS_MIN(j + size, yLast);
    793                   const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */
     793                  const psImageMaskType *maskData = &calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][yMin]; /* BW */
    794794                  const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */
    795795                  int vMin = - PS_MIN(j, size); /* Minimum kernel index */
    … …  
    832832                                     const psImage *image,
    833833                                     const psImage *mask,
    834                                      psMaskType maskVal,
     834                                     psImageMaskType maskVal,
    835835                                     psVector *gaussNorm,
    836836                                     float minGauss,
    … …  
    848848            int xMin = PS_MAX(i - size, 0);
    849849            int xMax = PS_MIN(i + size, xLast);
    850             const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin];
     850            const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[j][xMin];
    851851            const psF32 *imageData = &image->data.F32[j][xMin];
    852852            int uMin = - PS_MIN(i, size); /* Minimum kernel index */
    … …  
    863863                /* BW */
    864864                calculation->data.F32[i][j] = sumIG / sumG;
    865                 calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0;
     865                calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0;
    866866            } else {
    867867                /* BW */
    868                 calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF;
     868                calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0xFF;
    869869            }
    870870        }
    … …  
    876876                                     psImage *calculation,
    877877                                     psImage *calcMask,
    878                                      psMaskType maskVal,
     878                                     psImageMaskType maskVal,
    879879                                     psVector *gaussNorm,
    880880                                     float minGauss,
    … …  
    892892            int yMin = PS_MAX(j - size, 0);
    893893            int yMax = PS_MIN(j + size, yLast);
    894             const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */
     894            const psImageMaskType *maskData = &calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][yMin]; /* BW */
    895895            const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */
    896896            int vMin = - PS_MIN(j, size); /* Minimum kernel index */
    … …  
    921921    const psImage *mask   = job->args->data[3]; // input mask
    922922
    923     psMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[4],U8);
     923    psImageMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA);
    924924    psVector *gaussNorm   = job->args->data[5]; // gauss kernel
    925925    float minGauss        = PS_SCALAR_VALUE(job->args->data[6],F32);
    … …  
    941941    psImage *calculation  = job->args->data[1]; // calculation image
    942942    psImage *calcMask     = job->args->data[2]; // calculation mask
    943     psMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[3],U8);
     943    psImageMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[3],PS_TYPE_IMAGE_MASK_DATA);
    944944
    945945    psVector *gaussNorm   = job->args->data[4]; // gauss kernel
    … …  
    956956                                    const psImage *image,
    957957                                    const psImage *mask,
    958                                     psMaskType maskVal,
     958                                    psImageMaskType maskVal,
    959959                                    float sigma,
    960960                                    float numSigma,
    … …  
    963963    PS_ASSERT_IMAGE_NON_NULL(image, NULL);
    964964    PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    965     PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     965    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    966966    PS_ASSERT_IMAGES_SIZE_EQUAL(image, mask, NULL);
    967967
    … …  
    999999      case PS_TYPE_F32: {
    10001000          psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */
    1001           psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */
     1001          psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */
    10021002
    10031003          /** Smooth in X direction **/
    … …  
    10111011              psArrayAdd(job->args, 1, (psImage *) image); // cast away const
    10121012              psArrayAdd(job->args, 1, (psImage *) mask); // cast away const
    1013               PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
     1013              PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
    10141014              psArrayAdd(job->args, 1, gaussNorm);
    10151015              PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
    … …  
    10461046              psArrayAdd(job->args, 1, calculation);
    10471047              psArrayAdd(job->args, 1, calcMask);
    1048               PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
     1048              PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
    10491049              psArrayAdd(job->args, 1, gaussNorm);
    10501050              PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
    … …  
    10911091bool psImageSmoothMaskF32 (psImage *image,
    10921092                           psImage *mask,
    1093                            psMaskType maskVal,
     1093                           psImageMaskType maskVal,
    10941094                           double  sigma,
    10951095                           double  Nsigma)
    … …  
    11221122    psVector *calculation = psVectorAlloc(Nx, PS_TYPE_F32);
    11231123    for (int j = 0; j < Ny; j++) {
    1124         psU8  *vm = mask->data.U8[j];
     1124        psImageMaskType  *vm = mask->data.PS_TYPE_IMAGE_MASK_DATA[j];
    11251125        psF32 *vi = image->data.F32[j];
    11261126        psF32 *vo = calculation->data.F32;
    … …  
    11281128        for (int i = 0; i < Nx; i++, vi++, vo++, vm++) {
    11291129            int offset = PS_MIN (i, Nrange);
    1130             psU8  *sm = vm - offset;
     1130            psImageMaskType  *sm = vm - offset;
    11311131            psF32 *si = vi - offset;
    11321132            psF32 *sg = gauss - offset;
    … …  
    11711171        int yMax = PS_MIN (j + Nrange + 1, Ny);
    11721172        for (int n = yMin; n < yMax; n++) {
    1173             psU8  *vm = mask->data.U8[n];
     1173            psImageMaskType  *vm = mask->data.PS_TYPE_IMAGE_MASK_DATA[n];
    11741174            psF32 *vi = image->data.F32[n];
    11751175            psF32 *vo = output->data.F32;
    … …  
    12141214                                     const psImage *input, // Input image
    12151215                                     int start, int stop, // Range of rows
    1216                                      psMaskType maskVal, // Value to mask; NOTE subtle difference!
     1216                                     psImageMaskType maskVal, // Value to mask; NOTE subtle difference!
    12171217                                     int xMin, int xMax // Range in x for kernel
    12181218                                     )
    12191219{
    12201220    // Dereference mask images
    1221     psMaskType **inputData = input->data.PS_TYPE_MASK_DATA;
    1222     psMaskType **targetData = target->data.PS_TYPE_MASK_DATA;
     1221    psImageMaskType **inputData = input->data.PS_TYPE_IMAGE_MASK_DATA;
     1222    psImageMaskType **targetData = target->data.PS_TYPE_IMAGE_MASK_DATA;
    12231223
    12241224    int numCols = input->numCols;       // Number of columns
    … …  
    12411241                min = PS_MAX(0, min);
    12421242                max = PS_MIN(numCols - 1, max);
    1243                 memset(&targetData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK));
     1243                memset(&targetData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK));
    12441244            }
    12451245        }
    … …  
    12471247            // Mask from the minimum to the end of the row
    12481248            min = PS_MAX(0, min);
    1249             memset(&targetData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK));
     1249            memset(&targetData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK));
    12501250        }
    12511251    }
    … …  
    12561256                                     const psImage *input, // Input image
    12571257                                     int start, int stop, // Range of rows
    1258                                      psMaskType setVal, // Value to set; NOTE subtle difference!
     1258                                     psImageMaskType setVal, // Value to set; NOTE subtle difference!
    12591259                                     int yMin, int yMax // Range in y for kernel
    12601260                                     )
    12611261{
    12621262    // Dereference mask images
    1263     psMaskType **inputData = input->data.PS_TYPE_MASK_DATA;
    1264     psMaskType **targetData = target->data.PS_TYPE_MASK_DATA;
     1263    psImageMaskType **inputData = input->data.PS_TYPE_IMAGE_MASK_DATA;
     1264    psImageMaskType **targetData = target->data.PS_TYPE_IMAGE_MASK_DATA;
    12651265
    12661266    int numRows = input->numRows;       // Number of rows
    … …  
    13081308    int start = PS_SCALAR_VALUE(args->data[2], S32); // Row/col to start at
    13091309    int stop = PS_SCALAR_VALUE(args->data[3], S32); // Row/col to stop at
    1310     psMaskType maskVal = PS_SCALAR_VALUE(args->data[4], U8); // Value to mask/set
     1310    psImageMaskType maskVal = PS_SCALAR_VALUE(args->data[4], PS_TYPE_IMAGE_MASK_DATA); // Value to mask/set
    13111311    int kernelMin = PS_SCALAR_VALUE(args->data[5], S32); // Minimum range for kernel
    13121312    int kernelMax = PS_SCALAR_VALUE(args->data[6], S32); // Maximum range for kernel
    … …  
    13171317}
    13181318
    1319 psImage *psImageConvolveMask(psImage *out, const psImage *mask, psMaskType maskVal,
    1320                              psMaskType setVal, int xMin, int xMax, int yMin, int yMax)
     1319psImage *psImageConvolveMask(psImage *out, const psImage *mask, psImageMaskType maskVal,
     1320                             psImageMaskType setVal, int xMin, int xMax, int yMin, int yMax)
    13211321{
    13221322    PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    1323     PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     1323    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    13241324    if (out) {
    13251325        PS_ASSERT_IMAGE_NON_NULL(out, NULL);
    1326         PS_ASSERT_IMAGE_TYPE(out, PS_TYPE_MASK, NULL);
     1326        PS_ASSERT_IMAGE_TYPE(out, PS_TYPE_IMAGE_MASK, NULL);
    13271327        PS_ASSERT_IMAGES_SIZE_EQUAL(out, mask, NULL);
    13281328        if (out == mask && ((maskVal & setVal) || !setVal)) {
    … …  
    13541354
    13551355    // Propagate the non-masked values
    1356     out = (psImage*)psBinaryOp(out, (const psPtr)mask, "&", psScalarAlloc(~setVal, PS_TYPE_MASK));
     1356    out = (psImage*)psBinaryOp(out, (const psPtr)mask, "&", psScalarAlloc(~setVal, PS_TYPE_IMAGE_MASK));
    13571357
    13581358    if (!setVal) {
    … …  
    13601360    }
    13611361
    1362     psImage *conv = psImageAlloc(numCols, numRows, PS_TYPE_MASK); // Temporary convolved image
     1362    psImage *conv = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); // Temporary convolved image
    13631363    psImageInit(conv, 0);
    13641364
    … …  
    13771377            PS_ARRAY_ADD_SCALAR(job->args, start, PS_TYPE_S32);
    13781378            PS_ARRAY_ADD_SCALAR(job->args, stop, PS_TYPE_S32);
    1379             PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_MASK);
     1379            PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_IMAGE_MASK);
    13801380            PS_ARRAY_ADD_SCALAR(job->args, xMin, PS_TYPE_S32);
    13811381            PS_ARRAY_ADD_SCALAR(job->args, xMax, PS_TYPE_S32);
    … …  
    14151415            PS_ARRAY_ADD_SCALAR(job->args, start, PS_TYPE_S32);
    14161416            PS_ARRAY_ADD_SCALAR(job->args, stop, PS_TYPE_S32);
    1417             PS_ARRAY_ADD_SCALAR(job->args, setVal, PS_TYPE_MASK);
     1417            PS_ARRAY_ADD_SCALAR(job->args, setVal, PS_TYPE_IMAGE_MASK);
    14181418            PS_ARRAY_ADD_SCALAR(job->args, yMin, PS_TYPE_S32);
    14191419            PS_ARRAY_ADD_SCALAR(job->args, yMax, PS_TYPE_S32);
    … …  
    14601460                min = PS_MAX(0, min);
    14611461                max = PS_MIN(numCols - 1, max);
    1462                 memset(&convData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK));
     1462                memset(&convData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK));
    14631463            }
    14641464        }
    … …  
    14661466            // Mask from the minimum to the end of the row
    14671467            min = PS_MAX(0, min);
    1468             memset(&convData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK));
     1468            memset(&convData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK));
    14691469        }
    14701470    }

  • branches/eam_branch_20081230/psLib/src/imageops/psImageConvolve.h

    r21072 r21074  
    55 * @author Robert DeSonia, MHPCC
    66 *
    7  * @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-11-26 00:43:12 $
     7 * @version $Revision: 1.38.6.1 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2008-12-30 20:39:59 $
    99 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1010 */
    … …  
    148148psImage *psImageConvolveMask(psImage *out, ///< Output image, or NULL
    149149                             const psImage *mask, ///< Mask to convolve
    150                              psMaskType maskVal, ///< Mask value to convolve
    151                              psMaskType setVal, ///< Mask value to set; 0 to propagate maskVal
     150                             psImageMaskType maskVal, ///< Mask value to convolve
     151                             psImageMaskType setVal, ///< Mask value to set; 0 to propagate maskVal
    152152                             int xMin, int xMax, int yMin, int yMax ///< Convolution bounds
    153153    );
    … …  
    160160psImage *psImageConvolveMaskDirect(psImage *out, ///< Output image, or NULL
    161161                                   const psImage *mask, ///< Mask to convolve
    162                                    psMaskType maskVal, ///< Mask value to convolve
    163                                    psMaskType setVal, ///< Mask value to set; 0 to propagate maskVal
     162                                   psImageMaskType maskVal, ///< Mask value to convolve
     163                                   psImageMaskType setVal, ///< Mask value to set; 0 to propagate maskVal
    164164                                   int xMin, int xMax, int yMin, int yMax ///< Convolution bounds
    165165    );
    … …  
    174174psImage *psImageConvolveMaskFFT(psImage *out, ///< Output image, or NULL
    175175                                const psImage *mask, ///< Mask to convolve
    176                                 psMaskType maskVal, ///< Mask value to convolve
    177                                 psMaskType setVal, ///< Mask value to set; 0 to use maskVal
     176                                psImageMaskType maskVal, ///< Mask value to convolve
     177                                psImageMaskType setVal, ///< Mask value to set; 0 to use maskVal
    178178                                int xMin, int xMax, int yMin, int yMax, ///< Convolution bounds
    179179                                float thresh ///< Threshold (0..1) for convolved floating-point image
    … …  
    201201    const psImage *image,               ///< Input image (F32 or F64)
    202202    const psImage *mask,                ///< Mask image
    203     psMaskType maskVal,                 ///< Mask value
     203    psImageMaskType maskVal,            ///< Mask value
    204204    float sigma,                        ///< Width of the smoothing kernel (pixels)
    205205    float numSigma,                     ///< Size of the smoothing box (sigma)
    … …  
    211211                                    const psImage *image,
    212212                                    const psImage *mask,
    213                                     psMaskType maskVal,
     213                                    psImageMaskType maskVal,
    214214                                    float sigma,
    215215                                    float numSigma,
    … …  
    219219    psImage *image,                    ///< the image to be smoothed
    220220    psImage *mask,                     ///< optional mask
    221     psMaskType maskVal,
     221    psImageMaskType maskVal,            ///< masked bits
    222222    double  sigma,                     ///< the width of the smoothing kernel in pixels
    223223    double  Nsigma                     ///< the size of the smoothing box in sigmas

  • branches/eam_branch_20081230/psLib/src/imageops/psImageGeomManip.c

    r20299 r21074  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2008-10-21 22:10:53 $
     12 *  @version $Revision: 1.44.8.1 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2008-12-30 20:39:59 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3939                      const psImage* in,
    4040                      const psImage* mask,
    41                       psMaskType maskVal,
     41                      psImageMaskType maskVal,
    4242                      int scale,
    4343                      const psStats* stats)
    … …  
    4747    psS32 outRows;
    4848    psS32 outCols;
    49     psVector* vec;                     // vector to hold the values of a single bin.
    50     psVector* maskVec = NULL;          // vector to hold the mask of a single bin.
    51     psMaskType* maskData = NULL;
    52     psStats* myStats;
     49    psVector *vec;                     // vector to hold the values of a single bin.
     50    psVector *maskVec = NULL;          // vector to hold the mask of a single bin.
     51    psVectorMaskType *maskData = NULL;
     52    psStats *myStats;
    5353
    5454    if (in == NULL) {
    … …  
    8686
    8787    if (mask != NULL) {
    88         if (mask->type.type != PS_TYPE_MASK) {
     88        if (mask->type.type != PS_TYPE_IMAGE_MASK) {
    8989            char* typeStr;
    9090            PS_TYPE_NAME(typeStr,mask->type.type);
    9191            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    9292                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    93                     typeStr, PS_TYPE_MASK_NAME);
     93                    typeStr, PS_TYPE_IMAGE_MASK_NAME);
    9494            psFree(out);
    9595            psFree(vec);
    9696            return NULL;
    9797        }
    98         maskVec = psVectorAllocEmpty(scale * scale, PS_TYPE_MASK);
    99         maskData = maskVec->data.PS_TYPE_MASK_DATA;
     98        maskVec = psVectorAllocEmpty(scale * scale, PS_TYPE_VECTOR_MASK);
     99        maskData = maskVec->data.PS_TYPE_VECTOR_MASK_DATA;
    100100    }
    101101
    … …  
    114114        ps##TYPE *outRowData; \
    115115        ps##TYPE *vecData = vec->data.TYPE; \
    116         psMaskType *inRowMask = NULL; \
     116        psImageMaskType *inRowMask = NULL; \
    117117        for (psS32 row = 0; row < outRows; row++) { \
    118118            outRowData = out->data.TYPE[row]; \
    … …  
    126126                    ps##TYPE* inRowData = in->data.TYPE[inRow]; \
    127127                    if (mask != NULL) { \
    128                         inRowMask = mask->data.PS_TYPE_MASK_DATA[inRow]; \
     128                        inRowMask = mask->data.PS_TYPE_IMAGE_MASK_DATA[inRow]; \
    129129                    } \
    130130                    for (psS32 inCol = inCurrentCol; inCol < inNextCol && inCol < inCols; inCol++) { \
    131131                        if (maskData != NULL) { \
    132                             maskData[n] = inRowMask[inCol]; \
     132                            maskData[n] = (inRowMask[inCol] & maskVal); \
    133133                        } \
    134134                        vecData[n++] = inRowData[inCol]; \
    … …  
    139139                    maskVec->n = n; \
    140140                } \
    141                 psVectorStats(myStats, vec, NULL, maskVec, maskVal); \
     141                 psVectorStats(myStats, vec, NULL, maskVec, 0xff); /* the mask vector has only 0 or 1 */ \
    142142                outRowData[col] = (ps##TYPE)psStatsGetValue(myStats, statistic); \
    143143            } \
    … …  
    659659
    660660bool psImageShiftMask(psImage **out, psImage **outMask, const psImage* in, const psImage *inMask,
    661                       psMaskType maskVal, float dx, float dy, double exposed, psMaskType blank,
     661                      psImageMaskType maskVal, float dx, float dy, double exposed, psImageMaskType blank,
    662662                      psImageInterpolateMode mode)
    663663{
    … …  
    667667        PS_ASSERT_IMAGE_NON_NULL(inMask, false);
    668668        PS_ASSERT_IMAGES_SIZE_EQUAL(in, inMask, false);
    669         PS_ASSERT_IMAGE_TYPE(inMask, PS_TYPE_MASK, false);
     669        PS_ASSERT_IMAGE_TYPE(inMask, PS_TYPE_IMAGE_MASK, false);
    670670    }
    671671
    … …  
    675675    *out = psImageRecycle(*out, numCols, numRows, type);
    676676    if (outMask) {
    677         *outMask = psImageRecycle(*outMask, numCols, numRows, PS_TYPE_MASK);
     677        *outMask = psImageRecycle(*outMask, numCols, numRows, PS_TYPE_IMAGE_MASK);
    678678    }
    679679
    … …  
    702702    for (int row = 0; row < numRows; row++) { \
    703703        ps##TYPE* outRow = (*out)->data.TYPE[row]; \
    704         psMaskType *outMaskRow = (outMask ? (*outMask)->data.PS_TYPE_MASK_DATA[row] : NULL); \
     704        psImageMaskType *outMaskRow = (outMask ? (*outMask)->data.PS_TYPE_IMAGE_MASK_DATA[row] : NULL); \
    705705        float y = row + 0.5 - dy; \
    706706        for (int col = 0; col < numCols; col++) { \
    707707            float x = col + 0.5 - dx; \
    708708            double value; \
    709             psMaskType valueMask = 0; \
     709            psImageMaskType valueMask = 0; \
    710710            if (!psImageInterpolate(&value, NULL, &valueMask, x, y, interp)) { \
    711711                psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image."); \
    … …  
    750750                          const psImage *input,
    751751                          const psImage *inputMask,
    752                           psMaskType inputMaskVal,
     752                          psImageMaskType inputMaskVal,
    753753                          const psPlaneTransform *outToIn,
    754754                          psRegion region,
    … …  
    778778            return NULL;
    779779        }
    780         if (inputMask->type.type != PS_TYPE_MASK) {
     780        if (inputMask->type.type != PS_TYPE_IMAGE_MASK) {
    781781            char* typeStr;
    782782            PS_TYPE_NAME(typeStr,inputMask->type.type);
    783783            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    784784                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    785                     typeStr, PS_TYPE_MASK_NAME);
     785                    typeStr, PS_TYPE_IMAGE_MASK_NAME);
    786786            psFree(output);
    787787            return NULL;

  • branches/eam_branch_20081230/psLib/src/imageops/psImageGeomManip.h

    r16910 r21074  
    66 * @author Robert DeSonia, MHPCC
    77 *
    8  * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2008-03-11 00:41:30 $
     8 * @version $Revision: 1.22.36.1 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2008-12-30 20:39:59 $
    1010 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1111 */
    … …  
    3636    const psImage* in,                 ///< input image
    3737    const psImage* mask,               ///< mask for input image.  If NULL, no masking is done.
    38     psMaskType maskVal,                ///< the bits to check in mask.
     38    psImageMaskType maskVal,            ///< the bits to check in mask.
    3939    int scale,                         ///< the scale to rebin for each dimension
    4040    const psStats* stats
    … …  
    106106    const psImage* in,                  ///< Input image
    107107    const psImage *inMask,              ///< Input mask, or NULL
    108     psMaskType maskVal,                 ///< Value to mask
     108    psImageMaskType maskVal,            ///< Value to mask
    109109    float dx, float dy,                 ///< Shift to apply
    110110    double exposed,                     ///< Value to give exposed pixels
    111     psMaskType blank,                   ///< Mask value for exposed pixels
     111    psImageMaskType blank,              ///< Mask value for exposed pixels
    112112    psImageInterpolateMode mode         ///< Interpolation mode
    113113    );
    … …  
    159159    const psImage *input,              ///< psImage to apply transform to
    160160    const psImage *inputMask,          ///< if not NULL, mask of input psImage
    161     psMaskType inputMaskVal,           ///< masking value for inputMask
     161    psImageMaskType inputMaskVal,       ///< masking value for inputMask
    162162    const psPlaneTransform *outToIn,   ///< the transform to apply
    163163    psRegion region,                   ///< the size of the transformed image

  • branches/eam_branch_20081230/psLib/src/imageops/psImageInterpolate.c

    r21072 r21074  
    77 *  @author Paul Price, IfA
    88 *
    9  *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2008-11-15 03:09:34 $
     9 *  @version $Revision: 1.30.6.1 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-12-30 20:39:59 $
    1111 *
    1212 *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    … …  
    205205psImageInterpolation *psImageInterpolationAlloc(psImageInterpolateMode mode,
    206206                                                const psImage *image, const psImage *variance,
    207                                                 const psImage *mask, psMaskType maskVal,
     207                                                const psImage *mask, psImageMaskType maskVal,
    208208                                                double badImage, double badVariance,
    209                                                 psMaskType badMask, psMaskType poorMask,
     209                                                psImageMaskType badMask, psImageMaskType poorMask,
    210210                                                float poorFrac, int numKernels)
    211211{
    … …  
    274274// Interpolation engine for flat mode (nearest pixel)
    275275static inline psImageInterpolateStatus interpolateFlat(double *imageValue, double *varianceValue,
    276                                                        psMaskType *maskValue, float x, float y,
     276                                                       psImageMaskType *maskValue, float x, float y,
    277277                                                       const psImageInterpolation *interp)
    278278{
    … …  
    331331        if (maskValue) {
    332332            if (interp->mask) {
    333                 *maskValue = interp->mask->data.PS_TYPE_MASK_DATA[yInt][xInt];
     333                *maskValue = interp->mask->data.PS_TYPE_IMAGE_MASK_DATA[yInt][xInt];
    334334            } else {
    335335                *maskValue = 0;
    … …  
    456456// Interpolation engine for separable interpolation kernels
    457457static psImageInterpolateStatus interpolateSeparable(double *imageValue, double *varianceValue,
    458                                                      psMaskType *maskValue, float x, float y,
     458                                                     psImageMaskType *maskValue, float x, float y,
    459459                                                     const psImageInterpolation *interp)
    460460{
    … …  
    465465    const psImage *mask = interp->mask; // Image mask
    466466    const psImage *variance = interp->variance; // Image variance
    467     psMaskType maskVal = interp->maskVal; // Value to mask
     467    psImageMaskType maskVal = interp->maskVal; // Value to mask
    468468    bool wantVariance = variance && varianceValue; // Does the user want the variance value?
    469469    bool haveMask = mask && maskVal; // Does the user want the variance value?
    … …  
    582582                  const ps##TYPE *imageData = &image->data.TYPE[yPix][xMin]; \
    583583                  const ps##TYPE *varianceData = &variance->data.TYPE[yPix][xMin]; \
    584                   const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[yPix][xMin]; \
     584                  const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[yPix][xMin]; \
    585585                  const psF32 *xKernelData = xKernel; \
    586586                  const psF32 *xKernel2Data = xKernel2; \
    … …  
    642642              /* Dereferenced versions of inputs */ \
    643643              const ps##TYPE *imageData = &image->data.TYPE[yPix][xMin]; \
    644               const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[yPix][xMin]; \
     644              const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[yPix][xMin]; \
    645645              const psF32 *xKernelData = xKernel; \
    646646              const psF32 *xKernel2Data = xKernel2; \
    … …  
    713713// Interpolation engine for (separable) interpolation kernels
    714714static psImageInterpolateStatus interpolateKernel(double *imageValue, double *varianceValue,
    715                                                   psMaskType *maskValue, float x, float y,
     715                                                  psImageMaskType *maskValue, float x, float y,
    716716                                                  const psImageInterpolation *interp)
    717717{
    … …  
    722722    const psImage *mask = interp->mask; // Image mask
    723723    const psImage *variance = interp->variance; // Image variance
    724     psMaskType maskVal = interp->maskVal; // Value to mask
     724    psImageMaskType maskVal = interp->maskVal; // Value to mask
    725725    bool wantVariance = variance && varianceValue; // Does the user want the variance value?
    726726    bool haveMask = mask && maskVal; // Does the user want the variance value?
    … …  
    790790                      float kernelValue = kernel[j][i]; /* Value of kernel */ \
    791791                      float kernelValue2 = PS_SQR(kernelValue); /* Square of kernel */ \
    792                       if (mask->data.PS_TYPE_MASK_DATA[yPix][xPix] & maskVal) { \
     792                      if (mask->data.PS_TYPE_IMAGE_MASK_DATA[yPix][xPix] & maskVal) { \
    793793                          sumBad += kernelValue2; \
    794794                      } else { \
    … …  
    820820                  float kernelValue = kernel[j][i]; /* Value of kernel */ \
    821821                  float kernelValue2 = PS_SQR(kernelValue); /* Square of kernel */ \
    822                   if (mask->data.PS_TYPE_MASK_DATA[yPix][xPix] & maskVal) { \
     822                  if (mask->data.PS_TYPE_IMAGE_MASK_DATA[yPix][xPix] & maskVal) { \
    823823                      sumBad += kernelValue2; \
    824824                  } else { \
    … …  
    866866
    867867
    868 psImageInterpolateStatus psImageInterpolate(double *imageValue, double *varianceValue, psMaskType *maskValue,
     868psImageInterpolateStatus psImageInterpolate(double *imageValue, double *varianceValue, psImageMaskType *maskValue,
    869869                                            float x, float y, const psImageInterpolation *interp)
    870870{
    … …  
    885885    if (maskValue && mask) {
    886886        PS_ASSERT_IMAGE_NON_NULL(mask, PS_INTERPOLATE_STATUS_ERROR);
    887         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, PS_INTERPOLATE_STATUS_ERROR);
     887        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, PS_INTERPOLATE_STATUS_ERROR);
    888888        psAssert(image->numCols == mask->numCols && image->numRows == mask->numRows, "Image and mask sizes");
    889889    }

  • branches/eam_branch_20081230/psLib/src/imageops/psImageInterpolate.h

    r20327 r21074  
    77 * @author Paul Price, Institute for Astronomy
    88 *
    9  * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    10  * @date $Date: 2008-10-22 19:21:06 $
     9 * @version $Revision: 1.7.8.1 $ $Name: not supported by cvs2svn $
     10 * @date $Date: 2008-12-30 20:39:59 $
    1111 * Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    1212 */
    … …  
    5050    const psImage *variance;            ///< Variance image for interpolation
    5151    const psImage *mask;                ///< Mask image for interpolation
    52     psMaskType maskVal;                 ///< Value to mask
     52    psImageMaskType maskVal;            ///< Value to mask
    5353    double badImage;                    ///< Image value if x,y location is not good
    5454    double badVariance;                 ///< Variance value if x,y location is not good
    55     psMaskType badMask;                 ///< Mask value to give bad pixels
    56     psMaskType poorMask;                ///< Mask value to give poor pixels
     55    psImageMaskType badMask;            ///< Mask value to give bad pixels
     56    psImageMaskType poorMask;           ///< Mask value to give poor pixels
    5757    float poorFrac;                     ///< Fraction of flux in bad pixels before output is marked bad
    5858    bool shifting;                      ///< Shifting images? Don't interpolate if the shift is exact.
    … …  
    6969    const psImage *variance,            // Variance image
    7070    const psImage *mask,                // Mask image
    71     psMaskType maskVal,                 // Value to mask
     71    psImageMaskType maskVal,                 // Value to mask
    7272    double badImage,                    // Value for image if bad
    7373    double badVariance,                 // Value for variance if bad
    74     psMaskType badMask,                 // Mask value for bad pixels
    75     psMaskType poorMask,                // Mask value for poor pixels
     74    psImageMaskType badMask,                 // Mask value for bad pixels
     75    psImageMaskType poorMask,                // Mask value for poor pixels
    7676    float poorFrac,                     // Fraction of flux for question
    7777    int numKernels                      // Number of interpolation kernels to pre-calculate
    … …  
    8383    double *imageValue,                 ///< Return value for image
    8484    double *varianceValue,              ///< Return value for variance
    85     psMaskType *maskValue,              ///< Return value for mask
     85    psImageMaskType *maskValue,              ///< Return value for mask
    8686    float x, float y,                   ///< Location to which to interpolate
    8787    const psImageInterpolation *options ///< Options

  • branches/eam_branch_20081230/psLib/src/imageops/psImageMap.c

    r21072 r21074  
    77 *  @author Eugene Magnier, IfA
    88 *
    9  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2008-11-17 02:37:28 $
     9 *  @version $Revision: 1.11.6.1 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-12-30 20:39:59 $
    1111 *
    1212 *  Copyright 2007 Institute for Astronomy, University of Hawaii
    … …  
    145145    }
    146146
    147     psImage *mask = psImageAlloc (map->map->numCols, map->map->numRows, PS_TYPE_MASK);
     147    psImage *mask = psImageAlloc (map->map->numCols, map->map->numRows, PS_TYPE_IMAGE_MASK);
    148148    psImage *xCoord = psImageAlloc (map->map->numCols, map->map->numRows, PS_TYPE_F32);
    149149    psImage *yCoord = psImageAlloc (map->map->numCols, map->map->numRows, PS_TYPE_F32);
    … …  
    212212            // this will not in general be properly weighted...
    213213            if (psVectorStats (map->stats, fCell, dfCell, NULL, 0)) {
    214                 mask->data.U8[iy][ix] = 0;
     214                mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] = 0;
    215215                // XXX ensure only one option is selected, or save both position and width
    216216                map->map->data.F32[iy][ix] = psStatsGetValue (map->stats, map->stats->options);
    … …  
    224224                yCoord->data.F32[iy][ix] = psStatsGetValue (meanStat, meanStat->options);
    225225            } else {
    226                 mask->data.U8[iy][ix] = 1;
     226                mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] = 1;
    227227            }
    228228

  • branches/eam_branch_20081230/psLib/src/imageops/psImageMapFit.c

    r20075 r21074  
    77 *  @author Eugene Magnier, IfA
    88 *
    9  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2008-10-13 01:55:48 $
     9 *  @version $Revision: 1.11.8.1 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-12-30 20:40:00 $
    1111 *
    1212 *  Copyright 2007 Institute for Astronomy, University of Hawaii
    … …  
    4747
    4848// map defines the output image dimensions and scaling.
    49 bool psImageMapFit(psImageMap *map, const psVector *mask, psMaskType maskValue,
     49bool psImageMapFit(psImageMap *map, const psVector *mask, psVectorMaskType maskValue,
    5050                   const psVector *x, const psVector *y, const psVector *f, const psVector *df)
    5151{
    … …  
    145145            for (int i = 0; i < x->n; i++) {
    146146
    147                 if (mask && (mask->data.U8[i] & maskValue)) continue;
     147                if (mask && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) continue;
    148148
    149149                // base coordinate offset for this point (x,y) relative to this map element (n,m)
    … …  
    338338
    339339// measure residuals on each pass and clip outliers based on stats
    340 bool psImageMapClipFit(psImageMap *map, psStats *stats, psVector *inMask, psMaskType maskValue,
     340bool psImageMapClipFit(psImageMap *map, psStats *stats, psVector *inMask, psVectorMaskType maskValue,
    341341                       const psVector *x, const psVector *y, const psVector *f, const psVector *df)
    342342{
    … …  
    377377    psVector *mask = inMask;
    378378    if (!inMask) {
    379         mask = psVectorAlloc (x->n, PS_TYPE_U8);
     379        mask = psVectorAlloc (x->n, PS_TYPE_VECTOR_MASK);
    380380        psVectorInit (mask, 0);
    381381    }
    … …  
    429429        for (psS32 i = 0; i < resid->n; i++) {
    430430            // XXX this prevents recovery of previously masked values
    431             if (mask->data.U8[i] & maskValue) {
     431            if (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue) {
    432432                continue;
    433433            }
    … …  
    435435            if ((resid->data.F32[i] - meanValue > maxClipValue) || (resid->data.F32[i] - meanValue < minClipValue)) {
    436436                psTrace("psLib.imageops", 6, "Masking element %d  : %f vs %f : resid is %f\n", i, f->data.F32[i], fit->data.F32[i], resid->data.F32[i]);
    437                 mask->data.U8[i] |= 0x01;
     437                mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    438438                continue;
    439439            }
    … …  
    455455
    456456// map defines the output image dimensions and scaling.
    457 bool psImageMapFit1DinY(psImageMap *map, const psVector *mask, psMaskType maskValue,
     457bool psImageMapFit1DinY(psImageMap *map, const psVector *mask, psVectorMaskType maskValue,
    458458                        const psVector *x, const psVector *y, const psVector *f, const psVector *df)
    459459{
    … …  
    490490        for (int i = 0; i < y->n; i++) {
    491491
    492             if (mask && (mask->data.U8[i] & maskValue)) continue;
     492            if (mask && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) continue;
    493493
    494494            float dy = psImageBinningGetRuffY (map->binning, y->data.F32[i]) - (m + 0.5);
    … …  
    603603
    604604// map defines the output image dimensions and scaling.
    605 bool psImageMapFit1DinX(psImageMap *map, const psVector *mask, psMaskType maskValue,
     605bool psImageMapFit1DinX(psImageMap *map, const psVector *mask, psVectorMaskType maskValue,
    606606                        const psVector *x, const psVector *y, const psVector *f, const psVector *df)
    607607{
    … …  
    638638        for (int i = 0; i < x->n; i++) {
    639639
    640             if (mask && (mask->data.U8[i] & maskValue)) continue;
     640            if (mask && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) continue;
    641641
    642642            float dx = psImageBinningGetRuffX (map->binning, x->data.F32[i]) - (m + 0.5);

  • branches/eam_branch_20081230/psLib/src/imageops/psImageMapFit.h

    r15841 r21074  
    1010bool psImageMapFit(psImageMap *map,
    1111                   const psVector *mask,
    12                    psMaskType maskValue,
     12                   psVectorMaskType maskValue, //
    1313                   const psVector *x,
    1414                   const psVector *y,
    … …  
    2121                       psStats *stats,
    2222                       psVector *mask,  // WARNING: Mask is modified!
    23                        psMaskType maskValue,
     23                       psVectorMaskType maskValue,
    2424                       const psVector *x,
    2525                       const psVector *y,
    … …  
    3030bool psImageMapFit1DinY(psImageMap *map,
    3131                        const psVector *mask,
    32                         psMaskType maskValue,
     32                        psVectorMaskType maskValue,
    3333                        const psVector *x,
    3434                        const psVector *y,
    … …  
    3939bool psImageMapFit1DinX(psImageMap *map,
    4040                        const psVector *mask,
    41                         psMaskType maskValue,
     41                        psVectorMaskType maskValue,
    4242                        const psVector *x,
    4343                        const psVector *y,

  • branches/eam_branch_20081230/psLib/src/imageops/psImageMaskOps.c

    r21072 r21074  
    88 *  @author David Robbins, MHPCC
    99 *
    10  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2008-07-12 21:08:33 $
     10 *  @version $Revision: 1.7.28.1 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2008-12-30 20:40:00 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3737                       psRegion region,
    3838                       const char *op,
    39                        psMaskType maskValue)
     39                       psImageMaskType maskValue)
    4040{
    4141    if (image == NULL) {
    … …  
    5353          if ((i + image->col0) < region.x0) continue; \
    5454          if ((i + image->col0) > region.x1) continue; /* is this correct (not >= ?) */ \
    55           image->data.PS_TYPE_MASK_DATA[j][i] OP maskValue; \
     55          image->data.PS_TYPE_IMAGE_MASK_DATA[j][i] OP maskValue; \
    5656        } \
    5757      }
    … …  
    8484                       psRegion region,
    8585                       const char *op,
    86                        psMaskType maskValue)
     86                       psImageMaskType maskValue)
    8787{
    8888    if (image == NULL) {
    … …  
    100100            (i + image->col0) < region.x0 || \
    101101            (i + image->col0) > region.x1 ) { \
    102           image->data.PS_TYPE_MASK_DATA[j][i] OP maskValue; \
     102          image->data.PS_TYPE_IMAGE_MASK_DATA[j][i] OP maskValue; \
    103103        } } }
    104104
    … …  
    131131                       double radius,
    132132                       const char *op,
    133                        psMaskType maskValue)
     133                       psImageMaskType maskValue)
    134134{
    135135    if (image == NULL) {
    … …  
    150150            r2 = PS_SQR(dx) + PS_SQR(dy); \
    151151            if (r2 <= R2) { \
    152               image->data.PS_TYPE_MASK_DATA[iy][ix] OP maskValue; \
     152              image->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] OP maskValue; \
    153153            } } }
    154154
    … …  
    182182                       double radius,
    183183                       const char *op,
    184                        psMaskType maskValue)
     184                       psImageMaskType maskValue)
    185185{
    186186
    … …  
    201201            r2 = PS_SQR(dx) + PS_SQR(dy); \
    202202            if (r2 > R2) { \
    203               image->data.PS_TYPE_MASK_DATA[iy][ix] OP maskValue; \
     203              image->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] OP maskValue; \
    204204            } } }
    205205
    … …  
    228228psImage *psImageGrowMask(psImage *out,
    229229                         const psImage *in,
    230                          psMaskType maskVal,
     230                         psImageMaskType maskVal,
    231231                         unsigned int growSize,
    232                          psMaskType growVal)
     232                         psImageMaskType growVal)
    233233{
    234234    if (in == NULL) {
    … …  
    237237        return NULL;
    238238    }
    239     if (in->type.type != PS_TYPE_MASK) {
     239    if (in->type.type != PS_TYPE_IMAGE_MASK) {
    240240        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    241                 "Invalid input image.  Input image type must match psMaskType.\n");
     241                "Invalid input image.  Input image type must match psImageMaskType.\n");
    242242        return NULL;
    243243    }
    … …  
    261261    for (k = 0; k < in->numRows; k++) {
    262262        for (l = 0; l < in->numCols; l++) {
    263             out->data.PS_TYPE_MASK_DATA[k][l] = in->data.PS_TYPE_MASK_DATA[k][l];
    264             changed->data.PS_TYPE_MASK_DATA[k][l] = 0;
     263            out->data.PS_TYPE_IMAGE_MASK_DATA[k][l] = in->data.PS_TYPE_IMAGE_MASK_DATA[k][l];
     264            changed->data.PS_TYPE_IMAGE_MASK_DATA[k][l] = 0;
    265265        }
    266266    }
    … …  
    268268    for (int i = 0; i < in->numRows; i++) {
    269269        for (int j = 0; j < in->numCols; j++) {
    270             if ( (in->data.PS_TYPE_MASK_DATA[i][j] & maskVal) != 0 &&
    271                     changed->data.PS_TYPE_MASK_DATA[i][j] == 0) {
     270            if ( (in->data.PS_TYPE_IMAGE_MASK_DATA[i][j] & maskVal) != 0 &&
     271                    changed->data.PS_TYPE_IMAGE_MASK_DATA[i][j] == 0) {
    272272                m = i - growSize;
    273273                if (m < 0) {
    … …  
    281281                    for (l = n; l <= (j + growSize) && l < in->numCols; l++) {
    282282                        if (((k-i)*(k-i) + (l-j)*(l-j)) <= (growSize*growSize)) {
    283                             out->data.PS_TYPE_MASK_DATA[k][l] |= growVal;
    284                             if ( (in->data.PS_TYPE_MASK_DATA[i][j] & maskVal) == 0 ) {
    285                                 changed->data.PS_TYPE_MASK_DATA[k][l] = 1;
     283                            out->data.PS_TYPE_IMAGE_MASK_DATA[k][l] |= growVal;
     284                            if ( (in->data.PS_TYPE_IMAGE_MASK_DATA[i][j] & maskVal) == 0 ) {
     285                                changed->data.PS_TYPE_IMAGE_MASK_DATA[k][l] = 1;
    286286                            }
    287287                        }

  • branches/eam_branch_20081230/psLib/src/imageops/psImageMaskOps.h

    r11248 r21074  
    66 * @author David Robbins, MHPCC
    77 *
    8  * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2007-01-23 22:47:23 $
     8 * @version $Revision: 1.2.52.1 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2008-12-30 20:40:00 $
    1010 *
    1111 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3232    psRegion region,                   ///< the specified region
    3333    const char *op,                    ///< the logical operation
    34     psMaskType maskValue               ///< the specified bits
     34    psImageMaskType maskValue           ///< the specified bits
    3535);
    3636
    … …  
    4444    psRegion region,                   ///< the specified region
    4545    const char *op,                    ///< the logical operation
    46     psMaskType maskValue               ///< the specified bits
     46    psImageMaskType maskValue           ///< the specified bits
    4747);
    4848
    … …  
    5858    double radius,                     ///< the radius of the specified circle
    5959    const char *op,                    ///< the logical operation
    60     psMaskType maskValue               ///< the specified bits
     60    psImageMaskType maskValue           ///< the specified bits
    6161);
    6262
    … …  
    7272    double radius,                     ///< the radius of the specified circle
    7373    const char *op,                    ///< the logical operation
    74     psMaskType maskValue               ///< the specified bits
     74    psImageMaskType maskValue           ///< the specified bits
    7575);
    7676
    … …  
    8989    psImage *out,                      ///< the image to set and return
    9090    const psImage *in,                 ///< the input to image
    91     psMaskType maskVal,                ///< the specified mask value
     91    psImageMaskType maskVal,            ///< the specified mask value
    9292    unsigned int growSize,             ///< the range of values from maskVal
    93     psMaskType growVal                 ///< the output value to set
     93    psImageMaskType growVal             ///< the output value to set
    9494);
    9595

  • branches/eam_branch_20081230/psLib/src/imageops/psImagePixelExtract.c

    r20306 r21074  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2008-10-22 02:10:37 $
     10 *  @version $Revision: 1.33.8.1 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2008-12-30 20:40:00 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    206206                       const psImage* input,
    207207                       const psImage* mask,
    208                        psMaskType maskVal,
     208                       psImageMaskType maskVal,
    209209                       psRegion region,
    210210                       psImageCutDirection direction,
    … …  
    357357            return NULL;
    358358        }
    359         if (mask->type.type != PS_TYPE_MASK) {
     359        if (mask->type.type != PS_TYPE_IMAGE_MASK) {
    360360            char* typeStr;
    361361            PS_TYPE_NAME(typeStr,mask->type.type);
    362362            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    363363                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    364                     typeStr, PS_TYPE_MASK_NAME);
     364                    typeStr, PS_TYPE_IMAGE_MASK_NAME);
    365365            psFree(out);
    366366            return NULL;
    … …  
    394394        psVector* imgVec = psVectorAlloc(numRows, type);
    395395        psVector* maskVec = NULL;
    396         psMaskType* maskData = NULL;
     396        psImageMaskType* maskData = NULL;
    397397        psPixelCoord* outPosition = NULL;
    398398
    … …  
    416416
    417417        if (mask != NULL) {
    418             maskVec = psVectorAlloc(numRows, mask->type.type);
    419         }
    420         #define PSIMAGE_CUT_VERTICAL(TYPE) \
     418            maskVec = psVectorAlloc(numRows, PS_TYPE_VECTOR_MASK);
     419        }
     420
     421#define PSIMAGE_CUT_VERTICAL(TYPE) \
    421422    case PS_TYPE_##TYPE: { \
    422             psMaskType* maskVecData = NULL; \
    423             for (psS32 c=col0;c<col1;c++) { \
     423            psVectorMaskType* maskVecData = NULL; \
     424            for (psS32 c = col0; c < col1; c++) { \
    424425                ps##TYPE *imgData = input->data.TYPE[row0] + c; \
    425426                ps##TYPE *imgVecData = imgVec->data.TYPE; \
    426427                if (maskVec != NULL) { \
    427                     maskVecData = maskVec->data.U8; \
    428                     maskData = (psMaskType* )(mask->data.U8[row0]) + c; \
     428                    maskVecData = maskVec->data.PS_TYPE_VECTOR_MASK_DATA; \
     429                    maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[row0][c]; /* XXX double check this... */ \
     430                    /** old entry: maskData = (psMaskType* )(mask->data.PS_TYPE_IMAGE_MASK_DATA[row0]) + c; */ \
    429431                } \
    430                 for (psS32 r=row0;r<row1;r++) { \
    431                     *(imgVecData++) = *imgData; \
     432                for (psS32 r = row0; r < row1; r++) { \
     433                   *imgVecData = *imgData; \
     434                    imgVecData ++; \
    432435                    imgData += inCols; \
    433436                    if (maskVecData != NULL) { \
    434                         *(maskVecData++) = *maskData; \
     437                        *maskVecData = (*maskData & maskVal); \
     438                        maskVecData ++; \
    435439                        maskData += inCols; \
    436440                    } \
    437441                } \
    438                 psVectorStats(myStats,imgVec,NULL,maskVec,maskVal); \
     442                psVectorStats(myStats, imgVec, NULL, maskVec, 0xff); \
    439443                *outData = psStatsGetValue(myStats, statistic); \
    440444                if (outPosition != NULL) { \
    … …  
    471475        psFree(imgVec);
    472476        psFree(maskVec);
     477
    473478    } else if (direction == PS_CUT_Y_POS || direction == PS_CUT_Y_NEG) {
    474479        // Cut in Y direction
     480        // XXX use this if we drop the hackish stuff below: psVector* imgVec = psVectorAlloc(numCols, type);
    475481        psVector* imgVec = NULL;
    476482        psVector* maskVec = NULL;
    … …  
    479485
    480486        // fill in psVector to fake out the statistics functions.
     487        // XXX EAM : this seems rather hackish: just use the needed psVectorAlloc (like above)?
    481488        imgVec = psAlloc(sizeof(psVector));
    482489        imgVec->type = input->type;
    483490        P_PSVECTOR_SET_NALLOC(imgVec,numCols);
    484         if (mask != NULL) {
    485             maskVec = psAlloc(sizeof(psVector));
    486             maskVec->type = mask->type;
    487             P_PSVECTOR_SET_NALLOC(maskVec,numCols);
    488         }
     491        imgVec->n = imgVec->nalloc;
     492
    489493        // recycle output to make a proper sized/type output structure
    490494        // n.b. type is double as that is the type given for all stats in
    … …  
    492496        out = psVectorRecycle(out, numRows, PS_TYPE_F64);
    493497        out->n = numRows;
    494         imgVec->n = imgVec->nalloc;
    495         maskVec->n = maskVec->nalloc;
    496498        if (coords != NULL) {
    497499            coords = psPixelsRealloc(coords, numRows);
    … …  
    507509        }
    508510
     511        if (mask != NULL) {
     512            maskVec = psVectorAlloc(numRows, PS_TYPE_VECTOR_MASK);
     513            // XXX the old code (below) faked out the mask vector
     514            // maskVec = psAlloc(sizeof(psVector));
     515            // maskVec->type = mask->type;
     516            // P_PSVECTOR_SET_NALLOC(maskVec,numCols);
     517            // maskVec->n = maskVec->nalloc;
     518        }
     519
    509520        for (psS32 r = row0; r < row1; r++) {
    510521            // point the vector struct to the
    511522            // data to calculate the stats
    512523            imgVec->data.U8 = (psPtr )(input->data.U8[r] + col0 * elementSize);
     524
     525            // set the vector mask pixels based on the image pixels
    513526            if (maskVec != NULL) {
    514                 maskVec->data.U8 = (psPtr )(mask->data.U8[r] + col0 * sizeof(psMaskType));
    515             }
    516             psVectorStats(myStats, imgVec, NULL, maskVec, maskVal);
     527                psVectorMaskType *maskVecData = maskVec->data.PS_TYPE_VECTOR_MASK_DATA;
     528                psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[r][col0];
     529                for (psS32 c = col0; c < col1; c++) {
     530                    *maskVecData = (*maskData & maskVal);
     531                    maskVecData ++;
     532                    maskData ++;
     533                }
     534            }
     535
     536            psVectorStats(myStats, imgVec, NULL, maskVec, 0xff);
    517537            *outData = psStatsGetValue(myStats, statistic);
    518538            if (outPosition != NULL) {
    … …  
    544564                     const psImage* input,
    545565                     const psImage* mask,
    546                      psMaskType maskVal,
     566                     psImageMaskType maskVal,
    547567                     psRegion region,
    548568                     unsigned int nSamples,
    … …  
    651671            return NULL;
    652672        }
    653         if (mask->type.type != PS_TYPE_MASK) {
     673        if (mask->type.type != PS_TYPE_IMAGE_MASK) {
    654674            char* typeStr;
    655675            PS_TYPE_NAME(typeStr,mask->type.type);
    656676            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    657677                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    658                     typeStr, PS_TYPE_MASK_NAME);
     678                    typeStr, PS_TYPE_IMAGE_MASK_NAME);
    659679            psFree(out);
    660680            return NULL;
    … …  
    739759                           const psImage* input,
    740760                           const psImage* mask,
    741                            psMaskType maskVal,
     761                           psImageMaskType maskVal,
    742762                           float x,
    743763                           float y,
    … …  
    765785            return NULL;
    766786        }
    767         if (mask->type.type != PS_TYPE_MASK) {
     787        if (mask->type.type != PS_TYPE_IMAGE_MASK) {
    768788            char* typeStr;
    769789            PS_TYPE_NAME(typeStr,mask->type.type);
    770790            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    771791                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    772                     typeStr, PS_TYPE_MASK_NAME);
     792                    typeStr, PS_TYPE_IMAGE_MASK_NAME);
    773793            psFree(out);
    774794            return NULL;
    … …  
    868888        if (mask != NULL) {
    869889            bufferMask[lcv] = psVectorAllocEmpty(1+4*(rSq[lcv+1]-rSq[lcv]),
    870                                                  PS_TYPE_MASK);
     890                                                 PS_TYPE_VECTOR_MASK);
    871891        }
    872892    }
    … …  
    877897    for (psS32 row=startRow; row <= endRow; row++) {
    878898        psF32* inRow = input->data.F32[row];
    879         psMaskType* maskRow = NULL;
     899        psImageMaskType* maskRow = NULL;
    880900        if (mask != NULL) {
    881             maskRow = mask->data.PS_TYPE_MASK_DATA[row];
     901            maskRow = mask->data.PS_TYPE_IMAGE_MASK_DATA[row];
    882902        }
    883903        for (psS32 col=startCol; col <= endCol; col++) {
    … …  
    899919
    900920                    if (maskRow != NULL) {
    901                         bufferMask[r]->data.PS_TYPE_MASK_DATA[n] = maskRow[col];
     921                        bufferMask[r]->data.PS_TYPE_VECTOR_MASK_DATA[n] = (maskRow[col] & maskVal);
    902922                        bufferMask[r]->n = n+1;
    903923                    }
    … …  
    913933
    914934    for (psS32 r = 0; r < numOut; r++) {
    915         psVectorStats(myStats,buffer[r], NULL, bufferMask[r],maskVal);
     935        psVectorStats(myStats, buffer[r], NULL, bufferMask[r], 0xff);
    916936        outData[r] = psStatsGetValue(myStats, statistic);
    917937    }

  • branches/eam_branch_20081230/psLib/src/imageops/psImagePixelExtract.h

    r11248 r21074  
    55 * @author Robert DeSonia, MHPCC
    66 *
    7  * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2007-01-23 22:47:23 $
     7 * @version $Revision: 1.10.52.1 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2008-12-30 20:40:00 $
    99 *
    1010 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    8484    const psImage* input,              ///< the input image in which to perform the slice
    8585    const psImage* mask,               ///< the mask for the input image.
    86     psMaskType maskVal,                ///< the mask value to apply to the mask
     86    psImageMaskType maskVal,            ///< the mask value to apply to the mask
    8787    psRegion region,                   ///< the slice region
    8888    psImageCutDirection direction,     ///< the slice dimension and direction
    … …  
    112112    const psImage* input,              ///< the input image in which to perform the cut
    113113    const psImage* mask,               ///< the mask for the input image.
    114     psMaskType maskVal,                ///< the mask value to apply to the mask
     114    psImageMaskType maskVal,            ///< the mask value to apply to the mask
    115115    psRegion region,                   ///< the start and end points to cut along
    116116    unsigned int nSamples,             ///< the number of samples along the cut
    … …  
    135135    const psImage* input,              ///< the input image in which to perform the cut
    136136    const psImage* mask,               ///< the mask for the input image.
    137     psMaskType maskVal,                ///< the mask value to apply to the mask
     137    psImageMaskType maskVal,            ///< the mask value to apply to the mask
    138138    float x,                           ///< the column of the center of the cut circle
    139139    float y,                           ///< the row of the center of the cut circle

  • branches/eam_branch_20081230/psLib/src/imageops/psImagePixelInterpolate.c

    r15254 r21074  
    1111 *  @author Eugene Magnier, IfA
    1212 *
    13  *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2007-10-09 19:25:44 $
     13 *  @version $Revision: 1.3.38.1 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2008-12-30 20:40:00 $
    1515 *
    1616 *  Copyright 2007 Institute for Astronomy, University of Hawaii
    … …  
    5454                    /* do not test self */ \
    5555                    if (!jx && !jy) { continue; } \
    56                     if (mask->data.PS_TYPE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; } \
     56                    if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; } \
    5757                    nGood ++; \
    5858                } \
    … …  
    6767// just the mask, the output image contains enum values which define the type of interpolation which
    6868// can be performed
    69 psImage *psImagePixelInterpolateState (int *nBad, int *nPoor, psImage *mask, psMaskType maskVal) {
     69psImage *psImagePixelInterpolateState (int *nBad, int *nPoor, psImage *mask, psImageMaskType maskVal) {
    7070
    7171    psImage *result = psImageAlloc (mask->numCols, mask->numRows, PS_TYPE_S32);
    … …  
    7979
    8080            // state of the good pixels (unmasked)
    81             if (!(mask->data.PS_TYPE_MASK_DATA[iy][ix] & maskVal)) {
     81            if (!(mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] & maskVal)) {
    8282                // count good neighbor pixels (+ self)
    8383                int nGood = 0;
    … …  
    9494                        if (jx + ix < 0) { continue; }
    9595                        if (jx + ix >= mask->numCols) { continue; }
    96                         if (mask->data.PS_TYPE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
     96                        if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
    9797                        nGood ++;
    9898                        minX = PS_MIN (minX, jx);
    … …  
    137137
    138138// interpolate the poor pixels using the available options
    139 bool psImagePixelInterpolatePoor (psImage *image, psImage *state, psImage *mask, psMaskType maskVal) {
     139bool psImagePixelInterpolatePoor (psImage *image, psImage *state, psImage *mask, psImageMaskType maskVal) {
    140140
    141141    assert (image->numCols == state->numCols);
    … …  
    185185                          if (!jx && !jy) { continue; }
    186186                          // skip masked pixels
    187                           if (mask->data.PS_TYPE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
     187                          if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
    188188                          x->data.F32[n] = jx;
    189189                          y->data.F32[n] = jy;
    … …  
    241241   
    242242// interpolate the good pixels to their true centers
    243 bool psImagePixelInterpolateCenter (psImage *value, psImage *xCoord, psImage *yCoord, psImage *state, psImage *mask, psMaskType maskVal) {
     243bool psImagePixelInterpolateCenter (psImage *value, psImage *xCoord, psImage *yCoord, psImage *state, psImage *mask, psImageMaskType maskVal) {
    244244
    245245    assert (value->numCols == state->numCols);
    … …  
    299299                          if (jx + ix >= value->numCols) { continue; }
    300300                          // skip masked pixels
    301                           if (mask->data.PS_TYPE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
     301                          if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
    302302                          x->data.F32[n] = xCoord->data.F32[iy+jy][ix+jx];
    303303                          y->data.F32[n] = yCoord->data.F32[iy+jy][ix+jx];
    … …  
    331331                          if (jx + ix >= value->numCols) { continue; }
    332332                          // skip masked pixels
    333                           if (mask->data.PS_TYPE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
     333                          if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+jy][ix+jx] & maskVal) { continue; }
    334334                          x->data.F32[n] = xCoord->data.F32[iy+jy][ix+jx];
    335335                          y->data.F32[n] = yCoord->data.F32[iy+jy][ix+jx];
    … …  
    363363    for (int iy = 0; iy < value->numRows; iy++) {
    364364        for (int ix = 0; ix < value->numCols; ix++) {
    365           if (mask->data.PS_TYPE_MASK_DATA[iy][ix] & maskVal) { continue; }
     365          if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] & maskVal) { continue; }
    366366          value->data.F32[iy][ix] = output->data.F32[iy][ix];
    367367        }

  • branches/eam_branch_20081230/psLib/src/imageops/psImagePixelInterpolate.h

    r14924 r21074  
    77 *  @author Eugene Magnier, IfA
    88 *
    9  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2007-09-20 23:54:25 $
     9 *  @version $Revision: 1.2.40.1 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-12-30 20:40:00 $
    1111 *
    1212 *  Copyright 2007 Institute for Astronomy, University of Hawaii
    … …  
    3434} psImagePixelInterpolateType;
    3535
    36 psImage *psImagePixelInterpolateState (int *nBad, int *nPoor, psImage *mask, psMaskType maskVal);
    37 bool psImagePixelInterpolatePoor (psImage *image, psImage *state, psImage *mask, psMaskType maskVal);
    38 bool psImagePixelInterpolateCenter (psImage *value, psImage *xCoord, psImage *yCoord, psImage *state, psImage *mask, psMaskType maskVal);
     36psImage *psImagePixelInterpolateState (int *nBad, int *nPoor, psImage *mask, psImageMaskType maskVal);
     37bool psImagePixelInterpolatePoor (psImage *image, psImage *state, psImage *mask, psImageMaskType maskVal);
     38bool psImagePixelInterpolateCenter (psImage *value, psImage *xCoord, psImage *yCoord, psImage *state, psImage *mask, psImageMaskType maskVal);
    3939
    4040/// @}

  • branches/eam_branch_20081230/psLib/src/imageops/psImageStats.c

    r12431 r21074  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.106 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2007-03-14 00:39:50 $
     11 *  @version $Revision: 1.106.48.1 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2008-12-30 20:40:00 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5353                      const psImage* in,
    5454                      const psImage* mask,
    55                       psMaskType maskVal)
     55                      psImageMaskType maskVal)
    5656{
    5757    psVector *junkData = NULL;
    … …  
    6262    PS_ASSERT_IMAGE_NON_NULL(in, false)
    6363    if (mask != NULL) {
    64         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, false);
     64        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
    6565        PS_ASSERT_IMAGES_SIZE_EQUAL(in, mask, false);
    6666    }
     67
     68    if (in->parent == NULL) {
     69        // stuff the image data into a psVector struct.
     70        // XXX this is a bit hackish: does it save much time? (avoids a Nx*Ny alloc)
     71        junkData = (psVector *) psAlloc(sizeof(psVector));
     72        junkData->type = in->type;
     73        P_PSVECTOR_SET_NALLOC(junkData,in->numRows * in->numCols);
     74        junkData->n = junkData->nalloc;
     75        junkData->data.U8 = in->data.V[0];      // since psImage data is contiguous...
     76    } else {
     77        // image not necessarily contiguous
     78        int numRows = in->numRows;
     79        int numCols = in->numCols;
     80        int rowSize = numCols * (PSELEMTYPE_SIZEOF(in->type.type));
     81
     82        junkData = psVectorAlloc(numRows*numCols, in->type.type);
     83
     84        psU8* data = junkData->data.U8;
     85        for (int row = 0; row < numRows; row++) {
     86            memcpy(data, in->data.V[row], rowSize);
     87            data += rowSize;
     88        }
     89    }
     90
     91    if (mask != NULL) {
     92        // image not necessarily contiguous, generate a temp vector to hold the full image
     93        int numRows = mask->numRows;
     94        int numCols = mask->numCols;
     95
     96        junkMask = psVectorAlloc(numRows*numCols, PS_TYPE_VECTOR_MASK);
     97
     98        psVectorMaskType *data = junkMask->data.PS_TYPE_VECTOR_MASK_DATA;
     99        for (int row = 0, nVect = 0; row < numRows; row++) {
     100            for (int col = 0; col < numCols; col++, nVect++) {
     101                data[nVect] = (mask->data.PS_TYPE_IMAGE_MASK_DATA[row][col] & maskVal);
     102            }
     103        }
     104    }
     105
     106    psVectorStats(stats, junkData, NULL, junkMask, 0xff);
     107
     108    psFree(junkMask);
     109    psFree(junkData);
     110    return true;
     111}
     112
     113/*****************************************************************************
     114NOTE: We assume that the psHistogram structure out has already been allocated
     115and initialized.
     116 *****************************************************************************/
     117bool psImageHistogram(psHistogram* out,
     118                              const psImage* in,
     119                              const psImage* mask,
     120                              psImageMaskType maskVal)
     121{
     122    PS_ASSERT_PTR_NON_NULL(out, false);
     123    PS_ASSERT_PTR_NON_NULL(in, false);
     124    if (mask != NULL) {
     125        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, false);
     126        PS_ASSERT_IMAGES_SIZE_EQUAL(in, mask, false);
     127    }
     128    psVector* junkData = NULL;
     129    psVector* junkMask = NULL;
    67130
    68131    if (in->parent == NULL) {
    … …  
    89152
    90153    if (mask != NULL) {
    91         if (mask->parent == NULL) {
    92             // stuff the mask data into a psVector struct.
    93             junkMask = psAlloc(sizeof(psVector));
    94             junkMask->type = mask->type;
    95             P_PSVECTOR_SET_NALLOC(junkMask,mask->numRows * mask->numCols);
    96             junkMask->n = junkMask->nalloc;
    97             junkMask->data.U8 = mask->data.V[0];
    98         } else {
    99             // image not necessarily contiguous
    100             int numRows = mask->numRows;
    101             int numCols = mask->numCols;
    102             int rowSize = numCols * (PSELEMTYPE_SIZEOF(mask->type.type));
    103 
    104             junkMask = psVectorAlloc(numRows*numCols, mask->type.type);
    105 
    106             psU8* data = junkMask->data.U8;
    107             for (int row = 0; row < numRows; row++) {
    108                 memcpy(data, mask->data.V[row], rowSize);
    109                 data += rowSize;
    110             }
    111         }
    112     }
    113 
    114     psVectorStats(stats, junkData, NULL, junkMask, maskVal);
    115 
    116     psFree(junkMask);
    117     psFree(junkData);
    118     return true;
    119 }
    120 
    121 /*****************************************************************************
    122 NOTE: We assume that the psHistogram structure out has already been allocated
    123 and initialized.
    124  *****************************************************************************/
    125 bool psImageHistogram(psHistogram* out,
    126                               const psImage* in,
    127                               const psImage* mask,
    128                               psMaskType maskVal)
    129 {
    130     PS_ASSERT_PTR_NON_NULL(out, false);
    131     PS_ASSERT_PTR_NON_NULL(in, false);
    132     if (mask != NULL) {
    133         PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, false);
    134         PS_ASSERT_IMAGES_SIZE_EQUAL(in, mask, false);
    135     }
    136     psVector* junkData = NULL;
    137     psVector* junkMask = NULL;
    138 
    139     if (in->parent == NULL) {
    140         // stuff the image data into a psVector struct.
    141         junkData = (psVector *) psAlloc(sizeof(psVector));
    142         junkData->type = in->type;
    143         P_PSVECTOR_SET_NALLOC(junkData,in->numRows * in->numCols);
    144         junkData->n = junkData->nalloc;
    145         junkData->data.U8 = in->data.V[0];      // since psImage data is contiguous...
    146     } else {
    147         // image not necessarily contiguous
    148         int numRows = in->numRows;
    149         int numCols = in->numCols;
    150         int rowSize = numCols * (PSELEMTYPE_SIZEOF(in->type.type));
    151 
    152         junkData = psVectorAlloc(numRows*numCols, in->type.type);
    153 
    154         psU8* data = junkData->data.U8;
    155         for (int row = 0; row < numRows; row++) {
    156             memcpy(data, in->data.V[row], rowSize);
    157             data += rowSize;
    158         }
    159     }
    160 
    161     if (mask != NULL) {
    162         if (mask->parent == NULL) {
    163             // stuff the mask data into a psVector struct.
    164             junkMask = psAlloc(sizeof(psVector));
    165             junkMask->type = mask->type;
    166             P_PSVECTOR_SET_NALLOC(junkMask,mask->numRows * mask->numCols);
    167             junkMask->n = junkMask->nalloc;
    168             junkMask->data.U8 = mask->data.V[0];
    169         } else {
    170             // image not necessarily contiguous
    171             int numRows = mask->numRows;
    172             int numCols = mask->numCols;
    173             int rowSize = numCols * (PSELEMTYPE_SIZEOF(mask->type.type));
    174 
    175             junkMask = psVectorAlloc(numRows*numCols, mask->type.type);
    176 
    177             psU8* data = junkMask->data.U8;
    178             for (int row = 0; row < numRows; row++) {
    179                 memcpy(data, mask->data.V[row], rowSize);
    180                 data += rowSize;
    181             }
    182         }
     154        // image not necessarily contiguous; vector & image mask types do not match
     155        int numRows = mask->numRows;
     156        int numCols = mask->numCols;
     157
     158        junkMask = psVectorAlloc(numRows*numCols, PS_TYPE_VECTOR_MASK);
     159
     160        psVectorMaskType *data = junkMask->data.PS_TYPE_VECTOR_MASK_DATA;
     161        for (int row = 0, nVect = 0; row < numRows; row++) {
     162            for (int col = 0; col < numCols; col++, nVect++) {
     163                data[nVect] = (mask->data.PS_TYPE_IMAGE_MASK_DATA[row][col] & maskVal);
     164            }
     165        }
    183166    }
    184167
    … …  
    472455long psImageCountPixelMask (psImage *mask,
    473456                            psRegion region,
    474                             psMaskType value)
     457                            psImageMaskType value)
    475458{
    476459    long Npixels = 0;
    … …  
    479462    int x1 = 0;
    480463    int y1 = 0;
    481     psElemType type;
    482464
    483465    // this is not a valid error: a psRegion with ranges outside the valid pixels
    … …  
    608590    y1 = row1;
    609591
    610     type = mask->type.type;
    611     if (type != PS_TYPE_MASK) {
    612         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    613                 "psImage type does not match the specified psMaskType!\n");
    614         return -1;
    615     }
    616 
     592# define PS_IMAGE_COUNT_PIXEL_MASK(NAME,TYPE) \
     593    case PS_TYPE_##NAME: \
     594        for (long j = y0; j < y1; j++) { \
     595            for (long i = x0; i < x1; i++) { \
     596                if (mask->data.TYPE[j][i] & value) { \
     597                    Npixels ++; \
     598                } \
     599            } \
     600        } \
     601        break;
     602
     603    psElemType type = mask->type.type;
    617604    switch (type) {
    618     case PS_TYPE_U8:
    619     case PS_TYPE_U16:
    620         for (long j = y0; j < y1; j++) {
    621             for (long i = x0; i < x1; i++) {
    622                 if (mask->data.PS_TYPE_MASK_DATA[j][i] & value) {
    623                     Npixels ++;
    624                 }
    625             }
    626         }
    627         break;
    628     case PS_TYPE_S8:
    629     case PS_TYPE_S16:
    630     case PS_TYPE_S32:
    631     case PS_TYPE_S64:
    632     case PS_TYPE_U32:
    633     case PS_TYPE_U64:
    634     case PS_TYPE_F32:
    635     case PS_TYPE_F64:
     605        PS_IMAGE_COUNT_PIXEL_MASK(U8, U8);
     606        PS_IMAGE_COUNT_PIXEL_MASK(U16,U16);
     607        PS_IMAGE_COUNT_PIXEL_MASK(U32,U32);
     608        PS_IMAGE_COUNT_PIXEL_MASK(U64,U64);
     609        PS_IMAGE_COUNT_PIXEL_MASK(S8, S8);
     610        PS_IMAGE_COUNT_PIXEL_MASK(S16,S16);
     611        PS_IMAGE_COUNT_PIXEL_MASK(S32,S32);
     612        PS_IMAGE_COUNT_PIXEL_MASK(S64,S64);
     613
    636614    default:
    637615        // XXX this should include the mask type (as a string)
    638616        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    639                 _("Input psImage mask type is not a supported mask datatype"));
     617                _("Input psImage is an unsupported datatype"));
    640618
    641619        return -1;

  • branches/eam_branch_20081230/psLib/src/imageops/psImageStats.h

    r11759 r21074  
    99 * @author GLG, MHPCC
    1010 *
    11  * @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
    12  * @date $Date: 2007-02-13 03:01:23 $
     11 * @version $Revision: 1.31.50.1 $ $Name: not supported by cvs2svn $
     12 * @date $Date: 2008-12-30 20:40:00 $
    1313 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1414 */
    … …  
    4242    const psImage* in,                 ///< image (or subimage) to calculate stats
    4343    const psImage* mask,               ///< mask data for image (NULL ok)
    44     psMaskType maskVal                 ///< mask value for mask
     44    psImageMaskType maskVal             ///< mask value for mask
    4545);
    4646
    … …  
    5757    const psImage* in,                 ///< Image data to be histogramed.
    5858    const psImage* mask,               ///< mask data for image (NULL ok)
    59     psMaskType maskVal                 ///< mask Mask for mask
     59    psImageMaskType maskVal             ///< mask Mask for mask
    6060);
    6161
    … …  
    9797    psImage *mask,                     ///< input image to count
    9898    psRegion region,                   ///< input region of image
    99     psMaskType value                   ///< the mask value to satisfy
     99    psImageMaskType value               ///< the mask value to satisfy
    100100);
    101101

  • branches/eam_branch_20081230/psLib/src/math/psClip.c

    r11756 r21074  
    2222
    2323psClipParams *psClipParamsAlloc(psStatsOptions meanStat, psStatsOptions stdevStat,
    24                                 psMaskType masked, psMaskType clipped)
     24                                psVectorMaskType masked, psVectorMaskType clipped)
    2525{
    2626    psClipParams *params = psAlloc(sizeof(psClipParams)); // Clip parameters
    … …  
    4848    PS_ASSERT_VECTOR_NON_NULL(values, -1);
    4949    PS_ASSERT_VECTOR_NON_NULL(mask, -1);
    50     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_MASK, -1);
     50    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, -1);
    5151    PS_ASSERT_PTR(params, -1);
    5252    PS_ASSERT_VECTORS_SIZE_EQUAL(values, mask, -1);
    … …  
    6262    }
    6363
    64     psMaskType masked = params->masked; // Indicates masked values
    65     psMaskType clipped = params->clipped; // Indicates clipped values
     64    psVectorMaskType masked = params->masked; // Indicates masked values
     65    psVectorMaskType clipped = params->clipped; // Indicates clipped values
    6666    masked |= clipped;                  // Make sure we're also masking clipped values
    67     psMaskType *maskData = mask->data.PS_TYPE_MASK_DATA; // Dereference mask
     67    psVectorMaskType *maskData = mask->data.PS_TYPE_VECTOR_MASK_DATA; // Dereference mask
    6868    long totalMasked = 0;               // Total number of pixels masked
    6969
    … …  
    120120    PS_ASSERT_VECTOR_NON_NULL(values, -1);
    121121    PS_ASSERT_VECTOR_NON_NULL(mask, -1);
    122     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_MASK, -1);
     122    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, -1);
    123123    PS_ASSERT_PTR(params, -1);
    124124    PS_ASSERT_VECTORS_SIZE_EQUAL(values, mask, -1);
    … …  
    141141    }
    142142
    143     psMaskType masked = params->masked; // Indicates masked values
    144     psMaskType clipped = params->clipped; // Indicates clipped values
     143    psVectorMaskType masked = params->masked; // Indicates masked values
     144    psVectorMaskType clipped = params->clipped; // Indicates clipped values
    145145    masked |= clipped;                  // Make sure we're also masking clipped values
    146146
    … …  
    158158case PS_TYPE_##TYPE: { \
    159159        ps##TYPE *valuesData = values->data.TYPE; /* Dereference for speed */ \
    160         psMaskType *maskData = mask->data.PS_TYPE_MASK_DATA; /* Dereference mask for speed */ \
     160        psVectorMaskType *maskData = mask->data.PS_TYPE_VECTOR_MASK_DATA; /* Dereference mask for speed */ \
    161161        if (errors) { \
    162162            ps##TYPE *errorsData = errors->data.TYPE; \

  • branches/eam_branch_20081230/psLib/src/math/psClip.h

    r14452 r21074  
    44 * @author Paul Price, IfA.
    55 *
    6  * $Revision: 1.5 $ $Name: not supported by cvs2svn $
    7  * $Date: 2007-08-09 01:40:07 $
     6 * $Revision: 1.5.42.1 $ $Name: not supported by cvs2svn $
     7 * $Date: 2008-12-30 20:40:00 $
    88 * Copyright 2007 Institute for Astronomy, University of Hawaii
    99 */
    … …  
    2525    int iter;                           ///< Number of rejection iterations; unused by psClip functions
    2626    float rej;                          ///< Rejection limit (standard deviations)
    27     psMaskType masked;                  ///< Mask value for entries already masked
    28     psMaskType clipped;                 ///< Mask value to give to clipped entries
     27    psVectorMaskType masked;                  ///< Mask value for entries already masked
     28    psVectorMaskType clipped;                 ///< Mask value to give to clipped entries
    2929    double mean;                        ///< Resultant mean
    3030    double stdev;                       ///< Resultant stdev
    … …  
    3535psClipParams *psClipParamsAlloc(psStatsOptions meanStat, ///< Stats option to use for mean
    3636                                psStatsOptions stdevStat, ///< Stats option to use for standard deviation
    37                                 psMaskType masked, ///< Mask value for entries already masked
    38                                 psMaskType clipped ///< Mask value to give to clipped entries
     37                                psVectorMaskType masked, ///< Mask value for entries already masked
     38                                psVectorMaskType clipped ///< Mask value to give to clipped entries
    3939    ) PS_ATTR_MALLOC;
    4040

  • branches/eam_branch_20081230/psLib/src/math/psHistogram.c

    r17565 r21074  
    55 *  @author GLG (MHPCC), EAM (IfA)
    66 *
    7  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2008-05-07 23:11:30 $
     7 *  @version $Revision: 1.8.30.1 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2008-12-30 20:40:00 $
    99 *
    1010 *  Copyright 2006 IfA, University of Hawaii
    … …  
    231231                               const psVector* errors,
    232232                               const psVector* mask,
    233                                psMaskType maskVal)
     233                               psVectorMaskType maskVal)
    234234{
    235235    psTrace("psLib.math", 3, "---- %s() begin  ----\n", __func__);
    … …  
    244244    if (mask) {
    245245        PS_ASSERT_VECTORS_SIZE_EQUAL(values, mask, false);
    246         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     246        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    247247    }
    248248    if (errors) {
    … …  
    274274    for (long i = 0; i < inF32->n; i++) {
    275275        // Check if this pixel is masked, and if so, skip it.
    276         if (!mask || (mask && (!(mask->data.U8[i] & maskVal)))) {
     276        if (!mask || (mask && (!(mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskVal)))) {
    277277            if (inF32->data.F32[i] < out->bounds->data.F32[0]) {
    278278                // If this pixel is below minimum value, count it, then skip.

  • branches/eam_branch_20081230/psLib/src/math/psHistogram.h

    r14452 r21074  
    77 * @author GLG, MHPCC
    88 *
    9  * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    10  * @date $Date: 2007-08-09 01:40:07 $
     9 * @version $Revision: 1.4.42.1 $ $Name: not supported by cvs2svn $
     10 * @date $Date: 2008-12-30 20:40:00 $
    1111 *
    1212 * Copyright 2004-2005 IfA, University of Hawaii
    … …  
    8888    const psVector* errors,            ///< Errors
    8989    const psVector* mask,              ///< Mask dat for input vector
    90     psMaskType maskVal                 ///< Mask value
    91 );
     90    psVectorMaskType maskVal            ///< Mask value
     91    );
    9292
    9393/// @}

  • branches/eam_branch_20081230/psLib/src/math/psMinimizeLMM.c

    r19845 r21074  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2008-10-02 20:49:22 $
     12 *  @version $Revision: 1.35.12.1 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2008-12-30 20:40:00 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7474    PS_ASSERT_VECTOR_TYPE(params,    PS_TYPE_F32,  false);
    7575    if (paramMask) {
    76         PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_MASK, false);
     76        PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    7777    }
    7878
    … …  
    113113    // set tmpBeta values which are not masked
    114114    for (int j = 0, n = 0; j < params->n; j++) {
    115         if (paramMask && (paramMask->data.U8[j])) continue;
     115        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
    116116        tmpBeta->data.F32[j] = Beta->data.F32[n];
    117117        n++;
    … …  
    120120    // apply Beta to get new Params values
    121121    for (int j = 0; j < params->n; j++) {
    122         if (paramMask && (paramMask->data.U8[j])) {
     122        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
    123123            Params->data.F32[j] = params->data.F32[j];
    124124            continue;
    … …  
    140140    // apply tmpBeta after limits have been checked
    141141    for (int j = 0, n = 0; j < params->n; j++) {
    142         if (paramMask && (paramMask->data.U8[j])) continue;
     142        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
    143143        Beta->data.F32[n] = tmpBeta->data.F32[j];
    144144        n++;
    … …  
    269269    PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, false);
    270270    if (paramMask) {
    271         PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_MASK, false);
     271        PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    272272    }
    273273
    … …  
    297297        // we track alpha,beta and params,deriv separately
    298298        for (int j = 0, J = 0; j < params->n; j++) {
    299             if (paramMask && (paramMask->data.U8[j])) continue;
     299            if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
    300300
    301301            weight = deriv->data.F32[j] * dy->data.F32[i];
    302302
    303303            for (int k = 0, K = 0; k <= j; k++) {
    304                 if (paramMask && (paramMask->data.U8[k])) continue;
     304                if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
    305305                alpha->data.F32[J][K] += weight * deriv->data.F32[k];
    306306                K++;
    … …  
    351351        paramMask = constraint->paramMask;
    352352        if (paramMask != NULL) {
    353             PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_U8, false);
     353            PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    354354            PS_ASSERT_VECTORS_SIZE_EQUAL(params, paramMask, false);
    355355        }
    … …  
    493493        psImageInit (covar, 0.0);
    494494        for (int j = 0, J = 0; j < params->n; j++) {
    495             if (paramMask && (paramMask->data.U8[j])) {
     495            if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
    496496                covar->data.F32[j][j] = 1.0;
    497497                continue;
    498498            }
    499499            for (int k = 0, K = 0; k < params->n; k++) {
    500                 if (paramMask && (paramMask->data.U8[k])) continue;
     500                if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
    501501                covar->data.F32[j][k] = Alpha->data.F32[J][K];
    502502                K++;
    … …  
    535535        nParams = 0;
    536536        for (int i = 0; i < paramMask->n; i++) {
    537             if (paramMask->data.U8[i]) continue;
     537            if (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
    538538            nParams ++;
    539539        }

  • branches/eam_branch_20081230/psLib/src/math/psMinimizeLMM_ND.c

    r17442 r21074  
    88 *  @author EAM, IfA
    99 *
    10  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2008-04-11 08:01:29 $
     10 *  @version $Revision: 1.1.32.1 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2008-12-30 20:40:00 $
    1212 *
    1313 *  Copyright 2007 Institute for Astronomy, University of Hawaii
    … …  
    5555        paramMask = constraint->paramMask;
    5656        if (paramMask != NULL) {
    57             PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_U8, false);
     57            PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    5858            PS_ASSERT_VECTORS_SIZE_EQUAL(params, paramMask, false);
    5959        }
    … …  
    201201        psImageInit (covar, 0.0);
    202202        for (int j = 0, J = 0; j < params->n; j++) {
    203             if (paramMask && (paramMask->data.U8[j])) {
     203            if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
    204204                covar->data.F32[j][j] = 1.0;
    205205                continue;
    206206            }
    207207            for (int k = 0, K = 0; k < params->n; k++) {
    208                 if (paramMask && (paramMask->data.U8[k])) continue;
     208                if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
    209209                covar->data.F32[j][k] = Alpha->data.F32[J][K];
    210210                K++;
    … …  
    251251    PS_ASSERT_VECTOR_TYPE(params,    PS_TYPE_F32,  false);
    252252    if (paramMask) {
    253         PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_MASK, false);
     253        PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    254254    }
    255255
    … …  
    282282    // set tmpBeta values which are not masked
    283283    for (int j = 0, n = 0; j < params->n; j++) {
    284         if (paramMask && (paramMask->data.U8[j])) continue;
     284        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
    285285        tmpBeta->data.F32[j] = Beta->data.F32[n];
    286286        n++;
    … …  
    289289    // apply Beta to get new Params values
    290290    for (int j = 0; j < params->n; j++) {
    291         if (paramMask && (paramMask->data.U8[j])) {
     291        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
    292292            Params->data.F32[j] = params->data.F32[j];
    293293            continue;
    … …  
    309309    // apply tmpBeta after limits have been checked
    310310    for (int j = 0, n = 0; j < params->n; j++) {
    311         if (paramMask && (paramMask->data.U8[j])) continue;
     311        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
    312312        Beta->data.F32[n] = tmpBeta->data.F32[j];
    313313        n++;
    … …  
    438438    PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, false);
    439439    if (paramMask) {
    440         PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_MASK, false);
     440        PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    441441    }
    442442
    … …  
    474474        // we track alpha,beta and params,deriv separately
    475475        for (int j = 0, J = 0; j < params->n; j++) {
    476             if (paramMask && (paramMask->data.U8[j])) continue;
     476            if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
    477477
    478478            weight = deriv->data.F32[j] * dy->data.F32[i];
    479479
    480480            for (int k = 0, K = 0; k <= j; k++) {
    481                 if (paramMask && (paramMask->data.U8[k])) continue;
     481                if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
    482482                alpha->data.F32[J][K] += weight * deriv->data.F32[k];
    483483                K++;
    … …  
    512512        nParams = 0;
    513513        for (int i = 0; i < paramMask->n; i++) {
    514             if (paramMask->data.U8[i]) continue;
     514            if (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
    515515            nParams ++;
    516516        }

  • branches/eam_branch_20081230/psLib/src/math/psMinimizePolyFit.c

    r21072 r21074  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2008-09-02 19:03:38 $
     12 *  @version $Revision: 1.33.14.1 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2008-12-30 20:40:00 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    307307    psPolynomial1D* myPoly,
    308308    const psVector *mask,
    309     psMaskType maskValue,
     309    psVectorMaskType maskValue,
    310310    const psVector* y,
    311311    const psVector* yErr,
    … …  
    326326    if (mask != NULL) {
    327327        PS_ASSERT_VECTORS_SIZE_EQUAL(y, mask, NULL);
    328         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     328        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, NULL);
    329329    }
    330330
    … …  
    354354    psF64 **matrix = A->data.F64;       // Least-squares matrix
    355355    psF64 *vector = B->data.F64;        // Least-squares vector
    356     psU8 *dataMask = NULL;              // Mask for data
     356    psVectorMaskType *dataMask = NULL;              // Mask for data
    357357    if (mask) {
    358         dataMask = mask->data.U8;
    359     }
    360     psU8 *coeffMask = myPoly->coeffMask;      // Mask for polynomial terms
     358        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     359    }
     360    psMaskType *coeffMask = myPoly->coeffMask;      // Mask for polynomial terms
    361361    psF64 *yData = y->data.F64;         // Coordinate data
    362362    psF64 *yErrData = NULL;             // Errors in the coordinate
    … …  
    473473    psPolynomial1D* myPoly,
    474474    const psVector *mask,
    475     psMaskType maskValue,
     475    psVectorMaskType maskValue,
    476476    const psVector *f,
    477477    const psVector *fErr,
    … …  
    484484    if (mask) {
    485485        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    486         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     486        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    487487    }
    488488    if (x) {
    … …  
    529529
    530530    // Dereference some pointers for speed in the loop
    531     psU8 *dataMask = NULL;              // Dereferenced version of mask for data points
     531    psVectorMaskType *dataMask = NULL;              // Dereferenced version of mask for data points
    532532    if (mask) {
    533         dataMask = mask->data.U8;
    534     }
    535     psU8 *coeffMask = myPoly->coeffMask;      // Dereferenced version of mask for polynomial terms
     533        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     534    }
     535    psMaskType *coeffMask = myPoly->coeffMask;      // Dereferenced version of mask for polynomial terms
    536536    psF64 *ordinates = NULL;            // Dereferenced version of ordinate data
    537537    if (x) {
    … …  
    698698    psPolynomial1D *poly,
    699699    const psVector *mask,
    700     psMaskType maskValue,
     700    psVectorMaskType maskValue,
    701701    const psVector *f,
    702702    const psVector *fErr,
    … …  
    711711    if (mask != NULL) {
    712712        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    713         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     713        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    714714    }
    715715    if (fErr != NULL) {
    … …  
    782782    psStats *stats,
    783783    const psVector *mask,
    784     psMaskType maskValue,
     784    psVectorMaskType maskValue,
    785785    const psVector *f,
    786786    const psVector *fErr,
    … …  
    794794    PS_ASSERT_VECTOR_NON_NULL(mask, false);
    795795    PS_ASSERT_VECTORS_SIZE_EQUAL(mask, f, false);
    796     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     796    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    797797
    798798    if (fErr != NULL) {
    … …  
    862862            if (mask != NULL) {
    863863                for (psS32 i = 0 ; i < mask->n ; i++) {
    864                     psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     864                    psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    865865                }
    866866            }
    … …  
    895895            if (mask != NULL) {
    896896                for (psS32 i = 0 ; i < mask->n ; i++) {
    897                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     897                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    898898                        psTrace("psLib.math", 6,  "(f, fit)[%d] is (%f, %f).  resid is (%f)\n",
    899899                                i, f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    922922        // recovery is not allowed with this scheme
    923923        for (psS32 i = 0; i < resid->n; i++) {
    924             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     924            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    925925                continue;
    926926            }
    … …  
    936936
    937937                if (mask != NULL) {
    938                     mask->data.U8[i] |= 0x01;
     938                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    939939                }
    940940                continue;
    … …  
    979979    psPolynomial2D* myPoly,
    980980    const psVector* mask,
    981     psMaskType maskValue,
     981    psVectorMaskType maskValue,
    982982    const psVector *f,
    983983    const psVector *fErr,
    … …  
    10031003    if (mask != NULL) {
    10041004        PS_ASSERT_VECTORS_SIZE_EQUAL(y, mask, false);
    1005         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1005        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    10061006    }
    10071007
    … …  
    10261026    psF64 **matrix = A->data.F64;       // Dereference the least-squares matrix
    10271027    psF64 *vector = B->data.F64;        // Dereference the least-squares vector
    1028     psU8 **coeffMask = myPoly->coeffMask;     // Dereference mask for polynomial terms
    1029     psU8 *dataMask = NULL;              // Dereference mask for data
     1028    psMaskType **coeffMask = myPoly->coeffMask;     // Dereference mask for polynomial terms
     1029    psVectorMaskType *dataMask = NULL;              // Dereference mask for data
    10301030    if (mask) {
    1031         dataMask = mask->data.U8;
     1031        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
    10321032    }
    10331033    psF64 *xData = x->data.F64;         // Dereference x
    … …  
    11621162    psPolynomial2D *poly,
    11631163    const psVector *mask,
    1164     psMaskType maskValue,
     1164    psVectorMaskType maskValue,
    11651165    const psVector *f,
    11661166    const psVector *fErr,
    … …  
    11791179    if (mask != NULL) {
    11801180        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1181         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1181        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    11821182    }
    11831183    if (fErr != NULL) {
    … …  
    12311231    psStats *stats,
    12321232    const psVector *mask,
    1233     psMaskType maskValue,
     1233    psVectorMaskType maskValue,
    12341234    const psVector *f,
    12351235    const psVector *fErr,
    … …  
    12541254
    12551255    PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1256     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1256    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    12571257
    12581258    if (fErr != NULL) {
    … …  
    13001300            if (mask != NULL) {
    13011301                for (psS32 i = 0 ; i < mask->n ; i++) {
    1302                     psTrace("psLib.math", 7,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     1302                    psTrace("psLib.math", 7,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    13031303                }
    13041304            }
    … …  
    13291329            if (mask != NULL) {
    13301330                for (psS32 i = 0 ; i < mask->n ; i++) {
    1331                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     1331                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    13321332                        psTrace("psLib.math", 7,  "point %d at %f %f : value, fit : %f  %f resid: %f\n",
    13331333                                i, x->data.F32[i], y->data.F32[i], f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    13561356        // recovery is not allowed with this scheme
    13571357        for (psS32 i = 0; i < resid->n; i++) {
    1358             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     1358            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    13591359                continue;
    13601360            }
    … …  
    13701370
    13711371                if (mask != NULL) {
    1372                     mask->data.U8[i] |= 0x01;
     1372                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    13731373                }
    13741374                continue;
    … …  
    14031403    psPolynomial3D* myPoly,
    14041404    const psVector* mask,
    1405     psMaskType maskValue,
     1405    psVectorMaskType maskValue,
    14061406    const psVector *f,
    14071407    const psVector *fErr,
    … …  
    14331433    if (mask != NULL) {
    14341434        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1435         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1435        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    14361436    }
    14371437
    … …  
    14641464        fErrData = fErr->data.F64;
    14651465    }
    1466     psU8 *dataMask = NULL;              // Mask for data
     1466    psVectorMaskType *dataMask = NULL;              // Mask for data
    14671467    if (mask) {
    1468         dataMask = mask->data.U8;
    1469     }
    1470     psU8 ***coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
     1468        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     1469    }
     1470    psMaskType ***coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
    14711471    int nYZterm = nYterm * nZterm;      // Multiplication of the numbers, to calculate the index
    14721472
    … …  
    16031603    psPolynomial3D *poly,
    16041604    const psVector *mask,
    1605     psMaskType maskValue,
     1605    psVectorMaskType maskValue,
    16061606    const psVector *f,
    16071607    const psVector *fErr,
    … …  
    16231623    if (mask != NULL) {
    16241624        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1625         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1625        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    16261626    }
    16271627    if (fErr != NULL) {
    … …  
    16771677    psStats *stats,
    16781678    const psVector *mask,
    1679     psMaskType maskValue,
     1679    psVectorMaskType maskValue,
    16801680    const psVector *f,
    16811681    const psVector *fErr,
    … …  
    17051705
    17061706    PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    1707     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1707    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    17081708
    17091709    if (fErr != NULL) {
    … …  
    17511751            if (mask != NULL) {
    17521752                for (psS32 i = 0 ; i < mask->n ; i++) {
    1753                     psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     1753                    psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    17541754                }
    17551755            }
    … …  
    17781778            if (mask != NULL) {
    17791779                for (psS32 i = 0 ; i < mask->n ; i++) {
    1780                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     1780                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    17811781                        psTrace("psLib.math", 6,  "(f, fit)[%d] is (%f, %f).  resid is (%f)\n",
    17821782                                i, f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    18051805        // recovery is not allowed with this scheme
    18061806        for (psS32 i = 0; i < resid->n; i++) {
    1807             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     1807            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    18081808                continue;
    18091809            }
    … …  
    18191819
    18201820                if (mask != NULL) {
    1821                     mask->data.U8[i] |= 0x01;
     1821                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    18221822                }
    18231823                continue;
    … …  
    18501850    psPolynomial4D* myPoly,
    18511851    const psVector* mask,
    1852     psMaskType maskValue,
     1852    psVectorMaskType maskValue,
    18531853    const psVector *f,
    18541854    const psVector *fErr,
    … …  
    18841884    if (mask) {
    18851885        PS_ASSERT_VECTORS_SIZE_EQUAL(y, mask, false);
    1886         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     1886        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    18871887    }
    18881888
    … …  
    19181918        fErrData = fErr->data.F64;
    19191919    }
    1920     psU8 *dataMask = NULL;              // Mask for data
     1920    psVectorMaskType *dataMask = NULL;              // Mask for data
    19211921    if (mask) {
    1922         dataMask = mask->data.U8;
    1923     }
    1924     psU8 ****coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
     1922        dataMask = mask->data.PS_TYPE_VECTOR_MASK_DATA;
     1923    }
     1924    psMaskType ****coeffMask = myPoly->coeffMask;    // Mask for polynomial terms
    19251925    int nYZTterm = nYterm * nZterm * nTterm; // Multiplication of the numbers, for calculating the index
    19261926    int nZTterm = nZterm * nTterm;      // Multiplication of the numbers, for calculating the index
    … …  
    20682068    psPolynomial4D *poly,
    20692069    const psVector *mask,
    2070     psMaskType maskValue,
     2070    psVectorMaskType maskValue,
    20712071    const psVector *f,
    20722072    const psVector *fErr,
    … …  
    20912091    if (mask) {
    20922092        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    2093         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     2093        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    20942094    }
    20952095    if (fErr != NULL) {
    … …  
    21482148    psStats *stats,
    21492149    const psVector *mask,
    2150     psMaskType maskValue,
     2150    psVectorMaskType maskValue,
    21512151    const psVector *f,
    21522152    const psVector *fErr,
    … …  
    21812181
    21822182    PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, false);
    2183     PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     2183    PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    21842184
    21852185    if (fErr != NULL) {
    … …  
    22272227            if (mask != NULL) {
    22282228                for (psS32 i = 0 ; i < mask->n ; i++) {
    2229                     psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.U8[i]);
     2229                    psTrace("psLib.math", 6,  "mask[%d] is %d\n", i, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    22302230                }
    22312231            }
    … …  
    22552255            if (mask != NULL) {
    22562256                for (psS32 i = 0 ; i < mask->n ; i++) {
    2257                     if (!((mask != NULL) && (mask->data.U8[i] & maskValue))) {
     2257                    if (!((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue))) {
    22582258                        psTrace("psLib.math", 6,  "(f, fit)[%d] is (%f, %f).  resid is (%f)\n",
    22592259                                i, f->data.F32[i], fit->data.F32[i], resid->data.F64[i]);
    … …  
    22822282        // recovery is not allowed with this scheme
    22832283        for (psS32 i = 0; i < resid->n; i++) {
    2284             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     2284            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    22852285                continue;
    22862286            }
    … …  
    22962296
    22972297                if (mask != NULL) {
    2298                     mask->data.U8[i] |= 0x01;
     2298                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    22992299                }
    23002300                continue;

  • branches/eam_branch_20081230/psLib/src/math/psMinimizePolyFit.h

    r11248 r21074  
    77 * @author GLG, MHPCC
    88 *
    9  * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    10  * @date $Date: 2007-01-23 22:47:23 $
     9 * @version $Revision: 1.4.52.1 $ $Name: not supported by cvs2svn $
     10 * @date $Date: 2008-12-30 20:40:00 $
    1111 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1212 *
    … …  
    4848    psPolynomial1D *poly,
    4949    const psVector *mask,
    50     psMaskType maskValue,
     50    psVectorMaskType maskValue,
    5151    const psVector *f,
    5252    const psVector *fErr,
    … …  
    5757    psPolynomial2D *poly,
    5858    const psVector *mask,
    59     psMaskType maskValue,
     59    psVectorMaskType maskValue,
    6060    const psVector *f,
    6161    const psVector *fErr,
    … …  
    6767    psPolynomial3D *poly,
    6868    const psVector *mask,
    69     psMaskType maskValue,
     69    psVectorMaskType maskValue,
    7070    const psVector *f,
    7171    const psVector *fErr,
    … …  
    7878    psPolynomial4D *poly,
    7979    const psVector *mask,
    80     psMaskType maskValue,
     80    psVectorMaskType maskValue,
    8181    const psVector *f,
    8282    const psVector *fErr,
    … …  
    9292    psStats *stats,
    9393    const psVector *mask,
    94     psMaskType maskValue,
     94    psVectorMaskType maskValue,
    9595    const psVector *f,
    9696    const psVector *fErr,
    … …  
    102102    psStats *stats,
    103103    const psVector *mask,
    104     psMaskType maskValue,
     104    psVectorMaskType maskValue,
    105105    const psVector *f,
    106106    const psVector *fErr,
    … …  
    113113    psStats *stats,
    114114    const psVector *mask,
    115     psMaskType maskValue,
     115    psVectorMaskType maskValue,
    116116    const psVector *f,
    117117    const psVector *fErr,
    … …  
    125125    psStats *stats,
    126126    const psVector *mask,
    127     psMaskType maskValue,
     127    psVectorMaskType maskValue,
    128128    const psVector *f,
    129129    const psVector *fErr,

  • branches/eam_branch_20081230/psLib/src/math/psMinimizePowell.c

    r11668 r21074  
    1111 *  NOTE: XXX: The SDR is silent about data types.  F32 is implemented here.
    1212 *
    13  *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2007-02-06 21:36:09 $
     13 *  @version $Revision: 1.16.50.1 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2008-12-30 20:40:00 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4343#define PS_VECTOR_ADD_MULTIPLE(BASE, BASEMASK, LINE, OUT, MUL) \
    4444for (psS32 i=0;i<BASE->n;i++) { \
    45     if (BASEMASK->data.U8[i] == 0) { \
     45    if (BASEMASK->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) { \
    4646        OUT->data.F32[i] = BASE->data.F32[i] + (MUL * LINE->data.F32[i]); \
    4747    } else { \
    … …  
    6262BOOL_VAR = true; \
    6363for (psS32 i=0;i<IN->n;i++) { \
    64     if ((INMASK->data.U8[i] == 0) && (fabs(IN->data.F32[i]) >= FLT_EPSILON)) { \
     64    if ((INMASK->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) && (fabs(IN->data.F32[i]) >= FLT_EPSILON)) { \
    6565        BOOL_VAR = false; \
    6666        break; \
    … …  
    359359    PS_ASSERT_VECTOR_NON_NULL(paramMask, NAN);
    360360    PS_ASSERT_VECTOR_NON_EMPTY(paramMask, NAN);
    361     PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_U8, NAN);
     361    PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, NAN);
    362362    PS_ASSERT_PTR_NON_NULL(coords, NAN);
    363363    PS_ASSERT_PTR_NON_NULL(func, NAN);
    … …  
    388388        for (i=0;i<params->n;i++) {
    389389            psTrace("psLib.math", 6, "(params, paramMask, line)[%d] is (%f %d %f)\n", i,
    390                     params->data.F32[i], paramMask->data.U8[i], line->data.F32[i]);
     390                    params->data.F32[i], paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i], line->data.F32[i]);
    391391        }
    392392    }
    … …  
    527527
    528528    if (paramMask == NULL) {
    529         myParamMask = psVectorAlloc(params->n, PS_TYPE_U8);
     529        myParamMask = psVectorAlloc(params->n, PS_TYPE_VECTOR_MASK);
    530530        psVectorInit(myParamMask, 0);
    531531    } else {
    … …  
    572572        biggestIter = 0;
    573573        for (i=0;i<numDims;i++) {
    574             if (myParamMask->data.U8[i] == 0) {
     574            if (myParamMask->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) {
    575575                P_PSMINIMIZATION_SET_MAXITER((&dummyMin),PS_MINIMIZE_POWELL_LINEMIN_MAX_ITERATIONS);
    576576                *(float*)&dummyMin.tol = PS_MINIMIZE_POWELL_LINEMIN_ERROR_TOLERANCE;
    … …  
    603603        // 4: Set the vector u = Q - P
    604604        for (i=0;i<numDims;i++) {
    605             if (myParamMask->data.U8[i] == 0) {
     605            if (myParamMask->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) {
    606606                u->data.F32[i] = Q->data.F32[i] - params->data.F32[i];
    607607                u->n++;
    … …  
    649649
    650650        for (i=0;i<numDims;i++) {
    651             if (myParamMask->data.U8[i] == 0) {
     651            if (myParamMask->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) {
    652652                pQP->data.F32[i] = (2 * Q->data.F32[i]) - params->data.F32[i];
    653653            } else {
    … …  
    663663        if (term1 < term2) {
    664664            for (i=0;i<numDims;i++) {
    665                 if (myParamMask->data.U8[i] == 0) {
     665                if (myParamMask->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) {
    666666                    ((psVector *) v->data[biggestIter])->data.F32[i] = u->data.F32[i];
    667667                }
    … …  
    671671        // 7: Set P to Q
    672672        for (i=0;i<numDims;i++) {
    673             if (myParamMask->data.U8[i] == 0) {
     673            if (myParamMask->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) {
    674674                params->data.F32[i] = Q->data.F32[i];
    675675            }

  • branches/eam_branch_20081230/psLib/src/math/psPolynomialMD.c

    r21072 r21074  
    132132                              const psVector *values, // Measured values
    133133                              const psVector *mask, // Mask for values
    134                               psMaskType maskVal
     134                              psVectorMaskType maskVal
    135135                              )
    136136{
    … …  
    143143    int numGood = numValues;            // Number of good values
    144144    for (int i = 0; i < numValues; i++) {
    145         if (mask && (mask->data.U8[i] & maskVal)) {
     145        if (mask && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskVal)) {
    146146            numGood--;
    147147            continue;
    … …  
    253253
    254254bool psPolynomialMDFit(psPolynomialMD *poly, const psVector *values, const psVector *errors,
    255                        const psVector *mask, psMaskType maskVal, const psArray *coordsArray)
     255                       const psVector *mask, psVectorMaskType maskVal, const psArray *coordsArray)
    256256{
    257257    PS_ASSERT_POLYNOMIALMD_NON_NULL(poly, false);
    … …  
    268268    if (mask) {
    269269        PS_ASSERT_VECTOR_NON_NULL(mask, false);
    270         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_MASK, false);
     270        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    271271        PS_ASSERT_VECTORS_SIZE_EQUAL(values, mask, false);
    272272    }
    … …  
    321321}
    322322
    323 // XXX this function should take a (psMaskType markVal) argument
     323// XXX this function should take a (psVectorMaskType markVal) argument
    324324bool psPolynomialMDClipFit(psPolynomialMD *poly, const psVector *values, const psVector *errors,
    325                            const psVector *mask, psMaskType maskVal, const psArray *coordsArray,
     325                           const psVector *mask, psVectorMaskType maskVal, const psArray *coordsArray,
    326326                           int numIter, float rej)
    327327{
    … …  
    340340    if (mask) {
    341341        PS_ASSERT_VECTOR_NON_NULL(mask, false);
    342         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_MASK, false);
     342        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    343343        PS_ASSERT_VECTORS_SIZE_EQUAL(values, mask, false);
    344344    }
    … …  
    355355
    356356    // copy the input mask to a local temporary mask
    357     poly->ownMask = psVectorRecycle(poly->ownMask, numValues, PS_TYPE_U8); // Our own mask for input values
     357    poly->ownMask = psVectorRecycle(poly->ownMask, numValues, PS_TYPE_VECTOR_MASK); // Our own mask for input values
    358358    psVectorInit(poly->ownMask, 0);
    359359    for (int i = 0; mask && (i < numValues); i++) {
    360360        if (mask->data.PS_TYPE_MASK_DATA[i] & maskVal) {
    361             poly->ownMask->data.U8[i] = 0xff;
     361            poly->ownMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    362362            numGood--;
    363363        }
    … …  
    392392                    i, values->data.F32[i], values->data.F32[i] - poly->deviations->data.F32[i], poly->deviations->data.F32[i], limit);
    393393
    394             if (poly->ownMask->data.U8[i]) continue;
     394            if (poly->ownMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
    395395
    396396            if (fabs(poly->deviations->data.F32[i]) > limit) {
    … …  
    398398                        i, values->data.F32[i], values->data.F32[i] + poly->deviations->data.F32[i],
    399399                        poly->deviations->data.F32[i], limit);
    400                 poly->ownMask->data.U8[i] = 0xff;
     400                poly->ownMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    401401                numClipped++;
    402402                numGood--;
    … …  
    435435    psVectorInit(vector, 0.0);
    436436    for (int i = 0; i < numValues; i++) {
    437         if (mask->data.U8[i]) {
     437        if (mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    438438            continue;
    439439        }
    … …  
    462462
    463463bool psPolynomialMDClipFit(psPolynomialMD *poly, const psVector *values, const psVector *errors,
    464                            const psVector *mask, psMaskType maskVal, const psArray *coordsArray,
     464                           const psVector *mask, psVectorMaskType maskVal, const psArray *coordsArray,
    465465                           int numIter, float rej)
    466466{
    … …  
    478478    if (mask) {
    479479        PS_ASSERT_VECTOR_NON_NULL(mask, false);
    480         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_MASK, false);
     480        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    481481        PS_ASSERT_VECTORS_SIZE_EQUAL(values, mask, false);
    482482    }
    … …  
    516516    psImage *matrix = psImageAlloc(numTerms, numTerms, PS_TYPE_F64); // Least-squares matrix
    517517    psVector *vector = psVectorAlloc(numTerms, PS_TYPE_F64); // Least-squares vector
    518     psVector *ownMask = psVectorAlloc(numValues, PS_TYPE_U8); // Our own mask for input values
     518    psVector *ownMask = psVectorAlloc(numValues, PS_TYPE_VECTOR_MASK); // Our own mask for input values
    519519    psVectorInit(ownMask, 0);
    520520    if (mask) {
    521521        for (int i = 0; i < numValues; i++) {
    522522            if (mask->data.PS_TYPE_MASK_DATA[i] & maskVal) {
    523                 ownMask->data.U8[i] = 0xff;
     523                ownMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    524524                numGood--;
    525525            }
    … …  
    551551        float limit = rej * poly->stdevFit; // Rejection limit
    552552        for (int i = 0; i < numValues; i++) {
    553             if (ownMask->data.U8[i]) {
     553            if (ownMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    554554                continue;
    555555            }
    … …  
    558558                        i, values->data.F32[i], psPolynomialMDEval(poly, coordsArray->data[i]),
    559559                        deviations->data.F32[i], limit);
    560                 ownMask->data.U8[i] = 0xff;
     560                ownMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    561561                numClipped++;
    562562                numGood--;

  • branches/eam_branch_20081230/psLib/src/math/psPolynomialMD.h

    r21072 r21074  
    5252                       const psVector *errors, ///< Errors
    5353                       const psVector *mask, ///< Mask
    54                        psMaskType maskVal, ///< Value to mask
     54                       psVectorMaskType maskVal, ///< Value to mask
    5555                       const psArray *coordsArray ///< Array of coordinates
    5656    );
    … …  
    6161                           const psVector *errors, ///< Errors
    6262                           const psVector *mask, ///< Mask
    63                            psMaskType maskVal, ///< Value to mask
     63                           psVectorMaskType maskVal, ///< Value to mask
    6464                           const psArray *coordsArray, ///< Array of coordinates
    6565                           int numIter,    ///< Number of rejection iterations

  • branches/eam_branch_20081230/psLib/src/math/psPolynomialUtils.c

    r19844 r21074  
    2121    psStats *stats,
    2222    const psVector *mask,
    23     psMaskType maskValue,
     23    psVectorMaskType maskValue,
    2424    const psVector *f,
    2525    const psVector *fErr,
    … …  
    3636    if (mask != NULL) {
    3737        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
    38         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     38        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, NULL);
    3939    }
    4040    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
    … …  
    106106        // recovery is not allowed with this scheme
    107107        for (int i = 0; i < resid->n; i++) {
    108             if ((mask != NULL) && (mask->data.U8[i] & maskValue)) {
     108            if ((mask != NULL) && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    109109                continue;
    110110            }
    … …  
    112112            if (resid->data.F64[i] - stats->sampleMedian > sigma*maxClipSigma) {
    113113                if (mask != NULL) {
    114                     mask->data.U8[i] |= 0x01;
     114                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    115115                }
    116116                continue;
    … …  
    118118            if (resid->data.F64[i] - stats->sampleMedian < sigma*minClipSigma) {
    119119                if (mask != NULL) {
    120                     mask->data.U8[i] |= 0x01;
     120                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= 0x01;
    121121                }
    122122                continue;

  • branches/eam_branch_20081230/psLib/src/math/psPolynomialUtils.h

    r11248 r21074  
    22 * @brief extra psPolynomial-related functions
    33 *
    4  * $Revision: 1.5 $ $Name: not supported by cvs2svn $
    5  * $Date: 2007-01-23 22:47:23 $
     4 * $Revision: 1.5.52.1 $ $Name: not supported by cvs2svn $
     5 * $Date: 2008-12-30 20:40:00 $
    66 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    77 */
    … …  
    2424    psStats *stats,                     // Statistics to use in clipping
    2525    const psVector *mask,               // Mask for input values
    26     psMaskType maskValue,               // Mask value
     26    psVectorMaskType maskValue,         // Mask value
    2727    const psVector *f,                  // Value of the function, f(x,y,z,t)
    2828    const psVector *fErr,               // Error in the value

  • branches/eam_branch_20081230/psLib/src/math/psStats.c

    r20515 r21074  
    1313 * use ->min and ->max (PS_STAT_USE_RANGE)
    1414 *
    15  *  @version $Revision: 1.230 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2008-11-04 00:55:14 $
     15 *  @version $Revision: 1.230.8.1 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2008-12-30 20:40:00 $
    1717 *
    1818 *  Copyright 2006 IfA, University of Hawaii
    … …  
    6868#define PS_CLIPPED_SIGMA_UB 10.0
    6969#define PS_POLY_MEDIAN_MAX_ITERATIONS 30
    70 #define MASK_MARK 0x80   // bit to use internally to mark data as bad
     70
     71#define MASK_MARK 0x80   // XXX : can we change this? bit to use internally to mark data as bad
    7172#define PS_ROBUST_MAX_ITERATIONS 20     // Maximum number of iterations for robust statistics
    7273
    … …  
    178179                                 const psVector* errors,
    179180                                 const psVector* maskVector,
    180                                  psMaskType maskVal,
     181                                 psVectorMaskType maskVal,
    181182                                 psStats* stats)
    182183{
    … …  
    190191    int numData = myVector->n;          // Number of data points
    191192
    192     psU8 *maskData = (maskVector == NULL) ? NULL : maskVector->data.U8;
     193    psVectorMaskType *maskData = (maskVector == NULL) ? NULL : maskVector->data.PS_TYPE_VECTOR_MASK_DATA;
    193194    bool useRange = stats->options & PS_STAT_USE_RANGE;
    194195
    … …  
    245246    static long vectorMinMax(const psVector* myVector,
    246247                             const psVector* maskVector,
    247                              psMaskType maskVal,
     248                             psVectorMaskType maskVal,
    248249                             psStats* stats
    249250        )
    … …  
    257258    int numValid = 0;                   // Number of valid values
    258259
    259     psU8 *maskData = (maskVector == NULL) ? NULL : maskVector->data.U8;
     260    psVectorMaskType *maskData = (maskVector == NULL) ? NULL : maskVector->data.PS_TYPE_VECTOR_MASK_DATA;
    260261    bool useRange = stats->options & PS_STAT_USE_RANGE;
    261262
    … …  
    302303static bool vectorSampleMedian(const psVector* inVector,
    303304                               const psVector* maskVector,
    304                                psMaskType maskVal,
     305                               psVectorMaskType maskVal,
    305306                               psStats* stats)
    306307{
    … …  
    308309
    309310    bool useRange = stats->options & PS_STAT_USE_RANGE;
    310     psU8 *maskData = (maskVector == NULL) ? NULL : maskVector->data.U8; // Dereference the vector
     311    psVectorMaskType *maskData = (maskVector == NULL) ? NULL : maskVector->data.PS_TYPE_VECTOR_MASK_DATA; // Dereference the vector
    311312    psF32 *input = inVector->data.F32; // Dereference the vector
    312313
    … …  
    387388                              const psVector* errors,
    388389                              const psVector* maskVector,
    389                               psMaskType maskVal,
     390                              psVectorMaskType maskVal,
    390391                              psStats* stats)
    391392{
    … …  
    407408
    408409    psF32 *data = myVector->data.F32;   // Dereference
    409     psU8 *maskData = (maskVector == NULL) ? NULL : maskVector->data.U8;
     410    psVectorMaskType *maskData = (maskVector == NULL) ? NULL : maskVector->data.PS_TYPE_VECTOR_MASK_DATA;
    410411    bool useRange = stats->options & PS_STAT_USE_RANGE;
    411412    psF32 *errorsData = (errors == NULL) ? NULL : errors->data.F32;
    … …  
    468469static bool vectorSampleMoments(const psVector* myVector,
    469470                                const psVector* maskVector,
    470                                 psMaskType maskVal,
     471                                psVectorMaskType maskVal,
    471472                                psStats* stats)
    472473{
    … …  
    490491
    491492    psF32 *data = myVector->data.F32;   // Dereference
    492     psU8 *maskData = (maskVector == NULL) ? NULL : maskVector->data.U8;
     493    psVectorMaskType *maskData = (maskVector == NULL) ? NULL : maskVector->data.PS_TYPE_VECTOR_MASK_DATA;
    493494    bool useRange = stats->options & PS_STAT_USE_RANGE;
    494495
    … …  
    557558                               const psVector* errors,
    558559                               psVector* maskInput,
    559                                psMaskType maskValInput,
     560                               psVectorMaskType maskValInput,
    560561                               psStats* stats
    561562    )
    … …  
    580581
    581582    // We copy the mask vector, to preserve the original
    582     psMaskType maskVal = MASK_MARK | maskValInput;
     583    psVectorMaskType maskVal = MASK_MARK | maskValInput;
    583584
    584585    // use the temporary vector for local temporary mask
    585     stats->tmpMask = psVectorRecycle (stats->tmpMask, myVector->n, PS_TYPE_U8);
     586    stats->tmpMask = psVectorRecycle (stats->tmpMask, myVector->n, PS_TYPE_VECTOR_MASK);
    586587    psVector *tmpMask = stats->tmpMask;
    587588    psVectorInit(tmpMask, 0);
    588589    if (maskInput) {
    589590        for (long i = 0; i < myVector->n; i++) {
    590             if (maskInput->data.U8[i] & maskValInput) {
    591                 tmpMask->data.U8[i] = maskVal;
     591            if (maskInput->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValInput) {
     592                tmpMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = maskVal;
    592593            }
    593594        }
    … …  
    629630            // sqrt(A))
    630631            for (long j = 0; j < myVector->n; j++) {
    631                 if (!tmpMask->data.U8[j] &&
     632                if (!tmpMask->data.PS_TYPE_VECTOR_MASK_DATA[j] &&
    632633                    fabsf(myVector->data.F32[j] - clippedMean) > stats->clipSigma * errors->data.F32[j]) {
    633                     tmpMask->data.U8[j] = 0xff;
     634                    tmpMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
    634635                    psTrace(TRACE, 10, "Clipped %ld: %f +/- %f\n", j,
    635636                            myVector->data.F32[j], errors->data.F32[j]);
    … …  
    640641        } else {
    641642            for (long j = 0; j < myVector->n; j++) {
    642                 if (!tmpMask->data.U8[j] &&
     643                if (!tmpMask->data.PS_TYPE_VECTOR_MASK_DATA[j] &&
    643644                    fabsf(myVector->data.F32[j] - clippedMean) > (stats->clipSigma * clippedStdev)) {
    644                     tmpMask->data.U8[j] = 0xff;
     645                    tmpMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
    645646                    psTrace(TRACE, 10, "Clipped %ld: %f\n", j, myVector->data.F32[j]);
    646647                    numClipped++;
    … …  
    715716                              const psVector* errors,
    716717                              psVector* maskInput,
    717                               psMaskType maskValInput,
     718                              psVectorMaskType maskValInput,
    718719                              psStats* stats)
    719720{
    … …  
    726727    // and tested even if there is no supplied mask (and/or the maskVal is 0)
    727728    // XXX this would be better if we had globally defined mask values
    728     psMaskType maskVal = MASK_MARK | maskValInput;
     729    psVectorMaskType maskVal = MASK_MARK | maskValInput;
    729730    psVector *mask = psVectorAlloc(myVector->n, PS_TYPE_MASK); // The actual mask we will use
    730731    psVectorInit(mask, 0);
    731732    if (maskInput) {
    732733        for (long i = 0; i < myVector->n; i++) {
    733             if (maskInput->data.U8[i] & maskValInput) {
    734                 mask->data.U8[i] = maskVal;
     734            if (maskInput->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValInput) {
     735                mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = maskVal;
    735736            }
    736737        }
    … …  
    934935                if ((myVector->data.F32[i] < medianLo) || (myVector->data.F32[i] > medianHi)) {
    935936                    // XXXX is this correct?  is MASK_MARK safe?
    936                     mask->data.U8[i] |= MASK_MARK;
     937                    mask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= MASK_MARK;
    937938                    psTrace(TRACE, 6, "Masking element %ld is %f\n", i, myVector->data.F32[i]);
    938939                }
    … …  
    998999    long N50 = 0;
    9991000    for (long i = 0 ; i < myVector->n ; i++) {
    1000         if (!mask->data.U8[i] &&
     1001        if (!mask->data.PS_TYPE_VECTOR_MASK_DATA[i] &&
    10011002            (binLo25F32 <= myVector->data.F32[i]) && (binHi25F32 >= myVector->data.F32[i])) {
    10021003            N50++;
    … …  
    10461047                               const psVector* errors,
    10471048                               psVector* mask,
    1048                                psMaskType maskVal,
     1049                               psVectorMaskType maskVal,
    10491050                               psStats* stats)
    10501051{
    … …  
    12241225                                  const psVector* errors,
    12251226                                  psVector* mask,
    1226                                   psMaskType maskVal,
     1227                                  psVectorMaskType maskVal,
    12271228                                  psStats* stats)
    12281229{
    … …  
    13471348        // fitStats->clipIter = 3.0;
    13481349        // fitStats->clipSigma = 3.0;
    1349         // psVector *fitMask = psVectorAlloc(y->n, PS_TYPE_U8);
     1350        // psVector *fitMask = psVectorAlloc(y->n, PS_TYPE_VECTOR_MASK);
    13501351        // psVectorInit (fitMask, 0);
    13511352
    … …  
    14181419                                  const psVector* errors,
    14191420                                  psVector* mask,
    1420                                   psMaskType maskVal,
     1421                                  psVectorMaskType maskVal,
    14211422                                  psStats* stats)
    14221423{
    … …  
    17131714                                  const psVector* errors,
    17141715                                  psVector* mask,
    1715                                   psMaskType maskVal,
     1716                                  psVectorMaskType maskVal,
    17161717                                  psStats* stats)
    17171718{
    … …  
    22252226                   const psVector* errors,
    22262227                   const psVector* mask,
    2227                    psMaskType maskVal)
     2228                   psVectorMaskType maskVal)
    22282229{
    22292230    psTrace(TRACE, 3,"---- %s() begin  ----\n", __func__);
    … …  
    22332234    if (mask) {
    22342235        PS_ASSERT_VECTORS_SIZE_EQUAL(mask, in, false);
    2235         PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, false);
     2236        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_VECTOR_MASK, false);
    22362237    }
    22372238    if (errors) {

  • branches/eam_branch_20081230/psLib/src/math/psStats.h

    r21072 r21074  
    88 * @author GLG, MHPCC
    99 *
    10  * @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
    11  * @date $Date: 2008-08-03 20:55:09 $
     10 * @version $Revision: 1.65.18.1 $ $Name: not supported by cvs2svn $
     11 * @date $Date: 2008-12-30 20:40:00 $
    1212 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1313 */
    … …  
    9696 */
    9797bool psVectorStats(
    98     psStats* stats,                    ///< stats structure defines stats to be calculated and how
    99     const psVector* in,                ///< Vector to be analysed.
    100     const psVector* errors,            ///< Errors.
    101     const psVector* mask,              ///< Ignore elements where (maskVector & maskVal) != 0: must be INT or NULL
    102     psMaskType maskVal                ///< Only mask elements with one of these bits set in maskVector
     98    psStats* stats,            ///< stats structure defines stats to be calculated and how
     99    const psVector* in,                 ///< Vector to be analysed.
     100    const psVector* errors,             ///< Errors.
     101    const psVector* mask, ///< Ignore elements where (maskVector & maskVal) != 0: must be INT or NULL
     102    psVectorMaskType maskVal ///< Only mask elements with one of these bits set in maskVector
    103103);
    104104

  • branches/eam_branch_20081230/psLib/src/mathtypes/psVector.c

    r20547 r21074  
    1010*  @author Joshua Hoblitt, University of Hawaii
    1111*
    12 *  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2008-11-05 11:12:40 $
     12*  @version $Revision: 1.104.6.1 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2008-12-30 20:40:00 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    987987}
    988988
    989 // count number of pixels with given mask value
     989// count number of pixels with given mask value.  the comparison is against a U64 type to
     990// allow any int-type of vector.  all signed and unsigned int types are allowed
    990991long psVectorCountPixelMask (psVector *mask,
    991                              psMaskType value)
     992                             psU64 value)
    992993{
    993994    long Npixels = 0;
    … …  
    998999    }
    9991000
    1000     psElemType type;
    1001     type = mask->type.type;
    1002 
    1003     if (type != PS_TYPE_MASK) {
    1004         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    1005                 "psVector type does not match the specified psMaskType!\n");
    1006         return -1;
    1007     }
    1008 
     1001# define PS_VECTOR_COUNT_PIXEL_MASK(NAME,TYPE) \
     1002    case PS_TYPE_##NAME: \
     1003        for (long i = 0; i < mask->n; i++) { \
     1004            if (mask->data.TYPE[i] & value) { \
     1005                Npixels ++; \
     1006            } \
     1007        } \
     1008        break;
     1009
     1010    psElemType type = mask->type.type;
    10091011    switch (type) {
    1010     case PS_TYPE_U8:
    1011     case PS_TYPE_U16:
    1012         for (long i = 0; i < mask->n; i++) {
    1013             if (mask->data.PS_TYPE_MASK_DATA[i] & value) {
    1014                 Npixels ++;
    1015             }
    1016         }
    1017         break;
    1018     case PS_TYPE_S8:
    1019     case PS_TYPE_S16:
    1020     case PS_TYPE_S32:
    1021     case PS_TYPE_S64:
    1022     case PS_TYPE_U32:
    1023     case PS_TYPE_U64:
    1024     case PS_TYPE_F32:
    1025     case PS_TYPE_F64:
     1012        PS_VECTOR_COUNT_PIXEL_MASK(U8, U8);
     1013        PS_VECTOR_COUNT_PIXEL_MASK(U16,U16);
     1014        PS_VECTOR_COUNT_PIXEL_MASK(U32,U32);
     1015        PS_VECTOR_COUNT_PIXEL_MASK(U64,U64);
     1016        PS_VECTOR_COUNT_PIXEL_MASK(S8, S8);
     1017        PS_VECTOR_COUNT_PIXEL_MASK(S16,S16);
     1018        PS_VECTOR_COUNT_PIXEL_MASK(S32,S32);
     1019        PS_VECTOR_COUNT_PIXEL_MASK(S64,S64);
    10261020    default:
    10271021        psError(PS_ERR_BAD_PARAMETER_TYPE, true,

  • branches/eam_branch_20081230/psLib/src/mathtypes/psVector.h

    r19502 r21074  
    1010 * @author Joshua Hoblitt, University of Hawaii
    1111 *
    12  * @version $Revision: 1.73 $ $Name: not supported by cvs2svn $
    13  * @date $Date: 2008-09-12 00:22:48 $
     12 * @version $Revision: 1.73.14.1 $ $Name: not supported by cvs2svn $
     13 * @date $Date: 2008-12-30 20:40:00 $
    1414 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1515 */
    … …  
    379379 */
    380380long psVectorCountPixelMask(
    381     psVector *mask,                    ///< input vector to count
    382     psMaskType value                   ///< the mask value to satisfy
     381    psVector *mask,                     ///< input vector to count
     382    psU64 value                         ///< the mask value to satisfy
    383383);
    384384

  • branches/eam_branch_20081230/psLib/src/sys/psType.h

    r14454 r21074  
    1010*  @author Ross Harman, MHPCC
    1111*
    12 *  @version $Revision: 1.62 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2007-08-09 03:30:47 $
     12*  @version $Revision: 1.62.42.1 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2008-12-30 20:40:00 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    141141} psDataType;
    142142
     143// macros to abstract the generic mask type : these values must be consistent
    143144#define PS_TYPE_MASK PS_TYPE_U8        /**< the psElemType to use for mask image */
    144145#define PS_TYPE_MASK_DATA U8           /**< the data member to use for mask image */
    145146#define PS_TYPE_MASK_NAME "psU8"       /**< the data type for mask as a string */
    146 
    147147typedef psU8 psMaskType;               ///< the C datatype for a mask image
     148
     149// macros to abstract the vector mask type : these values must be consistent
     150#define PS_TYPE_VECTOR_MASK PS_TYPE_U8        /**< the psElemType to use for mask image */
     151#define PS_TYPE_VECTOR_MASK_DATA U8           /**< the data member to use for mask image */
     152#define PS_TYPE_VECTOR_MASK_NAME "psU8"       /**< the data type for mask as a string */
     153typedef psU8 psVectorMaskType;                    ///< the C datatype for a mask image
     154
     155// macros to abstract the image mask type : these values must be consistent
     156#define PS_TYPE_IMAGE_MASK PS_TYPE_U8        /**< the psElemType to use for mask image */
     157#define PS_TYPE_IMAGE_MASK_DATA U8           /**< the data member to use for mask image */
     158#define PS_TYPE_IMAGE_MASK_NAME "psU8"       /**< the data type for mask as a string */
     159typedef psU8 psImageMaskType;               ///< the C datatype for a mask image
    148160
    149161#define PS_MIN_S8        INT8_MIN      /**< minimum valid psS8 value */

  • branches/eam_branch_20081230/psLib/src/types/psPixels.c

    r21072 r21074  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2008-09-12 22:36:29 $
     9 *  @version $Revision: 1.43.14.1 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-12-30 20:40:00 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    150150                        const psPixels *pixels,
    151151                        psRegion region,
    152                         psMaskType maskVal)
     152                        psImageMaskType maskVal)
    153153{
    154154    PS_ASSERT_PIXELS_NON_NULL(pixels, NULL);
    … …  
    169169    int numRows = y1 - y0 + 1, numCols = x1 - x0 + 1; // Size of image
    170170
    171     out = psImageRecycle(out, numCols, numRows, PS_TYPE_MASK);
     171    out = psImageRecycle(out, numCols, numRows, PS_TYPE_IMAGE_MASK);
    172172    if (!out) {
    173173        psError(PS_ERR_UNKNOWN, false, _("Failed to create image of size %dx%d."), numCols, numRows);
    … …  
    181181    // cycle through the vector of pixels and insert pixels into image
    182182    long length = pixels->n;            // Length of pixel array
    183     psMaskType** outData = out->data.PS_TYPE_MASK_DATA;
     183    psImageMaskType** outData = out->data.PS_TYPE_IMAGE_MASK_DATA;
    184184    for (int p = 0; p < length; p++) {
    185185        float x = pixels->data[p].x;
    … …  
    196196psPixels* psPixelsFromMask(psPixels* out,
    197197                           const psImage* mask,
    198                            psMaskType maskVal)
     198                           psImageMaskType maskVal)
    199199{
    200200    PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
    201     PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
     201    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL);
    202202
    203203    int numRows = mask->numRows, numCols = mask->numCols; // Size of image
    … …  
    214214    for (int y = 0; y < numRows; y++) {
    215215        for (int x = 0; x < numCols; x++) {
    216             if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
     216            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
    217217                psPixelsAdd(out, out->nalloc, x, y);
    218218            }

  • branches/eam_branch_20081230/psLib/src/types/psPixels.h

    r21072 r21074  
    66 *  @author Robert DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2008-09-12 22:36:29 $
     8 *  @version $Revision: 1.30.14.1 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2008-12-30 20:40:00 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    189189    const psPixels* pixels,            ///< list of pixels to use
    190190    psRegion region,                   ///< region to define the output mask image
    191     psMaskType maskVal                 ///< the mask bit-values to act upon
     191    psImageMaskType maskVal             ///< the mask bit-values to act upon
    192192);
    193193
    … …  
    205205    psPixels *out,                     ///< psPixels to recycle, or NULL
    206206    const psImage *mask,               ///< the input mask psImage
    207     psMaskType maskVal                 ///< the mask bit-values to act upon
     207    psImageMaskType maskVal             ///< the mask bit-values to act upon
    208208);
    209209
Note: See TracChangeset for help on using the changeset viewer.