Index: /trunk/psModules/test/tst_pmReadoutCombine.c
===================================================================
--- /trunk/psModules/test/tst_pmReadoutCombine.c	(revision 2850)
+++ /trunk/psModules/test/tst_pmReadoutCombine.c	(revision 2851)
@@ -5,6 +5,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-12-27 23:16:51 $
+ *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-12-30 01:42:04 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -435,3 +435,2 @@
     return(!testStatus);
 }
-// This code will
Index: /trunk/psModules/test/tst_pmSubtractBias.c
===================================================================
--- /trunk/psModules/test/tst_pmSubtractBias.c	(revision 2850)
+++ /trunk/psModules/test/tst_pmSubtractBias.c	(revision 2851)
@@ -13,6 +13,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-12-29 02:52:28 $
+ *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-12-30 01:42:04 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -27,12 +27,13 @@
 static int test03(void);
 static int test04(void);
+static int testX(void);
 testDescription tests[] = {
-                              /*
-                                                            {test00, 000, "pmSubtractBias", 0, false},
-                                                            {test01, 000, "pmSubtractBias", 0, false},
-                                                            {test02, 000, "pmSubtractBias", 0, false},
-                                                            {test03, 000, "pmSubtractBias", 0, false},
-                              */
+
+                              {test00, 000, "pmSubtractBias", 0, false},
+                              {test01, 000, "pmSubtractBias", 0, false},
+                              {test02, 000, "pmSubtractBias", 0, false},
+                              {test03, 000, "pmSubtractBias", 0, false},
                               {test04, 000, "pmSubtractBias", 0, false},
+                              {testX,  000, "pmSubtractBias", 0, false},
                               {NULL}
                           };
@@ -44,6 +45,10 @@
 }
 
-#define NUM_ROWS 4
-#define NUM_COLS 4
+#define NUM_ROWS 8
+#define NUM_COLS 8
+/******************************************************************************
+doSubtractBiasFullFrame(): a sample psReadout as well as a bias image are
+created and the bias image is subtracted from the psReadout.
+ *****************************************************************************/
 int doSubtractBiasFullFrame(int numCols, int numRows)
 {
@@ -98,4 +103,9 @@
 }
 
+/******************************************************************************
+doSubtractFullOverscans(): a sample psReadout as well as several overscan
+images of the same size are created.  The overscan images are then subtracted
+from the psReadout.
+ *****************************************************************************/
 int doSubtractFullOverscans(int numCols, int numRows)
 {
@@ -162,4 +172,9 @@
 }
 
+/******************************************************************************
+doSubtractFullOverscans(): a sample psReadout as well as several overscan
+images of the same size are created.  The overscan images are collected
+pixel-by-pixel then subtracted column-wise from the psReadout.
+ *****************************************************************************/
 int doSubtractFullOverscanColumns(int numCols, int numRows)
 {
@@ -216,18 +231,10 @@
     return(testStatus);
 }
-
-int test02( void )
-{
-    int testStatus = 0;
-
-    testStatus |= doSubtractFullOverscanColumns(1, 1);
-    testStatus |= doSubtractFullOverscanColumns(1, NUM_ROWS);
-    testStatus |= doSubtractFullOverscanColumns(NUM_COLS, 1);
-    testStatus |= doSubtractFullOverscanColumns(NUM_COLS, NUM_ROWS);
-
-    return(testStatus);
-}
-
-int doSubtractFullOverscanRows(int numCols, int numRows)
+/******************************************************************************
+doSubtractFullOverscans(): a sample psReadout as well as several overscan
+images of the same size are created.  The overscan images are collected
+pixel-by-pixel then subtracted column-wise from the psReadout.
+ *****************************************************************************/
+int doSubtractFullOverscanColumnsPoly(int numCols, int numRows)
 {
     int i;
@@ -243,4 +250,5 @@
     psList *list;
     psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
 
     for (i=0;i<numRows;i++) {
@@ -256,8 +264,8 @@
     psListAdd(list, PS_LIST_HEAD, tmpImage4);
 
-    printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
-
-    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
-                               0, PM_FIT_NONE, NULL);
+    printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
+
+    myReadout = pmSubtractBias(myReadout, myPoly, list, PM_OVERSCAN_COLUMNS, stat,
+                               0, PM_FIT_POLYNOMIAL, NULL);
 
     for (i=0;i<numRows;i++) {
@@ -279,8 +287,223 @@
     psFree(stat);
     psFree(list);
+    psFree(myPoly);
+
+    printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
+    return(testStatus);
+}
+/******************************************************************************
+doSubtractFullOverscansSmall(): a sample psReadout as well as several overscan
+images of smaller size are created.  The overscan images are collected
+pixel-by-pixel then subtracted column-wise from the psReadout.
+ *****************************************************************************/
+int doSubtractFullOverscanColumnsSmall(int numCols, int numRows)
+{
+    int i;
+    int j;
+    float actual;
+    float expect;
+    int testStatus = 0;
+    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
+    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
+    psImage *tmpImage2 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
+    psImage *tmpImage3 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
+    psImage *tmpImage4 = psImageAlloc(numCols/2, numRows/2, PS_TYPE_F32);
+    psList *list;
+    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
+
+    for (i=0;i<numRows;i++) {
+        for (j=0;j<numCols;j++) {
+            myReadout->image->data.F32[i][j] = (float) (i + j);
+        }
+    }
+    for (i=0;i<numRows/2;i++) {
+        for (j=0;j<numCols/2;j++) {
+            tmpImage2->data.F32[i][j] = 3.0;
+            tmpImage3->data.F32[i][j] = 4.0;
+            tmpImage4->data.F32[i][j] = 5.0;
+        }
+    }
+    list = psListAlloc(tmpImage2);
+    psListAdd(list, PS_LIST_HEAD, tmpImage3);
+    psListAdd(list, PS_LIST_HEAD, tmpImage4);
+
+    printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
+
+    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_COLUMNS, stat,
+                               0, PM_FIT_POLYNOMIAL, NULL);
+
+    for (i=0;i<numRows;i++) {
+        for (j=0;j<numCols;j++) {
+            expect = ((float) (i + j)) - 12.0;
+            actual = myReadout->image->data.F32[i][j];
+            if (FLT_EPSILON < fabs(expect - actual)) {
+                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
+                testStatus = 1;
+            }
+        }
+    }
+
+
+    psFree(myReadout);
+    psFree(tmpImage2);
+    psFree(tmpImage3);
+    psFree(tmpImage4);
+    psFree(stat);
+    psFree(list);
+
+    printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
+    return(testStatus);
+}
+
+int test02( void )
+{
+    int testStatus = 0;
+
+    testStatus |= doSubtractFullOverscanColumns(1, 1);
+    testStatus |= doSubtractFullOverscanColumns(1, NUM_ROWS);
+    testStatus |= doSubtractFullOverscanColumns(NUM_COLS, 1);
+    testStatus |= doSubtractFullOverscanColumns(NUM_COLS, NUM_ROWS);
+    /* These tests do not make sense until the SDRS is clarified.
+        testStatus |= doSubtractFullOverscanColumnsSmall(1, 1);
+        testStatus |= doSubtractFullOverscanColumnsSmall(1, NUM_ROWS);
+        testStatus |= doSubtractFullOverscanColumnsSmall(NUM_COLS, 1);
+        testStatus |= doSubtractFullOverscanColumnsSmall(NUM_COLS, NUM_ROWS);
+    */
+
+    return(testStatus);
+}
+
+/******************************************************************************
+doSubtractFullOverscans(): a sample psReadout as well as several overscan
+images of the same size are created.  The overscan images are collected
+pixel-by-pixel then subtracted row-wise from the psReadout.
+ *****************************************************************************/
+int doSubtractFullOverscanRows(int numCols, int numRows)
+{
+    int i;
+    int j;
+    float actual;
+    float expect;
+    int testStatus = 0;
+    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
+    psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
+    psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
+    psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
+    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
+    psList *list;
+    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
+
+    for (i=0;i<numRows;i++) {
+        for (j=0;j<numCols;j++) {
+            myReadout->image->data.F32[i][j] = (float) (i + j);
+            tmpImage2->data.F32[i][j] = 3.0;
+            tmpImage3->data.F32[i][j] = 4.0;
+            tmpImage4->data.F32[i][j] = 5.0;
+        }
+    }
+    list = psListAlloc(tmpImage2);
+    psListAdd(list, PS_LIST_HEAD, tmpImage3);
+    psListAdd(list, PS_LIST_HEAD, tmpImage4);
+
+    printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
+
+    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
+                               0, PM_FIT_NONE, NULL);
+
+    for (i=0;i<numRows;i++) {
+        for (j=0;j<numCols;j++) {
+            expect = ((float) (i + j)) - 12.0;
+            actual = myReadout->image->data.F32[i][j];
+            if (FLT_EPSILON < fabs(expect - actual)) {
+                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
+                testStatus = 1;
+            }
+        }
+    }
+
+
+    psFree(myReadout);
+    psFree(tmpImage2);
+    psFree(tmpImage3);
+    psFree(tmpImage4);
+    psFree(stat);
+    psFree(list);
 
     printFooter(stdout, "pmSubtractBias", "Row Overscans", true);
     return(testStatus);
 }
+
+/******************************************************************************
+doSubtractFullOverscansSmall(): a sample psReadout as well as several overscan
+images of smaller size are created.  The overscan images are collected
+pixel-by-pixel then subtracted row-wise from the psReadout.
+ *****************************************************************************/
+int doSubtractFullOverscanRowsSmall(int numCols, int numRows)
+{
+    int i;
+    int j;
+    float actual;
+    float expect;
+    int testStatus = 0;
+    psS32 OSnumRows = numRows-1;
+    if (OSnumRows == 0) {
+        OSnumRows = 1;
+    }
+    psS32 OSnumCols = numCols-1;
+    if (OSnumCols == 0) {
+        OSnumCols = 1;
+    }
+    psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32);
+    psImage *tmpImage2 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
+    psImage *tmpImage3 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
+    psImage *tmpImage4 = psImageAlloc(OSnumCols, OSnumRows, PS_TYPE_F32);
+    psReadout *myReadout = psReadoutAlloc(numCols, numRows, tmpImage1);
+    psList *list;
+    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
+
+    for (i=0;i<numRows;i++) {
+        for (j=0;j<numCols;j++) {
+            myReadout->image->data.F32[i][j] = (float) (i + j);
+        }
+    }
+    for (i=0;i<OSnumRows;i++) {
+        for (j=0;j<OSnumCols;j++) {
+            tmpImage2->data.F32[i][j] = 3.0;
+            tmpImage3->data.F32[i][j] = 4.0;
+            tmpImage4->data.F32[i][j] = 5.0;
+        }
+    }
+    list = psListAlloc(tmpImage2);
+    psListAdd(list, PS_LIST_HEAD, tmpImage3);
+    psListAdd(list, PS_LIST_HEAD, tmpImage4);
+
+    printPositiveTestHeader(stdout, "pmSubtractBias", "Row Overscans");
+
+    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
+                               0, PM_FIT_SPLINE, NULL);
+
+    for (i=0;i<numRows;i++) {
+        for (j=0;j<numCols;j++) {
+            expect = ((float) (i + j)) - 12.0;
+            actual = myReadout->image->data.F32[i][j];
+            if (FLT_EPSILON < fabs(expect - actual)) {
+                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
+                testStatus = 1;
+            }
+        }
+    }
+
+
+    psFree(myReadout);
+    psFree(tmpImage2);
+    psFree(tmpImage3);
+    psFree(tmpImage4);
+    psFree(stat);
+    psFree(list);
+
+    printFooter(stdout, "pmSubtractBias", "Row Overscans", true);
+    return(testStatus);
+}
+
 
 int test03( void )
@@ -292,4 +515,8 @@
     testStatus |= doSubtractFullOverscanRows(NUM_COLS, 1);
     testStatus |= doSubtractFullOverscanRows(NUM_COLS, NUM_ROWS);
+    testStatus |= doSubtractFullOverscanRowsSmall(1, 1);
+    testStatus |= doSubtractFullOverscanRowsSmall(1, NUM_ROWS);
+    testStatus |= doSubtractFullOverscanRowsSmall(NUM_COLS, 1);
+    testStatus |= doSubtractFullOverscanRowsSmall(NUM_COLS, NUM_ROWS);
 
     return(testStatus);
@@ -385,6 +612,5 @@
     printf("------------------------------------------------------------------\n");
     printf("Calling pmSubtractBias() with non-NULL overscan list and PM_OVERSCAN_NONE.  Should generate warning.\n");
-    rc = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_NONE, stat,
-                        0, PM_FIT_NONE, myBias);
+    rc = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_NONE, stat, 0, PM_FIT_NONE, myBias);
 
     for (i=0;i<numRows;i++) {
@@ -482,6 +708,6 @@
     printf("------------------------------------------------------------------\n");
     printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_ROWS).  Should generate Warning.\n");
-    myReadout = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_ROWS, stat,
-                               0, PM_FIT_NONE, NULL);
+    rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_ROWS, stat,
+                        0, PM_FIT_NONE, NULL);
     /*
         for (i=0;i<numRows;i++) {
@@ -499,6 +725,6 @@
     printf("------------------------------------------------------------------\n");
     printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_COLUMNS).  Should generate Warning.\n");
-    myReadout = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_COLUMNS, stat,
-                               0, PM_FIT_NONE, NULL);
+    rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_COLUMNS, stat,
+                        0, PM_FIT_NONE, NULL);
     /*
         for (i=0;i<numRows;i++) {
@@ -535,4 +761,36 @@
     }
 
+    printf("------------------------------------------------------------------\n");
+    printf("Calling pmSubtractBias() with bogus PM_FIT.  Should generate Error.\n");
+    myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat,
+                               0, 54321, NULL);
+    if (rc != myReadout) {
+        printf("ERROR: pmSubtractBias() did not return input psReadout.\n");
+        testStatus = false;
+        psFree(rc);
+    }
+
+    printf("------------------------------------------------------------------\n");
+    printf("Calling pmSubtractBias() with bogus overScanAxis.  Should generate Error.\n");
+    myReadout = pmSubtractBias(myReadout, NULL, list, 54321, stat,
+                               0, PM_FIT_NONE, NULL);
+    if (rc != myReadout) {
+        printf("ERROR: pmSubtractBias() did not return input psReadout.\n");
+        testStatus = false;
+        psFree(rc);
+    }
+
+    /*
+        for (i=0;i<numRows;i++) {
+            for (j=0;j<numCols;j++) {
+                psF32 expect = ((float) (i + j)) - 12.0;
+                psF32 actual = rc->image->data.F32[i][j];
+                if (FLT_EPSILON < fabs(expect - actual)) {
+                    printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
+                    testStatus = 1;
+                }
+            }
+        }
+    */
 
     printf("------------------------------------------------------------------\n");
@@ -562,4 +820,248 @@
 }
 
+/******************************************************************************
+doSubtractFullOverscansSmall(): a sample psReadout as well as several overscan
+images of smaller size are created.  The overscan images are collected
+pixel-by-pixel then subtracted column-wise from the psReadout.
+ *****************************************************************************/
+int doSubtractFullOverscanColumnsGeneric(int imageNumCols,
+        int imageNumRows,
+        int overscanNumCols,
+        int overscanNumRows,
+        pmOverscanAxis overscanaxis,
+        pmFit fit,
+        psS32 nBin)
+{
+    int i;
+    int j;
+    float actual;
+    float expect;
+    int testStatus = 0;
+
+    psImage *tmpImage1 = psImageAlloc(imageNumCols, imageNumRows, PS_TYPE_F32);
+    psReadout *myReadout = psReadoutAlloc(imageNumCols, imageNumRows, tmpImage1);
+    for (i=0;i<imageNumRows;i++) {
+        for (j=0;j<imageNumCols;j++) {
+            myReadout->image->data.F32[i][j] = (float) (i + j);
+        }
+    }
+
+    psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
+    psSpline1D *mySpline = NULL;
+
+
+    /*
+        if (overscanNumRows <= 0) {
+            overscanNumRows = 1;
+        }
+        if (overscanNumCols <= 0) {
+            overscanNumCols = 1;
+        }
+    */
+    psImage *tmpImage2 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
+    psImage *tmpImage3 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
+    psImage *tmpImage4 = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32);
+    psList *list;
+    for (i=0;i<overscanNumRows;i++) {
+        for (j=0;j<overscanNumCols;j++) {
+            tmpImage2->data.F32[i][j] = 3.0;
+            tmpImage3->data.F32[i][j] = 4.0;
+            tmpImage4->data.F32[i][j] = 5.0;
+        }
+    }
+    list = psListAlloc(tmpImage2);
+    psListAdd(list, PS_LIST_HEAD, tmpImage3);
+    psListAdd(list, PS_LIST_HEAD, tmpImage4);
+
+    printPositiveTestHeader(stdout, "pmSubtractBias", "Column Overscans");
+
+    if (fit == PM_FIT_NONE) {
+        myReadout = pmSubtractBias(myReadout, NULL, list, overscanaxis, stat,
+                                   nBin, fit, NULL);
+    } else if (fit == PM_FIT_POLYNOMIAL) {
+        myReadout = pmSubtractBias(myReadout, myPoly, list, overscanaxis, stat,
+                                   nBin, fit, NULL);
+    } else if (fit == PM_FIT_SPLINE) {
+        myReadout = pmSubtractBias(myReadout, mySpline, list, overscanaxis, stat,
+                                   nBin, fit, NULL);
+    }
+
+    for (i=0;i<imageNumRows;i++) {
+        for (j=0;j<imageNumCols;j++) {
+            expect = ((float) (i + j)) - 12.0;
+            actual = myReadout->image->data.F32[i][j];
+            if (FLT_EPSILON < fabs(expect - actual)) {
+                printf("ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
+                testStatus = 1;
+            }
+        }
+    }
+
+
+    psFree(myReadout);
+    psFree(tmpImage2);
+    psFree(tmpImage3);
+    psFree(tmpImage4);
+    psFree(stat);
+    psFree(list);
+    psFree(myPoly);
+    psFree(mySpline);
+
+    printFooter(stdout, "pmSubtractBias", "Column Overscans", true);
+    return(testStatus);
+}
+
+int testX( void )
+{
+    int testStatus = 0;
+
+    // imageNumCols, imageNumRows, overscanNumCols, overscanNumRows,
+    // overscanaxis, fit, nBin
+
+    //
+    // Overscan images are same size, no fit, bin factor is 1.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_NONE, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_NONE, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_NONE, 1);
+
+    //
+    // Overscan images are same size, no fit, bin factor is 2.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_NONE, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_NONE, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_NONE, 2);
+    //
+    // Overscan images are too small, spline fit, bin factor is 1.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS-1, NUM_ROWS-1,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_SPLINE, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS-1, NUM_ROWS-1,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_SPLINE, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS-1, NUM_ROWS-1,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_SPLINE, 1);
+
+    //
+    // Overscan images are too small, spline fit, bin factor is 2.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS-1, NUM_ROWS-1,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_SPLINE, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS-1, NUM_ROWS-1,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_SPLINE, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS-1, NUM_ROWS-1,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_SPLINE, 2);
+
+    //
+    // Overscan images are same size, spline fit, bin factor is 1.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_SPLINE, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_SPLINE, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_SPLINE, 1);
+    //
+    // Overscan images are same size, spline fit, bin factor is 2.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_SPLINE, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_SPLINE, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_SPLINE, 2);
+
+    //
+    // Overscan images are same size, polynomial fit, bin factor is 1.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_POLYNOMIAL, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_POLYNOMIAL, 1);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_POLYNOMIAL, 1);
+    //
+    // Overscan images are same size, polynomial fit, bin factor is 2.
+    //
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ALL,
+                  PM_FIT_POLYNOMIAL, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_COLUMNS,
+                  PM_FIT_POLYNOMIAL, 2);
+
+    testStatus |= doSubtractFullOverscanColumnsGeneric(NUM_COLS, NUM_ROWS,
+                  NUM_COLS, NUM_ROWS,
+                  PM_OVERSCAN_ROWS,
+                  PM_FIT_POLYNOMIAL, 2);
+
+    return(testStatus);
+}
+
 
 //This code will ...
Index: /trunk/psModules/test/tst_pmSubtractSky.c
===================================================================
--- /trunk/psModules/test/tst_pmSubtractSky.c	(revision 2850)
+++ /trunk/psModules/test/tst_pmSubtractSky.c	(revision 2851)
@@ -7,6 +7,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-12-23 20:27:51 $
+ *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-12-30 01:42:04 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -327,4 +327,12 @@
     }
 
+    printf("----------------------------------------------------------------\n");
+    printf("Calling pmSubtractSky() with bogus psFit.  Should generate Error.\n\n");
+    rc = pmSubtractSky(myReadout, (void *) myPoly, 54321, 1, myStats, -1.0);
+    if (rc != myReadout) {
+        printf("ERROR: pmSubtractSky() returned something other than psReadout\n");
+        testStatus = false;
+    }
+
 
     //    myReadout = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL,
@@ -339,3 +347,2 @@
     return(testStatus);
 }
-// This code will