IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 19432


Ignore:
Timestamp:
Sep 8, 2008, 6:10:14 PM (18 years ago)
Author:
Paul Price
Message:

Discovered a problem with threaded implementation of pmDarkApply --- the polynomial is altered within pmDarkApplyScan, so it should not be global across threads. Checked and cleaned up the other threaded detrending functions.

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

Legend:

Unmodified
Added
Removed

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

    r19299 r19432  
    2323    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
    2424    pmReadout *in = job->args->data[0];
    25     pmReadout *sub = job->args->data[1];
     25    const pmReadout *sub = job->args->data[1];
    2626    float scale  = PS_SCALAR_VALUE(job->args->data[2],F32);
    2727    int xOffset  = PS_SCALAR_VALUE(job->args->data[3],S32);
    … …  
    2929    int rowStart = PS_SCALAR_VALUE(job->args->data[5],S32);
    3030    int rowStop  = PS_SCALAR_VALUE(job->args->data[6],S32);
    31     bool status = pmBiasSubtractScan (in, sub, scale, xOffset, yOffset, rowStart, rowStop);
    32     return status;
    33 }
    34 
    35 bool pmBiasSubtractScan (pmReadout *in, pmReadout *sub, float scale, int xOffset, int yOffset, int rowStart, int rowStop) {
    36 
     31    return pmBiasSubtractScan(in, sub, scale, xOffset, yOffset, rowStart, rowStop);
     32}
     33
     34bool pmBiasSubtractScan(pmReadout *in, const pmReadout *sub, float scale,
     35                        int xOffset, int yOffset, int rowStart, int rowStop)
     36{
    3737    psImage *inImage  = in->image;      // The input image
    3838    psImage *inMask   = in->mask;       // The input mask
    39     psImage *subImage = sub->image;    // The image to be subtracted
    40     psImage *subMask  = sub->mask;      // The mask for the subtraction image
     39    const psImage *subImage = sub->image; // The image to be subtracted
     40    const psImage *subMask  = sub->mask; // The mask for the subtraction image
    4141
    4242    if (scale == 1.0) {
    … …  
    6262}
    6363
    64 // pmBiasSubtractFrame(): this routine will take as input a readout for the input image and a readout for the bias
     64// pmBiasSubtractFrame():
     65// this routine will take as input a readout for the input image and a readout for the bias
    6566// image.  The bias image is subtracted in place from the input image.
    6667bool pmBiasSubtractFrame(pmReadout *in, // Input readout
    … …  
    129130
    130131    for (int rowStart = 0; rowStart < inImage->numRows; rowStart += scanRows) {
    131       int rowStop = PS_MIN (rowStart + scanRows, inImage->numRows);
    132 
    133       if (threaded) {
    134           // allocate a job, construct the arguments for this job
    135           psThreadJob *job = psThreadJobAlloc ("PSMODULES_DETREND_BIAS");
    136           psArrayAdd (job->args, 1, in);
    137           psArrayAdd (job->args, 1, sub);
    138           PS_ARRAY_ADD_SCALAR (job->args, scale, PS_TYPE_F32);
    139           PS_ARRAY_ADD_SCALAR (job->args, xOffset, PS_TYPE_S32);
    140           PS_ARRAY_ADD_SCALAR (job->args, yOffset, PS_TYPE_S32);
    141           PS_ARRAY_ADD_SCALAR (job->args, rowStart, PS_TYPE_S32);
    142           PS_ARRAY_ADD_SCALAR (job->args, rowStop, PS_TYPE_S32);
    143 
    144           // ppImageDetrendReadout(config, options, view)
    145           if (!psThreadJobAddPending (job)) {
    146               psFree(job);
    147               return false;
    148           }
    149           psFree(job);
    150       } else {
    151           pmBiasSubtractScan (in, sub, scale, xOffset, yOffset, rowStart, rowStop);
    152       }
     132        int rowStop = PS_MIN(rowStart + scanRows, inImage->numRows);
     133
     134        if (threaded) {
     135            // allocate a job, construct the arguments for this job
     136            psThreadJob *job = psThreadJobAlloc("PSMODULES_DETREND_BIAS");
     137            psArrayAdd(job->args, 1, in);
     138            psArrayAdd(job->args, 1, sub);
     139            PS_ARRAY_ADD_SCALAR(job->args, scale, PS_TYPE_F32);
     140            PS_ARRAY_ADD_SCALAR(job->args, xOffset, PS_TYPE_S32);
     141            PS_ARRAY_ADD_SCALAR(job->args, yOffset, PS_TYPE_S32);
     142            PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
     143            PS_ARRAY_ADD_SCALAR(job->args, rowStop, PS_TYPE_S32);
     144
     145            if (!psThreadJobAddPending(job)) {
     146                psFree(job);
     147                return false;
     148            }
     149            psFree(job);
     150        } else if (!pmBiasSubtractScan(in, sub, scale, xOffset, yOffset, rowStart, rowStop)) {
     151            psError(PS_ERR_UNKNOWN, false, "Unable to apply bias correction.");
     152            return false;
     153        }
    153154    }
    154155
    155156    if (threaded) {
    156157        // wait here for the threaded jobs to finish
    157         if (!psThreadPoolWait(false)) {
    158             psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image.");
    159             return false;
    160         }
    161         fprintf (stderr, "success for threaded jobs\n");
    162 
    163         // each job records its own goodPixel values; sum them here
    164         // we have only supplied one type of job, so we can assume the types here
    165         psThreadJob *job = NULL;
    166         while ((job = psThreadJobGetDone()) != NULL) {
    167             psFree (job);
     158        if (!psThreadPoolWait(true)) {
     159            psError(PS_ERR_UNKNOWN, false, "Unable to apply bias correction.");
     160            return false;
    168161        }
    169162    }

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

    r19299 r19432  
    55 * @author Paul Price, IfA
    66 *
    7  * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-08-30 02:28:07 $
     7 * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2008-09-09 04:10:14 $
    99 * Copyright 2004--2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    2727                   );
    2828
    29 // pmBiasSubtractFrame(): this routine will take as input a readout for the input image and a readout for the bias
     29// pmBiasSubtractFrame
     30// this routine will take as input a readout for the input image and a readout for the bias
    3031// image.  The bias image is subtracted in place from the input image.
    3132bool pmBiasSubtractFrame(pmReadout *in, // Input readout
    … …  
    3435    );
    3536
    36 bool pmBiasSubtractScan_Threaded(psThreadJob *job);
    37 bool pmBiasSubtractScan (pmReadout *in, pmReadout *sub, float scan, int xOffset, int yOffset, int rowStart, int rowStop);
     37/// Thread entry point for bias subtraction
     38bool pmBiasSubtractScan_Threaded(psThreadJob *job ///< Job to execute
     39    );
     40
     41/// Do bias subtraction for a scan
     42bool pmBiasSubtractScan(
     43    pmReadout *in,                      ///< Input image to correct
     44    const pmReadout *sub,               ///< Bias+dark image to subtract
     45    float scale,                        ///< Scale to apply
     46    int xOffset, int yOffset,           ///< Offset between input and bias images
     47    int rowStart, int rowStop           ///< Scan range
     48    );
    3849
    3950/// @}

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

    r19299 r19432  
    222222
    223223    // these calls allocate and save the requested images on the output analysis metadata
    224     psImage *counts = pmReadoutSetAnalysisImage(output->readouts->data[0], PM_READOUT_STACK_ANALYSIS_COUNT, numCols, numRows, PS_TYPE_U16, 0);
     224    psImage *counts = pmReadoutSetAnalysisImage(output->readouts->data[0], PM_READOUT_STACK_ANALYSIS_COUNT,
     225                                                numCols, numRows, PS_TYPE_U16, 0);
    225226    if (!counts) {
    226227        return false;
    227228    }
    228     psImage *sigma = pmReadoutSetAnalysisImage(output->readouts->data[0], PM_READOUT_STACK_ANALYSIS_SIGMA, numCols, numRows, PS_TYPE_F32, NAN);
     229    psImage *sigma = pmReadoutSetAnalysisImage(output->readouts->data[0], PM_READOUT_STACK_ANALYSIS_SIGMA,
     230                                               numCols, numRows, PS_TYPE_F32, NAN);
    229231    if (!sigma) {
    230232        return false;
    231233    }
    232234
    233     psMetadataAddPtr(output->analysis, PS_LIST_TAIL, PM_DARK_ANALYSIS_ORDINATES, PS_DATA_ARRAY | PS_META_REPLACE, "Dark ordinates", ordinates);
    234     psMetadataAddStr(output->analysis, PS_LIST_TAIL, PM_DARK_ANALYSIS_NORM, PS_META_REPLACE, "Dark normalisation", normConcept);
    235 
    236     psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.VALUES",  PS_DATA_ARRAY  | PS_META_REPLACE, "Dark values", values);
    237     psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.RO.MASK", PS_DATA_VECTOR | PS_META_REPLACE, "Dark Readout Mask", roMask);
    238     psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.NORM",    PS_DATA_VECTOR | PS_META_REPLACE, "Dark norm", norm);
    239     psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.ORDERS",  PS_DATA_VECTOR | PS_META_REPLACE, "Dark orders", orders);
     235    psMetadataAddPtr(output->analysis, PS_LIST_TAIL, PM_DARK_ANALYSIS_ORDINATES,
     236                     PS_DATA_ARRAY | PS_META_REPLACE, "Dark ordinates", ordinates);
     237    psMetadataAddStr(output->analysis, PS_LIST_TAIL, PM_DARK_ANALYSIS_NORM, PS_META_REPLACE,
     238                     "Dark normalisation", normConcept);
     239
     240    psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.VALUES",  PS_DATA_ARRAY  | PS_META_REPLACE,
     241                     "Dark values", values);
     242    psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.RO.MASK", PS_DATA_VECTOR | PS_META_REPLACE,
     243                     "Dark Readout Mask", roMask);
     244    psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.NORM",    PS_DATA_VECTOR | PS_META_REPLACE,
     245                     "Dark norm", norm);
     246    psMetadataAddPtr(output->analysis, PS_LIST_TAIL, "DARK.ORDERS",  PS_DATA_VECTOR | PS_META_REPLACE,
     247                     "Dark orders", orders);
    240248
    241249    for (int i = 0; i < numTerms; i++) {
    … …  
    272280
    273281    // retrieve the required parameter vectors
    274     psArray *values  = psMetadataLookupPtr(&mdok, output->analysis, "DARK.VALUES");  psAssert (values, "values not supplied");
    275     psVector *roMask = psMetadataLookupPtr(&mdok, output->analysis, "DARK.RO.MASK"); psAssert (roMask, "roMask not supplied");
    276     psVector *orders = psMetadataLookupPtr(&mdok, output->analysis, "DARK.ORDERS");  psAssert (orders, "orders not supplied");
     282    psArray *values  = psMetadataLookupPtr(&mdok, output->analysis, "DARK.VALUES");
     283    psAssert(values, "values not supplied");
     284    psVector *roMask = psMetadataLookupPtr(&mdok, output->analysis, "DARK.RO.MASK");
     285    psAssert(roMask, "roMask not supplied");
     286    psVector *orders = psMetadataLookupPtr(&mdok, output->analysis, "DARK.ORDERS");
     287    psAssert(orders, "orders not supplied");
    277288
    278289    psPolynomialMD *poly = psPolynomialMDAlloc(orders); // Polynomial for fitting
    … …  
    307318        int yOut = i - outReadout->row0; // y position on output readout
    308319
    309 # ifdef SHOW_BUSY
     320#ifdef SHOW_BUSY
    310321        if (psTraceGetLevel("psModules.detrend") > 9) {
    311322            printf("Processing row %d\r", i);
    312323            fflush(stdout);
    313324        }
    314 # endif
     325#endif
    315326
    316327        for (int j = minInputCols; j < maxInputCols; j++) {
    … …  
    337348            }
    338349
    339             // XXX test
    340             if (0 && (i == 377) && (j == 80)) {
    341                 FILE *f = fopen ("test.dat", "w");
    342                 for (int r = 0; r < inputs->n; r++) {
    343                     fprintf (f, "%d %d  %d  ", i, j, mask->data.U8[r]);
    344                     psVector *value = values->data[r];
    345                     for (int tmpj = 0; tmpj < value->n; tmpj++) {
    346                         fprintf (f, "%f ", value->data.F32[tmpj]);
    347                     }
    348                     fprintf (f, "%f\n", pixels->data.F32[r]);
    349                 }
    350                 fclose (f);
    351             }
    352 
    353350            if (!psPolynomialMDClipFit(poly, pixels, NULL, mask, maskVal, values, iter, rej)) {
    354351                psErrorClear();         // Nothing we can do about it
    … …  
    367364    psFree(mask);
    368365
    369     fprintf (stderr, "done with combine %x : %f sec\n", (unsigned int) id, psTimerMark (name));
    370366    return true;
    371367}
    … …  
    375371    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
    376372
    377     pmReadout *readout   = job->args->data[0];
    378     pmCell *dark         = job->args->data[1];
    379     psPolynomialMD *poly = job->args->data[2];
    380     psVector *values     = job->args->data[3];
    381 
    382     psMaskType bad = PS_SCALAR_VALUE(job->args->data[4],U8);
    383     bool doNorm    = PS_SCALAR_VALUE(job->args->data[5],U8);
    384     float norm     = PS_SCALAR_VALUE(job->args->data[6],F32);
    385     int rowStart   = PS_SCALAR_VALUE(job->args->data[7],S32);
    386     int rowStop    = PS_SCALAR_VALUE(job->args->data[8],S32);
    387     bool status = pmDarkApplyScan (readout, dark, poly, values, bad, doNorm, norm, rowStart, rowStop);
    388     return status;
    389 }
    390 
    391 bool pmDarkApplyScan (pmReadout *readout, const pmCell *dark, psPolynomialMD *poly, psVector *values, psMaskType bad, bool doNorm, float norm, int rowStart, int rowStop) {
    392 
     373    pmReadout *readout     = job->args->data[0]; // Readout to correct
     374    pmCell *dark           = job->args->data[1]; // Dark to apply
     375    const psVector *orders = job->args->data[2]; // Polynomial orders for each ordinate
     376    const psVector *values = job->args->data[3]; // Values for each ordinate
     377
     378    psMaskType bad = PS_SCALAR_VALUE(job->args->data[4], U8); // Mask value to give bad pixels
     379    bool doNorm    = PS_SCALAR_VALUE(job->args->data[5], U8); // Normalise values?
     380    float norm     = PS_SCALAR_VALUE(job->args->data[6], F32); // Value by which to normalise
     381    int rowStart   = PS_SCALAR_VALUE(job->args->data[7], S32); // Starting row for scan
     382    int rowStop    = PS_SCALAR_VALUE(job->args->data[8], S32); // Stopping row for scan
     383
     384    return pmDarkApplyScan(readout, dark, orders, values, bad, doNorm, norm, rowStart, rowStop);
     385}
     386
     387bool pmDarkApplyScan(pmReadout *readout, const pmCell *dark, const psVector *orders, const psVector *values,
     388                     psMaskType bad, bool doNorm, float norm, int rowStart, int rowStop)
     389{
    393390    int numCols = readout->image->numCols;
    394391    int numTerms = dark->readouts->n;   // Number of polynomial terms
    395392
    396     // thread here by scan
     393    psPolynomialMD *poly = psPolynomialMDAlloc(orders); // Polynomial to apply
     394
    397395    for (int y = rowStart; y < rowStop; y++) {
    398396        for (int x = 0; x < numCols; x++) {
    … …  
    411409        }
    412410    }
     411    psFree(poly);
     412
    413413    return true;
    414414}
    … …  
    478478    }
    479479
    480     psPolynomialMD *poly = psPolynomialMDAlloc(orders); // Polynomial to apply
    481     psFree(orders);
    482 
    483480    // thread here by scan
    484481
    … …  
    491488
    492489    for (int rowStart = 0; rowStart < readout->image->numRows; rowStart += scanRows) {
    493       int rowStop = PS_MIN (rowStart + scanRows, readout->image->numRows);
    494 
    495       if (threaded) {
    496           // allocate a job, construct the arguments for this job
    497           psThreadJob *job = psThreadJobAlloc ("PSMODULES_DETREND_DARK");
    498           psArrayAdd (job->args, 1, readout);
    499           psArrayAdd (job->args, 1, dark);
    500           psArrayAdd (job->args, 1, poly);
    501           psArrayAdd (job->args, 1, values);
    502           PS_ARRAY_ADD_SCALAR (job->args, bad, PS_TYPE_MASK);
    503           PS_ARRAY_ADD_SCALAR (job->args, doNorm, PS_TYPE_U8);
    504           PS_ARRAY_ADD_SCALAR (job->args, norm, PS_TYPE_F32);
    505           PS_ARRAY_ADD_SCALAR (job->args, rowStart, PS_TYPE_S32);
    506           PS_ARRAY_ADD_SCALAR (job->args, rowStop, PS_TYPE_S32);
    507 
    508           // ppImageDetrendReadout(config, options, view)
    509           if (!psThreadJobAddPending (job)) {
    510               psFree(job);
    511               return false;
    512           }
    513           psFree(job);
    514       } else {
    515           pmDarkApplyScan (readout, dark, poly, values, bad, doNorm, norm, rowStart, rowStop);
    516       }
     490        int rowStop = PS_MIN(rowStart + scanRows, readout->image->numRows);
     491
     492        if (threaded) {
     493            psThreadJob *job = psThreadJobAlloc("PSMODULES_DETREND_DARK");
     494            psArrayAdd(job->args, 1, readout);
     495            psArrayAdd(job->args, 1, dark);
     496            psArrayAdd(job->args, 1, orders);
     497            psArrayAdd(job->args, 1, values);
     498            PS_ARRAY_ADD_SCALAR(job->args, bad, PS_TYPE_MASK);
     499            PS_ARRAY_ADD_SCALAR(job->args, doNorm, PS_TYPE_U8);
     500            PS_ARRAY_ADD_SCALAR(job->args, norm, PS_TYPE_F32);
     501            PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
     502            PS_ARRAY_ADD_SCALAR(job->args, rowStop, PS_TYPE_S32);
     503
     504            if (!psThreadJobAddPending (job)) {
     505                psFree(job);
     506                psFree(orders);
     507                psFree(values);
     508                return false;
     509            }
     510            psFree(job);
     511        } else if (!pmDarkApplyScan(readout, dark, orders, values, bad, doNorm, norm, rowStart, rowStop)) {
     512            psError(PS_ERR_UNKNOWN, false, "Unable to apply dark.");
     513            psFree(orders);
     514            psFree(values);
     515            return false;
     516        }
    517517    }
    518518
    519519    if (threaded) {
    520520        // wait here for the threaded jobs to finish
    521         if (!psThreadPoolWait(false)) {
    522             psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image.");
     521        if (!psThreadPoolWait(true)) {
     522            psError(PS_ERR_UNKNOWN, false, "Unable to apply dark.");
     523            psFree(orders);
     524            psFree(values);
    523525            return false;
    524526        }
    525         fprintf (stderr, "success for threaded jobs\n");
    526 
    527         // free the done jobs
    528         psThreadJob *job = NULL;
    529         while ((job = psThreadJobGetDone()) != NULL) {
    530             psFree (job);
    531         }
    532     }
    533 
    534     psFree(poly);
     527    }
     528
     529    psFree(orders);
    535530    psFree(values);
    536531

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

    r19299 r19432  
    4040    );
    4141
    42 bool pmDarkApplyScan_Threaded(psThreadJob *job);
    43 bool pmDarkApplyScan (pmReadout *readout, const pmCell *dark, psPolynomialMD *poly, psVector *values, psMaskType bad, bool doNorm, float norm, int rowStart, int rowStop);
     42// Thread entry point for pmDarkApplyScan
     43bool pmDarkApplyScan_Threaded(psThreadJob *job // Job to execute
     44    );
     45
     46// Apply the dark correction to a scan
     47bool pmDarkApplyScan(pmReadout *readout, // Readout to correct
     48                     const pmCell *dark, // Dark to apply
     49                     const psVector *orders, // Polynomial orders for each ordinate
     50                     const psVector *values, // Values for each ordinate
     51                     psMaskType bad,    // Value to give bad pixels
     52                     bool doNorm,       // Normalise values?
     53                     float norm,        // Value by which to normalise
     54                     int rowStart, int rowStop // Scan range to work on
     55    );
    4456
    4557// Apply dark

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

    r19299 r19432  
    1717    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
    1818
    19     psImage *inImage   = job->args->data[0];
    20     psImage *inMask    = job->args->data[1];
    21     psImage *flatImage = job->args->data[2];
    22     psImage *flatMask  = job->args->data[3];
     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
    2323
    2424    psMaskType badFlat = PS_SCALAR_VALUE(job->args->data[4],U8);
    … …  
    2727    int rowStart       = PS_SCALAR_VALUE(job->args->data[7],S32);
    2828    int rowStop        = PS_SCALAR_VALUE(job->args->data[8],S32);
    29     bool status = pmFlatFieldScan (inImage, inMask, flatImage, flatMask, badFlat, xOffset, yOffset, rowStart, rowStop);
    30     return status;
     29    return pmFlatFieldScan(inImage, inMask, flatImage, flatMask, badFlat,
     30                           xOffset, yOffset, rowStart, rowStop);
    3131}
    3232
    … …  
    5050    break;
    5151
    52 bool pmFlatFieldScan (psImage *inImage, psImage *inMask, psImage *flatImage, psImage *flatMask, psMaskType badFlat, int xOffset, int yOffset, int rowStart, int rowStop) {
    53 
     52bool pmFlatFieldScan(psImage *inImage, psImage *inMask, const psImage *flatImage, const psImage *flatMask,
     53                     psMaskType badFlat, int xOffset, int yOffset, int rowStart, int rowStop)
     54{
    5455    switch (inImage->type.type) {
    5556        FLAT_DIVISION_CASE(U8,  0);
    … …  
    138139
    139140    for (int rowStart = 0; rowStart < inImage->numRows; rowStart += scanRows) {
    140       int rowStop = PS_MIN (rowStart + scanRows, inImage->numRows);
     141      int rowStop = PS_MIN(rowStart + scanRows, inImage->numRows);
    141142
    142143      if (threaded) {
    143144          // allocate a job, construct the arguments for this job
    144           psThreadJob *job = psThreadJobAlloc ("PSMODULES_DETREND_FLAT");
    145           psArrayAdd (job->args, 1, inImage);
    146           psArrayAdd (job->args, 1, inMask);
    147           psArrayAdd (job->args, 1, flatImage);
    148           psArrayAdd (job->args, 1, flatMask);
    149           PS_ARRAY_ADD_SCALAR (job->args, badFlat, PS_TYPE_U8);
    150           PS_ARRAY_ADD_SCALAR (job->args, xOffset, PS_TYPE_S32);
    151           PS_ARRAY_ADD_SCALAR (job->args, yOffset, PS_TYPE_S32);
    152           PS_ARRAY_ADD_SCALAR (job->args, rowStart, PS_TYPE_S32);
    153           PS_ARRAY_ADD_SCALAR (job->args, rowStop, PS_TYPE_S32);
     145          psThreadJob *job = psThreadJobAlloc("PSMODULES_DETREND_FLAT");
     146          psArrayAdd(job->args, 1, inImage);
     147          psArrayAdd(job->args, 1, inMask);
     148          psArrayAdd(job->args, 1, flatImage);
     149          psArrayAdd(job->args, 1, flatMask);
     150          PS_ARRAY_ADD_SCALAR(job->args, badFlat, PS_TYPE_U8);
     151          PS_ARRAY_ADD_SCALAR(job->args, xOffset, PS_TYPE_S32);
     152          PS_ARRAY_ADD_SCALAR(job->args, yOffset, PS_TYPE_S32);
     153          PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
     154          PS_ARRAY_ADD_SCALAR(job->args, rowStop, PS_TYPE_S32);
    154155
    155           // ppImageDetrendReadout(config, options, view)
    156           if (!psThreadJobAddPending (job)) {
     156          if (!psThreadJobAddPending(job)) {
    157157              psFree(job);
    158158              return false;
    159159          }
    160160          psFree(job);
    161       } else {
    162           pmFlatFieldScan (inImage, inMask, flatImage, flatMask, badFlat, xOffset, yOffset, rowStart, rowStop);
     161      } else if (!pmFlatFieldScan(inImage, inMask, flatImage, flatMask, badFlat,
     162                                  xOffset, yOffset, rowStart, rowStop)) {
     163          psError(PS_ERR_UNKNOWN, false, "Unable to flat-field image.");
     164          return false;
    163165      }
    164166    }
    … …  
    166168    if (threaded) {
    167169        // wait here for the threaded jobs to finish
    168         if (!psThreadPoolWait(false)) {
    169             psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image.");
     170        if (!psThreadPoolWait(true)) {
     171            psError(PS_ERR_UNKNOWN, false, "Unable to flat-field image.");
    170172            return false;
    171         }
    172         fprintf (stderr, "success for threaded jobs\n");
    173 
    174         // free done jobs
    175         psThreadJob *job = NULL;
    176         while ((job = psThreadJobGetDone()) != NULL) {
    177             psFree (job);
    178173        }
    179174    }
    … …  
    187182    psFree(timeString);
    188183
    189 
    190184    return true;
    191185}

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

    r19299 r19432  
    55 * @author Paul Price, IfA
    66 *
    7  * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-08-30 02:28:07 $
     7 * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2008-09-09 04:10:14 $
    99 * Copyright 2004-2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    2828                );
    2929
    30 bool pmFlatFieldScan_Threaded(psThreadJob *job);
    31 bool pmFlatFieldScan (psImage *inImage, psImage *inMask, psImage *flatImage, psImage *flatMask, psMaskType badFlag, int xOffset, int yOffset, int rowStart, int rowStop);
     30/// Thread entry point for flat-fielding
     31bool pmFlatFieldScan_Threaded(psThreadJob *job ///< Job to exectute
     32    );
     33
     34/// Flat-field a scan
     35bool pmFlatFieldScan(
     36    psImage *inImage,                   ///< Input image to correct
     37    psImage *inMask,                    ///< Input mask image
     38    const psImage *flatImage,           ///< Flat-field image
     39    const psImage *flatMask,            ///< Flat-field mask
     40    psMaskType badFlag,                 ///< Mask value to give bad pixels
     41    int xOffset, int yOffset,           ///< Offset between input and flat-field
     42    int rowStart, int rowStop           ///< Scan range
     43    );
    3244
    3345

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

    r19299 r19432  
    661661
    662662    psImage *image        = job->args->data[0];
    663     psImage *shutterImage = job->args->data[1];
     663    const psImage *shutterImage = job->args->data[1];
    664664    psImage *mask         = job->args->data[2];
    665665
    … …  
    668668    int rowStart     = PS_SCALAR_VALUE(job->args->data[5],S32);
    669669    int rowStop      = PS_SCALAR_VALUE(job->args->data[6],S32);
    670     bool status = pmShutterCorrectionApplyScan (image, shutterImage, mask, exptime, blank, rowStart, rowStop);
    671     return status;
    672 }
    673 
    674 bool pmShutterCorrectionApplyScan(psImage *image, psImage *shutterImage, psImage *mask, float exptime, psMaskType blank, int rowStart, int rowStop)
     670    return pmShutterCorrectionApplyScan (image, shutterImage, mask, exptime, blank, rowStart, rowStop);
     671}
     672
     673bool pmShutterCorrectionApplyScan(psImage *image, const psImage *shutterImage, psImage *mask, float exptime,
     674                                  psMaskType blank, int rowStart, int rowStop)
    675675{
    676676    for (int y = rowStart; y < rowStop; y++) {
    … …  
    753753            }
    754754        }
    755         psMetadataAddF32 (cell->concepts, PS_LIST_TAIL, "CELL.EXPOSURE", PS_META_REPLACE, "exposure time re-normalized to 1.0", 1.0); // Exposure time
     755        psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.EXPOSURE", PS_META_REPLACE,
     756                         "exposure time re-normalized to 1.0", 1.0); // Exposure time
    756757        psString line = NULL;
    757         psStringAppend (&line, "extreme exposure time %f, re-normalized to 1.0", exptime);
     758        psStringAppend(&line, "extreme exposure time %f, re-normalized to 1.0", exptime);
    758759        psMetadataAddStr(hdu->header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, line, "");
    759         psFree (line);
     760        psFree(line);
    760761    } else {
    761762        for (int rowStart = 0; rowStart < image->numRows; rowStart += scanRows) {
    … …  
    764765            if (threaded) {
    765766                // allocate a job, construct the arguments for this job
    766                 psThreadJob *job = psThreadJobAlloc ("PSMODULES_DETREND_SHUTTER");
    767                 psArrayAdd (job->args, 1, image);
    768                 psArrayAdd (job->args, 1, shutterImage);
    769                 psArrayAdd (job->args, 1, mask);
    770                 PS_ARRAY_ADD_SCALAR (job->args, exptime, PS_TYPE_F32);
    771                 PS_ARRAY_ADD_SCALAR (job->args, blank, PS_TYPE_MASK);
    772                 PS_ARRAY_ADD_SCALAR (job->args, rowStart, PS_TYPE_S32);
    773                 PS_ARRAY_ADD_SCALAR (job->args, rowStop, PS_TYPE_S32);
    774 
    775                 // ppImageDetrendReadout(config, options, view)
    776                 if (!psThreadJobAddPending (job)) {
     767                psThreadJob *job = psThreadJobAlloc("PSMODULES_DETREND_SHUTTER");
     768                psArrayAdd(job->args, 1, image);
     769                psArrayAdd(job->args, 1, shutterImage);
     770                psArrayAdd(job->args, 1, mask);
     771                PS_ARRAY_ADD_SCALAR(job->args, exptime, PS_TYPE_F32);
     772                PS_ARRAY_ADD_SCALAR(job->args, blank, PS_TYPE_MASK);
     773                PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
     774                PS_ARRAY_ADD_SCALAR(job->args, rowStop, PS_TYPE_S32);
     775
     776                if (!psThreadJobAddPending(job)) {
    777777                    psFree(job);
    778778                    return false;
    779779                }
    780780                psFree(job);
    781             } else {
    782                 pmShutterCorrectionApplyScan (image, shutterImage, mask, exptime, blank, rowStart, rowStop);
     781            } else if (!pmShutterCorrectionApplyScan(image, shutterImage, mask, exptime, blank,
     782                                                     rowStart, rowStop)) {
     783                psError(PS_ERR_UNKNOWN, false, "Unable to apply shutter correction.");
     784                psFree(shutterImage);
     785                return false;
    783786            }
    784787        }
    785788        if (threaded) {
    786789            // wait here for the threaded jobs to finish
    787             if (!psThreadPoolWait(false)) {
    788                 psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image.");
     790            if (!psThreadPoolWait(true)) {
     791                psError(PS_ERR_UNKNOWN, false, "Unable to apply shutter correction.");
     792                psFree(shutterImage);
    789793                return false;
    790             }
    791             fprintf (stderr, "success for threaded jobs\n");
    792 
    793             // free the done jobs
    794             psThreadJob *job = NULL;
    795             while ((job = psThreadJobGetDone()) != NULL) {
    796                 psFree (job);
    797794            }
    798795        }
    … …  
    10241021}
    10251022
    1026 bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs, psMaskType maskVal)
     1023bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs,
     1024                                        psMaskType maskVal)
    10271025{
    10281026    PS_ASSERT_PTR_NON_NULL(shutter, false);
    … …  
    10431041    }
    10441042
    1045     psImage *nums = pmReadoutSetAnalysisImage(shutter, PM_READOUT_STACK_ANALYSIS_COUNT, numCols, numRows, PS_TYPE_U16, 0); // Image with number fitted per pixel
     1043    psImage *nums = pmReadoutSetAnalysisImage(shutter, PM_READOUT_STACK_ANALYSIS_COUNT, numCols, numRows,
     1044                                              PS_TYPE_U16, 0); // Image with number fitted per pixel
    10461045    if (!nums) {
    10471046        return false;
    10481047    }
    1049     psImage *sigma = pmReadoutSetAnalysisImage(shutter, PM_READOUT_STACK_ANALYSIS_SIGMA, numCols, numRows, PS_TYPE_F32, NAN); // Image with stdev per pixel
     1048    psImage *sigma = pmReadoutSetAnalysisImage(shutter, PM_READOUT_STACK_ANALYSIS_SIGMA, numCols, numRows,
     1049                                               PS_TYPE_F32, NAN); // Image with stdev per pixel
    10501050    if (!sigma) {
    10511051        return false;

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

    r19299 r19432  
    55 * @author Paul Price, IfA
    66 *
    7  * @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-08-30 02:28:07 $
     7 * @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2008-09-09 04:10:14 $
    99 * Copyright 2006 Institute for Astronomy, University of Hawaii
    1010 */
    … …  
    124124    );
    125125
    126 bool pmShutterCorrectionApplyScan_Threaded(psThreadJob *job);
    127 bool pmShutterCorrectionApplyScan(psImage *image, psImage *shutterImage, psImage *mask, float exptime, psMaskType blank, int rowStart, int rowStop);
     126/// Thread entry point for applying a shutter correction
     127bool pmShutterCorrectionApplyScan_Threaded(
     128    psThreadJob *job                    ///< Job to execute
     129    );
     130
     131/// Apply the shutter correction to a scan
     132bool pmShutterCorrectionApplyScan(
     133    psImage *image,                     ///< Input image to correct
     134    const psImage *shutterImage,        ///< Shutter correction image
     135    psImage *mask,                      ///< Input mask image
     136    float exptime,                      ///< Exposure time to which to correct
     137    psMaskType blank,                   ///< Mask value to give blank pixels
     138    int rowStart, int rowStop           ///< Range of scan
     139    );
    128140
    129141/// Apply a shutter correction
    … …  
    193205
    194206// prepare outputs for shutter correction
    195 bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs, psMaskType maskVal);
     207bool pmShutterCorrectionGeneratePrepare(pmReadout *shutter, pmReadout *pattern, const psArray *inputs,
     208                                        psMaskType maskVal);
    196209
    197210/// @}
Note: See TracChangeset for help on using the changeset viewer.