IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21183 for trunk/psphot/src


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/psphot/src
Files:
43 edited

Legend:

Unmodified
Added
Removed

  • trunk/psphot/src/psphot.h

    r21166 r21183  
    4040bool            psphotMomentsStats (pmReadout *readout, psMetadata *recipe, psArray *sources);
    4141bool            psphotFitSourcesLinear (pmReadout *readout, psArray *sources, psMetadata *recipe, pmPSF *psf, bool final);
    42 bool            psphotReplaceUnfitSources (psArray *sources, psMaskType maskVal);
     42bool            psphotReplaceUnfitSources (psArray *sources, psImageMaskType maskVal);
     43
    4344bool            psphotReplaceAllSources (psArray *sources, psMetadata *recipe);
    4445bool            psphotRemoveAllSources (psArray *sources, psMetadata *recipe);
    … …  
    7071
    7172// used by psphotFindDetections
    72 psImage        *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal);
     73psImage        *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal);
    7374psArray        *psphotFindPeaks (psImage *significance, pmReadout *readout, psMetadata *recipe, const float threshold, const int nMax);
    74 bool            psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal);
     75bool            psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal);
    7576psErrorCode     psphotCullPeaks(const psImage *img, const psImage *weight, const psMetadata *recipe, psArray *footprints);
    7677
    … …  
    8182// basic support functions
    8283void            psphotModelClassInit (void);
    83 bool            psphotGrowthCurve (pmReadout *readout, pmPSF *psf, bool ignore, psMaskType maskVal);
     84bool            psphotGrowthCurve (pmReadout *readout, pmPSF *psf, bool ignore, psImageMaskType maskVal);
    8485bool            psphotSetMaskAndWeight (pmConfig *config, pmReadout *readout, psMetadata *recipe);
    8586void            psphotSourceFreePixels (psArray *sources);
    … …  
    8788// functions to set the correct source pixels
    8889bool            psphotInitRadiusPSF (const psMetadata *recipe, const pmModelType type);
    89 bool            psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal);
    90 bool            psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal, float dR);
     90bool            psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal);
     91bool            psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal, float dR);
    9192bool            psphotInitRadiusEXT (psMetadata *recipe, pmModelType type);
    92 bool            psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal);
     93bool            psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal);
    9394
    9495// output functions
    … …  
    109110bool            psphotInitLimitsPSF (psMetadata *recipe, pmReadout *readout);
    110111bool            psphotInitLimitsEXT (psMetadata *recipe);
    111 bool            psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal);
    112 bool            psphotFitBlob (pmReadout *readout, pmSource *source, psArray *sources, pmPSF *psf, psMaskType maskVal, psMaskType markVal);
    113 bool            psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal);
    114 pmModel        *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal);
    115 psArray        *psphotFitDBL (pmReadout *readout, pmSource *source, psMaskType maskVal, psMaskType markVal);
     112bool            psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal);
     113bool            psphotFitBlob (pmReadout *readout, pmSource *source, psArray *sources, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal);
     114bool            psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal);
     115pmModel        *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal);
     116psArray        *psphotFitDBL (pmReadout *readout, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal);
    116117
    117118// functions to support simultaneous multi-source fitting
    118 bool            psphotFitSet (pmSource *oneSrc, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psMaskType maskVal);
     119bool            psphotFitSet (pmSource *oneSrc, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psImageMaskType maskVal);
    119120
    120121// plotting functions (available if libkapa is installed)
    … …  
    137138bool            psphotMosaicSubimage (psImage *outImage, pmSource *source, int Xo, int Yo, int DX, int DY, bool normalize);
    138139
    139 bool            psphotAddWithTest (pmSource *source, bool useState, psMaskType maskVal);
    140 bool            psphotSubWithTest (pmSource *source, bool useState, psMaskType maskVal);
    141 bool            psphotSetState (pmSource *source, bool curState, psMaskType maskVal);
     140bool            psphotAddWithTest (pmSource *source, bool useState, psImageMaskType maskVal);
     141bool            psphotSubWithTest (pmSource *source, bool useState, psImageMaskType maskVal);
     142bool            psphotSetState (pmSource *source, bool curState, psImageMaskType maskVal);
    142143bool            psphotDeblendSatstars (psArray *sources, psMetadata *recipe);
    143144bool            psphotSourceSize (pmConfig *config, pmReadout *readout, psArray *sources, psMetadata *recipe, long first);
    144145
    145 bool            psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psMaskType maskVal);
    146 
    147 pmModel        *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal, int psfSize);
     146bool            psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psImageMaskType maskVal);
     147
     148pmModel        *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize);
    148149
    149150psKernel       *psphotKernelFromPSF (pmSource *source, int nPix);
    150151
    151 bool            psphotRadialProfile (pmSource *source, psMetadata *recipe, psMaskType maskVal);
    152 bool            psphotPetrosian (pmSource *source, psMetadata *recipe, psMaskType maskVal);
    153 bool            psphotIsophotal (pmSource *source, psMetadata *recipe, psMaskType maskVal);
    154 bool            psphotAnnuli (pmSource *source, psMetadata *recipe, psMaskType maskVal);
    155 bool            psphotKron (pmSource *source, psMetadata *recipe, psMaskType maskVal);
     152bool            psphotRadialProfile (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
     153bool            psphotPetrosian (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
     154bool            psphotIsophotal (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
     155bool            psphotAnnuli (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
     156bool            psphotKron (pmSource *source, psMetadata *recipe, psImageMaskType maskVal);
    156157
    157158// psphotVisual functions
    … …  
    168169bool psphotVisualShowSatStars (psMetadata *recipe, pmPSF *psf, psArray *sources);
    169170bool psphotVisualShowPSFModel (pmReadout *readout, pmPSF *psf);
    170 bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psMaskType maskVal);
     171bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psImageMaskType maskVal);
    171172bool psphotVisualPlotRadialProfiles (psMetadata *recipe, psArray *sources);
    172173bool psphotVisualShowFlags (psArray *sources);
    … …  
    223224bool psphotMakeFluxScale (psImage *image, psMetadata *recipe, pmPSF *psf);
    224225bool psphotMakeGrowthCurve (pmReadout *readout, psMetadata *recipe, pmPSF *psf);
    225 bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psMaskType maskVal, psMaskType markVal);
     226bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psImageMaskType maskVal, psImageMaskType markVal);
    226227
    227228bool psphotCheckStarDistribution (psArray *sources, psArray *stars, pmPSFOptions *options);

  • trunk/psphot/src/psphotAddNoise.c

    r20593 r21183  
    2323
    2424    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    25     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     25    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    2626    assert (maskVal);
    2727

  • trunk/psphot/src/psphotAnnuli.c

    r17396 r21183  
    11# include "psphotInternal.h"
    22
    3 bool psphotAnnuli (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
     3bool psphotAnnuli (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
    44
    55  assert (source->extpars);

  • trunk/psphot/src/psphotApResid.c

    r21175 r21183  
    4444
    4545    // bit-masks to test for good/bad pixels
    46     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     46    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    4747    assert (maskVal);
    4848
    4949    // bit-mask to mark pixels not used in analysis
    50     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     50    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    5151    assert (markVal);
    5252
    … …  
    100100            psArrayAdd(job->args, 1, psf);
    101101            PS_ARRAY_ADD_SCALAR(job->args, photMode, PS_TYPE_S32);
    102             PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8); // XXX change this to use abstract mask type info
     102            PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
    103103
    104104            PS_ARRAY_ADD_SCALAR(job->args, 0,        PS_TYPE_S32); // this is used as a return value for Nskip
    … …  
    139139
    140140    // gather the stats to assess the aperture residuals
    141     psVector *mask    = psVectorAllocEmpty (300, PS_TYPE_U8);
     141    psVector *mask    = psVectorAllocEmpty (300, PS_TYPE_VECTOR_MASK);
    142142    psVector *mag     = psVectorAllocEmpty (300, PS_TYPE_F32);
    143143    psVector *xPos    = psVectorAllocEmpty (300, PS_TYPE_F32);
    … …  
    176176        yPos->data.F32[Npsf]    = model->params->data.F32[PM_PAR_YPOS];
    177177
    178         mask->data.U8[Npsf] = 0;
     178        mask->data.PS_TYPE_VECTOR_MASK_DATA[Npsf] = 0;
    179179
    180180        dMag->data.F32[Npsf] = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
    … …  
    242242                     mag->data.F32[i], dMag->data.F32[i], dMagSys->data.F32[i],
    243243                     apResid->data.F32[i], apResidRes->data.F32[i],
    244                      mask->data.U8[i]);
     244                     mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
    245245        }
    246246        fclose (dumpFile);
    … …  
    325325    psVector *dMSubset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
    326326    psVector *dASubset = psVectorAllocEmpty (nGroup, PS_TYPE_F32);
    327     psVector *mkSubset = psVectorAllocEmpty (nGroup, PS_TYPE_U8);
     327    psVector *mkSubset = psVectorAllocEmpty (nGroup, PS_TYPE_VECTOR_MASK);
    328328
    329329    int n = 0;
    … …  
    334334            dMSubset->data.F32[j] = dMag->data.F32[N];
    335335            dASubset->data.F32[j] = dap->data.F32[N];
    336             mkSubset->data.U8[j]  = mask->data.U8[N];
     336            mkSubset->data.PS_TYPE_VECTOR_MASK_DATA[j] = mask->data.PS_TYPE_VECTOR_MASK_DATA[N];
    337337        }
    338338        dMSubset->n = j;
    … …  
    460460    pmPSF *psf                      = job->args->data[1];
    461461    pmSourcePhotometryMode photMode = PS_SCALAR_VALUE(job->args->data[2],S32);
    462     psMaskType maskVal              = PS_SCALAR_VALUE(job->args->data[3],U8);
     462    psImageMaskType maskVal         = PS_SCALAR_VALUE(job->args->data[3],PS_TYPE_IMAGE_MASK_DATA);
    463463
    464464    for (int i = 0; i < sources->n; i++) {

  • trunk/psphot/src/psphotBlendFit.c

    r21166 r21183  
    133133
    134134    // bit-masks to test for good/bad pixels
    135     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     135    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    136136    assert (maskVal);
    137137
    138138    // bit-mask to mark pixels not used in analysis
    139     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     139    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    140140    assert (markVal);
    141141

  • trunk/psphot/src/psphotChoosePSF.c

    r21082 r21183  
    2424
    2525    // bit-masks to test for good/bad pixels
    26     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     26    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    2727    assert (maskVal);
    2828
    2929    // bit-mask to mark pixels not used in analysis
    30     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     30    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    3131    assert (markVal);
    3232
    … …  
    258258    for (int i = 0; i < try->sources->n; i++) {
    259259        pmSource *source = try->sources->data[i];
    260         if (try->mask->data.U8[i]) {
     260        if (try->mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
    261261            source->mode &= ~PM_SOURCE_MODE_PSFSTAR;
    262262        }

  • trunk/psphot/src/psphotExtendedSourceAnalysis.c

    r19881 r21183  
    1212
    1313    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    14     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     14    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    1515    assert (maskVal);
    1616

  • trunk/psphot/src/psphotExtendedSourceFits.c

    r19881 r21183  
    1313
    1414    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    15     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     15    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    1616    assert (maskVal);
    1717
    18     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT"); // Mask value for bad pixels
     18    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT"); // Mask value for bad pixels
    1919    assert (markVal);
    2020

  • trunk/psphot/src/psphotExtendedSources.c

    r17111 r21183  
    1212
    1313    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    14     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     14    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    1515    assert (maskVal);
    1616

  • trunk/psphot/src/psphotFindDetections.c

    r20453 r21183  
    1010
    1111    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    12     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     12    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    1313    assert (maskVal);
    1414

  • trunk/psphot/src/psphotFindFootprints.c

    r20831 r21183  
    11# include "psphotInternal.h"
    22
    3 bool psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal) {
     3bool psphotFindFootprints (pmDetections *detections, psImage *significance, pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal) {
    44
    55    bool status;

  • trunk/psphot/src/psphotFitSet.c

    r14337 r21183  
    22
    33// This is only used by psphotModelTest.c
    4 bool psphotFitSet (pmSource *source, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psMaskType maskVal) {
     4bool psphotFitSet (pmSource *source, pmModel *oneModel, char *fitset, pmSourceFitMode mode, psImageMaskType maskVal) {
    55
    66    double x, y, Io;

  • trunk/psphot/src/psphotFitSourcesLinear.c

    r20938 r21183  
    1010// the analysis is performed wrt the simulated pixel values
    1111
    12 static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psMaskType markVal);
     12static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psImageMaskType markVal);
    1313
    1414bool psphotFitSourcesLinear (pmReadout *readout, psArray *sources, psMetadata *recipe, pmPSF *psf, bool final) {
    … …  
    2323
    2424    // bit-masks to test for good/bad pixels
    25     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     25    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    2626    assert (maskVal);
    2727
    2828    // bit-mask to mark pixels not used in analysis
    29     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     29    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    3030    assert (markVal);
    3131
    … …  
    233233// on the pixels which correspond to all of the sources of interest.  These elements fill in
    234234// the border matrix components in the sparse matrix equation.
    235 static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psMaskType markVal) {
     235static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psImageMaskType markVal) {
    236236
    237237    // generate the image-wide weight terms
    … …  
    248248        float x = model->params->data.F32[PM_PAR_XPOS];
    249249        float y = model->params->data.F32[PM_PAR_YPOS];
    250         psImageMaskCircle (source->maskView, x, y, model->radiusFit, "AND", PS_NOT_U8(markVal));
     250        psImageMaskCircle (source->maskView, x, y, model->radiusFit, "AND", PS_NOT_IMAGE_MASK(markVal));
    251251    }
    252252
    … …  
    254254    psF32 **image  = readout->image->data.F32;
    255255    psF32 **weight = readout->weight->data.F32;
    256     psU8  **mask   = readout->mask->data.U8;
     256    psImageMaskType  **mask   = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA;
    257257
    258258    double w, x, y, x2, xy, y2, xc, yc, wt, f, fo, fx, fy;
    … …  
    288288
    289289    // turn off MARK for all image pixels
    290     psImageMaskRegion (readout->mask, fullArray, "AND", PS_NOT_U8(markVal));
     290    psImageMaskRegion (readout->mask, fullArray, "AND", PS_NOT_IMAGE_MASK(markVal));
    291291
    292292    // set the Border T elements

  • trunk/psphot/src/psphotGuessModels.c

    r21166 r21183  
    4141
    4242    // bit-masks to test for good/bad pixels
    43     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     43    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    4444    assert (maskVal);
    4545
    4646    // bit-mask to mark pixels not used in analysis
    47     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     47    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    4848    assert (markVal);
    4949
    … …  
    7373
    7474            // XXX change these to use abstract mask type info
    75             PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
    76             PS_ARRAY_ADD_SCALAR(job->args, markVal,  PS_TYPE_U8);
     75            PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
     76            PS_ARRAY_ADD_SCALAR(job->args, markVal,  PS_TYPE_IMAGE_MASK);
    7777
    7878            if (!psThreadJobAddPending(job)) {
    … …  
    130130    pmPSF *psf         = job->args->data[2];
    131131   
    132     psMaskType maskVal = PS_SCALAR_VALUE(job->args->data[3],U8);
    133     psMaskType markVal = PS_SCALAR_VALUE(job->args->data[4],U8);
     132    psImageMaskType maskVal = PS_SCALAR_VALUE(job->args->data[3],PS_TYPE_IMAGE_MASK_DATA);
     133    psImageMaskType markVal = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA);
    134134
    135135    int nSrc = 0;

  • trunk/psphot/src/psphotIsophotal.c

    r17561 r21183  
    11# include "psphotInternal.h"
    22
    3 bool psphotIsophotal (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
     3bool psphotIsophotal (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
    44
    55  assert (source->extpars);

  • trunk/psphot/src/psphotKron.c

    r17396 r21183  
    11# include "psphotInternal.h"
    22
    3 bool psphotKron (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
     3bool psphotKron (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
    44
    55  psLogMsg ("psphot", PS_LOG_INFO, "not implemented\n");

  • trunk/psphot/src/psphotMagnitudes.c

    r21166 r21183  
    2828
    2929    // bit-masks to test for good/bad pixels
    30     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     30    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    3131    assert (maskVal);
    3232
    3333    // bit-mask to mark pixels not used in analysis
    34     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     34    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    3535    assert (markVal);
    3636

  • trunk/psphot/src/psphotMakeGrowthCurve.c

    r20453 r21183  
    1111
    1212    // bit-masks to test for good/bad pixels
    13     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     13    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    1414    assert (maskVal);
    1515
    1616    // bit-mask to mark pixels not used in analysis
    17     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     17    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    1818    assert (markVal);
    1919

  • trunk/psphot/src/psphotMakeResiduals.c

    r20453 r21183  
    11# include "psphotInternal.h"
    22
    3 bool psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psMaskType maskVal) {
     3bool psphotMakeResiduals (psArray *sources, psMetadata *recipe, pmPSF *psf, psImageMaskType maskVal) {
    44
    55    bool status, isPSF;
    66    double flux, dflux;
    7     psU8 mflux;
     7    psImageMaskType mflux;
    88
    99    psTimerStart ("psphot.residuals");
    … …  
    6969    // - set output pixel, weight, and mask
    7070
    71     // XXX need to set these correctly!!
    72     const int badMask = 1;              // mask bits
    73     const int poorMask = 2;             //       from psImageInterpolate
    74     const int clippedMask = 4;          // mask bit set for clipped values
     71    // these mask values do not correspond to the recipe values: they
     72    // are not propagated to images: they just need to fit in an 8-bit
     73    // value.  they are supplied to psImageInterpolate, which takes a
     74    // psImageMaskType; the mask portion of the result from
     75    // psImageInterpolate is supplied to fmasks, which is then used by
     76    // psVectorStats
     77
     78    const psImageMaskType badMask     = 0x01;   // mask bits
     79    const psImageMaskType poorMask    = 0x02;   // from psImageInterpolate
     80    const psImageMaskType clippedMask = 0x04;   // mask bit set for clipped values
     81    const psVectorMaskType fmaskVal = badMask | poorMask | clippedMask;
    7582
    7683    // determine the maximum image size from the input sources
    … …  
    95102        psImage *image  = psImageCopy (NULL, source->pixels,   PS_TYPE_F32);
    96103        psImage *weight = psImageCopy (NULL, source->weight,   PS_TYPE_F32);
    97         psImage *mask   = psImageCopy (NULL, source->maskView, PS_TYPE_U8);
     104        psImage *mask   = psImageCopy (NULL, source->maskView, PS_TYPE_IMAGE_MASK);
    98105        pmModelSub (image, mask, model, PM_MODEL_OP_FUNC, maskVal);
    99106
    … …  
    103110        psBinaryOp (weight, weight, "/", psScalarAlloc(Io*Io, PS_TYPE_F32));
    104111
    105         // we will interpolate the image and weight - include the mask or not?
    106         // XXX consider better values for the mask bits
    107         psImageInterpolation *interp =
    108             psImageInterpolationAlloc(mode, image, weight, NULL, 0xff, 0.0, 0.0, badMask, poorMask, 0.0, 0);
    109         psArrayAdd (input,  100, interp);
     112        // we interpolate the image and weight - include the mask or not?
     113        // XXX why not the mask?
     114        // psImageInterpolation *interp = psImageInterpolationAlloc(mode, image, weight, mask, maskVal, 0.0, 0.0, badMask, poorMask, 0.0, 0);
     115        psImageInterpolation *interp = psImageInterpolationAlloc(mode, image, weight, NULL, 0xff, 0.0, 0.0, badMask, poorMask, 0.0, 0);
     116        psArrayAdd (input, 100, interp);
    110117
    111118        // save the X,Y position for future reference
    … …  
    131138    psVector *fluxes  = psVectorAlloc (input->n, PS_TYPE_F32);
    132139    psVector *dfluxes = psVectorAlloc (input->n, PS_TYPE_F32);
    133     psVector *fmasks  = psVectorAlloc (input->n, PS_TYPE_U8);
     140    psVector *fmasks  = psVectorAlloc (input->n, PS_TYPE_VECTOR_MASK);
    134141
    135142    // statistic to use to determine baseline for clipping
    … …  
    164171                bool offImage = false;
    165172                if (psImageInterpolate (&flux, &dflux, &mflux, ix, iy, interp) == PS_INTERPOLATE_STATUS_OFF) {
     173                    // fprintf (stderr, "off image: %f %f : %f %f\n", ix, iy, flux, dflux);
    166174                    // This pixel is off the image
    167175                    offImage = true;
    168                     fmasks->data.U8[i] = 1;
    169                     // fprintf (stderr, "off image: %f %f : %f %f\n", ix, iy, flux, dflux);
    170                 }
    171                 fluxes->data.F32[i] = flux;
    172                 dfluxes->data.F32[i] = dflux;
    173                 fmasks->data.U8[i] = mflux;
     176                    fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = badMask;
     177                } else {
     178                  fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = mflux; // XXX is mflux IMAGE or VECTOR type?
     179                }
     180                fluxes->data.F32[i] = flux;
     181                dfluxes->data.F32[i] = dflux;
    174182                if (isnan(flux)) {
    175                     fmasks->data.U8[i] = 1;
    176                 }
    177                 if (fmasks->data.U8[i] == 0) {
     183                    fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = badMask;
     184                }
     185                if (fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] == 0) {
    178186                    nGoodPixel ++;
    179187                }
    180188            }
    181189
    182             // skip pixels which are off the image...
     190            // skip pixels with insufficient data
    183191            bool validPixel = (SPATIAL_ORDER == 0) ? (nGoodPixel > 1) : (nGoodPixel > 3);
    184192            if (!validPixel) {
    … …  
    186194                resid->Rx->data.F32[oy][ox] = 0.0;
    187195                resid->Ry->data.F32[oy][ox] = 0.0;
    188                 resid->mask->data.U8[oy][ox] = 1;
     196                resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox] = badMask;
    189197                continue;
    190198            }
    … …  
    192200            // measure the robust median to determine a baseline reference value
    193201            *fluxClip = *fluxClipDef;
    194             psVectorStats (fluxClip, fluxes, NULL, fmasks, 0xff);
     202            psVectorStats (fluxClip, fluxes, NULL, fmasks, fmaskVal);
    195203            psErrorClear();             // clear (ignore) any outstanding errors
    196204
    … …  
    202210                float swing = fabs(delta) / sigma;
    203211
    204                 // make this a user option
     212                // mask pixels which are out of range
    205213                if (swing > nSigma) {
    206                     fmasks->data.U8[i] = clippedMask;
    207                 }
    208                 if (!fmasks->data.U8[i]) nKeep++;
     214                    fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i] = clippedMask;
     215                }
     216                if (!fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i]) nKeep++;
    209217            }
    210218
    … …  
    212220                // measure the desired statistic on the unclipped pixels
    213221                *fluxStats = *fluxStatsDef;
    214                 psVectorStats (fluxStats, fluxes, NULL, fmasks, 0xff);
     222                psVectorStats (fluxStats, fluxes, NULL, fmasks, fmaskVal);
    215223                psErrorClear();         // clear (ignore) any outstanding errors
    216224
    … …  
    220228
    221229                if (fabs(resid->Ro->data.F32[oy][ox]) < pixelSN*fluxStats->sampleStdev/sqrt(nKeep)) {
    222                   resid->mask->data.U8[oy][ox] = 1;
    223                 }
    224 
    225                 // fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n", ox, oy, resid->Ro->data.F32[oy][ox], fluxStats->sampleStdev, fluxStats->sampleStdev/sqrt(nKeep), nKeep, resid->mask->data.U8[oy][ox]);
     230                  resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox] = 1;
     231                }
     232
     233                // fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n", ox, oy, resid->Ro->data.F32[oy][ox], fluxStats->sampleStdev, fluxStats->sampleStdev/sqrt(nKeep), nKeep, resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox]);
    226234
    227235            } else {
    … …  
    230238                psVectorInit(B, 0.0);
    231239                for (int i = 0; i < fluxes->n; i++) {
    232                     if (fmasks->data.U8[i]) continue;
     240                    if (fmasks->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
    233241                    B->data.F64[0] += fluxes->data.F32[i]/dfluxes->data.F32[i];
    234242                    B->data.F64[1] += fluxes->data.F32[i]*xC->data.F32[i]/dfluxes->data.F32[i];
    … …  
    260268
    261269                float dRo = sqrt(A->data.F32[0][0]);
    262                 // fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n", ox, oy, resid->Ro->data.F32[oy][ox], dRo, dRo/sqrt(nKeep), nKeep, resid->mask->data.U8[oy][ox]);
     270                // fprintf (stderr, "res: %2d %2d : %6.4f  %6.4f  %6.4f   %3d  %1d\n",
     271                // ox, oy, resid->Ro->data.F32[oy][ox], dRo, dRo/sqrt(nKeep), nKeep, resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox]);
    263272
    264273                if (fabs(resid->Ro->data.F32[oy][ox]) < pixelSN*dRo/sqrt(nKeep)) {
    265                   resid->mask->data.U8[oy][ox] = 1;
     274                  resid->mask->data.PM_TYPE_RESID_MASK_DATA[oy][ox] = 1;
    266275                }
    267276                //resid->weight->data.F32[oy][ox] = XXX;

  • trunk/psphot/src/psphotMaskReadout.c

    r18832 r21183  
    99    // XXX drop the write to recipe and move config into psphotRoughClass?
    1010    // XXX alternatively, define a function to set the psphot recipe masks
    11     psMaskType maskSat  = pmConfigMaskGet("SAT", config); // Mask value for saturated pixels
    12     psMetadataAddU8 (recipe, PS_LIST_TAIL, "MASK.SAT", PS_META_REPLACE, "user-defined mask", maskSat);
     11    psImageMaskType maskSat  = pmConfigMaskGet("SAT", config); // Mask value for saturated pixels
     12    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MASK.SAT", PS_META_REPLACE, "user-defined mask", maskSat);
    1313
    14     psMaskType maskBad  = pmConfigMaskGet("BAD", config); // Mask value for bad pixels
    15     psMetadataAddU8 (recipe, PS_LIST_TAIL, "MASK.BAD", PS_META_REPLACE, "user-defined mask", maskBad);
     14    psImageMaskType maskBad  = pmConfigMaskGet("BAD", config); // Mask value for bad pixels
     15    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MASK.BAD", PS_META_REPLACE, "user-defined mask", maskBad);
    1616
    1717    // generate mask & weight images if they don't already exit

  • trunk/psphot/src/psphotModelBackground.c

    r21108 r21183  
    4646
    4747    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    48     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     48    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    4949    assert (maskVal);
    5050

  • trunk/psphot/src/psphotModelTest.c

    r19881 r21183  
    1313
    1414    // bit-masks to test for good/bad pixels
    15     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     15    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    1616    assert (maskVal);
    1717
    1818    // bit-mask to mark pixels not used in analysis
    19     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     19    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    2020    assert (markVal);
    2121

  • trunk/psphot/src/psphotModelWithPSF.c

    r17396 r21183  
    2020        paramMask = constraint->paramMask;
    2121        if (paramMask != NULL) {
    22             PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_U8, false);
     22          PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    2323            PS_ASSERT_VECTORS_SIZE_EQUAL(params, paramMask, false);
    2424        }
    … …  
    145145        psImageInit (covar, 0.0);
    146146        for (int j = 0, J = 0; j < params->n; j++) {
    147             if (paramMask && (paramMask->data.U8[j])) {
     147            if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
    148148                covar->data.F32[j][j] = 1.0;
    149149                continue;
    150150            }
    151151            for (int k = 0, K = 0; k < params->n; k++) {
    152                 if (paramMask && (paramMask->data.U8[k])) continue;
     152                if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
    153153                covar->data.F32[j][k] = Alpha->data.F32[J][K];
    154154                K++;
    … …  
    197197    PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, false);
    198198    if (paramMask) {
    199         PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_MASK, false);
     199        PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
    200200    }
    201201
    … …  
    224224            // XXX probably should not skipped masked points:
    225225            // XXX skip if convolution of unmasked pixels will not see this pixel
    226             // if (source->maskObj->data.U8[i][j]) {
     226            // if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
    227227            // continue;
    228228            // }
    … …  
    246246
    247247            for (int n = 0; n < params->n; n++) {
    248                 if ((paramMask != NULL) && (paramMask->data.U8[n])) { continue; }
     248                if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
    249249                psImage *dmodel = pcm->dmodels->data[n];
    250250                dmodel->data.F32[i][j] = deriv->data.F32[n];
    … …  
    285285            // XXX are we doing the right thing with the mask?
    286286            // skip masked points
    287             if (source->maskObj->data.U8[i][j]) {
     287            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
    288288                continue;
    289289            }
    … …  
    308308            // alpha & beta only contain unmasked elements
    309309            for (int n1 = 0, N1 = 0; n1 < params->n; n1++) {
    310                 if ((paramMask != NULL) && (paramMask->data.U8[n1])) continue;
     310                if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n1])) continue;
    311311                psImage *dmodel = pcm->dmodelsConv->data[n1];
    312312                float weight = dmodel->data.F32[i][j] * yweight;
    313313                for (int n2 = 0, N2 = 0; n2 <= n1; n2++) {
    314                     if ((paramMask != NULL) && (paramMask->data.U8[n2])) continue;
     314                    if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n2])) continue;
    315315                    dmodel = pcm->dmodelsConv->data[n2];
    316316                    alpha->data.F32[N1][N2] += weight * dmodel->data.F32[i][j];
    … …  
    357357    for (psS32 n = 0; n < params->n; n++) {
    358358        pcm->dmodels->data[n] = NULL;
    359         if ((paramMask != NULL) && (paramMask->data.U8[n])) { continue; }
     359        if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
    360360        pcm->dmodels->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
    361361    }
    … …  
    366366    for (psS32 n = 0; n < params->n; n++) {
    367367        pcm->dmodelsConv->data[n] = NULL;
    368         if ((paramMask != NULL) && (paramMask->data.U8[n])) { continue; }
     368        if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
    369369        pcm->dmodelsConv->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
    370370    }

  • trunk/psphot/src/psphotMosaicChip.c

    r18712 r21183  
    2525    }
    2626
    27     psMaskType blankMask = pmConfigMaskGet("BLANK", config);
     27    psImageMaskType blankMask = pmConfigMaskGet("BLANK", config);
    2828
    2929    // mosaic the chip, forcing a deep copy (resulting images are not subimages)

  • trunk/psphot/src/psphotOutput.c

    r20237 r21183  
    7474        for (int j = 0; j < source->pixels->numCols; j++) {
    7575            // skip masked points
    76             if (source->maskObj->data.U8[i][j]) {
     76            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
    7777                continue;
    7878            }
    … …  
    8787                     source->pixels->data.F32[i][j],
    8888                     1.0 / source->weight->data.F32[i][j],
    89                      source->maskObj->data.U8[i][j]);
     89                     source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]);
    9090        }
    9191    }
    … …  
    237237
    238238// XXX add args as needed
    239 bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psMaskType maskVal, psMaskType markVal) {
     239bool psphotDumpPSFStars (pmReadout *readout, pmPSFtry *try, float radius, psImageMaskType maskVal, psImageMaskType markVal) {
    240240
    241241    psphotSaveImage (NULL, readout->image,  "rawstars.fits");
    … …  
    243243    for (int i = 0; i < try->sources->n; i++) {
    244244        // masked for: bad model fit, outlier in parameters
    245         if (try->mask->data.U8[i] & PSFTRY_MASK_ALL)
     245        if (try->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL)
    246246            continue;
    247247
    … …  
    256256        psImageKeepCircle (source->maskObj, x, y, radius, "OR", markVal);
    257257        pmModelSub (source->pixels, source->maskObj, source->modelPSF, PM_MODEL_OP_FULL, maskVal);
    258         psImageKeepCircle (source->maskObj, x, y, radius, "AND", PS_NOT_U8(markVal));
     258        psImageKeepCircle (source->maskObj, x, y, radius, "AND", PS_NOT_IMAGE_MASK(markVal));
    259259    }
    260260
    … …  
    264264
    265265        // masked for: bad model fit, outlier in parameters
    266         if (try->mask->data.U8[i] & PSFTRY_MASK_ALL) continue;
     266        if (try->mask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PSFTRY_MASK_ALL) continue;
    267267
    268268        pmSource *source = try->sources->data[i];

  • trunk/psphot/src/psphotPSFConvModel.c

    r18555 r21183  
    99// modelConv to contain the fitted parameters, and the modelFlux to contain the
    1010// convolved model image.
    11 pmModel *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal, int psfSize) {
     11pmModel *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) {
    1212   
    1313    // maskVal is used to test for rejected pixels, and must include markVal
    … …  
    7272    // create the minimization constraints
    7373    psMinConstraint *constraint = psMinConstraintAlloc();
    74     constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_U8);
     74    constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
    7575    constraint->checkLimits = modelConv->modelLimits;
    7676
    … …  
    7979    int nParams = params->n - 1;
    8080    psVectorInit (constraint->paramMask, 0);
    81     constraint->paramMask->data.U8[PM_PAR_SKY] = 1;
     81    constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1;
    8282
    8383    // force the floating parameters to fall within the contraint ranges
    … …  
    9797            fprintf (stderr, "%f ", params->data.F32[i]);
    9898        }
    99         if ((constraint->paramMask != NULL) && constraint->paramMask->data.U8[i])
     99        if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    100100            continue;
    101101        dparams->data.F32[i] = sqrt(covar->data.F32[i][i]);

  • trunk/psphot/src/psphotPetrosian.c

    r17561 r21183  
    11# include "psphotInternal.h"
    22
    3 bool psphotPetrosian (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
     3bool psphotPetrosian (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
    44
    55  bool status;

  • trunk/psphot/src/psphotRadialPlot.c

    r15017 r21183  
    6060    for (int iy = 0; iy < source->pixels->numRows; iy++) {
    6161        for (int ix = 0; ix < source->pixels->numCols; ix++) {
    62             if (source->maskObj->data.U8[iy][ix]) {
     62            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) {
    6363                rb->data.F32[nb] = hypot (ix - Xo, iy - Yo) ;
    6464                fb->data.F32[nb] = log10(source->pixels->data.F32[iy][ix]);

  • trunk/psphot/src/psphotRadialProfile.c

    r17396 r21183  
    1717}
    1818
    19 bool psphotRadialProfile (pmSource *source, psMetadata *recipe, psMaskType maskVal) {
     19bool psphotRadialProfile (pmSource *source, psMetadata *recipe, psImageMaskType maskVal) {
    2020
    2121    // allocate pmSourceExtendedParameters, if not already defined
    … …  
    5454    for (int iy = 0; iy < source->pixels->numRows; iy++) {
    5555        for (int ix = 0; ix < source->pixels->numCols; ix++) {
    56             if (source->maskObj->data.U8[iy][ix]) continue;
     56            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) continue;
    5757            radius->data.F32[n] = hypot (ix - Xo, iy - Yo) ;
    5858            flux->data.F32[n]   = source->pixels->data.F32[iy][ix];

  • trunk/psphot/src/psphotRadiusChecks.c

    r19308 r21183  
    1919
    2020// call this function whenever you (re)-define the PSF model
    21 bool psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal)
     21bool psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal)
    2222{
    2323    psF32 *PAR = model->params->data.F32;
    … …  
    5050}
    5151
    52 bool psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal, float dR) {
     52bool psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal, float dR) {
    5353
    5454    psF32 *PAR = model->params->data.F32;
    … …  
    8686
    8787// call this function whenever you (re)-define the EXT model
    88 bool psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psMaskType markVal) {
     88bool psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal) {
    8989
    9090    psF32 *PAR = model->params->data.F32;

  • trunk/psphot/src/psphotReplaceUnfit.c

    r20453 r21183  
    22
    33// replace the flux for sources which failed
    4 bool psphotReplaceUnfitSources (psArray *sources, psMaskType maskVal) {
     4bool psphotReplaceUnfitSources (psArray *sources, psImageMaskType maskVal) {
    55
    66    pmSource *source;
    … …  
    3131
    3232    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    33     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     33    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    3434    assert (maskVal);
    3535
    … …  
    5555
    5656    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    57     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     57    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    5858    assert (maskVal);
    5959
    … …  
    7272
    7373// add source, if the source has been subtracted; do not modify state
    74 bool psphotAddWithTest (pmSource *source, bool useState, psMaskType maskVal) {
     74bool psphotAddWithTest (pmSource *source, bool useState, psImageMaskType maskVal) {
    7575
    7676    // what is current state? (true : add; false : sub)
    … …  
    8383
    8484// sub source, if the source has been added; do not modify state
    85 bool psphotSubWithTest (pmSource *source, bool useState, psMaskType maskVal) {
     85bool psphotSubWithTest (pmSource *source, bool useState, psImageMaskType maskVal) {
    8686
    8787    // what is current state? (true : sub; false : add)
    … …  
    9494
    9595// add or sub source to match recorded state: supply current state as true (add) or false (sub)
    96 bool psphotSetState (pmSource *source, bool curState, psMaskType maskVal) {
     96bool psphotSetState (pmSource *source, bool curState, psImageMaskType maskVal) {
    9797
    9898    // what is desired state? (true : add; false : sub)

  • trunk/psphot/src/psphotRoughClass.c

    r20453 r21183  
    5757
    5858    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    59     psMaskType maskSat = psMetadataLookupU8(&status, recipe, "MASK.SAT"); // Mask value for bad pixels
     59    psImageMaskType maskSat = psMetadataLookupImageMask(&status, recipe, "MASK.SAT"); // Mask value for bad pixels
    6060    assert (maskSat);
    6161

  • trunk/psphot/src/psphotSetMaskBits.c

    r18469 r21183  
    1010bool psphotSetMaskBits (pmConfig *config) {
    1111
    12     psMaskType maskValue;
    13     psMaskType markValue;
     12    psImageMaskType maskValue;
     13    psImageMaskType markValue;
    1414
    1515    if (!pmConfigMaskSetBits (&maskValue, &markValue, config)) {
    … …  
    2626
    2727    // set maskValue and markValue in the psphot recipe
    28     psMetadataAddU8 (recipe, PS_LIST_TAIL, "MARK.PSPHOT", PS_META_REPLACE, "user-defined mask", markValue);
    29     psMetadataAddU8 (recipe, PS_LIST_TAIL, "MASK.PSPHOT", PS_META_REPLACE, "user-defined mask", maskValue);
     28    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MARK.PSPHOT", PS_META_REPLACE, "user-defined mask", markValue);
     29    psMetadataAddImageMask (recipe, PS_LIST_TAIL, "MASK.PSPHOT", PS_META_REPLACE, "user-defined mask", maskValue);
    3030
    3131    return true;

  • trunk/psphot/src/psphotSignificanceImage.c

    r20829 r21183  
    44// (S/N)^2.  If FWMH_X,Y have been recorded, use them, otherwise use PEAKS_SMOOTH_SIGMA for the
    55// smoothing kernel.
    6 psImage *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psMaskType maskVal) {
     6psImage *psphotSignificanceImage (pmReadout *readout, psMetadata *recipe, const int pass, psImageMaskType maskVal) {
    77
    88    float SIGMA_SMTH, NSIGMA_SMTH;
    … …  
    110110        for (int i = 0; i < smooth_im->numCols; i++) {
    111111            float value = smooth_im->data.F32[j][i];
    112             if (value < 0 || smooth_wt->data.F32[j][i] <= 0 || (mask->data.U8[j][i] & maskVal)) {
     112            if (value < 0 || smooth_wt->data.F32[j][i] <= 0 || (mask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] & maskVal)) {
    113113                smooth_im->data.F32[j][i] = 0.0;
    114114            } else {

  • trunk/psphot/src/psphotSkyReplace.c

    r20453 r21183  
    1717    // select the corresponding images
    1818    psF32 **image = readout->image->data.F32;
    19     psU8  **mask  = readout->mask->data.U8;
     19    psImageMaskType  **mask  = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA;
    2020    psF32 **back  = background->image->data.F32;
    2121

  • trunk/psphot/src/psphotSourceFits.c

    r21166 r21183  
    2222}
    2323
    24 bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal) {
     24bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) {
    2525
    2626    float x, y, dR;
    … …  
    147147}
    148148
    149 bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psMaskType maskVal, psMaskType markVal) {
     149bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) {
    150150
    151151    double chiTrend;
    … …  
    208208}
    209209
    210 bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *newSources, pmPSF *psf, psMaskType maskVal, psMaskType markVal) {
     210bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *newSources, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) {
    211211
    212212    bool okEXT, okDBL;
    … …  
    318318
    319319// fit a double PSF source to an extended blob
    320 psArray *psphotFitDBL (pmReadout *readout, pmSource *source, psMaskType maskVal, psMaskType markVal) {
     320psArray *psphotFitDBL (pmReadout *readout, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal) {
    321321
    322322    float dx, dy;
    … …  
    370370}
    371371
    372 pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psMaskType maskVal, psMaskType markVal) {
     372pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal) {
    373373
    374374    NfitEXT ++;

  • trunk/psphot/src/psphotSourcePlots.c

    r19869 r21183  
    77
    88    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    9     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     9    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    1010    assert (maskVal);
    1111

  • trunk/psphot/src/psphotSourceSize.c

    r20938 r21183  
    33
    44static float psphotModelContour(const psImage *image, const psImage *weight, const psImage *mask,
    5                                 psMaskType maskVal, const pmModel *model, float Ro);
    6 
    7 bool psphotMaskCosmicRay_Old (pmSource *source, psMaskType maskVal, psMaskType crMask);
    8 bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psMaskType maskVal, psMaskType crMask);
     5                                psImageMaskType maskVal, const pmModel *model, float Ro);
     6
     7bool psphotMaskCosmicRay_Old (pmSource *source, psImageMaskType maskVal, psImageMaskType crMask);
     8bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psImageMaskType maskVal, psImageMaskType crMask);
    99
    1010// we need to call this function after sources have been fitted to the PSF model and
    … …  
    2121
    2222    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    23     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     23    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    2424    assert (maskVal);
    2525
    2626    // bit to mask the cosmic-ray pixels
    27     psMaskType crMask  = pmConfigMaskGet("CR", config); // Mask value for cosmic rays
     27    psImageMaskType crMask  = pmConfigMaskGet("CR", config); // Mask value for cosmic rays
    2828
    2929    float CR_NSIGMA_LIMIT = psMetadataLookupF32 (&status, recipe, "PSPHOT.CR.NSIGMA.LIMIT");
    … …  
    6363        psF32 **resid  = source->pixels->data.F32;
    6464        psF32 **weight = source->weight->data.F32;
    65         psU8 **mask    = source->maskObj->data.U8;
     65        psImageMaskType **mask    = source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA;
    6666
    6767        // check for extendedness: measure the delta flux significance at the 1 sigma contour
    … …  
    191191// deviations?
    192192static float psphotModelContour(const psImage *image, const psImage *weight, const psImage *mask,
    193                                 psMaskType maskVal, const pmModel *model, float Ro)
     193                                psImageMaskType maskVal, const pmModel *model, float Ro)
    194194{
    195195    psF32 *PAR = model->params->data.F32; // Model parameters
    … …  
    239239
    240240        if (yPixM >= 0 && yPixM < image->numRows &&
    241             !(mask && (mask->data.PS_TYPE_MASK_DATA[yPixM][xPix] & maskVal))) {
     241            !(mask && (mask->data.PS_TYPE_IMAGE_MASK_DATA[yPixM][xPix] & maskVal))) {
    242242            float dSigma = image->data.F32[yPixM][xPix] / sqrtf(weight->data.F32[yPixM][xPix]);
    243243            nSigma += dSigma;
    … …  
    250250
    251251        if (yPixP >= 0 && yPixP < image->numRows &&
    252             !(mask && (mask->data.PS_TYPE_MASK_DATA[yPixP][xPix] & maskVal))) {
     252            !(mask && (mask->data.PS_TYPE_IMAGE_MASK_DATA[yPixP][xPix] & maskVal))) {
    253253            float dSigma = image->data.F32[yPixP][xPix] / sqrtf(weight->data.F32[yPixP][xPix]);
    254254            nSigma += dSigma;
    … …  
    260260}
    261261
    262 bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psMaskType maskVal, psMaskType crMask) {
     262bool psphotMaskCosmicRay_New (psImage *mask, pmSource *source, psImageMaskType maskVal, psImageMaskType crMask) {
    263263
    264264    // replace the source flux
    … …  
    294294       
    295295        for (int ix = xs; ix < xe; ix++) {
    296             mask->data.U8[iy][ix] |= crMask;
     296            mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] |= crMask;
    297297        }
    298298    }
    … …  
    300300}
    301301
    302 bool psphotMaskCosmicRay_Old (pmSource *source, psMaskType maskVal, psMaskType crMask) {
     302bool psphotMaskCosmicRay_Old (pmSource *source, psImageMaskType maskVal, psImageMaskType crMask) {
    303303
    304304    source->mode |= PM_SOURCE_MODE_CR_LIMIT;
    … …  
    320320        float SN = pixels->data.F32[yo][ix] / sqrt(weight->data.F32[yo][ix]);
    321321        if (SN > SN_LIMIT) {
    322             mask->data.U8[yo][ix] |= crMask;
     322            mask->data.PS_TYPE_IMAGE_MASK_DATA[yo][ix] |= crMask;
    323323        }
    324324    }
    … …  
    326326        float SN = pixels->data.F32[yo][ix] / sqrt(weight->data.F32[yo][ix]);
    327327        if (SN > SN_LIMIT) {
    328             mask->data.U8[yo][ix] |= crMask;
     328            mask->data.PS_TYPE_IMAGE_MASK_DATA[yo][ix] |= crMask;
    329329        }
    330330    }
    … …  
    339339
    340340            bool valid = false;
    341             valid |= (mask->data.U8[iy+1][ix] & crMask);
    342             valid |= (ix > 0) ? (mask->data.U8[iy+1][ix-1] & crMask) : 0;
    343             valid |= (ix <= mask->numCols) ? (mask->data.U8[iy+1][ix+1] & crMask) : 0;
     341            valid |= (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+1][ix] & crMask);
     342            valid |= (ix > 0) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+1][ix-1] & crMask) : 0;
     343            valid |= (ix <= mask->numCols) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy+1][ix+1] & crMask) : 0;
    344344
    345345            if (!valid) continue;
    346             mask->data.U8[iy][ix] |= crMask;
     346            mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] |= crMask;
    347347        }
    348348    }
    … …  
    355355
    356356            bool valid = false;
    357             valid |= (mask->data.U8[iy-1][ix] & crMask);
    358             valid |= (ix > 0) ? (mask->data.U8[iy-1][ix-1] & crMask) : 0;
    359             valid |= (ix <= mask->numCols) ? (mask->data.U8[iy-1][ix+1] & crMask) : 0;
     357            valid |= (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy-1][ix] & crMask);
     358            valid |= (ix > 0) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy-1][ix-1] & crMask) : 0;
     359            valid |= (ix <= mask->numCols) ? (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy-1][ix+1] & crMask) : 0;
    360360
    361361            if (!valid) continue;
    362             mask->data.U8[iy][ix] |= crMask;
     362            mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] |= crMask;
    363363        }
    364364    }

  • trunk/psphot/src/psphotSourceStats.c

    r21166 r21183  
    1717        nThreads = 0;
    1818    }
    19     // nThreads = 0; // XXX until testing is complete, do not thread this function
    2019
    2120    // determine properties (sky, moments) of initial sources
    … …  
    144143
    145144    // bit-masks to test for good/bad pixels
    146     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT");
     145    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT");
    147146    assert (maskVal);
    148147
    149148    // bit-mask to mark pixels not used in analysis
    150     psMaskType markVal = psMetadataLookupU8(&status, recipe, "MARK.PSPHOT");
     149    psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT");
    151150    assert (markVal);
    152151

  • trunk/psphot/src/psphotSubtractBackground.c

    r20453 r21183  
    2828
    2929    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    30     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     30    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    3131    assert (maskVal);
    3232

  • trunk/psphot/src/psphotTestPSF.c

    r18555 r21183  
    111111        psImageKeepCircle (source->mask, x, y, RADIUS, "OR", markVal);
    112112        status = pmSourceFitModel (source, model, PM_SOURCE_FIT_EXT);
    113         psImageKeepCircle (source->mask, x, y, RADIUS, "AND", PS_NOT_U8(markVal));
     113        psImageKeepCircle (source->mask, x, y, RADIUS, "AND", PS_NOT_IMAGE_MASK(markVal));
    114114
    115115        // write fitted parameters to file

  • trunk/psphot/src/psphotTestSourceOutput.c

    r14655 r21183  
    8080                float oy = yBin*(iy + 0.5 + image->row0 - yCenter) + yResidCenter;
    8181
    82                 psU8 mflux = 0;
     82                psImageMaskType mflux = 0;
    8383                double Fo = 0.0;
    8484                double Fx = 0.0;

  • trunk/psphot/src/psphotVisual.c

    r20938 r21183  
    5151        ALLOCATE (image.data2d[iy], float, image.Nx);
    5252        for (int ix = 0; ix < image.Nx; ix++) {
    53             image.data2d[iy][ix] = inImage->data.U8[iy][ix];
     53            image.data2d[iy][ix] = inImage->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix];
    5454        }
    5555    }
    … …  
    813813
    814814    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    815     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     815    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    816816    assert (maskVal);
    817817
    … …  
    973973
    974974    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    975     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     975    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    976976    assert (maskVal);
    977977
    … …  
    10971097}
    10981098
    1099 bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psMaskType maskVal) {
     1099bool psphotVisualPlotRadialProfile (int myKapa, pmSource *source, psImageMaskType maskVal) {
    11001100
    11011101    Graphdata graphdata;
    … …  
    11181118    for (int iy = 0; iy < source->pixels->numRows; iy++) {
    11191119        for (int ix = 0; ix < source->pixels->numCols; ix++) {
    1120             if (source->maskObj->data.U8[iy][ix]) {
     1120            if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) {
    11211121                // rb->data.F32[nb] = hypot (ix + 0.5 - Xo, iy + 0.5 - Yo) ;
    11221122                rb->data.F32[nb] = hypot (ix - Xo, iy - Yo) ;
    … …  
    12271227    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    12281228    bool status;
    1229     psMaskType maskVal = psMetadataLookupU8(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     1229    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    12301230    assert (maskVal);
    12311231
Note: See TracChangeset for help on using the changeset viewer.