Index: trunk/psModules/src/objects/pmTrend2D.c
===================================================================
--- trunk/psModules/src/objects/pmTrend2D.c	(revision 16065)
+++ trunk/psModules/src/objects/pmTrend2D.c	(revision 19961)
@@ -3,6 +3,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2008-01-15 02:47:51 $
+ *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2008-10-07 22:47:04 $
  *  Copyright 2004 Institute for Astronomy, University of Hawaii
  *
@@ -13,70 +13,66 @@
 #endif
 
-# include <strings.h>
-# include <pslib.h>
-# include "pmTrend2D.h"
-
-static void pmTrend2DFree (pmTrend2D *trend) {
-
-    if (trend == NULL) 
-        return;
-
-    psFree (trend->stats);
-    psFree (trend->poly);
-    psFree (trend->map);
+#include <strings.h>
+#include <pslib.h>
+#include "pmTrend2D.h"
+
+static void pmTrend2DFree(pmTrend2D *trend)
+{
+    psFree(trend->stats);
+    psFree(trend->poly);
+    psFree(trend->map);
     return;
 }
 
-pmTrend2D *pmTrend2DAlloc (pmTrend2DMode mode, psImage *image, int nXtrend, int nYtrend, psStats *stats)
-{
-    PS_ASSERT_PTR_NON_NULL(stats, NULL);
+pmTrend2D *pmTrend2DAlloc(pmTrend2DMode mode, psImage *image, int nXtrend, int nYtrend, psStats *stats)
+{
     if (mode == PM_TREND_MAP) {
-        PS_ASSERT_PTR_NON_NULL(image, NULL);
-    }
-
-    pmTrend2D *trend = (pmTrend2D *) psAlloc(sizeof(pmTrend2D));
-    psMemSetDeallocator(trend, (psFreeFunc) pmTrend2DFree);
+        psAssert(image, "Need an image for MAP trend mode");
+    }
+
+    pmTrend2D *trend = psAlloc(sizeof(pmTrend2D));
+    psMemSetDeallocator(trend, (psFreeFunc)pmTrend2DFree);
 
     trend->map = NULL;
     trend->poly = NULL;
-    trend->stats = psMemIncrRefCounter (stats);
+    trend->stats = psMemIncrRefCounter(stats);
     trend->mode = mode;
-	
-    switch (mode) {
-      case PM_TREND_POLY_ORD:
-	trend->poly = psPolynomial2DAlloc (PS_POLYNOMIAL_ORD, nXtrend, nYtrend);
-	// set masking somehow
- 	for (int nx = 0; nx < trend->poly->nX + 1; nx++) {
-	    for (int ny = 0; ny < trend->poly->nY + 1; ny++) {
-		if (nx + ny >= PS_MAX (trend->poly->nX, trend->poly->nY) + 1) {
-		    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_SET;
-		} else {
-		    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_NONE;
-		}
-	    }
-	}
-	break;
-
-      case PM_TREND_POLY_CHEB:
-	trend->poly = psPolynomial2DAlloc (PS_POLYNOMIAL_CHEB, nXtrend, nYtrend);
-	break;
+
+    switch (mode) {
+      case PM_TREND_POLY_ORD:
+        trend->poly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, nXtrend, nYtrend);
+        // set masking somehow
+        for (int nx = 0; nx < trend->poly->nX + 1; nx++) {
+            for (int ny = 0; ny < trend->poly->nY + 1; ny++) {
+                if (nx + ny >= PS_MAX (trend->poly->nX, trend->poly->nY) + 1) {
+                    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_SET;
+                } else {
+                    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_NONE;
+                }
+            }
+        }
+        break;
+
+      case PM_TREND_POLY_CHEB:
+        trend->poly = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, nXtrend, nYtrend);
+        break;
 
       case PM_TREND_MAP: {
-	  // binning defines the map scale relationship
-	  psImageBinning *binning = psImageBinningAlloc();
-	  binning->nXruff = nXtrend;
-	  binning->nYruff = nYtrend;
-	  binning->nXfine = image->numCols;
-	  binning->nYfine = image->numRows;
-
-	  trend->map = psImageMapAlloc (image, binning, stats);
-	  psFree (binning);
-	  break;
+          // binning defines the map scale relationship
+          psImageBinning *binning = psImageBinningAlloc();
+          binning->nXruff = nXtrend;
+          binning->nYruff = nYtrend;
+          binning->nXfine = image->numCols;
+          binning->nYfine = image->numRows;
+
+          trend->map = psImageMapAlloc(image, binning, stats);
+          psFree(binning);
+          break;
       }
       // XXX: Put a more graceful error here.
       default:
-	psAbort ("error");
-    }
-    return (trend);
+        psAbort("error");
+    }
+    return trend;
 }
 
@@ -87,103 +83,105 @@
 }
 
-pmTrend2D *pmTrend2DNoImageAlloc (pmTrend2DMode mode, psImageBinning *binning, psStats *stats)
+pmTrend2D *pmTrend2DNoImageAlloc(pmTrend2DMode mode, psImageBinning *binning, psStats *stats)
 {
     if (mode == PM_TREND_MAP) {
-        PS_ASSERT_PTR_NON_NULL(binning, NULL);
-        PS_ASSERT_PTR_NON_NULL(stats, NULL);
-    }
-    pmTrend2D *trend = (pmTrend2D *) psAlloc(sizeof(pmTrend2D));
-    psMemSetDeallocator(trend, (psFreeFunc) pmTrend2DFree);
+        psAssert(binning, "Need binning for MAP mode");
+    }
+    pmTrend2D *trend = psAlloc(sizeof(pmTrend2D));
+    psMemSetDeallocator(trend, (psFreeFunc)pmTrend2DFree);
 
     trend->map = NULL;
     trend->poly = NULL;
-    trend->stats = psMemIncrRefCounter (stats);
+    trend->stats = psMemIncrRefCounter(stats);
     trend->mode = mode;
-	
-    switch (mode) {
-      case PM_TREND_POLY_ORD:
-	trend->poly = psPolynomial2DAlloc (PS_POLYNOMIAL_ORD, binning->nXruff, binning->nYruff);
-	// set masking somehow
- 	for (int nx = 0; nx < trend->poly->nX + 1; nx++) {
-	    for (int ny = 0; ny < trend->poly->nY + 1; ny++) {
-		if (nx + ny >= PS_MAX (trend->poly->nX, trend->poly->nY) + 1) {
-		    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_SET;
-		} else {
-		    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_NONE;
-		}
-	    }
-	}
-	break;
-
-      case PM_TREND_POLY_CHEB:
-	trend->poly = psPolynomial2DAlloc (PS_POLYNOMIAL_CHEB, binning->nXruff, binning->nYruff);
-	break;
+
+    switch (mode) {
+      case PM_TREND_POLY_ORD:
+        trend->poly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, binning->nXruff, binning->nYruff);
+        // set masking somehow
+        for (int nx = 0; nx < trend->poly->nX + 1; nx++) {
+            for (int ny = 0; ny < trend->poly->nY + 1; ny++) {
+                if (nx + ny >= PS_MAX (trend->poly->nX, trend->poly->nY) + 1) {
+                    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_SET;
+                } else {
+                    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_NONE;
+                }
+            }
+        }
+        break;
+
+      case PM_TREND_POLY_CHEB:
+        trend->poly = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, binning->nXruff, binning->nYruff);
+        break;
 
       case PM_TREND_MAP: {
-	  // binning defines the map scale relationship
-	  trend->map = psImageMapNoImageAlloc (binning, stats);
-	  break;
+          // binning defines the map scale relationship
+          trend->map = psImageMapNoImageAlloc(binning, stats);
+          break;
       }
 
       default:
-	psAbort ("error");
-    }
-    return (trend);
-}
-
-pmTrend2D *pmTrend2DFieldAlloc (pmTrend2DMode mode, int nXfield, int nYfield, int nXtrend, int nYtrend, psStats *stats)
-{
-    PS_ASSERT_PTR_NON_NULL(stats, NULL);
-    pmTrend2D *trend = (pmTrend2D *) psAlloc(sizeof(pmTrend2D));
-    psMemSetDeallocator(trend, (psFreeFunc) pmTrend2DFree);
+        psAbort("error");
+    }
+    return trend;
+}
+
+pmTrend2D *pmTrend2DFieldAlloc(pmTrend2DMode mode, int nXfield, int nYfield,
+                               int nXtrend, int nYtrend, psStats *stats)
+{
+    psAssert(stats, "Require statistics");
+
+    pmTrend2D *trend = psAlloc(sizeof(pmTrend2D));
+    psMemSetDeallocator(trend, (psFreeFunc)pmTrend2DFree);
 
     trend->map = NULL;
     trend->poly = NULL;
-    trend->stats = psMemIncrRefCounter (stats);
+    trend->stats = psMemIncrRefCounter(stats);
     trend->mode = mode;
-	
-    switch (mode) {
-      case PM_TREND_POLY_ORD:
-	trend->poly = psPolynomial2DAlloc (PS_POLYNOMIAL_ORD, nXtrend, nYtrend);
-	// set masking somehow
- 	for (int nx = 0; nx < trend->poly->nX + 1; nx++) {
-	    for (int ny = 0; ny < trend->poly->nY + 1; ny++) {
-		if (nx + ny >= PS_MAX (trend->poly->nX, trend->poly->nY) + 1) {
-		    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_SET;
-		} else {
-		    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_NONE;
-		}
-	    }
-	}
-	break;
-
-      case PM_TREND_POLY_CHEB:
-	trend->poly = psPolynomial2DAlloc (PS_POLYNOMIAL_CHEB, nXtrend, nYtrend);
-	break;
+
+    switch (mode) {
+      case PM_TREND_POLY_ORD:
+        trend->poly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, nXtrend, nYtrend);
+        // set masking somehow
+        for (int nx = 0; nx < trend->poly->nX + 1; nx++) {
+            for (int ny = 0; ny < trend->poly->nY + 1; ny++) {
+                if (nx + ny >= PS_MAX (trend->poly->nX, trend->poly->nY) + 1) {
+                    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_SET;
+                } else {
+                    trend->poly->coeffMask[nx][ny] = PS_POLY_MASK_NONE;
+                }
+            }
+        }
+        break;
+
+      case PM_TREND_POLY_CHEB:
+        trend->poly = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, nXtrend, nYtrend);
+        break;
 
       case PM_TREND_MAP: {
-	  // binning defines the map scale relationship
-	  psImageBinning *binning = psImageBinningAlloc();
-	  binning->nXfine = nXfield;
-	  binning->nYfine = nYfield;
-	  binning->nXruff = nXtrend;
-	  binning->nYruff = nYtrend;
-
-	  trend->map = psImageMapAlloc (NULL, binning, stats);
-	  psFree (binning);
-	  break;
+          // binning defines the map scale relationship
+          psImageBinning *binning = psImageBinningAlloc();
+          binning->nXfine = nXfield;
+          binning->nYfine = nYfield;
+          binning->nXruff = nXtrend;
+          binning->nYruff = nYtrend;
+
+          trend->map = psImageMapAlloc(NULL, binning, stats);
+          psFree (binning);
+          break;
       }
 
       default:
         // XXX: Put a more graceful error here.
-	psAbort ("error");
-    }
-    return (trend);
-}
-
-bool pmTrend2DFit (pmTrend2D *trend, psVector *mask, psMaskType maskVal, psVector *x,
-                   psVector *y, psVector *f, psVector *df)
-{
-    PS_ASSERT_PTR_NON_NULL(trend, false);
+        psAbort("error");
+    }
+    return trend;
+}
+
+bool pmTrend2DFit(pmTrend2D *trend, psVector *mask, psMaskType maskVal, const psVector *x,
+                  const psVector *y, const psVector *f, const psVector *df)
+{
+    PM_ASSERT_TREND2D_NON_NULL(trend, false);
+    PM_ASSERT_TREND2D_STATS(trend, false);
     PS_ASSERT_VECTOR_NON_NULL(x, false);
     PS_ASSERT_VECTOR_NON_NULL(y, false);
@@ -194,25 +192,28 @@
       case PM_TREND_POLY_ORD:
       case PM_TREND_POLY_CHEB:
-        status = psVectorClipFitPolynomial2D (trend->poly, trend->stats, mask, maskVal, f, df, x, y);
-	// we can use the API here which adjusts the polynomial order based on the number
-	// of points in the image, and potentially based on the fractional range of the
-	// data?
-	break;
-
-      case PM_TREND_MAP:
-	// XXX supply fraction from trend elements
-	// XXX need to add the API which adjusts the scale
-	status = psImageMapClipFit (trend->map, trend->stats, mask, maskVal, x, y, f, df);
-	break;
-
-      default:
-	psAbort ("error");
+        status = psVectorClipFitPolynomial2D(trend->poly, trend->stats, mask, maskVal, f, df, x, y);
+        // we can use the API here which adjusts the polynomial order based on the number
+        // of points in the image, and potentially based on the fractional range of the
+        // data?
+        break;
+
+      case PM_TREND_MAP:
+        // XXX supply fraction from trend elements
+        // XXX need to add the API which adjusts the scale
+        status = psImageMapClipFit(trend->map, trend->stats, mask, maskVal, x, y, f, df);
+        break;
+
+      default:
+        psAbort ("error");
     }
     return status;
 }
 
-double pmTrend2DEval (pmTrend2D *trend, float x, float y)
-{
-    if (!trend) return 0.0;
+double pmTrend2DEval(const pmTrend2D *trend, float x, float y)
+{
+    // This might be in a tight loop, so no complicated assertions
+    if (!trend) {
+        return 0.0;
+    }
 
     double result;
@@ -220,20 +221,20 @@
       case PM_TREND_POLY_ORD:
       case PM_TREND_POLY_CHEB:
-	result = psPolynomial2DEval (trend->poly, x, y);
-	break;
-
-      case PM_TREND_MAP:
-	result = psImageMapEval (trend->map, x, y);
-	break;
-
-      default:
-	psAbort ("error");
+        result = psPolynomial2DEval(trend->poly, x, y);
+        break;
+
+      case PM_TREND_MAP:
+        result = psImageMapEval(trend->map, x, y);
+        break;
+
+      default:
+        psAbort ("error");
     }
     return result;
 }
 
-psVector *pmTrend2DEvalVector (pmTrend2D *trend, psVector *x, psVector *y)
-{
-    PS_ASSERT_PTR_NON_NULL(trend, NULL);
+psVector *pmTrend2DEvalVector(const pmTrend2D *trend, const psVector *x, const psVector *y)
+{
+    PM_ASSERT_TREND2D_NON_NULL(trend, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, false);
     PS_ASSERT_VECTOR_NON_NULL(y, false);
@@ -243,58 +244,55 @@
       case PM_TREND_POLY_ORD:
       case PM_TREND_POLY_CHEB:
-	result = psPolynomial2DEvalVector (trend->poly, x, y);
-	break;
-
-      case PM_TREND_MAP:
-	result = psImageMapEvalVector (trend->map, x, y);
-	break;
-
-      default:
-	psAbort ("error");
+        result = psPolynomial2DEvalVector (trend->poly, x, y);
+        break;
+
+      case PM_TREND_MAP:
+        result = psImageMapEvalVector (trend->map, x, y);
+        break;
+
+      default:
+        psAbort ("error");
     }
     return result;
 }
 
-psString pmTrend2DModeToString (pmTrend2DMode mode) {
-    
-    psString name;
-
+psString pmTrend2DModeToString(pmTrend2DMode mode)
+{
     switch (mode) {
       case PM_TREND_NONE:
-	name = psStringCopy ("NONE");
-	break;
-      case PM_TREND_POLY_ORD:
-	name = psStringCopy ("POLY_ORD");
-	break;
-      case PM_TREND_POLY_CHEB:
-	name = psStringCopy ("POLY_CHEB");
-	break;
-      case PM_TREND_MAP:
-	name = psStringCopy ("MAP");
-	break;
-      default:
-        psError (PS_ERR_UNKNOWN, true, "Unknown pmTrend2D mode\n");
-	psAbort ("invalid mode %d", mode);
-    }
-    return name;
-}
-
-pmTrend2DMode pmTrend2DModeFromString (psString name) {
-
-    if (!name) return PM_TREND_NONE;
-
-    if (!strcasecmp (name, "NONE")) {
-	return PM_TREND_NONE;
-    }
-    if (!strcasecmp (name, "POLY_ORD")) {
-	return PM_TREND_POLY_ORD;
-    }
-    if (!strcasecmp (name, "POLY_CHEB")) {
-	return PM_TREND_POLY_CHEB;
-    }
-    if (!strcasecmp (name, "MAP")) {
-	return PM_TREND_MAP;
-    }
-    psError (PS_ERR_UNKNOWN, true, "Unknown pmTrend2D mode %s\n", name);
+        return psStringCopy("NONE");
+      case PM_TREND_POLY_ORD:
+        return psStringCopy("POLY_ORD");
+        break;
+      case PM_TREND_POLY_CHEB:
+        return psStringCopy("POLY_CHEB");
+      case PM_TREND_MAP:
+        return psStringCopy("MAP");
+        break;
+      default:
+        psError(PS_ERR_UNKNOWN, true, "Unknown pmTrend2D mode");
+    }
+    psAbort("invalid mode %d", mode);
+}
+
+pmTrend2DMode pmTrend2DModeFromString(psString name)
+ {
+    if (!name) {
+        return PM_TREND_NONE;
+    }
+
+    if (!strcasecmp(name, "NONE")) {
+        return PM_TREND_NONE;
+    }
+    if (!strcasecmp(name, "POLY_ORD")) {
+        return PM_TREND_POLY_ORD;
+    }
+    if (!strcasecmp(name, "POLY_CHEB")) {
+        return PM_TREND_POLY_CHEB;
+    }
+    if (!strcasecmp(name, "MAP")) {
+        return PM_TREND_MAP;
+    }
+    psError(PS_ERR_UNKNOWN, true, "Unknown pmTrend2D mode %s", name);
     return PM_TREND_NONE;
 }