Changeset 5102

Timestamp:

Sep 22, 2005, 3:56:54 PM (21 years ago)

Author:

gusciora

Message:

....

Location:

trunk

Files:

• psLib/src/math/psSpline.c (modified) (6 diffs)
• psModules/src/pmSubtractBias.c (modified) (7 diffs)
• psModules/src/pmSubtractSky.c (modified) (6 diffs)

trunk/psLib/src/math/psSpline.c

@@ -7 +7 @@
 *  splines.
 *
-*  @version $Revision: 1.127 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-22 02:47:16 $
+*  @version $Revision: 1.128 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-23 01:56:54 $
 *
 *
@@ -207 +207 @@
 }
 
-
 /*****************************************************************************
 CalculateSecondDerivs(): Given a set of x/y vectors corresponding to a
@@ -223 +222 @@
 XXX: do an F64 version?
  *****************************************************************************/
-static psF32 *calculateSecondDerivs(const psVector* x,        ///< Ordinates (or NULL to just use the indices)
+static psF32 *calculateSecondDerivs(const psVector* x,        ///< Ordinates (or NULL to just use the in!
                                     const psVector* y)        ///< Coordinates
 {
@@ -229 +228 @@
             "---- calculateSecondDerivs() begin ----\n");
 
-    unsigned int i;
-    unsigned int k;
+    psS32 i;
+    psS32 k;
     psF32 sig;
     psF32 p;
-    unsigned int n = y->n;
+    psS32 n = y->n;
     psF32 *u = (psF32 *) psAlloc(n * sizeof(psF32));
     psF32 *derivs2 = (psF32 *) psAlloc(n * sizeof(psF32));
@@ -253 +252 @@
 
         psTrace(".psLib.dataManip.calculateSecondDerivs", 6,
-                "X[%u] is %f\n", i, X[i]);
+                "X[%d] is %f\n", i, X[i]);
         psTrace(".psLib.dataManip.calculateSecondDerivs", 6,
-                "Y[%u] is %f\n", i, Y[i]);
+                "Y[%d] is %f\n", i, Y[i]);
         psTrace(".psLib.dataManip.calculateSecondDerivs", 6,
-                "u[%u] is %f\n", i, u[i]);
+                "u[%d] is %f\n", i, u[i]);
     }
 
@@ -264 +263 @@
     derivs2[n-1] = (u[n-1] - (qn * u[n-2])) / ((qn * derivs2[n-2]) + 1.0);
 
-    //XXX: Changed from k=n-2;k>=0; because k is now unsigned//
-    for (k=(n-1);k>0;k--) {
+    for (k=(n-2);k>=0;k--) {
         derivs2[k] = derivs2[k] * derivs2[k+1] + u[k];
 
         psTrace(".psLib.dataManip.calculateSecondDerivs", 6,
-                "derivs2[%u] is %f\n", k, derivs2[k]);
-    }
-
+                "derivs2[%d] is %f\n", k, derivs2[k]);
+    }
     psFree(u);
     psTrace(".psLib.dataManip.calculateSecondDerivs", 4,
             "---- calculateSecondDerivs() end ----\n");
+
     return(derivs2);
 }
+
+
 
 /*****************************************************************************/

trunk/psModules/src/pmSubtractBias.c

@@ -6 +6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-12 20:38:25 $
+ *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-23 01:55:30 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -22 +22 @@
 #define PM_SUBTRACT_BIAS_SPLINE_ORDER 3
 
+// XXX: put these in psConstants.h
+void PS_POLY1D_PRINT(psPolynomial1D *poly)
+{
+    printf("-------------- PS_POLY1D_PRINT() --------------\n");
+    printf("poly->COOL_1D_n is %d\n", poly->COOL_1D_n);
+    for (psS32 i = 0 ; i < (1 + poly->COOL_1D_n) ; i++) {
+        printf("poly->coeff[%d] is %f\n", i, poly->coeff[i]);
+    }
+}
+
+void PS_PRINT_SPLINE(psSpline1D *mySpline)
+{
+    printf("-------------- PS_PRINT_SPLINE() --------------\n");
+    printf("mySpline->n is %d\n", mySpline->n);
+    for (psS32 i = 0 ; i < mySpline->n ; i++) {
+        PS_POLY1D_PRINT(mySpline->spline[i]);
+    }
+    PS_VECTOR_PRINT_F32(mySpline->knots);
+}
+
+#define PS_IMAGE_PRINT_F32_HIDEF(NAME) \
+printf("======== printing %s ========\n", #NAME); \
+for (int i = 0 ; i < (NAME)->numRows ; i++) { \
+    for (int j = 0 ; j < (NAME)->numCols ; j++) { \
+        printf("%.5f ", (NAME)->data.F32[i][j]); \
+    } \
+    printf("\n"); \
+}\
+
 /******************************************************************************
 psSubtractFrame(): this routine will take as input a readout for the input
 image and a readout for the bias image.  The bias image is subtracted in
 place from the input image.
- *****************************************************************************/
+*****************************************************************************/
 static pmReadout *SubtractFrame(pmReadout *in,
                                 const pmReadout *bias)
@@ -143 +172 @@
     return(opt);
 }
+
+
 
 /******************************************************************************
@@ -161 +192 @@
     psTrace(".psModule.pmSubtracBias.ScaleOverscanVector", 4,
             "---- ScaleOverscanVector() begin (%d -> %d) ----\n", overscanVector->n, n);
+    //    PS_VECTOR_PRINT_F32(overscanVector);
 
     if (NULL == overscanVector) {
@@ -218 +250 @@
             return(NULL);
         }
+        //        PS_PRINT_SPLINE(mySpline);
 
         // For each element of the new vector, convert the x-ordinate to that
@@ -230 +263 @@
             psFree(mySpline);
         }
+        //        PS_VECTOR_PRINT_F32(newVec);
+
 
     } else {
@@ -376 +411 @@
     tmpOverscan = (psListElem *) overscans->head;
     while (NULL != tmpOverscan) {
+        //        PS_IMAGE_PRINT_F32_HIDEF(in->image);
         myOverscanImage = (psImage *) tmpOverscan->data;
 

trunk/psModules/src/pmSubtractSky.c

@@ -6 +6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-08-16 01:10:34 $
+ *  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-23 01:55:30 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -306 +306 @@
     // polynomial if there are not enough rows/columns in the input image.
 
-    if (myPoly->nX > dataImage->numRows) {
+    if ((myPoly->COOL_2D_nX + 1) > dataImage->numRows) {
         psLogMsg(__func__, PS_LOG_WARN,
                  "WARNING: ImageFitPolynomial(): Reducing polynomial complexity in x-dimension.\n");
-        oldPolyX = myPoly->nX;
-        myPoly->nX = dataImage->numRows;
-    }
-    if (myPoly->nY > dataImage->numCols) {
+        oldPolyX = myPoly->COOL_2D_nX;
+        myPoly->COOL_2D_nX = dataImage->numRows - 1;
+    }
+    if ((myPoly->COOL_2D_nY + 1) > dataImage->numCols) {
         psLogMsg(__func__, PS_LOG_WARN,
                  "WARNING: ImageFitPolynomial(): Reducing polynomial complexity in y-dimension.\n");
-        oldPolyY = myPoly->nY;
-        myPoly->nY = dataImage->numCols;
+        oldPolyY = myPoly->COOL_2D_nY;
+        myPoly->COOL_2D_nY = dataImage->numCols - 1;
     }
     psS32 i;
@@ -324 +324 @@
     psS32 aRow;
     psS32 aCol;
-    // The myPoly->nX and ->nY terms are actually 1 larger
-    // than the order of the polynomial.
-    psS32 **polyTerms = buildPolyTerms(myPoly->nX-1, myPoly->nY-1);
+    psS32 **polyTerms = buildPolyTerms(myPoly->COOL_2D_nX, myPoly->COOL_2D_nY);
     // We determine how many coefficients will be in the polynomial that we
     // are fitting to this image.
-    psS32 localPolyTerms = CalculatePolyTerms(myPoly->nX-1, myPoly->nY-1);
+    psS32 localPolyTerms = CalculatePolyTerms(myPoly->COOL_2D_nX, myPoly->COOL_2D_nY);
     psImage *A = psImageAlloc(localPolyTerms, localPolyTerms, PS_TYPE_F64);
     psImage *Aout = psImageAlloc(localPolyTerms, localPolyTerms, PS_TYPE_F64);
@@ -347 +345 @@
         for (y=0;y<dataImage->numCols;y++) {
             if (maskImage->data.U8[x][y] == 0) {
-                buildSums((psF64) x, (psF64) y, myPoly->nX-1, myPoly->nY-1);
+                buildSums((psF64) x, (psF64) y, myPoly->COOL_2D_nX, myPoly->COOL_2D_nY);
 
                 /************************************************************
@@ -427 +425 @@
     // coefficients to 0.0, if necessary.
     //
+    // XXX: Verify this works after poly nOrder/nTerm change.
+    //
     if (oldPolyX != -1) {
-        myPoly->nX = oldPolyX;
-        for (i=oldPolyX ; i < myPoly->nX ; i++) {
-            for (j=0;j<myPoly->nY ; j++) {
+        myPoly->COOL_2D_nX = oldPolyX;
+        for (i=oldPolyX ; i < (1 + myPoly->COOL_2D_nX) ; i++) {
+            for (j=0;j<(1 + myPoly->COOL_2D_nY) ; j++) {
                 myPoly->coeff[i][j] = 0.0;
             }
@@ -436 +436 @@
     }
     if (oldPolyY != -1) {
-        myPoly->nY = oldPolyY;
-        for (i=0 ; i < myPoly->nX ; i++) {
-            for (j=oldPolyY;j<myPoly->nY ; j++) {
+        myPoly->COOL_2D_nY = oldPolyY;
+        for (i=0 ; i < (1 + myPoly->COOL_2D_nX) ; i++) {
+            for (j=oldPolyY;j < (1 + myPoly->COOL_2D_nY) ; j++) {
                 myPoly->coeff[i][j] = 0.0;
             }