Index: /trunk/psLib/src/math/psPolynomial.c
===================================================================
--- /trunk/psLib/src/math/psPolynomial.c	(revision 15252)
+++ /trunk/psLib/src/math/psPolynomial.c	(revision 15253)
@@ -7,6 +7,6 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.157 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2007-01-09 22:38:53 $
+*  @version $Revision: 1.158 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2007-10-09 19:24:46 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -95,5 +95,5 @@
     psFree(poly->coeff);
     psFree(poly->coeffErr);
-    psFree(poly->mask);
+    psFree(poly->coeffMask);
 }
 
@@ -105,9 +105,9 @@
         psFree(poly->coeff[x]);
         psFree(poly->coeffErr[x]);
-        psFree(poly->mask[x]);
+        psFree(poly->coeffMask[x]);
     }
     psFree(poly->coeff);
     psFree(poly->coeffErr);
-    psFree(poly->mask);
+    psFree(poly->coeffMask);
 }
 
@@ -121,14 +121,14 @@
             psFree(poly->coeff[x][y]);
             psFree(poly->coeffErr[x][y]);
-            psFree(poly->mask[x][y]);
+            psFree(poly->coeffMask[x][y]);
         }
         psFree(poly->coeff[x]);
         psFree(poly->coeffErr[x]);
-        psFree(poly->mask[x]);
+        psFree(poly->coeffMask[x]);
     }
 
     psFree(poly->coeff);
     psFree(poly->coeffErr);
-    psFree(poly->mask);
+    psFree(poly->coeffMask);
 }
 
@@ -144,18 +144,18 @@
                 psFree(poly->coeff[x][y][z]);
                 psFree(poly->coeffErr[x][y][z]);
-                psFree(poly->mask[x][y][z]);
+                psFree(poly->coeffMask[x][y][z]);
             }
             psFree(poly->coeff[x][y]);
             psFree(poly->coeffErr[x][y]);
-            psFree(poly->mask[x][y]);
+            psFree(poly->coeffMask[x][y]);
         }
         psFree(poly->coeff[x]);
         psFree(poly->coeffErr[x]);
-        psFree(poly->mask[x]);
+        psFree(poly->coeffMask[x]);
     }
 
     psFree(poly->coeff);
     psFree(poly->coeffErr);
-    psFree(poly->mask);
+    psFree(poly->coeffMask);
 }
 
@@ -221,5 +221,5 @@
 
     for (loop_x = 0; loop_x < poly->nX+1; loop_x++) {
-        if (poly->mask[loop_x] == 0) {
+        if (!(poly->coeffMask[loop_x] & PS_POLY_MASK_SET)) {
             psTrace("psLib.math", 8,
                     "polysum+= sum*coeff [%lf+= (%lf * %lf)\n", polySum, xSum, poly->coeff[loop_x]);
@@ -251,5 +251,5 @@
     // Special case where the Chebyshev poly is constant.
     if (nTerms == 1) {
-        if (poly->mask[0] == 0) {
+        if (!(poly->coeffMask[0] & PS_POLY_MASK_SET)) {
             tmp += poly->coeff[0];
         }
@@ -259,8 +259,8 @@
     // Special case where the Chebyshev poly is linear.
     if (nTerms == 2) {
-        if (poly->mask[0] == 0) {
+        if (!(poly->coeffMask[0] & PS_POLY_MASK_SET)) {
             tmp+= poly->coeff[0];
         }
-        if (poly->mask[1] == 0) {
+        if (!(poly->coeffMask[1] & PS_POLY_MASK_SET)) {
             tmp+= poly->coeff[1] * x;
         }
@@ -271,5 +271,5 @@
         // General case where the Chebyshev poly has 2 or more terms.
         d = psVectorAlloc(nTerms, PS_TYPE_F64);
-        if(poly->mask[nTerms-1] == 0) {
+        if (!(poly->coeffMask[nTerms-1] & PS_POLY_MASK_SET)) {
             d->data.F64[nTerms-1] = poly->coeff[nTerms-1];
         } else {
@@ -278,5 +278,5 @@
 
         d->data.F64[nTerms-2] = (2.0 * x * d->data.F64[nTerms-1]);
-        if(poly->mask[nTerms-2] == 0) {
+        if (!(poly->coeffMask[nTerms-2] & PS_POLY_MASK_SET)) {
             d->data.F64[nTerms-2] += poly->coeff[nTerms-2];
         }
@@ -284,5 +284,5 @@
         for (i=nTerms-3;i>=1;i--) {
             d->data.F64[i] = (2.0 * x * d->data.F64[i+1]) - (d->data.F64[i+2]);
-            if(poly->mask[i] == 0) {
+            if (!(poly->coeffMask[i] & PS_POLY_MASK_SET)) {
                 d->data.F64[i] += poly->coeff[i];
             }
@@ -290,5 +290,5 @@
 
         tmp = (x * d->data.F64[1]) - (d->data.F64[2]);
-        if(poly->mask[0] == 0) {
+        if (!(poly->coeffMask[0] & PS_POLY_MASK_SET)) {
             tmp += (0.5 * poly->coeff[0]);
         }
@@ -328,5 +328,5 @@
         ySum = xSum;
         for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
-            if (poly->mask[loop_x][loop_y] == 0) {
+            if (!(poly->coeffMask[loop_x][loop_y] & PS_POLY_MASK_SET)) {
                 polySum += ySum * poly->coeff[loop_x][loop_y];
             }
@@ -364,5 +364,5 @@
     for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
         for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
-            if (poly->mask[loop_x][loop_y] == 0) {
+            if (!(poly->coeffMask[loop_x][loop_y] & PS_POLY_MASK_SET)) {
                 polySum += poly->coeff[loop_x][loop_y] *
                            psPolynomial1DEval(chebPolys[loop_x], x) *
@@ -396,5 +396,5 @@
             zSum = ySum;
             for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
-                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
+                if (!(poly->coeffMask[loop_x][loop_y][loop_z] & PS_POLY_MASK_SET)) {
                     polySum += zSum * poly->coeff[loop_x][loop_y][loop_z];
                 }
@@ -439,5 +439,5 @@
         for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
             for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
-                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
+                if (!(poly->coeffMask[loop_x][loop_y][loop_z] & PS_POLY_MASK_SET)) {
                     polySum += poly->coeff[loop_x][loop_y][loop_z] *
                                psPolynomial1DEval(chebPolys[loop_x], x) *
@@ -479,5 +479,5 @@
                 tSum = zSum;
                 for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
-                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
+                    if (!(poly->coeffMask[loop_x][loop_y][loop_z][loop_t] & PS_POLY_MASK_SET)) {
                         polySum += tSum * poly->coeff[loop_x][loop_y][loop_z][loop_t];
                     }
@@ -532,5 +532,5 @@
             for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
                 for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
-                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
+                    if (!(poly->coeffMask[loop_x][loop_y][loop_z][loop_t] & PS_POLY_MASK_SET)) {
                         polySum += poly->coeff[loop_x][loop_y][loop_z][loop_t] *
                                    psPolynomial1DEval(chebPolys[loop_x], x) *
@@ -596,9 +596,9 @@
     newPoly->coeff = psAlloc((nOrder + 1) * sizeof(psF64));
     newPoly->coeffErr = psAlloc((nOrder + 1) * sizeof(psF64));
-    newPoly->mask = (psMaskType *)psAlloc((nOrder + 1) * sizeof(psMaskType));
+    newPoly->coeffMask = (psMaskType *)psAlloc((nOrder + 1) * sizeof(psMaskType));
     for (psU32 i = 0; i < (nOrder + 1); i++) {
         newPoly->coeff[i] = 0.0;
         newPoly->coeffErr[i] = 0.0;
-        newPoly->mask[i] = 0;
+        newPoly->coeffMask[i] = PS_POLY_MASK_NONE;
     }
 
@@ -626,9 +626,9 @@
     newPoly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
     newPoly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
-    newPoly->mask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
+    newPoly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
     for (x = 0; x < (1 + nX); x++) {
         newPoly->coeff[x] = psAlloc((1 + nY) * sizeof(psF64));
         newPoly->coeffErr[x] = psAlloc((1 + nY) * sizeof(psF64));
-        newPoly->mask[x] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
+        newPoly->coeffMask[x] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
     }
     for (x = 0; x < (1 + nX); x++) {
@@ -636,5 +636,5 @@
             newPoly->coeff[x][y] = 0.0;
             newPoly->coeffErr[x][y] = 0.0;
-            newPoly->mask[x][y] = 0;
+            newPoly->coeffMask[x][y] = PS_POLY_MASK_NONE;
         }
     }
@@ -661,9 +661,9 @@
             psFree (poly->coeff[i]);
             psFree (poly->coeffErr[i]);
-            psFree (poly->mask[i]);
+            psFree (poly->coeffMask[i]);
         }
         psFree (poly->coeff);
         psFree (poly->coeffErr);
-        psFree (poly->mask);
+        psFree (poly->coeffMask);
 
         poly->type = type;
@@ -673,9 +673,9 @@
         poly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
         poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
-        poly->mask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
+        poly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
         for (int i = 0; i < (1 + nX); i++) {
             poly->coeff[i] = psAlloc((1 + nY) * sizeof(psF64));
             poly->coeffErr[i] = psAlloc((1 + nY) * sizeof(psF64));
-            poly->mask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
+            poly->coeffMask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
         }
     }
@@ -684,5 +684,5 @@
             poly->coeff[i][j] = 0.0;
             poly->coeffErr[i][j] = 0.0;
-            poly->mask[i][j] = 0;
+            poly->coeffMask[i][j] = PS_POLY_MASK_NONE;
         }
     }
@@ -704,5 +704,5 @@
             out->coeff[i][j] = poly->coeff[i][j];
             out->coeffErr[i][j] = poly->coeffErr[i][j];
-            out->mask[i][j] = poly->mask[i][j];
+            out->coeffMask[i][j] = poly->coeffMask[i][j];
         }
     }
@@ -737,13 +737,13 @@
     newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 **));
     newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 **));
-    newPoly->mask = (psMaskType ***)psAlloc((nX + 1) * sizeof(psMaskType **));
+    newPoly->coeffMask = (psMaskType ***)psAlloc((nX + 1) * sizeof(psMaskType **));
     for (x = 0; x < (1 + nX); x++) {
         newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 *));
         newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 *));
-        newPoly->mask[x] = (psMaskType **)psAlloc((nY + 1) * sizeof(psMaskType *));
+        newPoly->coeffMask[x] = (psMaskType **)psAlloc((nY + 1) * sizeof(psMaskType *));
         for (y = 0; y < (nY + 1); y++) {
             newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
             newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
-            newPoly->mask[x][y] = (psMaskType *)psAlloc((nZ + 1) * sizeof(psMaskType));
+            newPoly->coeffMask[x][y] = (psMaskType *)psAlloc((nZ + 1) * sizeof(psMaskType));
         }
     }
@@ -753,5 +753,5 @@
                 newPoly->coeff[x][y][z] = 0.0;
                 newPoly->coeffErr[x][y][z] = 0.0;
-                newPoly->mask[x][y][z] = 0;
+                newPoly->coeffMask[x][y][z] = PS_POLY_MASK_NONE;
             }
         }
@@ -792,17 +792,17 @@
     newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 ***));
     newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 ***));
-    newPoly->mask = (psMaskType ****)psAlloc((nX + 1) * sizeof(psMaskType ***));
+    newPoly->coeffMask = (psMaskType ****)psAlloc((nX + 1) * sizeof(psMaskType ***));
     for (x = 0; x < (nX + 1); x++) {
         newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 **));
         newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 **));
-        newPoly->mask[x] = (psMaskType ***)psAlloc((nY + 1) * sizeof(psMaskType **));
+        newPoly->coeffMask[x] = (psMaskType ***)psAlloc((nY + 1) * sizeof(psMaskType **));
         for (y = 0; y < (nY + 1); y++) {
             newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
             newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
-            newPoly->mask[x][y] = (psMaskType **)psAlloc((nZ + 1) * sizeof(psMaskType *));
+            newPoly->coeffMask[x][y] = (psMaskType **)psAlloc((nZ + 1) * sizeof(psMaskType *));
             for (z = 0; z < (nZ + 1); z++) {
                 newPoly->coeff[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
                 newPoly->coeffErr[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
-                newPoly->mask[x][y][z] = (psMaskType *)psAlloc((nT + 1) * sizeof(psMaskType));
+                newPoly->coeffMask[x][y][z] = (psMaskType *)psAlloc((nT + 1) * sizeof(psMaskType));
             }
         }
@@ -814,5 +814,5 @@
                     newPoly->coeff[x][y][z][t] = 0.0;
                     newPoly->coeffErr[x][y][z][t] = 0.0;
-                    newPoly->mask[x][y][z][t] = 0;
+                    newPoly->coeffMask[x][y][z][t] = PS_POLY_MASK_NONE;
                 }
             }
Index: /trunk/psLib/src/math/psPolynomial.h
===================================================================
--- /trunk/psLib/src/math/psPolynomial.h	(revision 15252)
+++ /trunk/psLib/src/math/psPolynomial.h	(revision 15253)
@@ -8,6 +8,6 @@
  * @author GLG, MHPCC
  *
- * @version $Revision: 1.68 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-08-09 01:40:07 $
+ * @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-10-09 19:24:46 $
  *
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -27,4 +27,11 @@
 #include "psVector.h"
 #include "psScalar.h"
+
+typedef enum {
+    PS_POLY_MASK_NONE = 0,
+    PS_POLY_MASK_SET  = 1, // the coefficient should not be used (implies MASK_FIT)
+    PS_POLY_MASK_FIT  = 2, // the coefficient should not be fitted 
+    PS_POLY_MASK_BOTH = 3, // the coefficient should not be fitted 
+} psPolynomialMaskValues;
 
 /** Evaluate a non-normalized Gaussian with the given mean and sigma at the
@@ -60,5 +67,5 @@
     psF64 *coeff;                       ///< Coefficients
     psF64 *coeffErr;                    ///< Error in coefficients
-    psMaskType *mask;                   ///< Coefficient mask
+    psMaskType *coeffMask;		///< Coefficient mask
 }
 psPolynomial1D;
@@ -72,5 +79,5 @@
     psF64 **coeff;                      ///< Coefficients
     psF64 **coeffErr;                   ///< Error in coefficients
-    psMaskType **mask;                  ///< Coefficients mask
+    psMaskType **coeffMask;                  ///< Coefficients mask
 }
 psPolynomial2D;
@@ -85,5 +92,5 @@
     psF64 ***coeff;                     ///< Coefficients
     psF64 ***coeffErr;                  ///< Error in coefficients
-    psMaskType ***mask;                 ///< Coefficients mask
+    psMaskType ***coeffMask;                 ///< Coefficients mask
 }
 psPolynomial3D;
@@ -93,11 +100,11 @@
 {
     psPolynomialType type;              ///< Polynomial type
-    unsigned int nX;            ///< Polynomial order in x
-    unsigned int nY;            ///< Polynomial order in y
-    unsigned int nZ;            ///< Polynomial order in z
-    unsigned int nT;            ///< Polynomial order in t
+    unsigned int nX;			///< Polynomial order in x
+    unsigned int nY;			///< Polynomial order in y
+    unsigned int nZ;			///< Polynomial order in z
+    unsigned int nT;			///< Polynomial order in t
     psF64 ****coeff;                    ///< Coefficients
     psF64 ****coeffErr;                 ///< Error in coefficients
-    psMaskType ****mask;                ///< Coefficients mask
+    psMaskType ****coeffMask;		///< Coefficients mask
 }
 psPolynomial4D;