IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21183 for trunk/psLib


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

incorporating changes from 16bit mask upgrades (eam_branch_20081230)

Location:
trunk/psLib/src
Files:
1 added
48 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/fft/psImageFFT.c

    r20566 r21183  
    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.29 $ $Name: not supported by cvs2svn $
     9/// @date $Date: 2009-01-27 06:39:37 $
    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                }

  • trunk/psLib/src/fft/psImageFFT.h

    r17320 r21183  
    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.11 $ $Name: not supported by cvs2svn $
     8/// @date $Date: 2009-01-27 06:39:37 $
    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);

  • trunk/psLib/src/fits/psFitsImage.c

    r19384 r21183  
    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.41 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2009-01-27 06:39:37 $
    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);

  • trunk/psLib/src/fits/psFitsImage.h

    r19384 r21183  
    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.11 $ $Name: not supported by cvs2svn $
     7 * @date $Date: 2009-01-27 06:39:37 $
    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

  • trunk/psLib/src/fits/psFitsScale.c

    r19383 r21183  
    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    }

  • trunk/psLib/src/fits/psFitsScale.h

    r19383 r21183  
    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    );

  • trunk/psLib/src/imageops/psImageBackground.c

    r20216 r21183  
    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        }

  • trunk/psLib/src/imageops/psImageBackground.h

    r16115 r21183  
    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.7 $ $Name: not supported by cvs2svn $
     8 *  $Date: 2009-01-27 06:39:37 $
    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                      );

  • trunk/psLib/src/imageops/psImageConvolve.c

    r20830 r21183  
    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.82 $ $Name: not supported by cvs2svn $
     10/// @date $Date: 2009-01-27 06:39:37 $
    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    }

  • trunk/psLib/src/imageops/psImageConvolve.h

    r20830 r21183  
    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.39 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:37 $
    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

  • trunk/psLib/src/imageops/psImageGeomManip.c

    r20299 r21183  
    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.45 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2009-01-27 06:39:37 $
    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;

  • trunk/psLib/src/imageops/psImageGeomManip.h

    r16910 r21183  
    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.23 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2009-01-27 06:39:37 $
    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

  • trunk/psLib/src/imageops/psImageInterpolate.c

    r20758 r21183  
    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.31 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2009-01-27 06:39:37 $
    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    }

  • trunk/psLib/src/imageops/psImageInterpolate.h

    r20327 r21183  
    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.8 $ $Name: not supported by cvs2svn $
     10 * @date $Date: 2009-01-27 06:39:37 $
    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

  • trunk/psLib/src/imageops/psImageMap.c

    r21172 r21183  
    77 *  @author Eugene Magnier, IfA
    88 *
    9  *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2009-01-27 00:00:21 $
     9 *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2009-01-27 06:39:37 $
    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
    … …  
    353353}
    354354
    355 psVector *psImageMapEvalVector(const psImageMap *map, const psVector *mask, psMaskType maskValue, const psVector *x, const psVector *y)
     355psVector *psImageMapEvalVector(const psImageMap *map, const psVector *mask, psVectorMaskType maskValue, const psVector *x, const psVector *y)
    356356{
    357357    PS_ASSERT_IMAGE_MAP_NON_NULL(map, NULL);
    … …  
    365365
    366366    for (int i = 0; i < x->n; i++) {
    367       if (mask && (mask->data.U8[i] & maskValue)) {
     367      if (mask && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskValue)) {
    368368        result->data.F32[i] = 0.0;
    369369      } else { 

  • trunk/psLib/src/imageops/psImageMapFit.c

    r21172 r21183  
    77 *  @author Eugene Magnier, IfA
    88 *
    9  *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2009-01-27 00:00:21 $
     9 *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2009-01-27 06:39:37 $
    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);

  • trunk/psLib/src/imageops/psImageMapFit.h

    r15841 r21183  
    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,

  • trunk/psLib/src/imageops/psImageMaskOps.c

    r18494 r21183  
    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.8 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2009-01-27 06:39:37 $
    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                        }

  • trunk/psLib/src/imageops/psImageMaskOps.h

    r11248 r21183  
    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.3 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2009-01-27 06:39:37 $
    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

  • trunk/psLib/src/imageops/psImagePixelExtract.c

    r20306 r21183  
    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.34 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2009-01-27 06:39:37 $
    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    }

  • trunk/psLib/src/imageops/psImagePixelExtract.h

    r11248 r21183  
    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.11 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:37 $
    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

  • trunk/psLib/src/imageops/psImagePixelInterpolate.c

    r15254 r21183  
    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.4 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2009-01-27 06:39:37 $
    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        }

  • trunk/psLib/src/imageops/psImagePixelInterpolate.h

    r14924 r21183  
    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.3 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2009-01-27 06:39:37 $
    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/// @}

  • trunk/psLib/src/imageops/psImageStats.c

    r12431 r21183  
    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.107 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2009-01-27 06:39:37 $
    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;

  • trunk/psLib/src/imageops/psImageStats.h

    r11759 r21183  
    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.32 $ $Name: not supported by cvs2svn $
     12 * @date $Date: 2009-01-27 06:39:37 $
    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

  • trunk/psLib/src/math/psClip.c

    r11756 r21183  
    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; \

  • trunk/psLib/src/math/psClip.h

    r14452 r21183  
    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.6 $ $Name: not supported by cvs2svn $
     7 * $Date: 2009-01-27 06:39:38 $
    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

  • trunk/psLib/src/math/psConstants.h

    r17035 r21183  
    55 * @author GLG, MHPCC
    66 *
    7  * @version $Revision: 1.96 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-03-18 18:25:00 $
     7 * @version $Revision: 1.97 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-01-27 06:39:38 $
    99 *
    1010 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6767
    6868// These defines for bitwise opertaions are necessary to yield results of the proper size (use instead of ~)
    69 #define PS_NOT_U8(A)(UCHAR_MAX-(A)) // Perform bitwise NOT on A which is of type U8
    70 #define PS_NOT_U16(A)(USHORT_MAX-(A)) // Perform bitwaise NOT on A which is of type U16
     69#define PS_NOT_U8(A)(UINT8_MAX-(A)) // Perform bitwise NOT on A which is of type U8
     70#define PS_NOT_U16(A)(UINT16_MAX-(A)) // Perform bitwaise NOT on A which is of type U16
     71#define PS_NOT_U32(A)(UINT32_MAX-(A)) // Perform bitwise NOT on A which is of type U8
     72#define PS_NOT_U64(A)(UINT64_MAX-(A)) // Perform bitwaise NOT on A which is of type U16
    7173
    7274/// @}

  • trunk/psLib/src/math/psHistogram.c

    r17565 r21183  
    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.9 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2009-01-27 06:39:38 $
    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.

  • trunk/psLib/src/math/psHistogram.h

    r14452 r21183  
    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.5 $ $Name: not supported by cvs2svn $
     10 * @date $Date: 2009-01-27 06:39:38 $
    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/// @}

  • trunk/psLib/src/math/psMinimizeLMM.c

    r19845 r21183  
    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.36 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2009-01-27 06:39:38 $
    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        }

  • trunk/psLib/src/math/psMinimizeLMM_ND.c

    r17442 r21183  
    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.2 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2009-01-27 06:39:38 $
    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        }

  • trunk/psLib/src/math/psMinimizePolyFit.c

    r19304 r21183  
    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.34 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2009-01-27 06:39:38 $
    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;

  • trunk/psLib/src/math/psMinimizePolyFit.h

    r11248 r21183  
    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.5 $ $Name: not supported by cvs2svn $
     10 * @date $Date: 2009-01-27 06:39:38 $
    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,

  • trunk/psLib/src/math/psMinimizePowell.c

    r11668 r21183  
    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.17 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2009-01-27 06:39:38 $
    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            }

  • trunk/psLib/src/math/psPolynomialMD.c

    r19085 r21183  
    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    }
    … …  
    294294        PS_ASSERT_VECTOR_TYPE(coords, PS_TYPE_F32, false);
    295295
    296         if (mask && (mask->data.PS_TYPE_MASK_DATA[i] & maskVal)) {
     296        if (mask && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskVal)) {
    297297            continue;
    298298        }
    … …  
    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++) {
    360         if (mask->data.PS_TYPE_MASK_DATA[i] & maskVal) {
    361             poly->ownMask->data.U8[i] = 0xff;
     360        if (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskVal) {
     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    }
    … …  
    500500        PS_ASSERT_VECTOR_TYPE(coords, PS_TYPE_F32, false);
    501501
    502         if (mask && (mask->data.PS_TYPE_MASK_DATA[i] & maskVal)) {
     502        if (mask && (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskVal)) {
    503503            continue;
    504504        }
    … …  
    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++) {
    522             if (mask->data.PS_TYPE_MASK_DATA[i] & maskVal) {
    523                 ownMask->data.U8[i] = 0xff;
     522            if (mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & maskVal) {
     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--;

  • trunk/psLib/src/math/psPolynomialMD.h

    r19085 r21183  
    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

  • trunk/psLib/src/math/psPolynomialUtils.c

    r19844 r21183  
    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;

  • trunk/psLib/src/math/psPolynomialUtils.h

    r11248 r21183  
    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.6 $ $Name: not supported by cvs2svn $
     5 * $Date: 2009-01-27 06:39:38 $
    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

  • trunk/psLib/src/math/psStats.c

    r20515 r21183  
    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.231 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2009-01-27 06:39:38 $
    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     psVector *mask = psVectorAlloc(myVector->n, PS_TYPE_MASK); // The actual mask we will use
     729    psVectorMaskType maskVal = MASK_MARK | maskValInput;
     730    psVector *mask = psVectorAlloc(myVector->n, PS_TYPE_VECTOR_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) {
    … …  
    22552256        }
    22562257    }
    2257     psVector *maskU8 = NULL;            // Input mask vector, U8 version
     2258    psVector *maskVector = NULL;            // Input mask vector, U8 version
    22582259    if (mask) {
    2259         if (mask->type.type == PS_TYPE_MASK) {
    2260             maskU8 = psMemIncrRefCounter((psPtr)mask);
     2260        if (mask->type.type == PS_TYPE_VECTOR_MASK) {
     2261            maskVector = psMemIncrRefCounter((psPtr)mask);
    22612262        } else {
    2262             maskU8 = psVectorCopy(NULL, mask, PS_TYPE_MASK);
     2263            maskVector = psVectorCopy(NULL, mask, PS_TYPE_VECTOR_MASK);
    22632264        }
    22642265    }
    … …  
    22792280    // ************************************************************************
    22802281    if (stats->options & PS_STAT_SAMPLE_MEAN) {
    2281         if (!vectorSampleMean(inF32, errorsF32, maskU8, maskVal, stats)) {
     2282        if (!vectorSampleMean(inF32, errorsF32, maskVector, maskVal, stats)) {
    22822283            psError(PS_ERR_UNKNOWN, false, "Failed to calculate vector sample mean");
    22832284            status &= false;
    … …  
    22872288    // ************************************************************************
    22882289    if (stats->options & (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_QUARTILE)) {
    2289         if (!vectorSampleMedian(inF32, maskU8, maskVal, stats)) {
     2290        if (!vectorSampleMedian(inF32, maskVector, maskVal, stats)) {
    22902291            psError(PS_ERR_UNKNOWN, false, "Failed to calculate sample median");
    22912292            status &= false;
    … …  
    22952296    // ************************************************************************
    22962297    if (stats->options & PS_STAT_SAMPLE_STDEV) {
    2297         if (!vectorSampleStdev(inF32, errorsF32, maskU8, maskVal, stats)) {
     2298        if (!vectorSampleStdev(inF32, errorsF32, maskVector, maskVal, stats)) {
    22982299            psError(PS_ERR_UNKNOWN, false, "Failed to calculate sample stdev");
    22992300            status &= false;
    … …  
    23022303
    23032304    if (stats->options & (PS_STAT_SAMPLE_SKEWNESS | PS_STAT_SAMPLE_KURTOSIS)) {
    2304         if (!vectorSampleMoments(inF32, maskU8, maskVal, stats)) {
     2305        if (!vectorSampleMoments(inF32, maskVector, maskVal, stats)) {
    23052306            psError(PS_ERR_UNKNOWN, false, "Failed to calculate sample moments");
    23062307            status &= false;
    … …  
    23102311    // ************************************************************************
    23112312    if (stats->options & (PS_STAT_MAX | PS_STAT_MIN)) {
    2312         if (vectorMinMax(inF32, maskU8, maskVal, stats) == 0) {
     2313        if (vectorMinMax(inF32, maskVector, maskVal, stats) == 0) {
    23132314            psError(PS_ERR_UNKNOWN, false, "Failed to calculate vector minimum and maximum");
    23142315            status &= false;
    … …  
    23182319    // ************************************************************************
    23192320    if (stats->options & (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE)) {
    2320         if (!vectorRobustStats(inF32, errorsF32, maskU8, maskVal, stats)) {
     2321        if (!vectorRobustStats(inF32, errorsF32, maskVector, maskVal, stats)) {
    23212322            psError(PS_ERR_UNKNOWN, false, _("Failed to calculate robust statistics"));
    23222323            status &= false;
    … …  
    23262327    // ************************************************************************
    23272328    if (stats->options & (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV)) {
    2328         if (!vectorFittedStats(inF32, errorsF32, maskU8, maskVal, stats)) {
     2329        if (!vectorFittedStats(inF32, errorsF32, maskVector, maskVal, stats)) {
    23292330            psError(PS_ERR_UNKNOWN, false, _("Failed to calculate fitted statistics"));
    23302331            status &= false;
    … …  
    23372338            psAbort("you may not specify both FITTED_MEAN and FITTED_MEAN_V2");
    23382339        }
    2339         if (!vectorFittedStats_v2(inF32, errorsF32, maskU8, maskVal, stats)) {
     2340        if (!vectorFittedStats_v2(inF32, errorsF32, maskVector, maskVal, stats)) {
    23402341            psError(PS_ERR_UNKNOWN, false, _("Failed to calculate fitted statistics"));
    23412342            status &= false;
    … …  
    23482349            psAbort("you may not specify both FITTED_MEAN and FITTED_MEAN_V3");
    23492350        }
    2350         if (!vectorFittedStats_v3(inF32, errorsF32, maskU8, maskVal, stats)) {
     2351        if (!vectorFittedStats_v3(inF32, errorsF32, maskVector, maskVal, stats)) {
    23512352            psError(PS_ERR_UNKNOWN, false, _("Failed to calculate fitted statistics"));
    23522353            status &= false;
    … …  
    23592360            psAbort("you may not specify both FITTED_MEAN and FITTED_MEAN_V4");
    23602361        }
    2361         if (!vectorFittedStats_v4(inF32, errorsF32, maskU8, maskVal, stats)) {
     2362        if (!vectorFittedStats_v4(inF32, errorsF32, maskVector, maskVal, stats)) {
    23622363            psError(PS_ERR_UNKNOWN, false, _("Failed to calculate fitted statistics"));
    23632364            status &= false;
    … …  
    23672368    // ************************************************************************
    23682369    if ((stats->options & PS_STAT_CLIPPED_MEAN) || (stats->options & PS_STAT_CLIPPED_STDEV)) {
    2369         if (!vectorClippedStats(inF32, errorsF32, maskU8, maskVal, stats)) {
     2370        if (!vectorClippedStats(inF32, errorsF32, maskVector, maskVal, stats)) {
    23702371            psError(PS_ERR_UNKNOWN, false, "Failed to calculate clipped statistics\n");
    23712372            status &= false;
    … …  
    23752376    psFree(inF32);
    23762377    psFree(errorsF32);
    2377     psFree(maskU8);
     2378    psFree(maskVector);
    23782379    psTrace(TRACE, 3,"---- %s() end  ----\n", __func__);
    23792380    return status;

  • trunk/psLib/src/math/psStats.h

    r18876 r21183  
    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.66 $ $Name: not supported by cvs2svn $
     11 * @date $Date: 2009-01-27 06:39:38 $
    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

  • trunk/psLib/src/mathtypes/psVector.c

    r20547 r21183  
    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.105 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2009-01-27 06:39:38 $
    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,

  • trunk/psLib/src/mathtypes/psVector.h

    r19502 r21183  
    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.74 $ $Name: not supported by cvs2svn $
     13 * @date $Date: 2009-01-27 06:39:38 $
    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

  • trunk/psLib/src/sys/psType.h

    r14454 r21183  
    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.63 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2009-01-27 06:39:38 $
    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 
     147#define PS_MIN_MASK_TYPE 0             /**< minimum valid Mask value */
     148#define PS_MAX_MASK_TYPE UINT8_MAX     /**< maximum valid Mask value */
    147149typedef psU8 psMaskType;               ///< the C datatype for a mask image
     150#define PS_NOT_MASK(A)(UINT8_MAX-(A))
     151
     152// alternate versions if needed
     153// #define PS_NOT_MASK(A)(UINT16_MAX-(A))
     154// #define PS_NOT_MASK(A)(UINT32_MAX-(A))
     155// #define PS_NOT_MASK(A)(UINT64_MAX-(A))
     156
     157// macros to abstract the vector mask type : these values must be consistent
     158#define PS_TYPE_VECTOR_MASK PS_TYPE_U8        /**< the psElemType to use for mask image */
     159#define PS_TYPE_VECTOR_MASK_DATA U8           /**< the data member to use for mask image */
     160#define PS_TYPE_VECTOR_MASK_NAME "psU8"       /**< the data type for mask as a string */
     161#define PS_MIN_VECTOR_MASK_TYPE 0             /**< minimum valid Vector Mask value */
     162#define PS_MAX_VECTOR_MASK_TYPE UINT8_MAX     /**< maximum valid Vector Mask value */
     163typedef psU8 psVectorMaskType;                    ///< the C datatype for a mask image
     164#define PS_NOT_VECTOR_MASK(A)(UINT8_MAX-(A))
     165
     166// macros to abstract the image mask type : these values must be consistent
     167#define PS_TYPE_IMAGE_MASK PS_TYPE_U16       /**< the psElemType to use for mask image */
     168#define PS_TYPE_IMAGE_MASK_DATA U16          /**< the data member to use for mask image */
     169#define PS_TYPE_IMAGE_MASK_NAME "psU16"      /**< the data type for mask as a string */
     170#define PS_MIN_IMAGE_MASK_TYPE 0             /**< minimum valid Image Mask value */
     171#define PS_MAX_IMAGE_MASK_TYPE UINT16_MAX    /**< maximum valid Image Mask value */
     172typedef psU16 psImageMaskType;               ///< the C datatype for a mask image
     173#define PS_NOT_IMAGE_MASK(A)(UINT16_MAX-(A))
    148174
    149175#define PS_MIN_S8        INT8_MIN      /**< minimum valid psS8 value */

  • trunk/psLib/src/types/psMetadata.c

    r20417 r21183  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.174 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2008-10-28 00:13:19 $
     14 *  @version $Revision: 1.175 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2009-01-27 06:39:38 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    866866METADATA_ADD_TYPE(F32,psF32,PS_DATA_F32)
    867867METADATA_ADD_TYPE(F64,psF64,PS_DATA_F64)
     868
     869METADATA_ADD_TYPE(Mask,psMaskType,PS_TYPE_MASK)
     870METADATA_ADD_TYPE(VectorMask,psVectorMaskType,PS_TYPE_VECTOR_MASK)
     871METADATA_ADD_TYPE(ImageMask,psImageMaskType,PS_TYPE_IMAGE_MASK)
     872
    868873METADATA_ADD_TYPE(List,psList*,PS_DATA_LIST)
    869874METADATA_ADD_TYPE(Str,const char*,PS_DATA_STRING)
    … …  
    10111016}
    10121017
    1013 #define psMetadataLookupNumTYPE(TYPE) \
    1014 ps##TYPE psMetadataLookup##TYPE(bool *status, const psMetadata *md, const char *key) \
     1018#define psMetadataLookupNumTYPE(TYPE,NAME) \
     1019ps##TYPE psMetadataLookup##NAME(bool *status, const psMetadata *md, const char *key) \
    10151020{ \
    10161021    psMetadataItem *metadataItem = NULL; \
    … …  
    10811086}
    10821087
    1083 psMetadataLookupNumTYPE(F32)
    1084 psMetadataLookupNumTYPE(F64)
    1085 psMetadataLookupNumTYPE(S8)
    1086 psMetadataLookupNumTYPE(S16)
    1087 psMetadataLookupNumTYPE(S32)
    1088 psMetadataLookupNumTYPE(S64)
    1089 psMetadataLookupNumTYPE(U8)
    1090 psMetadataLookupNumTYPE(U16)
    1091 psMetadataLookupNumTYPE(U32)
    1092 psMetadataLookupNumTYPE(U64)
    1093 psMetadataLookupNumTYPE(Bool)
     1088psMetadataLookupNumTYPE(F32,F32)
     1089psMetadataLookupNumTYPE(F64,F64)
     1090psMetadataLookupNumTYPE(S8,S8)
     1091psMetadataLookupNumTYPE(S16,S16)
     1092psMetadataLookupNumTYPE(S32,S32)
     1093psMetadataLookupNumTYPE(S64,S64)
     1094psMetadataLookupNumTYPE(U8,U8)
     1095psMetadataLookupNumTYPE(U16,U16)
     1096psMetadataLookupNumTYPE(U32,U32)
     1097psMetadataLookupNumTYPE(U64,U64)
     1098psMetadataLookupNumTYPE(Bool,Bool)
     1099
     1100psMetadataLookupNumTYPE(MaskType,Mask)
     1101psMetadataLookupNumTYPE(VectorMaskType,VectorMask)
     1102psMetadataLookupNumTYPE(ImageMaskType,ImageMask)
    10941103
    10951104psMetadataItem* psMetadataGet(const psMetadata *md,

  • trunk/psLib/src/types/psMetadata.h

    r19056 r21183  
    99*  @author Ross Harman, MHPCC
    1010*
    11 *  @version $Revision: 1.105 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2008-08-14 03:18:41 $
     11*  @version $Revision: 1.106 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2009-01-27 06:39:38 $
    1313*
    1414*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    763763
    764764
     765/** Add a psMaskType value to metadata collection.
     766 *
     767 *  @return bool:  True for success, False for failure.
     768 */
     769bool psMetadataAddMask(
     770    psMetadata* md,                    ///< Metadata collection to insert metadata item
     771    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
     772    const char* name,                  ///< Name of metadata item
     773    int format,                        ///< psMetadataFlag options/flags
     774    const char* comment,               ///< Comment for metadata item
     775    psMaskType value                    ///< Value for metadata item data
     776);
     777
     778
     779/** Add a psVectorMaskType value to metadata collection.
     780 *
     781 *  @return bool:  True for success, False for failure.
     782 */
     783bool psMetadataAddVectorMask(
     784    psMetadata* md,                    ///< Metadata collection to insert metadata item
     785    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
     786    const char* name,                  ///< Name of metadata item
     787    int format,                        ///< psMetadataFlag options/flags
     788    const char* comment,               ///< Comment for metadata item
     789    psVectorMaskType value                      ///< Value for metadata item data
     790);
     791
     792
     793/** Add a psImageMaskType value to metadata collection.
     794 *
     795 *  @return bool:  True for success, False for failure.
     796 */
     797bool psMetadataAddImageMask(
     798    psMetadata* md,                    ///< Metadata collection to insert metadata item
     799    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
     800    const char* name,                  ///< Name of metadata item
     801    int format,                        ///< psMetadataFlag options/flags
     802    const char* comment,               ///< Comment for metadata item
     803    psImageMaskType value                       ///< Value for metadata item data
     804);
     805
     806
     807
    765808/** Add a psList to metadata collection.
    766809 *
    … …  
    10951138 */
    10961139psU64 psMetadataLookupU64(
     1140    bool *status,                      ///< Status of lookup.
     1141    const psMetadata *md,              ///< Metadata collection to lookup metadata item.
     1142    const char *key                    ///< Name of metadata key.
     1143);
     1144
     1145
     1146/** Find an item in the metadata collection based on key name and return its integer value.
     1147 *
     1148 *  Items may be found in the metadata by providing a key. If the key is
     1149 *  non-unique, the value of the first item is returned. If the item is not
     1150 *  found, zero is returned.
     1151 *
     1152 * @return psMaskType : Value of metadata item.
     1153 */
     1154psMaskType psMetadataLookupMask(
     1155    bool *status,                      ///< Status of lookup.
     1156    const psMetadata *md,              ///< Metadata collection to lookup metadata item.
     1157    const char *key                    ///< Name of metadata key.
     1158);
     1159
     1160
     1161/** Find an item in the metadata collection based on key name and return its integer value.
     1162 *
     1163 *  Items may be found in the metadata by providing a key. If the key is
     1164 *  non-unique, the value of the first item is returned. If the item is not
     1165 *  found, zero is returned.
     1166 *
     1167 * @return psVectorMaskType : Value of metadata item.
     1168 */
     1169psVectorMaskType psMetadataLookupVectorMask(
     1170    bool *status,                      ///< Status of lookup.
     1171    const psMetadata *md,              ///< Metadata collection to lookup metadata item.
     1172    const char *key                    ///< Name of metadata key.
     1173);
     1174
     1175
     1176/** Find an item in the metadata collection based on key name and return its integer value.
     1177 *
     1178 *  Items may be found in the metadata by providing a key. If the key is
     1179 *  non-unique, the value of the first item is returned. If the item is not
     1180 *  found, zero is returned.
     1181 *
     1182 * @return psImageMaskType : Value of metadata item.
     1183 */
     1184psImageMaskType psMetadataLookupImageMask(
    10971185    bool *status,                      ///< Status of lookup.
    10981186    const psMetadata *md,              ///< Metadata collection to lookup metadata item.

  • trunk/psLib/src/types/psPixels.c

    r19539 r21183  
    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.44 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2009-01-27 06:39:38 $
    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            }

  • trunk/psLib/src/types/psPixels.h

    r19539 r21183  
    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.31 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2009-01-27 06:39:38 $
    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.