IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2851


Ignore:
Timestamp:
Dec 29, 2004, 3:42:04 PM (22 years ago)
Author:
gusciora
Message:

...

Location:
trunk/psModules/test
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/test/tst_pmReadoutCombine.c

    r2832 r2851  
    55 *  @author GLG, MHPCC
    66 *
    7  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2004-12-27 23:16:51 $
     7 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2004-12-30 01:42:04 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    435435    return(!testStatus);
    436436}
    437 // This code will

  • trunk/psModules/test/tst_pmSubtractBias.c

    r2842 r2851  
    1313 *  @author GLG, MHPCC
    1414 *
    15  *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2004-12-29 02:52:28 $
     15 *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2004-12-30 01:42:04 $
    1717 *
    1818 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2727static int test03(void);
    2828static int test04(void);
     29static int testX(void);
    2930testDescription tests[] = {
    30                               /*
    31                                                             {test00, 000, "pmSubtractBias", 0, false},
    32                                                             {test01, 000, "pmSubtractBias", 0, false},
    33                                                             {test02, 000, "pmSubtractBias", 0, false},
    34                                                             {test03, 000, "pmSubtractBias", 0, false},
    35                               */
     31
     32                              {test00, 000, "pmSubtractBias", 0, false},
     33                              {test01, 000, "pmSubtractBias", 0, false},
     34                              {test02, 000, "pmSubtractBias", 0, false},
     35                              {test03, 000, "pmSubtractBias", 0, false},
    3636                              {test04, 000, "pmSubtractBias", 0, false},
     37                              {testX,  000, "pmSubtractBias", 0, false},
    3738                              {NULL}
    3839                          };
    … …  
    4445}
    4546
    46 #define NUM_ROWS 4
    47 #define NUM_COLS 4
     47#define NUM_ROWS 8
     48#define NUM_COLS 8
     49/******************************************************************************
     50doSubtractBiasFullFrame(): a sample psReadout as well as a bias image are
     51created and the bias image is subtracted from the psReadout.
     52 *****************************************************************************/
    4853int doSubtractBiasFullFrame(int numCols, int numRows)
    4954{
    … …  
    98103}
    99104
     105/******************************************************************************
     106doSubtractFullOverscans(): a sample psReadout as well as several overscan
     107images of the same size are created.  The overscan images are then subtracted
     108from the psReadout.
     109 *****************************************************************************/
    100110int doSubtractFullOverscans(int numCols, int numRows)
    101111{
    … …  
    162172}
    163173
     174/******************************************************************************
     175doSubtractFullOverscans(): a sample psReadout as well as several overscan
     176images of the same size are created.  The overscan images are collected
     177pixel-by-pixel then subtracted column-wise from the psReadout.
     178 *****************************************************************************/
    164179int doSubtractFullOverscanColumns(int numCols, int numRows)
    165180{
    … …  
    216231    return(testStatus);
    217232}
    218 
    219 int test02( void )
    220 {
    221     int testStatus = 0;
    222 
    223     testStatus |= doSubtractFullOverscanColumns(1, 1);
    224     testStatus |= doSubtractFullOverscanColumns(1, NUM_ROWS);
    225     testStatus |= doSubtractFullOverscanColumns(NUM_COLS, 1);
    226     testStatus |= doSubtractFullOverscanColumns(NUM_COLS, NUM_ROWS);
    227 
    228     return(testStatus);
    229 }
    230 
    231 int doSubtractFullOverscanRows(int numCols, int numRows)
     233/******************************************************************************
     234doSubtractFullOverscans(): a sample psReadout as well as several overscan
     235images of the same size are created.  The overscan images are collected
     236pixel-by-pixel then subtracted column-wise from the psReadout.
     237 *****************************************************************************/
     238int doSubtractFullOverscanColumnsPoly(int numCols, int numRows)
    232239{
    233240    int i;
    … …  
    243250    psList *list;
    244251    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
     252    psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
    245253
    246254    for (i=0;i<numRows;i++) {
    … …  
    256264    psListAdd(list, PS_LIST_HEAD, tmpImage4);
    257265
    258     printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
    259 
    260     myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
    261                                0, PM_FIT_NONE, NULL);
     266    printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
     267
     268    myReadout = pmSubtractBias(myReadout, myPoly, list, PM_OVERSCAN_COLUMNS, stat,
     269                               0, PM_FIT_POLYNOMIAL, NULL);
    262270
    263271    for (i=0;i<numRows;i++) {
    … …  
    279287    psFree(stat);
    280288    psFree(list);
     289    psFree(myPoly);
     290
     291    printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
     292    return(testStatus);
     293}
     294/******************************************************************************
     295doSubtractFullOverscansSmall(): a sample psReadout as well as several overscan
     296images of smaller size are created.  The overscan images are collected
     297pixel-by-pixel then subtracted column-wise from the psReadout.
     298 *****************************************************************************/
     299int doSubtractFullOverscanColumnsSmall(int numCols, int numRows)
     300{
     301    int i;
     302    int j;
     303    float actual;
     304    float expect;
     305    int testStatus = 0;
     306    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     307    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     308    psImage *tmpImage2 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
     309    psImage *tmpImage3 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
     310    psImage *tmpImage4 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
     311    psList *list;
     312    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
     313
     314    for (i=0;i<numRows;i++) {
     315        for (j=0;j<numCols;j++) {
     316            myReadout->image->data.F32[i][j] = (float) (i + j);
     317        }
     318    }
     319    for (i=0;i<numRows/2;i++) {
     320        for (j=0;j<numCols/2;j++) {
     321            tmpImage2->data.F32[i][j] = 3.0;
     322            tmpImage3->data.F32[i][j] = 4.0;
     323            tmpImage4->data.F32[i][j] = 5.0;
     324        }
     325    }
     326    list = psListAlloc(tmpImage2);
     327    psListAdd(list, PS_LIST_HEAD, tmpImage3);
     328    psListAdd(list, PS_LIST_HEAD, tmpImage4);
     329
     330    printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
     331
     332    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_COLUMNS, stat,
     333                               0, PM_FIT_POLYNOMIAL, NULL);
     334
     335    for (i=0;i<numRows;i++) {
     336        for (j=0;j<numCols;j++) {
     337            expect = ((float) (i + j)) - 12.0;
     338            actual = myReadout->image->data.F32[i][j];
     339            if (FLT_EPSILON < fabs(expect - actual)) {
     340                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
     341                testStatus = 1;
     342            }
     343        }
     344    }
     345
     346
     347    psFree(myReadout);
     348    psFree(tmpImage2);
     349    psFree(tmpImage3);
     350    psFree(tmpImage4);
     351    psFree(stat);
     352    psFree(list);
     353
     354    printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
     355    return(testStatus);
     356}
     357
     358int test02( void )
     359{
     360    int testStatus = 0;
     361
     362    testStatus |= doSubtractFullOverscanColumns(1, 1);
     363    testStatus |= doSubtractFullOverscanColumns(1, NUM_ROWS);
     364    testStatus |= doSubtractFullOverscanColumns(NUM_COLS, 1);
     365    testStatus |= doSubtractFullOverscanColumns(NUM_COLS, NUM_ROWS);
     366    /* These tests do not make sense until the SDRS is clarified.
     367        testStatus |= doSubtractFullOverscanColumnsSmall(1, 1);
     368        testStatus |= doSubtractFullOverscanColumnsSmall(1, NUM_ROWS);
     369        testStatus |= doSubtractFullOverscanColumnsSmall(NUM_COLS, 1);
     370        testStatus |= doSubtractFullOverscanColumnsSmall(NUM_COLS, NUM_ROWS);
     371    */
     372
     373    return(testStatus);
     374}
     375
     376/******************************************************************************
     377doSubtractFullOverscans(): a sample psReadout as well as several overscan
     378images of the same size are created.  The overscan images are collected
     379pixel-by-pixel then subtracted row-wise from the psReadout.
     380 *****************************************************************************/
     381int doSubtractFullOverscanRows(int numCols, int numRows)
     382{
     383    int i;
     384    int j;
     385    float actual;
     386    float expect;
     387    int testStatus = 0;
     388    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     389    psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     390    psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     391    psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     392    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     393    psList *list;
     394    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
     395
     396    for (i=0;i<numRows;i++) {
     397        for (j=0;j<numCols;j++) {
     398            myReadout->image->data.F32[i][j] = (float) (i + j);
     399            tmpImage2->data.F32[i][j] = 3.0;
     400            tmpImage3->data.F32[i][j] = 4.0;
     401            tmpImage4->data.F32[i][j] = 5.0;
     402        }
     403    }
     404    list = psListAlloc(tmpImage2);
     405    psListAdd(list, PS_LIST_HEAD, tmpImage3);
     406    psListAdd(list, PS_LIST_HEAD, tmpImage4);
     407
     408    printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
     409
     410    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
     411                               0, PM_FIT_NONE, NULL);
     412
     413    for (i=0;i<numRows;i++) {
     414        for (j=0;j<numCols;j++) {
     415            expect = ((float) (i + j)) - 12.0;
     416            actual = myReadout->image->data.F32[i][j];
     417            if (FLT_EPSILON < fabs(expect - actual)) {
     418                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
     419                testStatus = 1;
     420            }
     421        }
     422    }
     423
     424
     425    psFree(myReadout);
     426    psFree(tmpImage2);
     427    psFree(tmpImage3);
     428    psFree(tmpImage4);
     429    psFree(stat);
     430    psFree(list);
    281431
    282432    printFooter(stdout, "pmSubtractBias", "Row Overscans", true);
    283433    return(testStatus);
    284434}
     435
     436/******************************************************************************
     437doSubtractFullOverscansSmall(): a sample psReadout as well as several overscan
     438images of smaller size are created.  The overscan images are collected
     439pixel-by-pixel then subtracted row-wise from the psReadout.
     440 *****************************************************************************/
     441int doSubtractFullOverscanRowsSmall(int numCols, int numRows)
     442{
     443    int i;
     444    int j;
     445    float actual;
     446    float expect;
     447    int testStatus = 0;
     448    psS32 OSnumRows = numRows-1;
     449    if (OSnumRows == 0) {
     450        OSnumRows = 1;
     451    }
     452    psS32 OSnumCols = numCols-1;
     453    if (OSnumCols == 0) {
     454        OSnumCols = 1;
     455    }
     456    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     457    psImage *tmpImage2 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
     458    psImage *tmpImage3 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
     459    psImage *tmpImage4 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
     460    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
     461    psList *list;
     462    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
     463
     464    for (i=0;i<numRows;i++) {
     465        for (j=0;j<numCols;j++) {
     466            myReadout->image->data.F32[i][j] = (float) (i + j);
     467        }
     468    }
     469    for (i=0;i<OSnumRows;i++) {
     470        for (j=0;j<OSnumCols;j++) {
     471            tmpImage2->data.F32[i][j] = 3.0;
     472            tmpImage3->data.F32[i][j] = 4.0;
     473            tmpImage4->data.F32[i][j] = 5.0;
     474        }
     475    }
     476    list = psListAlloc(tmpImage2);
     477    psListAdd(list, PS_LIST_HEAD, tmpImage3);
     478    psListAdd(list, PS_LIST_HEAD, tmpImage4);
     479
     480    printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
     481
     482    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
     483                               0, PM_FIT_SPLINE, NULL);
     484
     485    for (i=0;i<numRows;i++) {
     486        for (j=0;j<numCols;j++) {
     487            expect = ((float) (i + j)) - 12.0;
     488            actual = myReadout->image->data.F32[i][j];
     489            if (FLT_EPSILON < fabs(expect - actual)) {
     490                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
     491                testStatus = 1;
     492            }
     493        }
     494    }
     495
     496
     497    psFree(myReadout);
     498    psFree(tmpImage2);
     499    psFree(tmpImage3);
     500    psFree(tmpImage4);
     501    psFree(stat);
     502    psFree(list);
     503
     504    printFooter(stdout, "pmSubtractBias", "Row Overscans", true);
     505    return(testStatus);
     506}
     507
    285508
    286509int test03( void )
    … …  
    292515    testStatus |= doSubtractFullOverscanRows(NUM_COLS, 1);
    293516    testStatus |= doSubtractFullOverscanRows(NUM_COLS, NUM_ROWS);
     517    testStatus |= doSubtractFullOverscanRowsSmall(1, 1);
     518    testStatus |= doSubtractFullOverscanRowsSmall(1, NUM_ROWS);
     519    testStatus |= doSubtractFullOverscanRowsSmall(NUM_COLS, 1);
     520    testStatus |= doSubtractFullOverscanRowsSmall(NUM_COLS, NUM_ROWS);
    294521
    295522    return(testStatus);
    … …  
    385612    printf("------------------------------------------------------------------\n");
    386613    printf("Calling pmSubtractBias() with non-NULL overscan list and PM_OVERSCAN_NONE.  Should generate warning.\n");
    387     rc = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_NONE, stat,
    388                         0, PM_FIT_NONE, myBias);
     614    rc = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_NONE, stat, 0, PM_FIT_NONE, myBias);
    389615
    390616    for (i=0;i<numRows;i++) {
    … …  
    482708    printf("------------------------------------------------------------------\n");
    483709    printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_ROWS).  Should generate Warning.\n");
    484     myReadout = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_ROWS, stat,
    485                                0, PM_FIT_NONE, NULL);
     710    rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_ROWS, stat,
     711                        0, PM_FIT_NONE, NULL);
    486712    /*
    487713        for (i=0;i<numRows;i++) {
    … …  
    499725    printf("------------------------------------------------------------------\n");
    500726    printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_COLUMNS).  Should generate Warning.\n");
    501     myReadout = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_COLUMNS, stat,
    502                                0, PM_FIT_NONE, NULL);
     727    rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_COLUMNS, stat,
     728                        0, PM_FIT_NONE, NULL);
    503729    /*
    504730        for (i=0;i<numRows;i++) {
    … …  
    535761    }
    536762
     763    printf("------------------------------------------------------------------\n");
     764    printf("Calling pmSubtractBias() with bogus PM_FIT.  Should generate Error.\n");
     765    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
     766                               0, 54321, NULL);
     767    if (rc != myReadout) {
     768        printf("ERROR: pmSubtractBias() did not return input psReadout.\n");
     769        testStatus = false;
     770        psFree(rc);
     771    }
     772
     773    printf("------------------------------------------------------------------\n");
     774    printf("Calling pmSubtractBias() with bogus overScanAxis.  Should generate Error.\n");
     775    myReadout = pmSubtractBias(myReadout, NULL, list, 54321, stat,
     776                               0, PM_FIT_NONE, NULL);
     777    if (rc != myReadout) {
     778        printf("ERROR: pmSubtractBias() did not return input psReadout.\n");
     779        testStatus = false;
     780        psFree(rc);
     781    }
     782
     783    /*
     784        for (i=0;i<numRows;i++) {
     785            for (j=0;j<numCols;j++) {
     786                psF32 expect = ((float) (i + j)) - 12.0;
     787                psF32 actual = rc->image->data.F32[i][j];
     788                if (FLT_EPSILON < fabs(expect - actual)) {
     789                    printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
     790                    testStatus = 1;
     791                }
     792            }
     793        }
     794    */
    537795
    538796    printf("------------------------------------------------------------------\n");
    … …  
    562820}
    563821
     822/******************************************************************************
     823doSubtractFullOverscansSmall(): a sample psReadout as well as several overscan
     824images of smaller size are created.  The overscan images are collected
     825pixel-by-pixel then subtracted column-wise from the psReadout.
     826 *****************************************************************************/
     827int doSubtractFullOverscanColumnsGeneric(int imageNumCols,
     828        int imageNumRows,
     829        int overscanNumCols,
     830        int overscanNumRows,
     831        pmOverscanAxis overscanaxis,
     832        pmFit fit,
     833        psS32 nBin)
     834{
     835    int i;
     836    int j;
     837    float actual;
     838    float expect;
     839    int testStatus = 0;
     840
     841    psImage *tmpImage1 = psImageAlloc(imageNumCols, imageNumRows, PS_TYPE_F32);
     842    psReadout *myReadout = psReadoutAlloc(imageNumCols, imageNumRows, tmpImage1);
     843    for (i=0;i<imageNumRows;i++) {
     844        for (j=0;j<imageNumCols;j++) {
     845            myReadout->image->data.F32[i][j] = (float) (i + j);
     846        }
     847    }
     848
     849    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
     850    psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
     851    psSpline1D *mySpline = NULL;
     852
     853
     854    /*
     855        if (overscanNumRows <= 0) {
     856            overscanNumRows = 1;
     857        }
     858        if (overscanNumCols <= 0) {
     859            overscanNumCols = 1;
     860        }
     861    */
     862    psImage *tmpImage2 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
     863    psImage *tmpImage3 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
     864    psImage *tmpImage4 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
     865    psList *list;
     866    for (i=0;i<overscanNumRows;i++) {
     867        for (j=0;j<overscanNumCols;j++) {
     868            tmpImage2->data.F32[i][j] = 3.0;
     869            tmpImage3->data.F32[i][j] = 4.0;
     870            tmpImage4->data.F32[i][j] = 5.0;
     871        }
     872    }
     873    list = psListAlloc(tmpImage2);
     874    psListAdd(list, PS_LIST_HEAD, tmpImage3);
     875    psListAdd(list, PS_LIST_HEAD, tmpImage4);
     876
     877    printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
     878
     879    if (fit == PM_FIT_NONE) {
     880        myReadout = pmSubtractBias(myReadout, NULL, list, overscanaxis, stat,
     881                                   nBin, fit, NULL);
     882    } else if (fit == PM_FIT_POLYNOMIAL) {
     883        myReadout = pmSubtractBias(myReadout, myPoly, list, overscanaxis, stat,
     884                                   nBin, fit, NULL);
     885    } else if (fit == PM_FIT_SPLINE) {
     886        myReadout = pmSubtractBias(myReadout, mySpline, list, overscanaxis, stat,
     887                                   nBin, fit, NULL);
     888    }
     889
     890    for (i=0;i<imageNumRows;i++) {
     891        for (j=0;j<imageNumCols;j++) {
     892            expect = ((float) (i + j)) - 12.0;
     893            actual = myReadout->image->data.F32[i][j];
     894            if (FLT_EPSILON < fabs(expect - actual)) {
     895                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
     896                testStatus = 1;
     897            }
     898        }
     899    }
     900
     901
     902    psFree(myReadout);
     903    psFree(tmpImage2);
     904    psFree(tmpImage3);
     905    psFree(tmpImage4);
     906    psFree(stat);
     907    psFree(list);
     908    psFree(myPoly);
     909    psFree(mySpline);
     910
     911    printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
     912    return(testStatus);
     913}
     914
     915int testX( void )
     916{
     917    int testStatus = 0;
     918
     919    // imageNumCols, imageNumRows, overscanNumCols, overscanNumRows,
     920    // overscanaxis, fit, nBin
     921
     922    //
     923    // Overscan images are same size, no fit, bin factor is 1.
     924    //
     925    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     926                  NUM_COLS, NUM_ROWS,
     927                  PM_OVERSCAN_ALL,
     928                  PM_FIT_NONE, 1);
     929
     930    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     931                  NUM_COLS, NUM_ROWS,
     932                  PM_OVERSCAN_COLUMNS,
     933                  PM_FIT_NONE, 1);
     934
     935    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     936                  NUM_COLS, NUM_ROWS,
     937                  PM_OVERSCAN_ROWS,
     938                  PM_FIT_NONE, 1);
     939
     940    //
     941    // Overscan images are same size, no fit, bin factor is 2.
     942    //
     943    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     944                  NUM_COLS, NUM_ROWS,
     945                  PM_OVERSCAN_ALL,
     946                  PM_FIT_NONE, 2);
     947
     948    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     949                  NUM_COLS, NUM_ROWS,
     950                  PM_OVERSCAN_COLUMNS,
     951                  PM_FIT_NONE, 2);
     952
     953    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     954                  NUM_COLS, NUM_ROWS,
     955                  PM_OVERSCAN_ROWS,
     956                  PM_FIT_NONE, 2);
     957    //
     958    // Overscan images are too small, spline fit, bin factor is 1.
     959    //
     960    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     961                  NUM_COLS-1, NUM_ROWS-1,
     962                  PM_OVERSCAN_ALL,
     963                  PM_FIT_SPLINE, 1);
     964
     965    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     966                  NUM_COLS-1, NUM_ROWS-1,
     967                  PM_OVERSCAN_COLUMNS,
     968                  PM_FIT_SPLINE, 1);
     969
     970    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     971                  NUM_COLS-1, NUM_ROWS-1,
     972                  PM_OVERSCAN_ROWS,
     973                  PM_FIT_SPLINE, 1);
     974
     975    //
     976    // Overscan images are too small, spline fit, bin factor is 2.
     977    //
     978    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     979                  NUM_COLS-1, NUM_ROWS-1,
     980                  PM_OVERSCAN_ALL,
     981                  PM_FIT_SPLINE, 2);
     982
     983    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     984                  NUM_COLS-1, NUM_ROWS-1,
     985                  PM_OVERSCAN_COLUMNS,
     986                  PM_FIT_SPLINE, 2);
     987
     988    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     989                  NUM_COLS-1, NUM_ROWS-1,
     990                  PM_OVERSCAN_ROWS,
     991                  PM_FIT_SPLINE, 2);
     992
     993    //
     994    // Overscan images are same size, spline fit, bin factor is 1.
     995    //
     996    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     997                  NUM_COLS, NUM_ROWS,
     998                  PM_OVERSCAN_ALL,
     999                  PM_FIT_SPLINE, 1);
     1000
     1001    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1002                  NUM_COLS, NUM_ROWS,
     1003                  PM_OVERSCAN_COLUMNS,
     1004                  PM_FIT_SPLINE, 1);
     1005
     1006    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1007                  NUM_COLS, NUM_ROWS,
     1008                  PM_OVERSCAN_ROWS,
     1009                  PM_FIT_SPLINE, 1);
     1010    //
     1011    // Overscan images are same size, spline fit, bin factor is 2.
     1012    //
     1013    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1014                  NUM_COLS, NUM_ROWS,
     1015                  PM_OVERSCAN_ALL,
     1016                  PM_FIT_SPLINE, 2);
     1017
     1018    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1019                  NUM_COLS, NUM_ROWS,
     1020                  PM_OVERSCAN_COLUMNS,
     1021                  PM_FIT_SPLINE, 2);
     1022
     1023    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1024                  NUM_COLS, NUM_ROWS,
     1025                  PM_OVERSCAN_ROWS,
     1026                  PM_FIT_SPLINE, 2);
     1027
     1028    //
     1029    // Overscan images are same size, polynomial fit, bin factor is 1.
     1030    //
     1031    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1032                  NUM_COLS, NUM_ROWS,
     1033                  PM_OVERSCAN_ALL,
     1034                  PM_FIT_POLYNOMIAL, 1);
     1035
     1036    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1037                  NUM_COLS, NUM_ROWS,
     1038                  PM_OVERSCAN_COLUMNS,
     1039                  PM_FIT_POLYNOMIAL, 1);
     1040
     1041    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1042                  NUM_COLS, NUM_ROWS,
     1043                  PM_OVERSCAN_ROWS,
     1044                  PM_FIT_POLYNOMIAL, 1);
     1045    //
     1046    // Overscan images are same size, polynomial fit, bin factor is 2.
     1047    //
     1048    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1049                  NUM_COLS, NUM_ROWS,
     1050                  PM_OVERSCAN_ALL,
     1051                  PM_FIT_POLYNOMIAL, 2);
     1052
     1053    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1054                  NUM_COLS, NUM_ROWS,
     1055                  PM_OVERSCAN_COLUMNS,
     1056                  PM_FIT_POLYNOMIAL, 2);
     1057
     1058    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
     1059                  NUM_COLS, NUM_ROWS,
     1060                  PM_OVERSCAN_ROWS,
     1061                  PM_FIT_POLYNOMIAL, 2);
     1062
     1063    return(testStatus);
     1064}
     1065
    5641066
    5651067//This code will ...

  • trunk/psModules/test/tst_pmSubtractSky.c

    r2810 r2851  
    77 *  @author GLG, MHPCC
    88 *
    9  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-12-23 20:27:51 $
     9 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-12-30 01:42:04 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    327327    }
    328328
     329    printf("----------------------------------------------------------------\n");
     330    printf("Calling pmSubtractSky() with bogus psFit.  Should generate Error.\n\n");
     331    rc = pmSubtractSky(myReadout, (void *) myPoly, 54321, 1, myStats, -1.0);
     332    if (rc != myReadout) {
     333        printf("ERROR: pmSubtractSky() returned something other than psReadout\n");
     334        testStatus = false;
     335    }
     336
    329337
    330338    //    myReadout = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL,
    … …  
    339347    return(testStatus);
    340348}
    341 // This code will
Note: See TracChangeset for help on using the changeset viewer.