IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18558


Ignore:
Timestamp:
Jul 15, 2008, 10:29:11 AM (18 years ago)
Author:
eugene
Message:

re-org and cleanup of the mask bits to make it consistent with the pmConfigMaskSetBits concepts

Location:
trunk
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/ppMerge/src/ppMergeArguments.c

    r18365 r18558  
    138138    psMetadataAddS32(arguments, PS_LIST_TAIL, "-nkeep",    0, "Minimum number of pixels in stack to keep", 0);
    139139    psMetadataAddBool(arguments, PS_LIST_TAIL, "-weights", 0, "Use image weights in combination?", false);
    140     psMetadataAddStr(arguments, PS_LIST_TAIL, "-maskval",  0, "Mask value for input data", NULL);
     140
     141    // XXX EAM : not clear this should be allowed on the command line.
     142    // psMetadataAddStr(arguments, PS_LIST_TAIL, "-maskval",  0, "Mask value for input data", NULL);
     143
    141144    psMetadataAddStr(arguments, PS_LIST_TAIL, "-combine",  0, "Statistic to use for combination", NULL);
    142145    psMetadataAddStr(arguments, PS_LIST_TAIL, "-mean",     0, "Statistic to use to measure the mean", NULL);
    … …  
    159162    psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask-mode",     0, "Mode to identify bad pixels", NULL);
    160163    psMetadataAddS32(arguments, PS_LIST_TAIL, "-mask-grow",     0, "Number of pixels to grow final mask", 0);
    161     psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask-growval",  0, "Value to give grown mask pixels", NULL);
     164    psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask-set-valud",0, "Value to set for output mask pixels", NULL);
    162165    psMetadataAddBool(arguments, PS_LIST_TAIL, "-mask-chip",    0, "Measure mask statistics by chip?", false);
    163166
    … …  
    264267    VALUE_ARG_RECIPE_INT("-nkeep",      "NKEEP",    S32, 0);
    265268    VALUE_ARG_RECIPE_BOOL("-weights",   "WEIGHTS");
    266     VALUE_ARG_RECIPE_MASK("-maskval",   "MASKVAL");
     269
     270    // XXX we do not supply this on the command line
     271    // VALUE_ARG_RECIPE_MASK("-maskval",   "MASKVAL");
     272
    267273    VALUE_ARG_RECIPE_STAT("-combine",   "COMBINE");
    268274    VALUE_ARG_RECIPE_STAT("-mean",      "MEAN");
    … …  
    281287    VALUE_ARG_RECIPE_FLOAT("-mask-suspect", "MASK.SUSPECT", F32);
    282288    VALUE_ARG_RECIPE_FLOAT("-mask-bad",     "MASK.BAD",     F32);
    283     VALUE_ARG_RECIPE_INT("-mask-grow",      "MASK.GROW",    S32, -1);
    284     VALUE_ARG_RECIPE_MASK("-mask-growval",  "MASK.GROWVAL");
     289    VALUE_ARG_RECIPE_INT("-mask-grow",      "MASK.GROW",    S32, 0);
     290    VALUE_ARG_RECIPE_STR("-mask-set-value", "MASK.SET.VALUE");
    285291    VALUE_ARG_RECIPE_BOOL("-mask-chip",     "MASK.CHIPSTATS");
    286292

  • trunk/ppMerge/src/ppMergeLoop.c

    r18166 r18558  
    3939    float frachigh = psMetadataLookupF32(NULL, arguments, "FRACHIGH"); // Reject fraction of hi pixels
    4040    int nKeep = psMetadataLookupS32(NULL, arguments, "NKEEP"); // Minimum number of values to keep
    41     psMaskType maskVal = psMetadataLookupU8(NULL, arguments, "MASKVAL"); // Value to mask
    4241    psStatsOptions combineStat = psMetadataLookupS32(NULL, arguments, "COMBINE"); // Combination statistic
    4342    bool useWeights = psMetadataLookupBool(NULL, arguments, "WEIGHTS"); // Use weights?
    … …  
    4948    int fringeSmoothY = psMetadataLookupS32(NULL, arguments, "FRINGE.YSMOOTH"); // Smoothing regions in y
    5049
     50    // set the mask and mark bit values based on the named masks
     51    psMaskType maskVal;
     52    psMaskType markVal;
     53    if (!pmConfigMaskSetBits (&maskVal, &markVal, config)) {
     54        psError (PS_ERR_UNKNOWN, true, "Unable to define the mask bit values");
     55        return false;
     56    }
     57
    5158    pmCombineParams *combination = pmCombineParamsAlloc(combineStat); // Combination parameters
    5259    combination->maskVal = maskVal;
    53     combination->blank = pmConfigMask("BLANK", config);
     60    combination->blank = pmConfigMaskGet("BLANK", config);
    5461    combination->nKeep = nKeep;
    5562    combination->fracHigh = frachigh;
    … …  
    294301            }
    295302
    296             if (!ppStatsFPA(stats, outFPA, view, maskVal | pmConfigMask("BLANK", config), config)) {
     303            if (!ppStatsFPA(stats, outFPA, view, maskVal, config)) {
    297304                psError(PS_ERR_UNKNOWN, true, "Unable to generate stats for image.");
    298305                goto ERROR;

  • trunk/ppMerge/src/ppMergeMask.c

    r18365 r18558  
    1818                      psRandom *rng,    // Random number generator
    1919                      psMetadata *stats // Statistics output
    20                       )
     20    )
    2121{
    2222    assert(config);
    … …  
    2828    psStatsOptions meanStat = psMetadataLookupS32(NULL, config->arguments, "MEAN"); // Statistic for mean
    2929    psStatsOptions stdevStat = psMetadataLookupS32(NULL, config->arguments, "STDEV"); // Statistic for stdev
    30     psMaskType maskVal = psMetadataLookupU8(NULL, config->arguments, "MASKVAL"); // Value to mask
    3130    int sample = psMetadataLookupS32(NULL, config->arguments, "SAMPLE"); // Size of sample for statistics
    3231    bool chipStats = psMetadataLookupBool(&mdok, config->arguments, "MASK.CHIPSTATS"); // Statistics on chip?
    … …  
    3534    pmMaskIdentifyMode maskMode = psMetadataLookupS32(NULL, config->arguments, "MASK.MODE"); // Mode for identifying bad pixels
    3635    int maskGrow = psMetadataLookupS32(NULL, config->arguments, "MASK.GROW"); // Radius to grow mask
    37     psMaskType maskGrowVal = psMetadataLookupU8(NULL, config->arguments, "MASK.GROWVAL"); // Value for grown mask
    3836
    3937    bool smoothSuspect = psMetadataLookupBool(&mdok, config->arguments, "MASK.SMOOTH.SUSPECT"); // Radius to grow mask
    4038    float smoothScale = psMetadataLookupF32(&mdok, config->arguments, "MASK.SMOOTH.SCALE"); // Radius to grow mask
    4139
     40    psMaskType markVal;
     41    psMaskType maskValRaw;
     42    if (!pmConfigMaskSetBits (&maskValRaw, &markVal, config)) {
     43        psError (PS_ERR_UNKNOWN, true, "Unable to define the mask bit values");
     44        return false;
     45    }
     46
     47    char *maskOutName = psMetadataLookupStr (&mdok, config->arguments, "MASK.SET.VALUE");
     48    psMaskType maskValOut = pmConfigMaskGet (maskOutName, config);
     49    if (!maskValOut) {
     50        psError (PS_ERR_UNKNOWN, true, "Undefined output mask bit value");
     51        return false;
     52    }
     53   
    4254    psStats *statistics = psStatsAlloc(meanStat | stdevStat); // Statistics for background
    4355
    … …  
    137149                int x = pixel % numCols;
    138150                int y = pixel / numCols;
    139                 if ((mask && (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal)) ||
    140                     !isfinite(image->data.F32[y][x]) ||
    141                     (outMask && (outMask->data.PS_TYPE_MASK_DATA[y][x] & maskVal))) {
    142                     continue;
    143                 }
     151                if (mask && (mask->data.PS_TYPE_MASK_DATA[y][x] & maskValRaw)) continue;
     152                if (outMask && (outMask->data.PS_TYPE_MASK_DATA[y][x] & maskValOut)) continue;
     153                if (!isfinite(image->data.F32[y][x])) continue;
    144154
    145155                values->data.F32[valueIndex++] = image->data.F32[y][x];
    … …  
    155165                }
    156166
    157                 if (!pmMaskFlagSuspectPixels(outRO, readout, psStatsGetValue(statistics, meanStat),
    158                                              psStatsGetValue(statistics, stdevStat), maskSuspect, maskVal)) {
     167                float mean = psStatsGetValue(statistics, meanStat);
     168                float stdev = psStatsGetValue(statistics, stdevStat);
     169
     170                // this function increments the count for each suspect pixel in each input plane
     171                // maskValRaw is used to test for valid input pixels
     172                if (!pmMaskFlagSuspectPixels(outRO, readout, mean, stdev, maskSuspect, maskValRaw)) {
    159173                    psError(PS_ERR_UNKNOWN, false, "Unable to find suspect values in file %d", i);
    160174                    psFree(inView);
    … …  
    189203
    190204                pmHDU *hdu = pmHDUFromCell(inCell); // HDU for cell
    191                 if (!hdu || hdu->blankPHU) {
    192                     // No data here
    193                     continue;
    194                 }
     205                if (!hdu || hdu->blankPHU) continue;
     206
    195207                pmReadout *readout = inCell->readouts->data[0]; // Readout of interest
    196208
    … …  
    198210                pmReadout *outRO = pmFPAfileThisReadout(config->files, inView, "PPMERGE.OUTPUT.MASK");
    199211
    200                 if (!pmMaskFlagSuspectPixels(outRO, readout, psStatsGetValue(statistics, meanStat),
    201                                              psStatsGetValue(statistics, stdevStat), maskSuspect, maskVal)) {
     212                float mean = psStatsGetValue(statistics, meanStat);
     213                float stdev = psStatsGetValue(statistics, stdevStat);
     214
     215                if (!pmMaskFlagSuspectPixels(outRO, readout, mean, stdev, maskSuspect, maskValRaw)) {
    202216                    psError(PS_ERR_UNKNOWN, false, "Unable to find suspect values in file %d", i);
    203217                    goto MERGE_MASK_ERROR;
    … …  
    229243    while ((outCell = pmFPAviewNextCell(outView, outFPA, 1))) {
    230244
    231         // skipp inactive cells
     245        // skip inactive cells
    232246        if (!outCell->process) continue;
    233247
    234248        pmHDU *hdu = pmHDUFromCell(outCell); // HDU for cell
    235         if (!hdu || hdu->blankPHU) {
    236             // No data here
    237             continue;
    238         }
     249        if (!hdu || hdu->blankPHU) continue;
    239250
    240251        psTrace("ppMerge", 1, "Getting bad pixels for chip %d cell %d", outView->chip, outView->cell);
    … …  
    250261        }
    251262
    252         if (!pmMaskIdentifyBadPixels(outRO, maskVal, maskBad, maskMode)) {
     263        // set the bad pixels to the value 'maskVal'
     264        if (!pmMaskIdentifyBadPixels(outRO, maskValOut, maskBad, maskMode)) {
    253265            psError(PS_ERR_UNKNOWN, false, "Unable to mask bad pixels");
    254266            goto MERGE_MASK_ERROR;
    … …  
    274286        }
    275287
    276         if (maskGrowVal > 0) {
    277             psImage *grown = psImageGrowMask(NULL, outRO->mask, maskVal, maskGrow, maskGrowVal); // Grown mask
     288        if (maskGrow > 0) {
     289            psImage *grown = psImageGrowMask(NULL, outRO->mask, maskValOut, maskGrow, maskValOut); // Grown mask
    278290            psFree(outRO->mask);
    279291            outRO->mask = grown;
    … …  
    307319            outRO->image = psImageAlloc(outRO->mask->numCols, outRO->mask->numRows, PS_TYPE_F32);
    308320            psImageInit(outRO->image, 1.0);
    309             if (!ppStatsFPA(stats, outRO->parent->parent->parent, outView,
    310                             maskVal | pmConfigMask("BLANK", config), config)) {
     321            if (!ppStatsFPA(stats, outRO->parent->parent->parent, outView, maskValOut, config)) {
    311322                psError(PS_ERR_UNEXPECTED_NULL, true, "Unable to generate stats for image.");
    312323                psFree(outRO);
    … …  
    337348}
    338349
    339 
    340 
    341 
    342 
    343350bool ppMergeMask(pmConfig *config)
    344351{
    … …  
    381388        goto PPMERGE_MASK_ERROR;
    382389    }
     390
     391    // XXX this function should use pmConfigMaskReadHeader () to get the named values defined
     392    // for the input masks.
    383393
    384394    psString outName = ppMergeOutputFile(config); // Name of output file
    … …  
    414424                psListAdd(inChips, PS_LIST_TAIL, chip);
    415425            }
     426
     427            // XXX I need to call pmConfigMaskWriteHeader for the PHU somewhere, after it is created!
     428
    416429            if (!pmConceptsAverageChips(outChip, inChips, true)) {
    417430                psError(PS_ERR_UNKNOWN, false, "Unable to average Chip concepts.");

  • trunk/ppMerge/src/ppMergeScaleZero.c

    r18218 r18558  
    2121    psStatsOptions meanStat = psMetadataLookupS32(NULL, config->arguments, "MEAN"); // Statistic for mean
    2222    psStatsOptions stdevStat = psMetadataLookupS32(NULL, config->arguments, "STDEV"); // Statistic for stdev
    23     psMaskType maskVal = psMetadataLookupU8(NULL, config->arguments, "MASKVAL"); // Value to mask
    2423    int shutterSize = psMetadataLookupS32(NULL, config->arguments, "SHUTTER.SIZE"); // Size of shutter region
     24
     25    psMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
    2526
    2627    psVector *gains = NULL;             // Gains for each cell

  • trunk/ppStats/src/ppStatsFPA.c

    r14010 r18558  
    2121    }
    2222
    23     // Override recipe mask value if one is provided
    24     if (maskVal != 0) {
    25         data->maskVal = maskVal;
    26     }
     23    // Override recipe mask value
     24    data->maskVal = maskVal;
    2725
    2826    if (data->fpa) {

  • trunk/ppStats/src/ppStatsMetadata.c

    r14010 r18558  
    2929    data->doStats = false;
    3030
    31     // Override recipe mask value if one is provided
    32     if (maskVal != 0) {
    33         data->maskVal = maskVal;
    34     }
     31    // Override recipe mask value
     32    data->maskVal = maskVal;
    3533
    3634    if (data->fpa) {

  • trunk/ppStats/src/ppStatsPixels.c

    r14010 r18558  
    2828    data->concepts = psListAlloc(NULL);
    2929
    30     // Override recipe mask value if one is provided
    31     if (maskVal != 0) {
    32         data->maskVal = maskVal;
    33     }
     30    // Override recipe mask value
     31    data->maskVal = maskVal;
    3432
    3533    if (data->fpa) {

  • trunk/ppStats/src/ppStatsSetupFromRecipe.c

    r13999 r18558  
    127127    }
    128128
     129    // set the mask value used for stand-alone analyses.
    129130    if (data->maskVal == 0) {
    130131        const char *names = psMetadataLookupStr(&mdok, recipe, "MASKVAL"); // Names for mask value
    131132        if (mdok) {
    132             data->maskVal = pmConfigMask(names, config);
     133            data->maskVal = pmConfigMaskGet(names, config);
    133134        } else {
    134135            psWarning("MASKVAL in recipe is not of type STR --- retaining default.\n");

  • trunk/pswarp/src/Makefile.am

    r15608 r18558  
    1515        pswarpParseCamera.c             \
    1616        pswarpPixelFraction.c           \
     17        pswarpSetMaskBits.c             \
    1718        pswarpTransformReadout_Opt.c    \
    1819        pswarpVersion.c           

  • trunk/pswarp/src/pswarp.h

    r18179 r18558  
    3838pmConfig *pswarpArguments (int argc, char **argv);
    3939bool pswarpOptions(pmConfig *config);
     40bool pswarpSetMaskBits (pmConfig *config);
    4041bool pswarpParseCamera (pmConfig *config);
    4142bool pswarpDefine (pmConfig *config);

  • trunk/pswarp/src/pswarpArguments.c

    r17525 r18558  
    109109    }
    110110
    111     // Get mask parameters
    112     psMaskType maskIn, maskPoor, maskBad; // Mask values for input, "poor" and "bad" pixels
    113 
    114     psString maskNames = psMetadataLookupStr(&status, recipe, "MASK.IN");
    115     if (!status) {
    116         maskIn = 0x00;
    117         psWarning("MASK.IN is not set in the %s recipe --- defaulting to %x.", PSWARP_RECIPE, maskIn);
    118     }
    119     maskIn = pmConfigMask(maskNames, config); // Mask for input data
    120 
    121     maskNames = psMetadataLookupStr(&status, recipe, "MASK.POOR");
    122     if (!status) {
    123         maskPoor = 0x00;
    124         psWarning("MASK.POOR is not set in the %s recipe --- defaulting to %x.", PSWARP_RECIPE, maskPoor);
    125     }
    126     maskPoor = pmConfigMask(maskNames, config); // Mask for "poor" warped data
    127 
    128     maskNames = psMetadataLookupStr(&status, recipe, "MASK.BAD");
    129     if (!status) {
    130         maskBad = 0x00;
    131         psWarning("MASK.BAD is not set in the %s recipe --- defaulting to %x.", PSWARP_RECIPE, maskBad);
    132     }
    133     maskBad = pmConfigMask(maskNames, config); // Mask for bad warped data
    134 
    135111    float poorFrac = psMetadataLookupF32(&status, recipe, "POOR.FRAC"); // Frac of bad flux for a "poor"
    136112    if (!status) {
    … …  
    152128    psMetadataAddS32(config->arguments, PS_LIST_TAIL, "INTERPOLATION.MODE", 0,
    153129                     "Interpolation mode", interpolationMode);
    154     psMetadataAddU8(config->arguments, PS_LIST_TAIL, "MASK.IN", 0,
    155                     "Mask for input data", maskIn);
    156     psMetadataAddU8(config->arguments, PS_LIST_TAIL, "MASK.POOR", 0,
    157                     "Mask for poor warped data", maskPoor);
    158     psMetadataAddU8(config->arguments, PS_LIST_TAIL, "MASK.BAD", 0,
    159                     "Mask for bad warped data", maskBad);
    160130    psMetadataAddF32(config->arguments, PS_LIST_TAIL, "POOR.FRAC", 0,
    161131                     "Fraction of bad flux for a pixel to be marked as poor", poorFrac);

  • trunk/pswarp/src/pswarpLoop.c

    r18189 r18558  
    6464bool pswarpLoop(pmConfig *config)
    6565{
    66 
    67     psMaskType maskPoor = psMetadataLookupU8(NULL, config->arguments, "MASK.POOR"); // Mask for "poor" data
    68     psMaskType maskBad = psMetadataLookupU8(NULL, config->arguments, "MASK.BAD"); // Mask for bad data
     66    bool status;
     67
     68    // load the recipe
     69    psMetadata *recipe = psMetadataLookupPtr (&status, config->recipes, PSWARP_RECIPE);
     70    if (!recipe) {
     71        psError(PSPHOT_ERR_CONFIG, false, "missing recipe %s", PSWARP_RECIPE);
     72        return false;
     73    }
     74
     75    // output mask bits
     76    psMaskType maskValue = psMetadataLookupU8(&status, recipe, "MASK.OUTPUT");
     77    psAssert (status, "MASK.OUTPUT was not defined");
    6978
    7079    // select the input data sources
    … …  
    333342    // Perform statistics on the output image
    334343    if (stats) {
    335         if (!ppStatsFPA(stats, output->parent->parent->parent, view, maskBad | maskPoor, config)) {
     344        if (!ppStatsFPA(stats, output->parent->parent->parent, view, maskValue, config)) {
    336345            psWarning("Unable to perform statistics on warped image.");
    337346        }

  • trunk/pswarp/src/pswarpParseCamera.c

    r17599 r18558  
    3737    if (!inMask) {
    3838        psLogMsg ("pswarp", 3, "no mask supplied\n");
     39    }
     40   
     41    // loading the mask here should have invoked pmConfigMaskReadHeader()
     42    if (!pswarpSetMaskBits (config)) {
     43        psError(PS_ERR_IO, false, "failed to set mask bits");
     44        return NULL;
    3945    }
    4046

  • trunk/pswarp/src/pswarpPixelFraction.c

    r17780 r18558  
    2828    PS_ASSERT_METADATA_NON_NULL(config->arguments, false);
    2929
     30    bool status;
     31
    3032    float minFrac = psMetadataLookupF32(NULL, config->arguments, "ACCEPT.FRAC"); // Minimum fraction
    31     psMaskType maskPoor = psMetadataLookupU8(NULL, config->arguments, "MASK.POOR"); // Mask for "poor" data
    32     psMaskType maskBad = psMetadataLookupU8(NULL, config->arguments, "MASK.BAD"); // Mask for bad data
    33     psMaskType maskVal = maskPoor | maskBad; // Mask to apply
     33
     34    // load the recipe
     35    psMetadata *recipe = psMetadataLookupPtr (NULL, config->recipes, PSWARP_RECIPE);
     36    if (!recipe) {
     37        psError(PSPHOT_ERR_CONFIG, false, "missing recipe %s", PSWARP_RECIPE);
     38        return false;
     39    }
     40
     41    // output mask bits
     42    psMaskType maskValue = psMetadataLookupU8(&status, recipe, "MASK.OUTPUT");
     43    psAssert (status, "MASK.OUTPUT was not defined");
    3444
    3545    psImage *image = readout->image;    // Image of interest
    … …  
    4555    for (int y = 0; y < numRows; y++) {
    4656        for (int x = 0; x < numCols; x++) {
    47             if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
     57            if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskValue) {
    4858                numBad++;
    4959            } else {

  • trunk/pswarp/src/pswarpTransformReadout_Opt.c

    r18188 r18558  
    1717    psImageInterpolateMode interpolationMode = psMetadataLookupS32(NULL, config->arguments,
    1818                                                                   "INTERPOLATION.MODE");
    19     psMaskType maskIn = psMetadataLookupU8(NULL, config->arguments, "MASK.IN"); // Mask for input data
    20     psMaskType maskPoor = psMetadataLookupU8(NULL, config->arguments, "MASK.POOR"); // Mask for "poor" data
    21     psMaskType maskBad = psMetadataLookupU8(NULL, config->arguments, "MASK.BAD"); // Mask for bad data
     19    // load the recipe
     20    psMetadata *recipe = psMetadataLookupPtr (NULL, config->recipes, PSWARP_RECIPE);
     21    if (!recipe) {
     22        psError(PSPHOT_ERR_CONFIG, false, "missing recipe %s", PSWARP_RECIPE);
     23        return false;
     24    }
     25
     26    // output mask bits
     27    psMaskType maskIn   = psMetadataLookupU8(&mdok, recipe, "MASK.INPUT");
     28    psMaskType maskPoor = pmConfigMaskGet("POOR.WARP", config);
     29    psMaskType maskBad  = pmConfigMaskGet("BAD.WARP", config);
     30    psAssert (mdok, "MASK.INPUT was not defined");
     31
    2232    float poorFrac = psMetadataLookupF32(NULL, config->arguments, "POOR.FRAC"); // Flux fraction for "poor"
    2333
    … …  
    6272
    6373    // Interpolation options
    64     psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(interpolationMode, inImage,
     74    psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(interpolationMode, inImage, 
    6575                                                                       inVar, inMask, maskIn, NAN, NAN,
    6676                                                                       maskBad, maskPoor, poorFrac);
Note: See TracChangeset for help on using the changeset viewer.