Index: trunk/psModules/src/imcombine/pmSubtraction.c
===================================================================
--- trunk/psModules/src/imcombine/pmSubtraction.c	(revision 14195)
+++ trunk/psModules/src/imcombine/pmSubtraction.c	(revision 14197)
@@ -4,6 +4,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-07-13 20:28:28 $
+ *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-07-13 20:55:26 $
  *
  *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
@@ -25,5 +25,5 @@
 #include "pmSubtraction.h"
 
-//#define CAN_PASS_STATIC_INLINE          // Can I pass the address of a static inline function?
+#define USE_FUNCTIONS_INSTEAD_OF_MACROS          // Can I pass the address of a static inline function?
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -55,5 +55,5 @@
 }
 
-#ifndef CAN_PASS_STATIC_INLINE
+#ifndef USE_FUNCTIONS_INSTEAD_OF_MACROS
 // Generate an image of the solved kernel
 // Meant to replace the following function declaration:
@@ -193,19 +193,20 @@
           /* SPAM and FRIES use the same method */
           case PM_SUBTRACTION_KERNEL_SPAM:
-          case PM_SUBTRACTION_KERNEL_FRIES:
-            int uStart = kernels->u->data.S32[i];
-            int uStop = kernels->uStop->data.S32[i];
-            int vStart = kernels->v->data.S32[i];
-            int vStop = kernels->vStop->data.S32[i];
-            for (int v = vStart; v <= vStop; v++) {
-                for (int u = uStart; u <= uStop; u++) {
-                    kernel->kernel[v][u] += value;
-                }
-            }
-            if (kernels->spatialOrder > 0 && i != kernels->subIndex) {
-                /* The (0,0) element is subtracted from most kernels to preserve photometric scaling */
-                kernel->kernel[0][0] += subValue;
-            }
-            break;
+          case PM_SUBTRACTION_KERNEL_FRIES: {
+              int uStart = kernels->u->data.S32[i];
+              int uStop = kernels->uStop->data.S32[i];
+              int vStart = kernels->v->data.S32[i];
+              int vStop = kernels->vStop->data.S32[i];
+              for (int v = vStart; v <= vStop; v++) {
+                  for (int u = uStart; u <= uStop; u++) {
+                      kernel->kernel[v][u] += value;
+                  }
+              }
+              if (kernels->spatialOrder > 0 && i != kernels->subIndex) {
+                  /* The (0,0) element is subtracted from most kernels to preserve photometric scaling */
+                  kernel->kernel[0][0] += subValue;
+              }
+              break;
+          }
           case PM_SUBTRACTION_KERNEL_ISIS: {
               psKernel *preCalc = kernels->preCalc->data[i];// Precalculated values
@@ -231,5 +232,5 @@
 #endif
 
-#ifndef CAN_PASS_STATIC_INLINE
+#ifndef USE_FUNCTIONS_INSTEAD_OF_MACROS
 // Generate the convolved pixel value
 // Meant to replace the following function declaration:
@@ -274,13 +275,15 @@
           int vStart = (KERNELS)->v->data.S32[(INDEX)]; \
           int vStop = (KERNELS)->vStop->data.S32[(INDEX)]; \
+          double sum = 0.0; \
           for (int v = vStart; v <= vStop; v++) { \
               for (int u = uStart; u <= uStop; u++) { \
-                  (TARGET) += FUNC(polyValue) * (IMAGE)->data.F32[(Y) + v][(X) + u]; \
+                  sum += FUNC(polyValue) * (IMAGE)->data.F32[(Y) + v][(X) + u]; \
               } \
           } \
           if ((KERNELS)->spatialOrder > 0 && (INDEX) != (KERNELS)->subIndex) { \
               /* The (0,0) element is subtracted from most kernels to preserve photometric scaling */ \
-              (TARGET) += FUNC(-1.0) * (IMAGE)->data.F32[(Y)][(X)]; \
+              sum += FUNC(-1.0) * (IMAGE)->data.F32[(Y)][(X)]; \
           } \
+          (TARGET) = sum;
           break; \
       } \
@@ -340,14 +343,15 @@
           int vStart = kernels->v->data.S32[index];
           int vStop = kernels->vStop->data.S32[index];
+          double sum = 0.0;
           for (int v = vStart; v <= vStop; v++) {
               for (int u = uStart; u <= uStop; u++) {
-                  value += weightFunc(polyValue) * image->data.F32[y + v][x + u];
+                  sum += weightFunc(polyValue) * image->data.F32[y + v][x + u];
               }
           }
           if (kernels->spatialOrder > 0 && index != kernels->subIndex) {
               /* The (0,0) element is subtracted from most kernels to preserve photometric scaling */
-              value += weightFunc(-1.0) * image->data.F32[y][x];
+              sum += weightFunc(-1.0) * image->data.F32[y][x];
           }
-          break;
+          return sum;
       }
       case PM_SUBTRACTION_KERNEL_ISIS: {
@@ -582,5 +586,5 @@
                     // Generate the convolutions
                     for (int i = 0; i < numKernels; i++) {
-#ifdef CAN_PASS_STATIC_INLINE
+#ifdef USE_FUNCTIONS_INSTEAD_OF_MACROS
                         convolutions->data.F64[i] = convolvePixel(kernels, i, x, y, reference, polyValues,
                                                                   imageWeighting);
@@ -785,5 +789,5 @@
                 for (int x = footprint; x <= footprint; x++) {
                     for (int k = 0; k < numKernels; k++) {
-#ifdef CAN_PASS_STATIC_INLINE
+#ifdef USE_FUNCTIONS_INSTEAD_OF_MACROS
                         convolvedStamp->data.F32[y + footprint][x + footprint] +=
                             convolvePixel(kernels, k, xStamp + x, yStamp + y, refImage, polyValues,
@@ -872,5 +876,5 @@
 
     // The appropriate kernel
-#ifdef CAN_PASS_STATIC_INLINE
+#ifdef USE_FUNCTIONS_INSTEAD_OF_MACROS
     psKernel *kernel = solvedKernel(NULL, solution, kernels, polyValues, imageWeighting);
 #else
@@ -974,5 +978,5 @@
                                            2.0 * (float)(i + size - numCols/2.0) / (float)numCols,
                                            2.0 * (float)(j + size - numRows/2.0) / (float)numRows);
-#ifdef CAN_PASS_STATIC_INLINE
+#ifdef USE_FUNCTIONS_INSTEAD_OF_MACROS
             kernelImage = solvedKernel(kernelImage, solution, kernels, polyValues, imageWeighting);
             if (inWeight) {