IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Nov 15, 2005, 10:09:03 AM (21 years ago)
Author:
gusciora
Message:

SubtractBias was recoded. Significant mods to removeBadPixels.
Additional mods to other files.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/test/imsubtract/tst_pmSubtractBias.c

    r5188 r5516  
    33 *  @brief Contains the tests for pmSubtractBias.c:
    44 *
    5  * test00: This code will subtract full bias frames from the input image.
    6  * test01: Multiple overscan regions, calculate a scalar statistic for
    7  *  each, then subtract from the input image.
    8  * test02: Calculate a column overscan vector and subtract it from each
    9  *  column in the input image.
    10  * test03: Calculate a row overscan vector and subtract it from each
     5 * test00a: This code will subtract full bias frames from the input image.
     6 * XXX: Must test:
     7 *  Various image offsets.
     8 *  Various image size combinations.
     9 *  Various data types for the bias and input images.
     10 *  Ensure code works when CELL.TRIMSEC is not set.
     11 * test00b: This code will subtract full dark frames from the input image.
     12 * XXX: Must test:
     13 *  Various image offsets.
     14 *  Various image size combinations.
     15 *  Various data types for the bias and input images.
     16 *  Code properly determines CELL.DARKTIME from cell metadata.
     17 *  Ensure code works when CELL.DARKTIME is not set.
     18 *  Ensure code works when CELL.TRIMSEC is not set.
     19 *  test03: Calculate a row overscan vector and subtract it from each
    1120 *  row in the input image.
    12  * test04:
     21 * test05:
    1322 *
    1423 *  @author GLG, MHPCC
    … …  
    1625 *  XXX: Memory leaks are not being detected.
    1726 *
    18  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    19  *  @date $Date: 2005-09-29 21:57:31 $
     27 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     28 *  @date $Date: 2005-11-15 20:09:03 $
    2029 *
    2130 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2534#include "pslib.h"
    2635#include "pmSubtractBias.h"
    27 static int test00(void);
    28 static int test01(void);
    29 static int test02(void);
    30 static int test03(void);
    31 static int test04(void);
    32 static int testX(void);
     36static int test00a(void);
     37static int test00b(void);
     38//static int test01(void);
     39//static int test02(void);
     40//static int test03(void);
     41//static int test04(void);
     42static int test05(void);
    3343testDescription tests[] = {
    34                               {test00, 000, "pmSubtractBias", 0, true},
    35                               {test01, 000, "pmSubtractBias", 0, true},
    36                               {test02, 000, "pmSubtractBias", 0, true},
    37                               {test03, 000, "pmSubtractBias", 0, false},
    38                               {test04, 000, "pmSubtractBias", 0, true},
    39                               {testX,  000, "pmSubtractBias", 0, true},
     44                              {test00a, 000, "doSubtractBiasFullFrame", 0, false},
     45                              {test00b, 000, "doSubtractDarkFullFrame", 0, false},
     46                              //                              {test01, 000, "pmSubtractBias", 0, true},
     47                              //                              {test02, 000, "pmSubtractBias", 0, true},
     48                              //                              {test03, 000, "pmSubtractBias", 0, false},
     49                              //                              {test04, 000, "pmSubtractBias", 0, true},
     50                              {test05, 000, "pmSubtractBias", 0, false},
    4051                              {NULL}
    4152                          };
    … …  
    4556{
    4657    psLogSetFormat("HLNM");
     58
     59    psTraceSetLevel(".", 0);
     60    psTraceSetLevel("spline1DFree", 0);
     61    psTraceSetLevel("calculateSecondDerivs", 0);
     62    psTraceSetLevel("vectorBinDisectF32", 0);
     63    psTraceSetLevel("vectorBinDisectF64", 0);
     64    psTraceSetLevel("p_psVectorBinDisect", 0);
     65    psTraceSetLevel("psSpline1DAlloc", 0);
     66    psTraceSetLevel("psVectorFitSpline1D", 0);
     67    psTraceSetLevel("psSpline1DEval", 0);
     68    psTraceSetLevel("psSpline1DEvalVector", 0);
     69
    4770    return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv);
    4871}
    … …  
    5073#define NUM_ROWS 8
    5174#define NUM_COLS 8
     75#define MAX_HEADER_MSG_LENGTH 1000
     76#define POLYNOMIAL_FIT_ORDER 2
     77#define NUM_OVERSCANS 2
    5278/******************************************************************************
    5379doSubtractBiasFullFrame(): a sample pmReadout as well as a bias image are
    … …  
    6389    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    6490    psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    65     //    pmReadout *myReadout = pmReadoutAlloc(numCols, numRows, tmpImage1);
    66     //    pmReadout *myBias = pmReadoutAlloc(numCols, numRows, tmpImage2);
    6791    pmReadout *myReadout = pmReadoutAlloc(NULL);
    6892    pmReadout *myBias = pmReadoutAlloc(NULL);
    … …  
    7094    myBias->image = tmpImage2;
    7195
    72 
    73     printPositiveTestHeader(stdout, "pmSubtractBias", "doSubtractBiasFullFrame");
     96    char *HeaderMessageStr = (char *) psAlloc(MAX_HEADER_MSG_LENGTH);
     97    sprintf(HeaderMessageStr, "doSubtractBiasFullFrame(%d, %d)", numRows, numCols);
     98    printPositiveTestHeader(stdout, "pmSubtractBias", HeaderMessageStr);
    7499    for (i=0;i<numRows;i++) {
    75100        for (j=0;j<numCols;j++) {
    … …  
    79104    }
    80105
    81     myReadout = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_NONE, NULL,
    82                                0, PM_FIT_NONE, myBias);
     106    myReadout = pmSubtractBias(myReadout, NULL, PM_FIT_NONE, false,
     107                               NULL, 0, myBias, NULL);
    83108
    84109    for (i=0;i<numRows;i++) {
    … …  
    96121    psFree(myReadout);
    97122    psFree(myBias);
    98     printFooter(stdout, "pmSubtractBias", "doSubtractBiasFullFrame", true);
     123    printFooter(stdout, "pmSubtractBias", HeaderMessageStr, true);
     124    psFree(HeaderMessageStr);
    99125    return(testStatus);
    100126}
    101127
    102128
    103 int test00( void )
     129int test00a( void )
    104130{
    105131    int testStatus = 0;
    … …  
    112138}
    113139
     140
    114141/******************************************************************************
    115 doSubtractFullOverscans(): a sample pmReadout as well as several overscan
    116 images of the same size are created.  The overscan images are then subtracted
    117 from the pmReadout.
     142doSubtractDarkFullFrame(): a sample pmReadout as well as a dark image are
     143created and the dark image is subtracted from the pmReadout.
    118144 *****************************************************************************/
    119 int doSubtractFullOverscans(int numCols, int numRows)
     145int doSubtractDarkFullFrame(int numCols, int numRows)
    120146{
    121147    int i;
    … …  
    126152    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    127153    psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    128     psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    129     psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    130     //    pmReadout *myReadout = pmReadoutAlloc(numCols, numRows, tmpImage1);
    131154    pmReadout *myReadout = pmReadoutAlloc(NULL);
     155    pmReadout *myDark = pmReadoutAlloc(NULL);
    132156    myReadout->image = tmpImage1;
    133 
    134 
    135     printPositiveTestHeader(stdout, "pmSubtractBias", "doSubtractFullOverscans");
    136     psList *list;
    137     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    138 
     157    myDark->image = tmpImage2;
     158
     159    char *HeaderMessageStr = (char *) psAlloc(MAX_HEADER_MSG_LENGTH);
     160    sprintf(HeaderMessageStr, "doSubtractDarkFullFrame(%d, %d)", numRows, numCols);
     161    printPositiveTestHeader(stdout, "pmSubtractBias", HeaderMessageStr);
    139162    for (i=0;i<numRows;i++) {
    140163        for (j=0;j<numCols;j++) {
    141164            myReadout->image->data.F32[i][j] = (float) (i + j);
    142             tmpImage2->data.F32[i][j] = 3.0;
    143             tmpImage3->data.F32[i][j] = 4.0;
    144             tmpImage4->data.F32[i][j] = 5.0;
    145         }
    146     }
    147     list = psListAlloc(tmpImage2);
    148     psListAdd(list, PS_LIST_HEAD, tmpImage3);
    149     psListAdd(list, PS_LIST_HEAD, tmpImage4);
    150 
    151     myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ALL, stat,
    152                                0, PM_FIT_NONE, NULL);
     165            myDark->image->data.F32[i][j] = 1.0;
     166        }
     167    }
     168
     169    myReadout = pmSubtractBias(myReadout, NULL, PM_FIT_NONE, false,
     170                               NULL, 0, NULL, myDark);
    153171
    154172    for (i=0;i<numRows;i++) {
    155173        for (j=0;j<numCols;j++) {
    156             expect = ((float) (i + j)) - 12.0;
     174            expect = ((float) (i + j)) - 1.0;
    157175            actual = myReadout->image->data.F32[i][j];
    158176            if (FLT_EPSILON < fabs(expect - actual)) {
    … …  
    165183
    166184    psFree(myReadout);
    167     psFree(tmpImage2);
    168     psFree(tmpImage3);
    169     psFree(tmpImage4);
    170     psFree(stat);
    171     psFree(list);
    172 
    173     printFooter(stdout, "pmSubtractBias", "doSubtractFullOverscans", true);
     185    psFree(myDark);
     186    printFooter(stdout, "pmSubtractBias", HeaderMessageStr, true);
     187    psFree(HeaderMessageStr);
    174188    return(testStatus);
    175189}
    176190
    177 int test01( void )
     191
     192int test00b( void )
    178193{
    179194    int testStatus = 0;
    180195
    181     testStatus |= doSubtractFullOverscans(1, 1);
    182     testStatus |= doSubtractFullOverscans(1, NUM_ROWS);
    183     testStatus |= doSubtractFullOverscans(NUM_COLS, 1);
    184     testStatus |= doSubtractFullOverscans(NUM_COLS, NUM_ROWS);
    185 
     196    testStatus |= doSubtractDarkFullFrame(1, 1);
     197    testStatus |= doSubtractDarkFullFrame(NUM_COLS, 1);
     198    testStatus |= doSubtractDarkFullFrame(1, NUM_ROWS);
     199    testStatus |= doSubtractDarkFullFrame(NUM_COLS, NUM_ROWS);
    186200    return(testStatus);
    187201}
    188202
    189 /******************************************************************************
    190 doSubtractFullOverscans(): a sample pmReadout as well as several overscan
    191 images of the same size are created.  The overscan images are collected
    192 pixel-by-pixel then subtracted column-wise from the pmReadout.
    193  *****************************************************************************/
    194 int doSubtractFullOverscanColumns(int numCols, int numRows)
    195 {
    196     int i;
    197     int j;
    198     float actual;
    199     float expect;
    200     int testStatus = 0;
    201     psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    202     psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    203     psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    204     psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    205     pmReadout *myReadout = pmReadoutAlloc(NULL);
    206     myReadout->image = tmpImage1;
    207     psList *list;
    208     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    209 
    210     for (i=0;i<numRows;i++) {
    211         for (j=0;j<numCols;j++) {
    212             myReadout->image->data.F32[i][j] = (float) (i + j);
    213             tmpImage2->data.F32[i][j] = 3.0;
    214             tmpImage3->data.F32[i][j] = 4.0;
    215             tmpImage4->data.F32[i][j] = 5.0;
    216         }
    217     }
    218     list = psListAlloc(tmpImage2);
    219     psListAdd(list, PS_LIST_HEAD, tmpImage3);
    220     psListAdd(list, PS_LIST_HEAD, tmpImage4);
    221 
    222     printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
    223 
    224     myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_COLUMNS, stat,
    225                                0, PM_FIT_NONE, NULL);
    226 
    227     for (i=0;i<numRows;i++) {
    228         for (j=0;j<numCols;j++) {
    229             expect = ((float) (i + j)) - 12.0;
    230             actual = myReadout->image->data.F32[i][j];
    231             if (FLT_EPSILON < fabs(expect - actual)) {
    232                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    233                 testStatus = 1;
    234             }
    235         }
    236     }
    237 
    238 
    239     psFree(myReadout);
    240     psFree(tmpImage2);
    241     psFree(tmpImage3);
    242     psFree(tmpImage4);
    243     psFree(stat);
    244     psFree(list);
    245 
    246     printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
    247     return(testStatus);
    248 }
    249 /******************************************************************************
    250 doSubtractFullOverscans(): a sample pmReadout as well as several overscan
    251 images of the same size are created.  The overscan images are collected
    252 pixel-by-pixel then subtracted column-wise from the pmReadout.
    253  *****************************************************************************/
    254 int doSubtractFullOverscanColumnsPoly(int numCols, int numRows)
    255 {
    256     int i;
    257     int j;
    258     float actual;
    259     float expect;
    260     int testStatus = 0;
    261     psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    262     psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    263     psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    264     psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    265     pmReadout *myReadout = pmReadoutAlloc(NULL);
    266     myReadout->image = tmpImage1;
    267     psList *list;
    268     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    269     psPolynomial1D *myPoly = psPolynomial1DAlloc(1, PS_POLYNOMIAL_ORD);
    270 
    271     for (i=0;i<numRows;i++) {
    272         for (j=0;j<numCols;j++) {
    273             myReadout->image->data.F32[i][j] = (float) (i + j);
    274             tmpImage2->data.F32[i][j] = 3.0;
    275             tmpImage3->data.F32[i][j] = 4.0;
    276             tmpImage4->data.F32[i][j] = 5.0;
    277         }
    278     }
    279     list = psListAlloc(tmpImage2);
    280     psListAdd(list, PS_LIST_HEAD, tmpImage3);
    281     psListAdd(list, PS_LIST_HEAD, tmpImage4);
    282 
    283     printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
    284 
    285     myReadout = pmSubtractBias(myReadout, myPoly, list, PM_OVERSCAN_COLUMNS, stat,
    286                                0, PM_FIT_POLYNOMIAL, NULL);
    287 
    288     for (i=0;i<numRows;i++) {
    289         for (j=0;j<numCols;j++) {
    290             expect = ((float) (i + j)) - 12.0;
    291             actual = myReadout->image->data.F32[i][j];
    292             if (FLT_EPSILON < fabs(expect - actual)) {
    293                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    294                 testStatus = 1;
    295             }
    296         }
    297     }
    298 
    299 
    300     psFree(myReadout);
    301     psFree(tmpImage2);
    302     psFree(tmpImage3);
    303     psFree(tmpImage4);
    304     psFree(stat);
    305     psFree(list);
    306     psFree(myPoly);
    307 
    308     printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
    309     return(testStatus);
    310 }
    311 /******************************************************************************
    312 doSubtractFullOverscansSmall(): a sample pmReadout as well as several overscan
    313 images of smaller size are created.  The overscan images are collected
    314 pixel-by-pixel then subtracted column-wise from the pmReadout.
    315  *****************************************************************************/
    316 int doSubtractFullOverscanColumnsSmall(int numCols, int numRows)
    317 {
    318     int i;
    319     int j;
    320     float actual;
    321     float expect;
    322     int testStatus = 0;
    323     psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    324     pmReadout *myReadout = pmReadoutAlloc(NULL);
    325     myReadout->image = tmpImage1;
    326     psImage *tmpImage2 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
    327     psImage *tmpImage3 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
    328     psImage *tmpImage4 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
    329     psList *list;
    330     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    331 
    332     for (i=0;i<numRows;i++) {
    333         for (j=0;j<numCols;j++) {
    334             myReadout->image->data.F32[i][j] = (float) (i + j);
    335         }
    336     }
    337     for (i=0;i<numRows/2;i++) {
    338         for (j=0;j<numCols/2;j++) {
    339             tmpImage2->data.F32[i][j] = 3.0;
    340             tmpImage3->data.F32[i][j] = 4.0;
    341             tmpImage4->data.F32[i][j] = 5.0;
    342         }
    343     }
    344     list = psListAlloc(tmpImage2);
    345     psListAdd(list, PS_LIST_HEAD, tmpImage3);
    346     psListAdd(list, PS_LIST_HEAD, tmpImage4);
    347 
    348     printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
    349 
    350     myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_COLUMNS, stat,
    351                                0, PM_FIT_POLYNOMIAL, NULL);
    352 
    353     for (i=0;i<numRows;i++) {
    354         for (j=0;j<numCols;j++) {
    355             expect = ((float) (i + j)) - 12.0;
    356             actual = myReadout->image->data.F32[i][j];
    357             if (FLT_EPSILON < fabs(expect - actual)) {
    358                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    359                 testStatus = 1;
    360             }
    361         }
    362     }
    363 
    364 
    365     psFree(myReadout);
    366     psFree(tmpImage2);
    367     psFree(tmpImage3);
    368     psFree(tmpImage4);
    369     psFree(stat);
    370     psFree(list);
    371 
    372     printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
    373     return(testStatus);
    374 }
    375 
    376 int test02( void )
    377 {
    378     int testStatus = 0;
    379 
    380     testStatus |= doSubtractFullOverscanColumns(1, 1);
    381     testStatus |= doSubtractFullOverscanColumns(1, NUM_ROWS);
    382     testStatus |= doSubtractFullOverscanColumns(NUM_COLS, 1);
    383     testStatus |= doSubtractFullOverscanColumns(NUM_COLS, NUM_ROWS);
    384     /* These tests do not make sense until the SDRS is clarified.
    385         testStatus |= doSubtractFullOverscanColumnsSmall(1, 1);
    386         testStatus |= doSubtractFullOverscanColumnsSmall(1, NUM_ROWS);
    387         testStatus |= doSubtractFullOverscanColumnsSmall(NUM_COLS, 1);
    388         testStatus |= doSubtractFullOverscanColumnsSmall(NUM_COLS, NUM_ROWS);
    389     */
    390 
    391     return(testStatus);
    392 }
    393 
    394 /******************************************************************************
    395 doSubtractFullOverscans(): a sample pmReadout as well as several overscan
    396 images of the same size are created.  The overscan images are collected
    397 pixel-by-pixel then subtracted row-wise from the pmReadout.
    398  *****************************************************************************/
    399 int doSubtractFullOverscanRows(int numCols, int numRows)
    400 {
    401     int i;
    402     int j;
    403     float actual;
    404     float expect;
    405     int testStatus = 0;
    406     psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    407     psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    408     psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    409     psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    410     pmReadout *myReadout = pmReadoutAlloc(NULL);
    411     myReadout->image = tmpImage1;
    412     psList *list;
    413     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    414 
    415     for (i=0;i<numRows;i++) {
    416         for (j=0;j<numCols;j++) {
    417             myReadout->image->data.F32[i][j] = (float) (i + j);
    418             tmpImage2->data.F32[i][j] = 3.0;
    419             tmpImage3->data.F32[i][j] = 4.0;
    420             tmpImage4->data.F32[i][j] = 5.0;
    421         }
    422     }
    423     list = psListAlloc(tmpImage2);
    424     psListAdd(list, PS_LIST_HEAD, tmpImage3);
    425     psListAdd(list, PS_LIST_HEAD, tmpImage4);
    426 
    427     printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
    428 
    429     myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
    430                                0, PM_FIT_NONE, NULL);
    431 
    432     for (i=0;i<numRows;i++) {
    433         for (j=0;j<numCols;j++) {
    434             expect = ((float) (i + j)) - 12.0;
    435             actual = myReadout->image->data.F32[i][j];
    436             if (FLT_EPSILON < fabs(expect - actual)) {
    437                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    438                 testStatus = 1;
    439             }
    440         }
    441     }
    442 
    443 
    444     psFree(myReadout);
    445     psFree(tmpImage2);
    446     psFree(tmpImage3);
    447     psFree(tmpImage4);
    448     psFree(stat);
    449     psFree(list);
    450 
    451     printFooter(stdout, "pmSubtractBias", "Row Overscans", true);
    452     return(testStatus);
    453 }
    454 
    455 /******************************************************************************
    456 doSubtractFullOverscansSmall(): a sample pmReadout as well as several overscan
    457 images of smaller size are created.  The overscan images are collected
    458 pixel-by-pixel then subtracted row-wise from the pmReadout.
    459  *****************************************************************************/
    460 int doSubtractFullOverscanRowsSmall(int numCols, int numRows)
    461 {
    462     int i;
    463     int j;
    464     float actual;
    465     float expect;
    466     int testStatus = 0;
    467     psS32 OSnumRows = numRows-1;
    468     if (OSnumRows == 0) {
    469         OSnumRows = 1;
    470     }
    471     psS32 OSnumCols = numCols-1;
    472     if (OSnumCols == 0) {
    473         OSnumCols = 1;
    474     }
    475     psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    476     psImage *tmpImage2 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
    477     psImage *tmpImage3 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
    478     psImage *tmpImage4 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
    479     pmReadout *myReadout = pmReadoutAlloc(NULL);
    480     myReadout->image = tmpImage1;
    481     psList *list;
    482     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    483 
    484     for (i=0;i<numRows;i++) {
    485         for (j=0;j<numCols;j++) {
    486             myReadout->image->data.F32[i][j] = (float) (i + j);
    487         }
    488     }
    489     for (i=0;i<OSnumRows;i++) {
    490         for (j=0;j<OSnumCols;j++) {
    491             tmpImage2->data.F32[i][j] = 3.0;
    492             tmpImage3->data.F32[i][j] = 4.0;
    493             tmpImage4->data.F32[i][j] = 5.0;
    494         }
    495     }
    496     list = psListAlloc(tmpImage2);
    497     psListAdd(list, PS_LIST_HEAD, tmpImage3);
    498     psListAdd(list, PS_LIST_HEAD, tmpImage4);
    499 
    500     printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
    501 
    502     myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
    503                                0, PM_FIT_SPLINE, NULL);
    504 
    505     for (i=0;i<numRows;i++) {
    506         for (j=0;j<numCols;j++) {
    507             expect = ((float) (i + j)) - 12.0;
    508             actual = myReadout->image->data.F32[i][j];
    509             if (FLT_EPSILON < fabs(expect - actual)) {
    510                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    511                 testStatus = 1;
    512             }
    513         }
    514     }
    515 
    516 
    517     psFree(myReadout);
    518     psFree(tmpImage2);
    519     psFree(tmpImage3);
    520     psFree(tmpImage4);
    521     psFree(stat);
    522     psFree(list);
    523 
    524     printFooter(stdout, "pmSubtractBias", "Row Overscans", true);
    525     return(testStatus);
    526 }
    527 
    528 
    529 // XXX: HEY
    530 int test03( void )
    531 {
    532     int testStatus = 0;
    533 
    534     //    testStatus |= doSubtractFullOverscanRows(1, 1);
    535     //    testStatus |= doSubtractFullOverscanRows(1, NUM_ROWS);
    536     //    testStatus |= doSubtractFullOverscanRows(NUM_COLS, 1);
    537     //    testStatus |= doSubtractFullOverscanRows(NUM_COLS, NUM_ROWS);
    538     //    testStatus |= doSubtractFullOverscanRowsSmall(1, 1);
    539     //    testStatus |= doSubtractFullOverscanRowsSmall(1, NUM_ROWS);
    540     //    testStatus |= doSubtractFullOverscanRowsSmall(NUM_COLS, 1);
    541     testStatus |= doSubtractFullOverscanRowsSmall(NUM_COLS, NUM_ROWS);
    542 
    543     return(testStatus);
    544 }
    545 
    546 
    547 
     203
     204/*
    548205int doSubtractOverscansTestInputCases(int numCols, int numRows)
    549206{
    … …  
    568225    myBias->image = tmpImage5;
    569226    printPositiveTestHeader(stdout, "pmSubtractBias", "Testing input parameter error conditions");
    570 
     227 
    571228    psImage *tmpImage5ShortRows = psImageAlloc(numCols, numRows-1, PS_TYPE_F32);
    572229    pmReadout *myBiasShortRows = pmReadoutAlloc(NULL);
    … …  
    575232    pmReadout *myBiasShortCols = pmReadoutAlloc(NULL);
    576233    myBiasShortCols->image = tmpImage5ShortCols;
    577 
     234 
    578235    for (i=0;i<numRows;i++) {
    579236        for (j=0;j<numCols;j++) {
    … …  
    588245    psListAdd(list, PS_LIST_HEAD, tmpImage3);
    589246    psListAdd(list, PS_LIST_HEAD, tmpImage4);
    590 
     247 
    591248    for (i=0;i<numRows-1;i++) {
    592249        for (j=0;j<numCols-1;j++) {
    … …  
    609266        }
    610267    }
    611 
    612 
     268 
     269 
    613270    printf("------------------------------------------------------------------\n");
    614271    printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_ALL.  Should generate error.\n");
    … …  
    618275        testStatus = false;
    619276    }
    620 
     277 
    621278    printf("------------------------------------------------------------------\n");
    622279    printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_ROWS.  Should generate error.\n");
    … …  
    627284        psFree(rc);
    628285    }
    629 
     286 
    630287    printf("------------------------------------------------------------------\n");
    631288    printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_COLUMNS.  Should generate error.\n");
    … …  
    636293        psFree(rc);
    637294    }
    638 
     295 
    639296    printf("------------------------------------------------------------------\n");
    640297    printf("Calling pmSubtractBias() with non-NULL overscan list and PM_OVERSCAN_NONE.  Should generate warning.\n");
    641298    rc = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_NONE, stat, 0, PM_FIT_NONE, myBias);
    642 
     299 
    643300    for (i=0;i<numRows;i++) {
    644301        for (j=0;j<numCols;j++) {
    … …  
    649306                testStatus = 1;
    650307            }
    651 
     308 
    652309            // Restore myReadout for next test.
    653310            myReadout->image->data.F32[i][j] = (float) (i + j);
    654311        }
    655312    }
    656 
    657     /* XXX: This does not seem to be a requirement.
     313 
     314    // XXX: This does not seem to be a requirement.
     315    if (0) {
    658316        printf("------------------------------------------------------------------\n");
    659317        printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_NONE.  Should generate warning.\n");
    … …  
    674332            }
    675333        }
    676     */
    677 
     334    }
     335 
    678336    printf("------------------------------------------------------------------\n");
    679337    printf("Calling pmSubtractBias() with PM_OVERSCAN_NONE and PM_FIT_POLYNOMIAL.  Should generate Warning.\n");
    … …  
    687345                testStatus = 1;
    688346            }
    689 
     347 
    690348            // Restore myReadout for next test.
    691349            myReadout->image->data.F32[i][j] = (float) (i + j);
    692350        }
    693351    }
    694 
    695 
     352 
     353 
    696354    printf("------------------------------------------------------------------\n");
    697355    printf("Calling pmSubtractBias() with PM_OVERSCAN_ALL and PM_FIT_SPLINE.  Should generate Warning.\n");
    … …  
    702360        psFree(rc);
    703361    }
    704 
     362 
    705363    for (i=0;i<numRows;i++) {
    706364        for (j=0;j<numCols;j++) {
    … …  
    711369                testStatus = 1;
    712370            }
    713 
     371 
    714372            // Restore myReadout for next test.
    715373            myReadout->image->data.F32[i][j] = (float) (i + j);
    716374        }
    717375    }
    718 
    719 
     376 
     377 
    720378    printf("------------------------------------------------------------------\n");
    721379    printf("Calling pmSubtractBias() with multiple stats->options.  Should generate Warning.\n");
    … …  
    734392    }
    735393    stat->options = PS_STAT_SAMPLE_MEAN;
    736 
     394 
    737395    printf("------------------------------------------------------------------\n");
    738396    printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_ROWS).  Should generate Warning.\n");
    739397    rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_ROWS, stat,
    740398                        0, PM_FIT_NONE, NULL);
    741     /*
     399    if (0) {
    742400        for (i=0;i<numRows;i++) {
    743401            for (j=0;j<numCols;j++) {
    … …  
    750408            }
    751409        }
    752     */
    753 
     410    }
     411 
    754412    printf("------------------------------------------------------------------\n");
    755413    printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_COLUMNS).  Should generate Warning.\n");
    756414    rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_COLUMNS, stat,
    757415                        0, PM_FIT_NONE, NULL);
    758     /*
     416    if (0) {
    759417        for (i=0;i<numRows;i++) {
    760418            for (j=0;j<numCols;j++) {
    … …  
    767425            }
    768426        }
    769     */
    770 
     427    }
     428 
    771429    printf("------------------------------------------------------------------\n");
    772430    printf("Calling pmSubtractBias() undersize bias image (short rows).  Should generate Error.\n");
    … …  
    778436        psFree(rc);
    779437    }
    780 
    781 
     438 
     439 
    782440    printf("------------------------------------------------------------------\n");
    783441    printf("Calling pmSubtractBias() undersize bias image (short columns).  Should generate Error.\n");
    … …  
    789447        psFree(rc);
    790448    }
    791 
     449 
    792450    printf("------------------------------------------------------------------\n");
    793451    printf("Calling pmSubtractBias() with bogus PM_FIT.  Should generate Error.\n");
    … …  
    799457        psFree(rc);
    800458    }
    801 
     459 
    802460    printf("------------------------------------------------------------------\n");
    803461    printf("Calling pmSubtractBias() with bogus overScanAxis.  Should generate Error.\n");
    … …  
    809467        psFree(rc);
    810468    }
    811 
    812     /*
     469 
     470    if (0) {
    813471        for (i=0;i<numRows;i++) {
    814472            for (j=0;j<numCols;j++) {
    … …  
    821479            }
    822480        }
    823     */
    824 
     481    }
     482 
    825483    printf("------------------------------------------------------------------\n");
    826484    psFree(myReadout);
    … …  
    837495    psFree(list);
    838496    psFree(listShort);
    839 
     497 
    840498    printFooter(stdout, "pmSubtractBias", "Testing input parameter error conditions", true);
    841499    return(testStatus);
    842500}
    843 
     501 
    844502int test04( void )
    845503{
    846504    int testStatus = 0;
    847 
     505 
    848506    testStatus |= doSubtractOverscansTestInputCases(NUM_COLS, NUM_ROWS);
    849507    return(testStatus);
    850508}
     509*/
    851510
    852511/******************************************************************************
    853 doSubtractFullOverscansSmall(): a sample pmReadout as well as several overscan
    854 images of smaller size are created.  The overscan images are collected
    855 pixel-by-pixel then subtracted column-wise from the pmReadout.
     512doSubtractFullOverscanColumnsGeneric(): This is a general version of the
     513bias subtraction tests which allows the various parameters to be specified
     514as arguments.
    856515 *****************************************************************************/
    857 int doSubtractFullOverscanColumnsGeneric(int imageNumCols,
    858         int imageNumRows,
    859         int overscanNumCols,
    860         int overscanNumRows,
    861         pmOverscanAxis overscanaxis,
    862         pmFit fit,
    863         psS32 nBin)
     516int doSubtractFullOverscanColumnsGeneric(
     517    int imageNumCols,
     518    int imageNumRows,
     519    int overscanNumCols,
     520    int overscanNumRows,
     521    int numOverscans,
     522    pmOverscanAxis overscanaxis,
     523    pmFit fit,
     524    psS32 nBin)
    864525{
    865526    int i;
    … …  
    869530    int testStatus = 0;
    870531
    871     psImage *tmpImage1 = psImageAlloc(imageNumCols, imageNumRows, PS_TYPE_F32);
    872     //    pmReadout *myReadout = pmReadoutAlloc(imageNumCols, imageNumRows, tmpImage1);
    873     pmReadout *myReadout = pmReadoutAlloc(NULL);
    874     myReadout->image = tmpImage1;
     532    printPositiveTestHeader(stdout, "pmSubtractBias", "PUT COMMENT HERE");
     533    printf("---- doSubtractFullOverscanColumnsGeneric() ----\n");
     534    printf("    Image size: %d by %d\n", imageNumRows, imageNumCols);
     535    printf("    Overscan size: %d by %d\n", overscanNumRows, overscanNumCols);
     536    printf("    Total Overscans: %d\n", numOverscans);
     537    printf("    Binning factor: %d\n", nBin);
     538    if (overscanaxis == PM_OVERSCAN_ROWS)
     539        printf("    Overscan axis: PM_OVERSCAN_ROWS\n");
     540    if (overscanaxis == PM_OVERSCAN_COLUMNS)
     541        printf("    Overscan axis: PM_OVERSCAN_COLUMNS\n");
     542    if (overscanaxis == PM_OVERSCAN_ALL)
     543        printf("    Overscan axis: PM_OVERSCAN_ALL\n");
     544    if (overscanaxis == PM_OVERSCAN_NONE)
     545        printf("    Overscan axis: PM_OVERSCAN_NONE\n");
     546    if (fit == PM_FIT_NONE)
     547        printf("    Fit type: PM_FIT_NONE\n");
     548    if (fit == PM_FIT_POLYNOMIAL)
     549        printf("    Fit type: PM_FIT_POLYNOMIAL\n");
     550    if (fit == PM_FIT_SPLINE)
     551        printf("    Fit type: PM_FIT_SPLINE\n");
     552
     553    //
     554    // Create and initialize input image, FPA hierarchy.
     555    //
     556    const psMetadata *camera = psMetadataAlloc();
     557    pmFPA* fpa = pmFPAAlloc(camera);
     558
     559    if (fpa == NULL) {
     560        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc returned a NULL.\n");
     561        return 1;
     562    }
     563
     564    pmChip *chip = pmChipAlloc(fpa, "ChipName");
     565    if (chip == NULL) {
     566        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmChipAlloc returned a NULL.\n");
     567        return 2;
     568    }
     569
     570    pmCell *cell = pmCellAlloc(chip, (psMetadata *) camera, "CellName");
     571    if (cell == NULL) {
     572        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmCellAlloc returned a NULL.\n");
     573        return 3;
     574    }
     575
     576    pmReadout *myReadout = pmReadoutAlloc(cell);
     577    myReadout->image = psImageAlloc(imageNumCols, imageNumRows, PS_TYPE_F32);
     578    for (i=0;i<myReadout->image->numRows;i++) {
     579        for (j=0;j<myReadout->image->numCols;j++) {
     580            myReadout->image->data.F32[i][j] = (float) (i + j);
     581        }
     582    }
     583
     584    //
     585    // Set overscan axis in the metadata.
     586    //
     587    psBool rc;
     588    if (overscanaxis == PM_OVERSCAN_ROWS) {
     589        rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 1);
     590    } else if (overscanaxis == PM_OVERSCAN_COLUMNS) {
     591        rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 2);
     592    } else if (overscanaxis == PM_OVERSCAN_ALL) {
     593        rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 3);
     594    } else if (overscanaxis == PM_OVERSCAN_NONE) {
     595        rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 0);
     596    }
     597    if (rc == false) {
     598        printf("TEST ERROR: Could not set CELL.READDIR metadata.\n");
     599        testStatus = 1;
     600    }
     601
     602    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
     603    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLYNOMIAL_FIT_ORDER, PS_POLYNOMIAL_ORD);
     604    psSpline1D *mySpline = NULL;
     605
     606
     607    if (0) {
     608        if (overscanNumRows <= 0) {
     609            overscanNumRows = 1;
     610        }
     611        if (overscanNumCols <= 0) {
     612            overscanNumCols = 1;
     613        }
     614    }
     615    psF32 oAverage = 0.0;
     616    myReadout->bias = NULL;
     617    for (psS32 i = 0 ; i < numOverscans ; i++) {
     618        psImage *tmpImage = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
     619        psF32 oValue = (float) (i + 3);
     620        PS_IMAGE_SET_F32(tmpImage, oValue);
     621        oAverage += oValue;
     622        if (myReadout->bias == NULL) {
     623            myReadout->bias = psListAlloc(tmpImage);
     624        } else {
     625            psListAdd(myReadout->bias, PS_LIST_HEAD, tmpImage);
     626        }
     627    }
     628    oAverage/= (psF32) numOverscans;
     629
     630
     631    if (fit == PM_FIT_NONE) {
     632        myReadout = pmSubtractBias(myReadout, NULL, PM_FIT_NONE, overscanaxis,
     633                                   stat, nBin, NULL, NULL);
     634    } else if (fit == PM_FIT_POLYNOMIAL) {
     635        myReadout = pmSubtractBias(myReadout, myPoly, PM_FIT_POLYNOMIAL, overscanaxis,
     636                                   stat, nBin, NULL, NULL);
     637    } else if (fit == PM_FIT_SPLINE) {
     638        myReadout = pmSubtractBias(myReadout, mySpline, PM_FIT_SPLINE, overscanaxis,
     639                                   stat, nBin, NULL, NULL);
     640    }
     641
    875642    for (i=0;i<imageNumRows;i++) {
    876643        for (j=0;j<imageNumCols;j++) {
    877             myReadout->image->data.F32[i][j] = (float) (i + j);
    878         }
    879     }
    880 
    881     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    882     psPolynomial1D *myPoly = psPolynomial1DAlloc(1, PS_POLYNOMIAL_ORD);
    883     psSpline1D *mySpline = NULL;
    884 
    885 
    886     /*
    887         if (overscanNumRows <= 0) {
    888             overscanNumRows = 1;
    889         }
    890         if (overscanNumCols <= 0) {
    891             overscanNumCols = 1;
    892         }
    893     */
    894     psImage *tmpImage2 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
    895     psImage *tmpImage3 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
    896     psImage *tmpImage4 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
    897     psList *list;
    898     for (i=0;i<overscanNumRows;i++) {
    899         for (j=0;j<overscanNumCols;j++) {
    900             tmpImage2->data.F32[i][j] = 3.0;
    901             tmpImage3->data.F32[i][j] = 4.0;
    902             tmpImage4->data.F32[i][j] = 5.0;
    903         }
    904     }
    905     list = psListAlloc(tmpImage2);
    906     psListAdd(list, PS_LIST_HEAD, tmpImage3);
    907     psListAdd(list, PS_LIST_HEAD, tmpImage4);
    908 
    909     printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
    910 
    911     if (fit == PM_FIT_NONE) {
    912         myReadout = pmSubtractBias(myReadout, NULL, list, overscanaxis, stat,
    913                                    nBin, fit, NULL);
    914     } else if (fit == PM_FIT_POLYNOMIAL) {
    915         myReadout = pmSubtractBias(myReadout, myPoly, list, overscanaxis, stat,
    916                                    nBin, fit, NULL);
    917     } else if (fit == PM_FIT_SPLINE) {
    918         myReadout = pmSubtractBias(myReadout, mySpline, list, overscanaxis, stat,
    919                                    nBin, fit, NULL);
    920     }
    921 
    922     for (i=0;i<imageNumRows;i++) {
    923         for (j=0;j<imageNumCols;j++) {
    924             expect = ((float) (i + j)) - 12.0;
     644            expect = ((float) (i + j)) - oAverage;
    925645            actual = myReadout->image->data.F32[i][j];
    926646            if (FLT_EPSILON < fabs(expect - actual)) {
    927647                printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    928648                testStatus = 1;
     649            } else {
     650                //printf("COOL: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    929651            }
    930652        }
    931653    }
    932 
    933 
     654    psFree(fpa);
     655    psFree(chip);
     656    psFree(cell);
     657    psListElem *tmpElem = (psListElem *) myReadout->bias->head;
     658    while (NULL != tmpElem) {
     659        psFree((psImage *) tmpElem->data);
     660        tmpElem = tmpElem->next;
     661    }
    934662    psFree(myReadout);
    935     psFree(tmpImage2);
    936     psFree(tmpImage3);
    937     psFree(tmpImage4);
     663    psFree(camera);
    938664    psFree(stat);
    939     psFree(list);
    940665    psFree(myPoly);
    941666    psFree(mySpline);
    … …  
    945670}
    946671
    947 int testX( void )
     672
     673
     674
     675
     676
     677
     678
     679
     680
     681
     682
     683
     684
     685
     686
     687
     688
     689
     690
     691
     692
     693
     694
     695
     696
     697
     698
     699
     700
     701
     702
     703
     704
     705/******************************************************************************
     706test05a() The following combinations are tested here:
     707 Overscan images are same size, no fit, bin factor is 1.
     708 Overscan images are same size, no fit, bin factor is 2.
     709 *****************************************************************************/
     710int test05a(
     711    psS32 imageNumCols,
     712    psS32 imageNumRows,
     713    psS32 overscanNumCols,
     714    psS32 overscanNumRows)
    948715{
    949716    int testStatus = 0;
    … …  
    955722    // Overscan images are same size, no fit, bin factor is 1.
    956723    //
    957     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    958                   NUM_COLS, NUM_ROWS,
     724    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     725                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
    959726                  PM_OVERSCAN_ALL,
    960727                  PM_FIT_NONE, 1);
    961728
    962     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    963                   NUM_COLS, NUM_ROWS,
     729    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     730                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
    964731                  PM_OVERSCAN_COLUMNS,
    965732                  PM_FIT_NONE, 1);
    966733
    967     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    968                   NUM_COLS, NUM_ROWS,
     734    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     735                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
    969736                  PM_OVERSCAN_ROWS,
    970737                  PM_FIT_NONE, 1);
    … …  
    973740    // Overscan images are same size, no fit, bin factor is 2.
    974741    //
    975     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    976                   NUM_COLS, NUM_ROWS,
     742    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     743                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
    977744                  PM_OVERSCAN_ALL,
    978745                  PM_FIT_NONE, 2);
    979746
    980     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    981                   NUM_COLS, NUM_ROWS,
     747    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     748                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
    982749                  PM_OVERSCAN_COLUMNS,
    983750                  PM_FIT_NONE, 2);
    984751
    985     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    986                   NUM_COLS, NUM_ROWS,
     752    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     753                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
    987754                  PM_OVERSCAN_ROWS,
    988755                  PM_FIT_NONE, 2);
    989     //
    990     // Overscan images are too small, spline fit, bin factor is 1.
    991     //
    992     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    993                   NUM_COLS-1, NUM_ROWS-1,
    994                   PM_OVERSCAN_ALL,
    995                   PM_FIT_SPLINE, 1);
    996 
    997     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    998                   NUM_COLS-1, NUM_ROWS-1,
    999                   PM_OVERSCAN_COLUMNS,
    1000                   PM_FIT_SPLINE, 1);
    1001 
    1002     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1003                   NUM_COLS-1, NUM_ROWS-1,
    1004                   PM_OVERSCAN_ROWS,
    1005                   PM_FIT_SPLINE, 1);
    1006 
    1007     //
    1008     // Overscan images are too small, spline fit, bin factor is 2.
    1009     //
    1010     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1011                   NUM_COLS-1, NUM_ROWS-1,
    1012                   PM_OVERSCAN_ALL,
    1013                   PM_FIT_SPLINE, 2);
    1014 
    1015     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1016                   NUM_COLS-1, NUM_ROWS-1,
    1017                   PM_OVERSCAN_COLUMNS,
    1018                   PM_FIT_SPLINE, 2);
    1019 
    1020     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1021                   NUM_COLS-1, NUM_ROWS-1,
    1022                   PM_OVERSCAN_ROWS,
    1023                   PM_FIT_SPLINE, 2);
    1024 
    1025     //
    1026     // Overscan images are same size, spline fit, bin factor is 1.
    1027     //
    1028     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1029                   NUM_COLS, NUM_ROWS,
    1030                   PM_OVERSCAN_ALL,
    1031                   PM_FIT_SPLINE, 1);
    1032 
    1033     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1034                   NUM_COLS, NUM_ROWS,
    1035                   PM_OVERSCAN_COLUMNS,
    1036                   PM_FIT_SPLINE, 1);
    1037 
    1038     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1039                   NUM_COLS, NUM_ROWS,
    1040                   PM_OVERSCAN_ROWS,
    1041                   PM_FIT_SPLINE, 1);
    1042     //
    1043     // Overscan images are same size, spline fit, bin factor is 2.
    1044     //
    1045     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1046                   NUM_COLS, NUM_ROWS,
    1047                   PM_OVERSCAN_ALL,
    1048                   PM_FIT_SPLINE, 2);
    1049 
    1050     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1051                   NUM_COLS, NUM_ROWS,
    1052                   PM_OVERSCAN_COLUMNS,
    1053                   PM_FIT_SPLINE, 2);
    1054 
    1055     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1056                   NUM_COLS, NUM_ROWS,
    1057                   PM_OVERSCAN_ROWS,
    1058                   PM_FIT_SPLINE, 2);
    1059 
    1060     //
    1061     // Overscan images are same size, polynomial fit, bin factor is 1.
    1062     //
    1063     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1064                   NUM_COLS, NUM_ROWS,
    1065                   PM_OVERSCAN_ALL,
    1066                   PM_FIT_POLYNOMIAL, 1);
    1067 
    1068     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1069                   NUM_COLS, NUM_ROWS,
    1070                   PM_OVERSCAN_COLUMNS,
    1071                   PM_FIT_POLYNOMIAL, 1);
    1072 
    1073     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1074                   NUM_COLS, NUM_ROWS,
    1075                   PM_OVERSCAN_ROWS,
    1076                   PM_FIT_POLYNOMIAL, 1);
    1077     //
    1078     // Overscan images are same size, polynomial fit, bin factor is 2.
    1079     //
    1080     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1081                   NUM_COLS, NUM_ROWS,
    1082                   PM_OVERSCAN_ALL,
    1083                   PM_FIT_POLYNOMIAL, 2);
    1084 
    1085     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1086                   NUM_COLS, NUM_ROWS,
    1087                   PM_OVERSCAN_COLUMNS,
    1088                   PM_FIT_POLYNOMIAL, 2);
    1089 
    1090     testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
    1091                   NUM_COLS, NUM_ROWS,
    1092                   PM_OVERSCAN_ROWS,
    1093                   PM_FIT_POLYNOMIAL, 2);
    1094756
    1095757    return(testStatus);
    1096758}
    1097759
     760
     761/******************************************************************************
     762test05b() The following combinations are tested here:
     763 Overscan images are too small, spline fit, bin factor is 1.
     764 Overscan images are too small, spline fit, bin factor is 2.
     765 Overscan images are same size, spline fit, bin factor is 1.
     766 Overscan images are same size, spline fit, bin factor is 2.
     767 Overscan images are too big,   spline fit, bin factor is 1.
     768 Overscan images are too big,   spline fit, bin factor is 2.
     769 A single overscan image of the same size, spline fit, bin factor is 1.
     770 
     771 Overscan images are too small, polynomial fit, bin factor is 1.
     772 Overscan images are too small, polynomial fit, bin factor is 2.
     773 Overscan images are same size, polynomial fit, bin factor is 1.
     774 Overscan images are same size, polynomial fit, bin factor is 2.
     775 Overscan images are too big,   polynomial fit, bin factor is 1.
     776 Overscan images are too big,   polynomial fit, bin factor is 2.
     777 A single overscan image of the same size, polynomial fit, bin factor is 1.
     778 
     779XXX: Must add M-by-N image size tests.
     780 *****************************************************************************/
     781int test05b(
     782    psS32 imageNumCols,
     783    psS32 imageNumRows,
     784    psS32 overscanNumCols,
     785    psS32 overscanNumRows)
     786{
     787    int testStatus = 0;
     788
     789    //
     790    // Overscan images are too small, spline fit, bin factor is 1.
     791    //
     792    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     793                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     794                  PM_OVERSCAN_ALL,
     795                  PM_FIT_SPLINE, 1);
     796
     797    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     798                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     799                  PM_OVERSCAN_COLUMNS,
     800                  PM_FIT_SPLINE, 1);
     801
     802    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     803                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     804                  PM_OVERSCAN_ROWS,
     805                  PM_FIT_SPLINE, 1);
     806
     807    //
     808    // Overscan images are too small, spline fit, bin factor is 2.
     809    //
     810    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     811                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     812                  PM_OVERSCAN_ALL,
     813                  PM_FIT_SPLINE, 2);
     814
     815    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     816                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     817                  PM_OVERSCAN_COLUMNS,
     818                  PM_FIT_SPLINE, 2);
     819
     820    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     821                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     822                  PM_OVERSCAN_ROWS,
     823                  PM_FIT_SPLINE, 2);
     824
     825
     826    //
     827    // Overscan images are same size, spline fit, bin factor is 1.
     828    //
     829    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     830                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     831                  PM_OVERSCAN_ALL,
     832                  PM_FIT_SPLINE, 1);
     833
     834    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     835                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     836                  PM_OVERSCAN_COLUMNS,
     837                  PM_FIT_SPLINE, 1);
     838
     839    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     840                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     841                  PM_OVERSCAN_ROWS,
     842                  PM_FIT_SPLINE, 1);
     843
     844    //
     845    // Overscan images are same size, spline fit, bin factor is 2.
     846    //
     847    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     848                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     849                  PM_OVERSCAN_ALL,
     850                  PM_FIT_SPLINE, 2);
     851
     852    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     853                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     854                  PM_OVERSCAN_COLUMNS,
     855                  PM_FIT_SPLINE, 2);
     856
     857    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     858                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     859                  PM_OVERSCAN_ROWS,
     860                  PM_FIT_SPLINE, 2);
     861
     862    //
     863    // Overscan images are too big, spline fit, bin factor is 1.
     864    //
     865    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     866                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     867                  PM_OVERSCAN_ALL,
     868                  PM_FIT_SPLINE, 1);
     869
     870    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     871                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     872                  PM_OVERSCAN_COLUMNS,
     873                  PM_FIT_SPLINE, 1);
     874
     875    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     876                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     877                  PM_OVERSCAN_ROWS,
     878                  PM_FIT_SPLINE, 1);
     879
     880    //
     881    // Overscan images are too big, spline fit, bin factor is 2.
     882    //
     883    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     884                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     885                  PM_OVERSCAN_ALL,
     886                  PM_FIT_SPLINE, 2);
     887
     888    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     889                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     890                  PM_OVERSCAN_COLUMNS,
     891                  PM_FIT_SPLINE, 2);
     892
     893    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     894                  overscanNumCols+2, overscanNumRows+2 , NUM_OVERSCANS,
     895                  PM_OVERSCAN_ROWS,
     896                  PM_FIT_SPLINE, 2);
     897
     898
     899    //
     900    // A single overscan image of the same size, spline fit, bin factor is 1.
     901    //
     902    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     903                  overscanNumCols, overscanNumRows, 1,
     904                  PM_OVERSCAN_ALL,
     905                  PM_FIT_SPLINE, 1);
     906
     907    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     908                  overscanNumCols, overscanNumRows, 1,
     909                  PM_OVERSCAN_COLUMNS,
     910                  PM_FIT_SPLINE, 1);
     911
     912    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     913                  overscanNumCols, overscanNumRows, 1,
     914                  PM_OVERSCAN_ROWS,
     915                  PM_FIT_SPLINE, 1);
     916
     917
     918    //
     919    // Overscan images are too small, polynomial fit, bin factor is 1.
     920    //
     921    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     922                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     923                  PM_OVERSCAN_ALL,
     924                  PM_FIT_POLYNOMIAL, 1);
     925
     926    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     927                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     928                  PM_OVERSCAN_COLUMNS,
     929                  PM_FIT_POLYNOMIAL, 1);
     930
     931    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     932                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     933                  PM_OVERSCAN_ROWS,
     934                  PM_FIT_POLYNOMIAL, 1);
     935
     936    //
     937    // Overscan images are too small, polynomial fit, bin factor is 2.
     938    //
     939    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     940                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     941                  PM_OVERSCAN_ALL,
     942                  PM_FIT_POLYNOMIAL, 2);
     943
     944    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     945                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     946                  PM_OVERSCAN_COLUMNS,
     947                  PM_FIT_POLYNOMIAL, 2);
     948
     949    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     950                  overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS,
     951                  PM_OVERSCAN_ROWS,
     952                  PM_FIT_POLYNOMIAL, 2);
     953
     954
     955    //
     956    // Overscan images are same size, polynomial fit, bin factor is 1.
     957    //
     958    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     959                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     960                  PM_OVERSCAN_ALL,
     961                  PM_FIT_POLYNOMIAL, 1);
     962
     963    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     964                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     965                  PM_OVERSCAN_COLUMNS,
     966                  PM_FIT_POLYNOMIAL, 1);
     967
     968    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     969                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     970                  PM_OVERSCAN_ROWS,
     971                  PM_FIT_POLYNOMIAL, 1);
     972
     973    //
     974    // Overscan images are same size, polynomial fit, bin factor is 2.
     975    //
     976    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     977                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     978                  PM_OVERSCAN_ALL,
     979                  PM_FIT_POLYNOMIAL, 2);
     980
     981    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     982                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     983                  PM_OVERSCAN_COLUMNS,
     984                  PM_FIT_POLYNOMIAL, 2);
     985
     986    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     987                  overscanNumCols, overscanNumRows, NUM_OVERSCANS,
     988                  PM_OVERSCAN_ROWS,
     989                  PM_FIT_POLYNOMIAL, 2);
     990
     991    //
     992    // Overscan images are too big, polynomial fit, bin factor is 1.
     993    //
     994    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     995                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     996                  PM_OVERSCAN_ALL,
     997                  PM_FIT_POLYNOMIAL, 1);
     998
     999    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1000                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     1001                  PM_OVERSCAN_COLUMNS,
     1002                  PM_FIT_POLYNOMIAL, 1);
     1003
     1004    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1005                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     1006                  PM_OVERSCAN_ROWS,
     1007                  PM_FIT_POLYNOMIAL, 1);
     1008
     1009    //
     1010    // Overscan images are too big, polynomial fit, bin factor is 2.
     1011    //
     1012    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1013                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     1014                  PM_OVERSCAN_ALL,
     1015                  PM_FIT_POLYNOMIAL, 2);
     1016
     1017    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1018                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     1019                  PM_OVERSCAN_COLUMNS,
     1020                  PM_FIT_POLYNOMIAL, 2);
     1021
     1022    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1023                  overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS,
     1024                  PM_OVERSCAN_ROWS,
     1025                  PM_FIT_POLYNOMIAL, 2);
     1026
     1027    //
     1028    // A single overscan image of the same size, polynomial fit, bin factor is 1.
     1029    //
     1030    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1031                  overscanNumCols, overscanNumRows, 1,
     1032                  PM_OVERSCAN_ALL,
     1033                  PM_FIT_POLYNOMIAL, 1);
     1034
     1035    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1036                  overscanNumCols, overscanNumRows, 1,
     1037                  PM_OVERSCAN_COLUMNS,
     1038                  PM_FIT_POLYNOMIAL, 1);
     1039
     1040    testStatus |= doSubtractFullOverscanColumnsGeneric(imageNumCols, imageNumRows,
     1041                  overscanNumCols, overscanNumRows, 1,
     1042                  PM_OVERSCAN_ROWS,
     1043                  PM_FIT_POLYNOMIAL, 1);
     1044
     1045    return(testStatus);
     1046}
     1047
     1048
     1049
     1050#define LOW_COLS 3
     1051#define LOW_ROWS 3
     1052
     1053/******************************************************************************
     1054test05(): See test05a() and test05b().
     1055 
     1056We run the tests in test05b() starting with all possible combinations of
     1057sizes.
     1058 
     1059XXX: Must add M-by-N image size tests.
     1060 *****************************************************************************/
     1061int test05()
     1062{
     1063    int testStatus = 0;
     1064    testStatus = test05a(NUM_COLS, NUM_ROWS, NUM_COLS, NUM_ROWS);
     1065
     1066    //    testStatus|= test05b(LOW_COLS, LOW_ROWS, LOW_COLS, LOW_ROWS);
     1067    //    testStatus|= test05b(LOW_COLS, LOW_ROWS, LOW_COLS, NUM_ROWS);
     1068    //    testStatus|= test05b(LOW_COLS, LOW_ROWS, NUM_COLS, LOW_ROWS);
     1069    //    testStatus|= test05b(LOW_COLS, LOW_ROWS, NUM_COLS, NUM_ROWS);
     1070
     1071    //    testStatus|= test05b(LOW_COLS, NUM_ROWS, LOW_COLS, LOW_ROWS);
     1072    //    testStatus|= test05b(LOW_COLS, NUM_ROWS, LOW_COLS, NUM_ROWS);
     1073    //    testStatus|= test05b(LOW_COLS, NUM_ROWS, NUM_COLS, LOW_ROWS);
     1074    //    testStatus|= test05b(LOW_COLS, NUM_ROWS, NUM_COLS, NUM_ROWS);
     1075
     1076    //    testStatus|= test05b(NUM_COLS, LOW_ROWS, LOW_COLS, LOW_ROWS);
     1077    //    testStatus|= test05b(NUM_COLS, LOW_ROWS, LOW_COLS, NUM_ROWS);
     1078    //    testStatus|= test05b(NUM_COLS, LOW_ROWS, NUM_COLS, LOW_ROWS);
     1079    //    testStatus|= test05b(NUM_COLS, LOW_ROWS, NUM_COLS, NUM_ROWS);
     1080
     1081    //    testStatus|= test05b(NUM_COLS, NUM_ROWS, LOW_COLS, LOW_ROWS);
     1082    //    testStatus|= test05b(NUM_COLS, NUM_ROWS, LOW_COLS, NUM_ROWS);
     1083    //    testStatus|= test05b(NUM_COLS, NUM_ROWS, NUM_COLS, LOW_ROWS);
     1084    testStatus|= test05b(NUM_COLS, NUM_ROWS, NUM_COLS, NUM_ROWS);
     1085
     1086
     1087    return(testStatus);
     1088}
     1089
     1090
Note: See TracChangeset for help on using the changeset viewer.