IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21456


Ignore:
Timestamp:
Feb 12, 2009, 9:25:52 AM (17 years ago)
Author:
Paul Price
Message:

Adding modification of variance map by the flat-field. Removing multiple type cases for flat-field, since all images are of type F32.

Location:
trunk/psModules/src/detrend
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/src/detrend/pmDetrendThreads.c

    r18960 r21456  
    5454
    5555    {
    56         psThreadTask *task = psThreadTaskAlloc("PSMODULES_DETREND_FLAT", 9);
     56        psThreadTask *task = psThreadTaskAlloc("PSMODULES_DETREND_FLAT", 10);
    5757        task->function = &pmFlatFieldScan_Threaded;
    5858        psThreadTaskAdd(task);

  • trunk/psModules/src/detrend/pmFlatField.c

    r21183 r21456  
    1717    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
    1818
    19     psImage *inImage   = job->args->data[0]; // Input image
    20     psImage *inMask    = job->args->data[1]; // Input mask
    21     const psImage *flatImage = job->args->data[2]; // Flat-field image
    22     const psImage *flatMask  = job->args->data[3]; // Flat-field mask
     19    psImage *inImage = job->args->data[0]; // Input image
     20    psImage *inMask  = job->args->data[1]; // Input mask
     21    psImage *inVar   = job->args->data[2]; // Input variance
     22    const psImage *flatImage = job->args->data[3]; // Flat-field image
     23    const psImage *flatMask  = job->args->data[4]; // Flat-field mask
    2324
    24     psImageMaskType badFlat = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA);
    25     int xOffset        = PS_SCALAR_VALUE(job->args->data[5],S32);
    26     int yOffset        = PS_SCALAR_VALUE(job->args->data[6],S32);
    27     int rowStart       = PS_SCALAR_VALUE(job->args->data[7],S32);
    28     int rowStop        = PS_SCALAR_VALUE(job->args->data[8],S32);
    29     return pmFlatFieldScan(inImage, inMask, flatImage, flatMask, badFlat,
     25    psImageMaskType badFlat = PS_SCALAR_VALUE(job->args->data[5], PS_TYPE_IMAGE_MASK_DATA);
     26    int xOffset        = PS_SCALAR_VALUE(job->args->data[6], S32);
     27    int yOffset        = PS_SCALAR_VALUE(job->args->data[7], S32);
     28    int rowStart       = PS_SCALAR_VALUE(job->args->data[8], S32);
     29    int rowStop        = PS_SCALAR_VALUE(job->args->data[9], S32);
     30
     31    return pmFlatFieldScan(inImage, inMask, inVar, flatImage, flatMask, badFlat,
    3032                           xOffset, yOffset, rowStart, rowStop);
    3133}
    3234
    33 // Macro for all PS types
    34 #define FLAT_DIVISION_CASE(TYPE, SPECIAL)       \
    35     case PS_TYPE_##TYPE:                        \
    36     for (int j = rowStart; j < rowStop; j++) { \
    37         for (int i = 0; i < inImage->numCols; i++) { \
    38             ps##TYPE flatValue = flatImage->data.TYPE[j + yOffset][i + xOffset]; \
    39             if (!isfinite(flatValue) || flatValue <= 0.0 || \
    40                 (flatMask && flatMask->data.PS_TYPE_IMAGE_MASK_DATA[j + yOffset][i + xOffset])) { \
    41                 if (inMask) { \
    42                     inMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= badFlat; \
    43                 } \
    44                 inImage->data.TYPE[j][i] = SPECIAL; \
    45             } else { \
    46                 inImage->data.TYPE[j][i] /= flatValue; \
    47             } \
    48         } \
    49     } \
    50     break;
    5135
    52 bool pmFlatFieldScan(psImage *inImage, psImage *inMask, const psImage *flatImage, const psImage *flatMask,
    53                      psImageMaskType badFlat, int xOffset, int yOffset, int rowStart, int rowStop)
     36bool pmFlatFieldScan(psImage *inImage, psImage *inMask, psImage *inVar, const psImage *flatImage,
     37                     const psImage *flatMask, psImageMaskType badFlat,
     38                     int xOffset, int yOffset, int rowStart, int rowStop)
    5439{
    55     switch (inImage->type.type) {
    56         FLAT_DIVISION_CASE(U8,  0);
    57         FLAT_DIVISION_CASE(U16, 0);
    58         FLAT_DIVISION_CASE(U32, 0);
    59         FLAT_DIVISION_CASE(U64, 0);
    60         FLAT_DIVISION_CASE(S8,  0);
    61         FLAT_DIVISION_CASE(S16, 0);
    62         FLAT_DIVISION_CASE(S32, 0);
    63         FLAT_DIVISION_CASE(S64, 0);
    64         FLAT_DIVISION_CASE(F32, NAN);
    65         FLAT_DIVISION_CASE(F64, NAN);
    66     default:
    67         psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unsupported type for input image: %x\n",
    68                 inImage->type.type);
    69         return false;
     40    // Neglecting asserts, because inputs should have been checked already
     41
     42    int numCols = inImage->numCols;     // Number of columns
     43
     44    // Using i,j for image; x,y for flat.
     45    for (int j = rowStart, y = yOffset; j < rowStop; j++, y++) {
     46        for (int i = 0, x = xOffset; i < numCols; i++, x++) {
     47            float flatValue = 1.0 / flatImage->data.F32[y][x];
     48            if (!isfinite(flatValue) || flatValue <= 0.0 ||
     49                (flatMask && flatMask->data.PS_TYPE_IMAGE_MASK_DATA[y][x])) {
     50                if (inMask) {
     51                    inMask->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= badFlat;
     52                }
     53                inImage->data.F32[j][i] = NAN;
     54                if (inVar) {
     55                    inVar->data.F32[j][i] = NAN;
     56                }
     57            } else {
     58                inImage->data.F32[j][i] *= flatValue;
     59                if (inVar) {
     60                    inVar->data.F32[j][i] *= PS_SQR(flatValue);
     61                }
     62            }
     63        }
    7064    }
     65
    7166    return true;
    7267}
    … …  
    7469bool pmFlatField(pmReadout *in, const pmReadout *flat, psImageMaskType badFlat)
    7570{
    76     PS_ASSERT_PTR_NON_NULL(in, false);
    77     PS_ASSERT_PTR_NON_NULL(in->image, false);
    78     PS_ASSERT_IMAGE_NON_EMPTY(in->image, false);
    79     PS_ASSERT_PTR_NON_NULL(flat, false);
    80     PS_ASSERT_PTR_NON_NULL(flat->image, false);
    81     PS_ASSERT_IMAGE_NON_EMPTY(flat->image, false);
     71    PM_ASSERT_READOUT_NON_NULL(in, false);
     72    PM_ASSERT_READOUT_IMAGE(in, false);
     73    PM_ASSERT_READOUT_NON_NULL(flat, false);
     74    PM_ASSERT_READOUT_IMAGE(flat, false);
    8275    if (in->mask) {
    83         PS_ASSERT_IMAGE_TYPE(in->mask, PS_TYPE_IMAGE_MASK, false);
    84         PS_ASSERT_IMAGES_SIZE_EQUAL(in->mask, in->image, false);
     76        PM_ASSERT_READOUT_MASK(in, false);
    8577    }
    86     PS_ASSERT_IMAGE_TYPE(flat->image, in->image->type.type, false);
     78    if (in->variance) {
     79        PM_ASSERT_READOUT_VARIANCE(in, false);
     80    }
    8781    if (flat->mask) {
    88         PS_ASSERT_IMAGE_TYPE(flat->mask, PS_TYPE_IMAGE_MASK, false);
    89         PS_ASSERT_IMAGES_SIZE_EQUAL(flat->mask, flat->image, false);
     82        PM_ASSERT_READOUT_MASK(flat, false);
    9083    }
    9184
    9285    psImage *inImage   = in->image;     // Input image
    9386    psImage *inMask    = in->mask;      // Mask for input image
     87    psImage *inVar     = in->variance;  // Variance for input image
    9488    psImage *flatImage = flat->image;   // Flat-field image
    9589    psImage *flatMask  = flat->mask;    // Mask for flat-field image
    … …  
    146140          psArrayAdd(job->args, 1, inImage);
    147141          psArrayAdd(job->args, 1, inMask);
     142          psArrayAdd(job->args, 1, inVar);
    148143          psArrayAdd(job->args, 1, flatImage);
    149144          psArrayAdd(job->args, 1, flatMask);
    … …  
    159154          }
    160155          psFree(job);
    161       } else if (!pmFlatFieldScan(inImage, inMask, flatImage, flatMask, badFlat,
     156      } else if (!pmFlatFieldScan(inImage, inMask, inVar, flatImage, flatMask, badFlat,
    162157                                  xOffset, yOffset, rowStart, rowStop)) {
    163158          psError(PS_ERR_UNKNOWN, false, "Unable to flat-field image.");

  • trunk/psModules/src/detrend/pmFlatField.h

    r21183 r21456  
    55 * @author Paul Price, IfA
    66 *
    7  * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2009-01-27 06:39:38 $
     7 * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2009-02-12 19:25:52 $
    99 * Copyright 2004-2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    3636    psImage *inImage,                   ///< Input image to correct
    3737    psImage *inMask,                    ///< Input mask image
     38    psImage *inVar,                     ///< Input variance image
    3839    const psImage *flatImage,           ///< Flat-field image
    3940    const psImage *flatMask,            ///< Flat-field mask
    40     psImageMaskType badFlag,                 ///< Mask value to give bad pixels
     41    psImageMaskType badFlag,            ///< Mask value to give bad pixels
    4142    int xOffset, int yOffset,           ///< Offset between input and flat-field
    4243    int rowStart, int rowStop           ///< Scan range
Note: See TracChangeset for help on using the changeset viewer.