Changeset 2856 for trunk/psModules/src/pmSubtractBias.c

Timestamp:

Dec 30, 2004, 11:35:04 AM (22 years ago)

Author:

gusciora

Message:

Modified calls to psReadoutAlloc().

File:

• trunk/psModules/src/pmSubtractBias.c (modified) (23 diffs)

trunk/psModules/src/pmSubtractBias.c

@@ -6 +6 @@
  *  @author George Gusciora, MHPCC
  *
- *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-12-30 01:41:51 $
+ *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-12-30 21:35:03 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -29 +29 @@
                            const psReadout *bias)
 {
-    int i;
-    int j;
+    psS32 i;
+    psS32 j;
 
     if (bias == NULL) {
@@ -38 +38 @@
     }
 
-    // XXX: What should be returned here?
     if (((in->image)->numRows + in->row0 - bias->row0) > (bias->image)->numRows) {
         psError(PS_ERR_UNKNOWN,true, "bias image does not have enough rows\n");
@@ -48 +47 @@
     }
 
-    // XXX: Verify that this is the correct way to use offsets.
     for (i=0;i<(in->image)->numRows;i++) {
         for (j=0;j<(in->image)->numCols;j++) {
@@ -65 +63 @@
 /******************************************************************************
 p_psImageSubtractScalar(): subtract a scalar from the input image.
- 
-// XXX: Is there already a function which does this?
  *****************************************************************************/
 psImage *p_psImageSubtractScalar(psImage *image,
-                                 float scalar)
+                                 psF32 scalar)
 {
-    int i;
-    int j;
-
-    for (i=0;i<image->numRows;i++) {
-        for (j=0;j<image->numCols;j++) {
+    for (psS32 i=0;i<image->numRows;i++) {
+        for (psS32 j=0;j<image->numCols;j++) {
             (image->data.F32[i][j])-= scalar;
         }
@@ -83 +76 @@
 
 /******************************************************************************
-GenNewStatOptions(): this routine will take as input the options member of
-the stat data structure, determine if multiple options have been specified,
-issue a warning message if so, and return the highest priority option
-(according to the order of the if-statements in this code).
+GenNewStatOptions(): this routine will take as input the options member of the
+stat data structure, determine if multiple options have been specified, issue
+a warning message if so, and return the highest priority option (according to
+the order of the if-statements in this code).  The higher priority options are
+listed lower in the code.
  *****************************************************************************/
 psStatsOptions GenNewStatOptions(const psStats *stat)
 {
-    int numOptions = 0;
+    psS32 numOptions = 0;
     psStatsOptions opt = 0;
+
+    if (stat->options & PS_STAT_ROBUST_MODE) {
+        if (numOptions == 0) {
+            opt = PS_STAT_ROBUST_MODE;
+        }
+        numOptions++;
+    }
+
+    if (stat->options & PS_STAT_ROBUST_MEDIAN) {
+        if (numOptions == 0) {
+            opt = PS_STAT_ROBUST_MEDIAN;
+        }
+        numOptions++;
+    }
+
+    if (stat->options & PS_STAT_ROBUST_MEAN) {
+        if (numOptions == 0) {
+            opt = PS_STAT_ROBUST_MEAN;
+        }
+        numOptions++;
+    }
+
+    if (stat->options & PS_STAT_CLIPPED_MEAN) {
+        if (numOptions == 0) {
+            opt = PS_STAT_CLIPPED_MEAN;
+        }
+        numOptions++;
+    }
+
+    if (stat->options & PS_STAT_SAMPLE_MEDIAN) {
+        if (numOptions == 0) {
+            opt = PS_STAT_SAMPLE_MEDIAN;
+        }
+        numOptions++;
+    }
 
     if (stat->options & PS_STAT_SAMPLE_MEAN) {
@@ -98 +127 @@
     }
 
-    if (stat->options & PS_STAT_SAMPLE_MEDIAN) {
-        if (numOptions == 0) {
-            opt = PS_STAT_SAMPLE_MEDIAN;
-        }
-        numOptions++;
-    }
-
-    if (stat->options & PS_STAT_CLIPPED_MEAN) {
-        if (numOptions == 0) {
-            opt = PS_STAT_CLIPPED_MEAN;
-        }
-        numOptions++;
-    }
-
-    if (stat->options & PS_STAT_ROBUST_MEAN) {
-        if (numOptions == 0) {
-            opt = PS_STAT_ROBUST_MEAN;
-        }
-        numOptions++;
-    }
-
-    if (stat->options & PS_STAT_ROBUST_MEDIAN) {
-        if (numOptions == 0) {
-            opt = PS_STAT_ROBUST_MEDIAN;
-        }
-        numOptions++;
-    }
-
-    if (stat->options & PS_STAT_ROBUST_MODE) {
-        if (numOptions == 0) {
-            opt = PS_STAT_ROBUST_MODE;
-        }
-        numOptions++;
-    }
 
     if (numOptions == 0) {
@@ -154 +149 @@
  *****************************************************************************/
 psVector *ScaleOverscanVector(psVector *overscanVector,
-                              int n,
+                              psS32 n,
                               void *fitSpec,
                               pmFit fit)
@@ -178 +173 @@
     psPolynomial1D *myPoly;
     psSpline1D *mySpline;
-    float x;
-    int i;
+    psF32 x;
+    psS32 i;
 
     if (fit == PM_FIT_POLYNOMIAL) {
         // Fit a polynomial to the old overscan vector.
         myPoly = (psPolynomial1D *) fitSpec;
+        PS_POLY_CHECK_NULL(myPoly, NULL);
         myPoly = psVectorFitPolynomial1D(myPoly, NULL, overscanVector, NULL);
+        if (myPoly == NULL) {
+            psError(PS_ERR_UNKNOWN, false, "ScaleOverscanVector(): Could not fit a polynomial to the psVector.\n");
+            return(NULL);
+        }
 
         // For each element of the new vector, convert the x-ordinate to that
@@ -190 +190 @@
         // interpolated value at that point, and set the new vector.
         for (i=0;i<n;i++) {
-            x = ((float) i) * ((float) overscanVector->n) / ((float) n);
+            x = ((psF32) i) * ((psF32) overscanVector->n) / ((psF32) n);
             newVec->data.F32[i] = psPolynomial1DEval(myPoly, x);
         }
@@ -200 +200 @@
             mustFreeSpline = 1;
         }
+
         //
         // NOTE: Since the X arg in the psVectorFitSpline1D() function is NULL,
@@ -206 +207 @@
         //
         mySpline = psVectorFitSpline1D(mySpline, NULL, overscanVector, NULL);
+        if (mySpline == NULL) {
+            psError(PS_ERR_UNKNOWN, false, "ScaleOverscanVector(): Could not fit a spline to the psVector.\n");
+            return(NULL);
+        }
 
         // For each element of the new vector, convert the x-ordinate to that
@@ -212 +217 @@
         for (i=0;i<n;i++) {
             // Scale to [0 : overscanVector->n - 1]
-            x = ((float) i) * ((float) (overscanVector->n-1)) / ((float) n);
+            x = ((psF32) i) * ((psF32) (overscanVector->n-1)) / ((psF32) n);
             newVec->data.F32[i] = psSpline1DEval(mySpline, x);
         }
@@ -228 +233 @@
 }
 
+/******************************************************************************
+XXX: The SDRS does not specify type support.  F32 is implemented here.
+ *****************************************************************************/
 psReadout *pmSubtractBias(psReadout *in,
                           void *fitSpec,
@@ -233 +241 @@
                           pmOverscanAxis overScanAxis,
                           psStats *stat,
-                          int nBinOrig,
+                          psS32 nBinOrig,
                           pmFit fit,
                           const psReadout *bias)
@@ -263 +271 @@
         return(in);
     }
-    int i;
-    int j;
-    int numBins = 0;
+    psS32 i;
+    psS32 j;
+    psS32 numBins = 0;
     static psVector *overscanVector = NULL;
     psVector *tmpRow = NULL;
@@ -276 +284 @@
     psPolynomial1D *myPoly = NULL;
     psSpline1D *mySpline = NULL;
-    int nBin;
-    //  XXX: This comment isn't right?
-    //  Determine if multiple options are specified in stat.
+    psS32 nBin;
+
     //
+    //  Create a static stats data structure and determine the highest
+    //  priority stats option.
+    //
+    static psStats *myStats = NULL;
+    if (myStats == NULL) {
+        myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
+        p_psMemSetPersistent(myStats, true);
+    }
     if (stat != NULL) {
-        stat->options = GenNewStatOptions(stat);
+        myStats->options = GenNewStatOptions(stat);
     }
 
@@ -314 +329 @@
         while (NULL != tmpOverscan) {
             myOverscanImage = (psImage *) tmpOverscan->data;
-            psImageStats(stat, myOverscanImage, NULL, 0xffffffff);
-            p_psGetStatValue(stat, &statValue);
+            psImageStats(myStats, myOverscanImage, NULL, 0xffffffff);
+            p_psGetStatValue(myStats, &statValue);
             p_psImageSubtractScalar(in->image, statValue);
 
@@ -356 +371 @@
                     tmpRow->data.F32[j] = myOverscanImage->data.F32[j][i];
                 }
-                stat = psVectorStats(stat, tmpRow, NULL, NULL, 0);
-                p_psGetStatValue(stat, &statValue);
+                myStats = psVectorStats(myStats, tmpRow, NULL, NULL, 0);
+                p_psGetStatValue(myStats, &statValue);
                 overscanVector->data.F32[i] = statValue;
             }
@@ -399 +414 @@
                     tmpCol->data.F32[j] = myOverscanImage->data.F32[i][j];
                 }
-                stat = psVectorStats(stat, tmpCol, NULL, NULL, 0);
-                p_psGetStatValue(stat, &statValue);
+                myStats = psVectorStats(myStats, tmpCol, NULL, NULL, 0);
+                p_psGetStatValue(myStats, &statValue);
                 overscanVector->data.F32[i] = statValue;
             }
@@ -441 +456 @@
                     }
                 }
-                stat = psVectorStats(stat, binVec, NULL, NULL, 0);
-                p_psGetStatValue(stat, &statValue);
+                myStats = psVectorStats(myStats, binVec, NULL, NULL, 0);
+                p_psGetStatValue(myStats, &statValue);
                 myBin->data.F32[i] = statValue;
             }
@@ -492 +507 @@
                     psF32 tmpF32 = 0.0;
                     if (fit == PM_FIT_POLYNOMIAL) {
-                        tmpF32 = psPolynomial1DEval(myPoly, ((float) i) / ((float) nBin));
+                        tmpF32 = psPolynomial1DEval(myPoly, ((psF32) i) / ((psF32) nBin));
                     } else if (fit == PM_FIT_SPLINE) {
-                        tmpF32 = psSpline1DEval(mySpline, ((float) i) / ((float) nBin));
+                        tmpF32 = psSpline1DEval(mySpline, ((psF32) i) / ((psF32) nBin));
                     }
                     for (j=0;j<(in->image)->numRows;j++) {
                         (in->image)->data.F32[j][i]-= tmpF32;
-
                     }
                 }
@@ -510 +524 @@
                     psF32 tmpF32 = 0.0;
                     if (fit == PM_FIT_POLYNOMIAL) {
-                        tmpF32 = psPolynomial1DEval(myPoly, ((float) i) / ((float) nBin));
+                        tmpF32 = psPolynomial1DEval(myPoly, ((psF32) i) / ((psF32) nBin));
                     } else if (fit == PM_FIT_SPLINE) {
-                        tmpF32 = psSpline1DEval(mySpline, ((float) i) / ((float) nBin));
+                        tmpF32 = psSpline1DEval(mySpline, ((psF32) i) / ((psF32) nBin));
                     }