Index: /trunk/psModules/src/imcombine/pmSubtractionKernels.c
===================================================================
--- /trunk/psModules/src/imcombine/pmSubtractionKernels.c	(revision 14531)
+++ /trunk/psModules/src/imcombine/pmSubtractionKernels.c	(revision 14532)
@@ -99,15 +99,15 @@
 
 pmSubtractionKernels *pmSubtractionKernelsISIS(int size, int spatialOrder,
-                                               const psVector *sigmas, const psVector *orders)
-{
-    PS_ASSERT_VECTOR_NON_NULL(sigmas, NULL);
-    PS_ASSERT_VECTOR_TYPE(sigmas, PS_TYPE_F32, NULL);
+                                               const psVector *fwhms, const psVector *orders)
+{
+    PS_ASSERT_VECTOR_NON_NULL(fwhms, NULL);
+    PS_ASSERT_VECTOR_TYPE(fwhms, PS_TYPE_F32, NULL);
     PS_ASSERT_VECTOR_NON_NULL(orders, NULL);
     PS_ASSERT_VECTOR_TYPE(orders, PS_TYPE_S32, NULL);
-    PS_ASSERT_VECTORS_SIZE_EQUAL(sigmas, orders, NULL);
+    PS_ASSERT_VECTORS_SIZE_EQUAL(fwhms, orders, NULL);
     PS_ASSERT_INT_POSITIVE(size, NULL);
     PS_ASSERT_INT_NONNEGATIVE(spatialOrder, NULL);
 
-    int numGaussians = sigmas->n;       // Number of Gaussians
+    int numGaussians = fwhms->n;       // Number of Gaussians
 
     int num = 0;                        // Number of basis functions
@@ -115,5 +115,5 @@
     for (int i = 0; i < numGaussians; i++) {
         int gaussOrder = orders->data.S32[i]; // Polynomial order to apply to Gaussian
-        psStringAppend(&params, "(%.2f,%d)", sigmas->data.F32[i], orders->data.S32[i]);
+        psStringAppend(&params, "(%.2f,%d)", fwhms->data.F32[i], orders->data.S32[i]);
         num += (gaussOrder + 1) * (gaussOrder + 2) / 2;
     }
@@ -133,5 +133,7 @@
     // Set the kernel parameters
     for (int i = 0, index = 0; i < numGaussians; i++) {
-        float norm = 1.0 / (M_2_PI * sqrtf(sigmas->data.F32[i])); // Normalisation for Gaussian
+        float sigma = fwhms->data.F32[i] / (2.0 * sqrtf(2.0 * logf(2.0))); // Gaussian sigma
+        float norm = 1.0 / (M_2_PI * sqrtf(sigma)); // Normalisation for Gaussian
+
         // Iterate over (u,v) order
         for (int uOrder = 0; uOrder <= orders->data.S32[i]; uOrder++) {
@@ -144,5 +146,5 @@
                     for (int u = -size; u <= size; u++) {
                         sum += preCalc->kernel[v][u] = norm * power(u, uOrder) * power(v, vOrder) *
-                            expf(-0.5 * (PS_SQR(u) + PS_SQR(v)) / PS_SQR(sigmas->data.F32[i]));
+                            expf(-0.5 * (PS_SQR(u) + PS_SQR(v)) / PS_SQR(sigma));
                     }
                 }
@@ -163,5 +165,5 @@
                 }
 
-                kernels->widths->data.F32[index] = sigmas->data.F32[i];
+                kernels->widths->data.F32[index] = fwhms->data.F32[i];
                 kernels->u->data.S32[index] = uOrder;
                 kernels->v->data.S32[index] = vOrder;
@@ -169,5 +171,5 @@
 
                 psTrace("psModules.imcombine", 7, "Kernel %d: %f %d %d\n", index,
-                        sigmas->data.F32[i], uOrder, vOrder);
+                        fwhms->data.F32[i], uOrder, vOrder);
             }
         }
@@ -378,18 +380,18 @@
 
 // Grid United with Normal Kernel
-pmSubtractionKernels *pmSubtractionKernelsGUNK(int size, int spatialOrder, const psVector *sigmas,
+pmSubtractionKernels *pmSubtractionKernelsGUNK(int size, int spatialOrder, const psVector *fwhms,
                                                const psVector *orders, int inner)
 {
     PS_ASSERT_INT_POSITIVE(size, NULL);
     PS_ASSERT_INT_NONNEGATIVE(spatialOrder, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(sigmas, NULL);
-    PS_ASSERT_VECTOR_TYPE(sigmas, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(fwhms, NULL);
+    PS_ASSERT_VECTOR_TYPE(fwhms, PS_TYPE_F32, NULL);
     PS_ASSERT_VECTOR_NON_NULL(orders, NULL);
     PS_ASSERT_VECTOR_TYPE(orders, PS_TYPE_S32, NULL);
-    PS_ASSERT_VECTORS_SIZE_EQUAL(sigmas, orders, NULL);
+    PS_ASSERT_VECTORS_SIZE_EQUAL(fwhms, orders, NULL);
     PS_ASSERT_INT_NONNEGATIVE(inner, NULL);
     PS_ASSERT_INT_LESS_THAN(inner, size, NULL);
 
-    int numGaussians = sigmas->n;       // Number of Gaussians
+    int numGaussians = fwhms->n;       // Number of Gaussians
     int numGaussianVars = 0;            // Number of Gaussian variant functions in the kernel
     psString params = NULL;             // List of params
@@ -397,5 +399,5 @@
         int gaussOrder = orders->data.S32[i]; // Polynomial order to apply to Gaussian
         numGaussianVars += (gaussOrder + 1) * (gaussOrder + 2) / 2;
-        psStringAppend(&params, "(%.2f,%d)", sigmas->data.F32[i], orders->data.S32[i]);
+        psStringAppend(&params, "(%.2f,%d)", fwhms->data.F32[i], orders->data.S32[i]);
     }
 
@@ -419,5 +421,6 @@
     // Set the Gaussian kernel parameters
     for (int i = 0, index = 0; i < numGaussians; i++) {
-        float norm = 1.0 / (M_2_PI * sqrtf(sigmas->data.F32[i])); // Normalisation for Gaussian
+        float sigma = fwhms->data.F32[i] / (2.0 * sqrtf(2.0 * logf(2.0))); // Gaussian sigma
+        float norm = 1.0 / (M_2_PI * sqrtf(sigma)); // Normalisation for Gaussian
         // Iterate over (u,v) order
         for (int uOrder = 0; uOrder <= orders->data.S32[i]; uOrder++) {
@@ -429,5 +432,5 @@
                     for (int u = -size; u <= size; u++) {
                         sum += preCalc->kernel[v][u] = norm * power(u, uOrder) * power(v, vOrder) *
-                            expf(-0.5 * (PS_SQR(u) + PS_SQR(v)) / PS_SQR(sigmas->data.F32[i]));
+                            expf(-0.5 * (PS_SQR(u) + PS_SQR(v)) / PS_SQR(fwhms->data.F32[i]));
                     }
                 }
@@ -448,5 +451,5 @@
                 }
 
-                kernels->widths->data.F32[index] = sigmas->data.F32[i];
+                kernels->widths->data.F32[index] = fwhms->data.F32[i];
                 kernels->u->data.S32[index] = uOrder;
                 kernels->v->data.S32[index] = vOrder;
@@ -454,5 +457,5 @@
 
                 psTrace("psModules.imcombine", 7, "Kernel %d: %f %d %d\n", index,
-                        sigmas->data.F32[i], uOrder, vOrder);
+                        fwhms->data.F32[i], uOrder, vOrder);
             }
         }
@@ -616,5 +619,5 @@
 
 pmSubtractionKernels *pmSubtractionKernelsGenerate(pmSubtractionKernelsType type, int size, int spatialOrder,
-                                                   const psVector *sigmas, const psVector *orders, int inner,
+                                                   const psVector *fwhms, const psVector *orders, int inner,
                                                    int binning, int ringsOrder)
 {
@@ -623,5 +626,5 @@
         return pmSubtractionKernelsPOIS(size, spatialOrder);
       case PM_SUBTRACTION_KERNEL_ISIS:
-        return pmSubtractionKernelsISIS(size, spatialOrder, sigmas, orders);
+        return pmSubtractionKernelsISIS(size, spatialOrder, fwhms, orders);
       case PM_SUBTRACTION_KERNEL_SPAM:
         return pmSubtractionKernelsSPAM(size, spatialOrder, inner, binning);
@@ -629,5 +632,5 @@
         return pmSubtractionKernelsFRIES(size, spatialOrder, inner);
       case PM_SUBTRACTION_KERNEL_GUNK:
-        return pmSubtractionKernelsGUNK(size, spatialOrder, sigmas, orders, inner);
+        return pmSubtractionKernelsGUNK(size, spatialOrder, fwhms, orders, inner);
       case PM_SUBTRACTION_KERNEL_RINGS:
         return pmSubtractionKernelsRINGS(size, ringsOrder, inner, spatialOrder);