IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2856


Ignore:
Timestamp:
Dec 30, 2004, 11:35:04 AM (22 years ago)
Author:
gusciora
Message:

Modified calls to psReadoutAlloc().

Location:
trunk/psModules
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/src/pmSubtractBias.c

    r2850 r2856  
    66 *  @author George Gusciora, MHPCC
    77 *
    8  *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2004-12-30 01:41:51 $
     8 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2004-12-30 21:35:03 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2929                           const psReadout *bias)
    3030{
    31     int i;
    32     int j;
     31    psS32 i;
     32    psS32 j;
    3333
    3434    if (bias == NULL) {
    … …  
    3838    }
    3939
    40     // XXX: What should be returned here?
    4140    if (((in->image)->numRows + in->row0 - bias->row0) > (bias->image)->numRows) {
    4241        psError(PS_ERR_UNKNOWN,true, "bias image does not have enough rows\n");
    … …  
    4847    }
    4948
    50     // XXX: Verify that this is the correct way to use offsets.
    5149    for (i=0;i<(in->image)->numRows;i++) {
    5250        for (j=0;j<(in->image)->numCols;j++) {
    … …  
    6563/******************************************************************************
    6664p_psImageSubtractScalar(): subtract a scalar from the input image.
    67  
    68 // XXX: Is there already a function which does this?
    6965 *****************************************************************************/
    7066psImage *p_psImageSubtractScalar(psImage *image,
    71                                  float scalar)
     67                                 psF32 scalar)
    7268{
    73     int i;
    74     int j;
    75 
    76     for (i=0;i<image->numRows;i++) {
    77         for (j=0;j<image->numCols;j++) {
     69    for (psS32 i=0;i<image->numRows;i++) {
     70        for (psS32 j=0;j<image->numCols;j++) {
    7871            (image->data.F32[i][j])-= scalar;
    7972        }
    … …  
    8376
    8477/******************************************************************************
    85 GenNewStatOptions(): this routine will take as input the options member of
    86 the stat data structure, determine if multiple options have been specified,
    87 issue a warning message if so, and return the highest priority option
    88 (according to the order of the if-statements in this code).
     78GenNewStatOptions(): this routine will take as input the options member of the
     79stat data structure, determine if multiple options have been specified, issue
     80a warning message if so, and return the highest priority option (according to
     81the order of the if-statements in this code).  The higher priority options are
     82listed lower in the code.
    8983 *****************************************************************************/
    9084psStatsOptions GenNewStatOptions(const psStats *stat)
    9185{
    92     int numOptions = 0;
     86    psS32 numOptions = 0;
    9387    psStatsOptions opt = 0;
     88
     89    if (stat->options & PS_STAT_ROBUST_MODE) {
     90        if (numOptions == 0) {
     91            opt = PS_STAT_ROBUST_MODE;
     92        }
     93        numOptions++;
     94    }
     95
     96    if (stat->options & PS_STAT_ROBUST_MEDIAN) {
     97        if (numOptions == 0) {
     98            opt = PS_STAT_ROBUST_MEDIAN;
     99        }
     100        numOptions++;
     101    }
     102
     103    if (stat->options & PS_STAT_ROBUST_MEAN) {
     104        if (numOptions == 0) {
     105            opt = PS_STAT_ROBUST_MEAN;
     106        }
     107        numOptions++;
     108    }
     109
     110    if (stat->options & PS_STAT_CLIPPED_MEAN) {
     111        if (numOptions == 0) {
     112            opt = PS_STAT_CLIPPED_MEAN;
     113        }
     114        numOptions++;
     115    }
     116
     117    if (stat->options & PS_STAT_SAMPLE_MEDIAN) {
     118        if (numOptions == 0) {
     119            opt = PS_STAT_SAMPLE_MEDIAN;
     120        }
     121        numOptions++;
     122    }
    94123
    95124    if (stat->options & PS_STAT_SAMPLE_MEAN) {
    … …  
    98127    }
    99128
    100     if (stat->options & PS_STAT_SAMPLE_MEDIAN) {
    101         if (numOptions == 0) {
    102             opt = PS_STAT_SAMPLE_MEDIAN;
    103         }
    104         numOptions++;
    105     }
    106 
    107     if (stat->options & PS_STAT_CLIPPED_MEAN) {
    108         if (numOptions == 0) {
    109             opt = PS_STAT_CLIPPED_MEAN;
    110         }
    111         numOptions++;
    112     }
    113 
    114     if (stat->options & PS_STAT_ROBUST_MEAN) {
    115         if (numOptions == 0) {
    116             opt = PS_STAT_ROBUST_MEAN;
    117         }
    118         numOptions++;
    119     }
    120 
    121     if (stat->options & PS_STAT_ROBUST_MEDIAN) {
    122         if (numOptions == 0) {
    123             opt = PS_STAT_ROBUST_MEDIAN;
    124         }
    125         numOptions++;
    126     }
    127 
    128     if (stat->options & PS_STAT_ROBUST_MODE) {
    129         if (numOptions == 0) {
    130             opt = PS_STAT_ROBUST_MODE;
    131         }
    132         numOptions++;
    133     }
    134129
    135130    if (numOptions == 0) {
    … …  
    154149 *****************************************************************************/
    155150psVector *ScaleOverscanVector(psVector *overscanVector,
    156                               int n,
     151                              psS32 n,
    157152                              void *fitSpec,
    158153                              pmFit fit)
    … …  
    178173    psPolynomial1D *myPoly;
    179174    psSpline1D *mySpline;
    180     float x;
    181     int i;
     175    psF32 x;
     176    psS32 i;
    182177
    183178    if (fit == PM_FIT_POLYNOMIAL) {
    184179        // Fit a polynomial to the old overscan vector.
    185180        myPoly = (psPolynomial1D *) fitSpec;
     181        PS_POLY_CHECK_NULL(myPoly, NULL);
    186182        myPoly = psVectorFitPolynomial1D(myPoly, NULL, overscanVector, NULL);
     183        if (myPoly == NULL) {
     184            psError(PS_ERR_UNKNOWN, false, "ScaleOverscanVector(): Could not fit a polynomial to the psVector.\n");
     185            return(NULL);
     186        }
    187187
    188188        // For each element of the new vector, convert the x-ordinate to that
    … …  
    190190        // interpolated value at that point, and set the new vector.
    191191        for (i=0;i<n;i++) {
    192             x = ((float) i) * ((float) overscanVector->n) / ((float) n);
     192            x = ((psF32) i) * ((psF32) overscanVector->n) / ((psF32) n);
    193193            newVec->data.F32[i] = psPolynomial1DEval(myPoly, x);
    194194        }
    … …  
    200200            mustFreeSpline = 1;
    201201        }
     202
    202203        //
    203204        // NOTE: Since the X arg in the psVectorFitSpline1D() function is NULL,
    … …  
    206207        //
    207208        mySpline = psVectorFitSpline1D(mySpline, NULL, overscanVector, NULL);
     209        if (mySpline == NULL) {
     210            psError(PS_ERR_UNKNOWN, false, "ScaleOverscanVector(): Could not fit a spline to the psVector.\n");
     211            return(NULL);
     212        }
    208213
    209214        // For each element of the new vector, convert the x-ordinate to that
    … …  
    212217        for (i=0;i<n;i++) {
    213218            // Scale to [0 : overscanVector->n - 1]
    214             x = ((float) i) * ((float) (overscanVector->n-1)) / ((float) n);
     219            x = ((psF32) i) * ((psF32) (overscanVector->n-1)) / ((psF32) n);
    215220            newVec->data.F32[i] = psSpline1DEval(mySpline, x);
    216221        }
    … …  
    228233}
    229234
     235/******************************************************************************
     236XXX: The SDRS does not specify type support.  F32 is implemented here.
     237 *****************************************************************************/
    230238psReadout *pmSubtractBias(psReadout *in,
    231239                          void *fitSpec,
    … …  
    233241                          pmOverscanAxis overScanAxis,
    234242                          psStats *stat,
    235                           int nBinOrig,
     243                          psS32 nBinOrig,
    236244                          pmFit fit,
    237245                          const psReadout *bias)
    … …  
    263271        return(in);
    264272    }
    265     int i;
    266     int j;
    267     int numBins = 0;
     273    psS32 i;
     274    psS32 j;
     275    psS32 numBins = 0;
    268276    static psVector *overscanVector = NULL;
    269277    psVector *tmpRow = NULL;
    … …  
    276284    psPolynomial1D *myPoly = NULL;
    277285    psSpline1D *mySpline = NULL;
    278     int nBin;
    279     //  XXX: This comment isn't right?
    280     //  Determine if multiple options are specified in stat.
     286    psS32 nBin;
     287
    281288    //
     289    //  Create a static stats data structure and determine the highest
     290    //  priority stats option.
     291    //
     292    static psStats *myStats = NULL;
     293    if (myStats == NULL) {
     294        myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
     295        p_psMemSetPersistent(myStats, true);
     296    }
    282297    if (stat != NULL) {
    283         stat->options = GenNewStatOptions(stat);
     298        myStats->options = GenNewStatOptions(stat);
    284299    }
    285300
    … …  
    314329        while (NULL != tmpOverscan) {
    315330            myOverscanImage = (psImage *) tmpOverscan->data;
    316             psImageStats(stat, myOverscanImage, NULL, 0xffffffff);
    317             p_psGetStatValue(stat, &statValue);
     331            psImageStats(myStats, myOverscanImage, NULL, 0xffffffff);
     332            p_psGetStatValue(myStats, &statValue);
    318333            p_psImageSubtractScalar(in->image, statValue);
    319334
    … …  
    356371                    tmpRow->data.F32[j] = myOverscanImage->data.F32[j][i];
    357372                }
    358                 stat = psVectorStats(stat, tmpRow, NULL, NULL, 0);
    359                 p_psGetStatValue(stat, &statValue);
     373                myStats = psVectorStats(myStats, tmpRow, NULL, NULL, 0);
     374                p_psGetStatValue(myStats, &statValue);
    360375                overscanVector->data.F32[i] = statValue;
    361376            }
    … …  
    399414                    tmpCol->data.F32[j] = myOverscanImage->data.F32[i][j];
    400415                }
    401                 stat = psVectorStats(stat, tmpCol, NULL, NULL, 0);
    402                 p_psGetStatValue(stat, &statValue);
     416                myStats = psVectorStats(myStats, tmpCol, NULL, NULL, 0);
     417                p_psGetStatValue(myStats, &statValue);
    403418                overscanVector->data.F32[i] = statValue;
    404419            }
    … …  
    441456                    }
    442457                }
    443                 stat = psVectorStats(stat, binVec, NULL, NULL, 0);
    444                 p_psGetStatValue(stat, &statValue);
     458                myStats = psVectorStats(myStats, binVec, NULL, NULL, 0);
     459                p_psGetStatValue(myStats, &statValue);
    445460                myBin->data.F32[i] = statValue;
    446461            }
    … …  
    492507                    psF32 tmpF32 = 0.0;
    493508                    if (fit == PM_FIT_POLYNOMIAL) {
    494                         tmpF32 = psPolynomial1DEval(myPoly, ((float) i) / ((float) nBin));
     509                        tmpF32 = psPolynomial1DEval(myPoly, ((psF32) i) / ((psF32) nBin));
    495510                    } else if (fit == PM_FIT_SPLINE) {
    496                         tmpF32 = psSpline1DEval(mySpline, ((float) i) / ((float) nBin));
     511                        tmpF32 = psSpline1DEval(mySpline, ((psF32) i) / ((psF32) nBin));
    497512                    }
    498513                    for (j=0;j<(in->image)->numRows;j++) {
    499514                        (in->image)->data.F32[j][i]-= tmpF32;
    500 
    501515                    }
    502516                }
    … …  
    510524                    psF32 tmpF32 = 0.0;
    511525                    if (fit == PM_FIT_POLYNOMIAL) {
    512                         tmpF32 = psPolynomial1DEval(myPoly, ((float) i) / ((float) nBin));
     526                        tmpF32 = psPolynomial1DEval(myPoly, ((psF32) i) / ((psF32) nBin));
    513527                    } else if (fit == PM_FIT_SPLINE) {
    514                         tmpF32 = psSpline1DEval(mySpline, ((float) i) / ((float) nBin));
     528                        tmpF32 = psSpline1DEval(mySpline, ((psF32) i) / ((psF32) nBin));
    515529                    }
    516530

  • trunk/psModules/test/tst_pmReadoutCombine.c

    r2851 r2856  
    55 *  @author GLG, MHPCC
    66 *
    7  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2004-12-30 01:42:04 $
     7 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2004-12-30 21:35:04 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    115115        *(int *) (& (tmpImage->row0)) = baseRows[r];
    116116        *(int *) (& (tmpImage->col0)) = baseCols[r];
    117         psReadout *tmpReadout = psReadoutAlloc(baseColsReadout[r],
    118                                                baseRowsReadout[r],
    119                                                tmpImage);
     117        /*
     118                psReadout *tmpReadout = psReadoutAlloc(baseColsReadout[r],
     119                                                       baseRowsReadout[r],
     120                                                       tmpImage);
     121        */
     122        psReadout *tmpReadout = psReadoutAlloc();
     123        tmpReadout->image = tmpImage;
     124
    120125        minOutRow = PS_MIN(minOutRow, (baseRowsReadout[r] + baseRows[r]));
    121126        minOutCol = PS_MIN(minOutCol, (baseColsReadout[r] + baseCols[r]));
    … …  
    226231        *(int *) (& (tmpImage->row0)) = baseRows[r];
    227232        *(int *) (& (tmpImage->col0)) = baseCols[r];
    228         psReadout *tmpReadout = psReadoutAlloc(baseColsReadout[r],
    229                                                baseRowsReadout[r],
    230                                                tmpImage);
     233        /*
     234                psReadout *tmpReadout = psReadoutAlloc(baseColsReadout[r],
     235                                                       baseRowsReadout[r],
     236                                                       tmpImage);
     237        */
     238        psReadout *tmpReadout = psReadoutAlloc();
     239        tmpReadout->image = tmpImage;
    231240        minOutRow = PS_MIN(minOutRow, (baseRowsReadout[r] + baseRows[r]));
    232241        minOutCol = PS_MIN(minOutCol, (baseColsReadout[r] + baseCols[r]));

  • trunk/psModules/test/tst_pmSubtractBias.c

    r2851 r2856  
    1313 *  @author GLG, MHPCC
    1414 *
    15  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2004-12-30 01:42:04 $
     15 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2004-12-30 21:35:04 $
    1717 *
    1818 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2929static int testX(void);
    3030testDescription tests[] = {
    31 
    3231                              {test00, 000, "pmSubtractBias", 0, false},
    3332                              {test01, 000, "pmSubtractBias", 0, false},
    … …  
    6059    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    6160    psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    62     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
    63     psReadout *myBias = psReadoutAlloc(numCols, numRows, tmpImage2);
     61    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     62    //    psReadout *myBias = psReadoutAlloc(numCols, numRows, tmpImage2);
     63    psReadout *myReadout = psReadoutAlloc();
     64    psReadout *myBias = psReadoutAlloc();
     65    myReadout->image = tmpImage1;
     66    myBias->image = tmpImage2;
     67
    6468
    6569    for (i=0;i<numRows;i++) {
    … …  
    99103    testStatus |= doSubtractBiasFullFrame(1, NUM_ROWS);
    100104    testStatus |= doSubtractBiasFullFrame(NUM_COLS, NUM_ROWS);
    101 
    102105    return(testStatus);
    103106}
    … …  
    119122    psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    120123    psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    121     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     124    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     125    psReadout *myReadout = psReadoutAlloc();
     126    myReadout->image = tmpImage1;
     127
     128
    122129    psList *list;
    123130    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    … …  
    188195    psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    189196    psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    190     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     197    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     198    psReadout *myReadout = psReadoutAlloc();
     199    myReadout->image = tmpImage1;
    191200    psList *list;
    192201    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    … …  
    247256    psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    248257    psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    249     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     258    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     259    psReadout *myReadout = psReadoutAlloc();
     260    myReadout->image = tmpImage1;
    250261    psList *list;
    251262    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    … …  
    305316    int testStatus = 0;
    306317    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    307     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     318    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     319    psReadout *myReadout = psReadoutAlloc();
     320    myReadout->image = tmpImage1;
    308321    psImage *tmpImage2 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
    309322    psImage *tmpImage3 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
    … …  
    390403    psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    391404    psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    392     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     405    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     406    psReadout *myReadout = psReadoutAlloc();
     407    myReadout->image = tmpImage1;
    393408    psList *list;
    394409    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    … …  
    458473    psImage *tmpImage3 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
    459474    psImage *tmpImage4 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
    460     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     475    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     476    psReadout *myReadout = psReadoutAlloc();
     477    myReadout->image = tmpImage1;
    461478    psList *list;
    462479    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    … …  
    537554    psImage *tmpImage3Short = psImageAlloc(numCols-1, numRows-1, PS_TYPE_F32);
    538555    psImage *tmpImage4Short = psImageAlloc(numCols-1, numRows-1, PS_TYPE_F32);
    539     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     556    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     557    psReadout *myReadout = psReadoutAlloc();
     558    myReadout->image = tmpImage1;
    540559    psReadout *rc = NULL;
    541560    psList *list;
    … …  
    543562    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    544563    psImage *tmpImage5 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    545     psReadout *myBias = psReadoutAlloc(numCols, numRows, tmpImage5);
     564    //    psReadout *myBias = psReadoutAlloc(numCols, numRows, tmpImage5);
     565    psReadout *myBias = psReadoutAlloc();
     566    myBias->image = tmpImage5;
     567
    546568    psImage *tmpImage5ShortRows = psImageAlloc(numCols, numRows-1, PS_TYPE_F32);
    547     psReadout *myBiasShortRows = psReadoutAlloc(numCols, numRows-1, tmpImage5ShortRows);
     569    //    psReadout *myBiasShortRows = psReadoutAlloc(numCols, numRows-1, tmpImage5ShortRows);
     570    psReadout *myBiasShortRows = psReadoutAlloc();
     571    myBiasShortRows->image = tmpImage5ShortRows;
    548572    psImage *tmpImage5ShortCols = psImageAlloc(numCols-1, numRows, PS_TYPE_F32);
    549     psReadout *myBiasShortCols = psReadoutAlloc(numCols-1, numRows, tmpImage5ShortCols);
     573    //    psReadout *myBiasShortCols = psReadoutAlloc(numCols-1, numRows, tmpImage5ShortCols);
     574    psReadout *myBiasShortCols = psReadoutAlloc();
     575    myBiasShortCols->image = tmpImage5ShortCols;
    550576
    551577    for (i=0;i<numRows;i++) {
    … …  
    840866
    841867    psImage *tmpImage1 = psImageAlloc(imageNumCols, imageNumRows, PS_TYPE_F32);
    842     psReadout *myReadout = psReadoutAlloc(imageNumCols, imageNumRows, tmpImage1);
     868    //    psReadout *myReadout = psReadoutAlloc(imageNumCols, imageNumRows, tmpImage1);
     869    psReadout *myReadout = psReadoutAlloc();
     870    myReadout->image = tmpImage1;
    843871    for (i=0;i<imageNumRows;i++) {
    844872        for (j=0;j<imageNumCols;j++) {

  • trunk/psModules/test/tst_pmSubtractSky.c

    r2851 r2856  
    77 *  @author GLG, MHPCC
    88 *
    9  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-12-30 01:42:04 $
     9 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-12-30 21:35:04 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4848    int testStatus = 0;
    4949    psImage *tmpImageF32 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    50     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImageF32);
     50    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImageF32);
     51    psReadout *myReadout = psReadoutAlloc();
     52    myReadout->image = tmpImageF32;
    5153    psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    5254    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_X_ORDER, POLY_Y_ORDER, PS_POLYNOMIAL_ORD);
    … …  
    8284    int testStatus = 0;
    8385    psImage *tmpImageF32 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    84     psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImageF32);
     86    //    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImageF32);
     87    psReadout *myReadout = psReadoutAlloc();
     88    myReadout->image = tmpImageF32;
    8589    psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    8690    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_X_ORDER, POLY_Y_ORDER, PS_POLYNOMIAL_ORD);
    … …  
    181185    psImage *tmpImageF32 = psImageAlloc(NUM_COLS_SMALL, NUM_ROWS_SMALL, PS_TYPE_F32);
    182186    psImage *tmpImageF64 = psImageAlloc(NUM_COLS_SMALL, NUM_ROWS_SMALL, PS_TYPE_F64);
    183     psReadout *myReadout = psReadoutAlloc(NUM_COLS_SMALL, NUM_ROWS_SMALL, tmpImageF32);
     187    //    psReadout *myReadout = psReadoutAlloc(NUM_COLS_SMALL, NUM_ROWS_SMALL, tmpImageF32);
     188    psReadout *myReadout = psReadoutAlloc();
     189    myReadout->image = tmpImageF32;
    184190    psReadout *rc = NULL;
    185191    psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
Note: See TracChangeset for help on using the changeset viewer.