Changeset 13395

Timestamp:

May 15, 2007, 5:53:36 PM (19 years ago)

Author:

Paul Price

Message:

Bit better optimisation on convolution: was generating the kernel
every row, but now generate the kernel within each box of the kernel
size.

File:

• trunk/psModules/src/imcombine/pmSubtraction.c (modified) (2 diffs)

trunk/psModules/src/imcombine/pmSubtraction.c

@@ -4 +4 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-05-16 01:04:43 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-05-16 03:53:36 $
  *
  *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
@@ -621 +621 @@
     psKernel *kernelWeight = NULL;      // Kernel for the weight map
 
-    for (int y = size; y < inImage->numRows - size; y++) {
-        for (int x = size; x < inImage->numCols - size; x++) {
-            convImage->data.F32[y][x] = background;
+    for (int j = size; j < inImage->numRows - fullSize; j += fullSize) {
+        for (int i = size; i < inImage->numCols - fullSize; i += fullSize) {
 
             // Only generate polynomial values every kernel footprint, since we have already assumed
             // (with the stamps) that it does not vary rapidly on this scale.
-            if (x % fullSize == size) {
-                psFree(polyValues);
-                polyValues = spatialPolyValues(kernels->spatialOrder,
-                                               2.0 * (float)(x - numCols/2.0) / (float)numCols,
-                                               2.0 * (float)(y - numRows/2.0) / (float)numRows);
-                kernelImage = solvedKernel(kernelImage, solution, kernels, polyValues, imageWeighting);
-                if (inWeight) {
-                    kernelWeight = solvedKernel(kernelWeight, solution, kernels, polyValues,
-                                                varianceWeighting);
-                }
-            }
-
-            // Check and propagate the kernel footprint, if required
-            if (inMask) {
-                for (int v = -size; v <= size; v++) {
-                    for (int u = -size; u <= size; u++) {
-                        convMask->data.PS_TYPE_MASK_DATA[y][x] |=
-                            inMask->data.PS_TYPE_MASK_DATA[y + v][x + u];
+            psFree(polyValues);
+            polyValues = spatialPolyValues(kernels->spatialOrder,
+                                           2.0 * (float)(i + size - numCols/2.0) / (float)numCols,
+                                           2.0 * (float)(j + size - numRows/2.0) / (float)numRows);
+            kernelImage = solvedKernel(kernelImage, solution, kernels, polyValues, imageWeighting);
+            if (inWeight) {
+                kernelWeight = solvedKernel(kernelWeight, solution, kernels, polyValues,
+                                            varianceWeighting);
+            }
+
+            for (int y = j; y < j + fullSize; y++) {
+                for (int x = i; x < i + fullSize; x++) {
+                    convImage->data.F32[y][x] = background;
+
+                    // Check and propagate the kernel footprint, if required
+                    if (inMask) {
+                        for (int v = -size; v <= size; v++) {
+                            for (int u = -size; u <= size; u++) {
+                                convMask->data.PS_TYPE_MASK_DATA[y][x] |=
+                                    inMask->data.PS_TYPE_MASK_DATA[y + v][x + u];
+                            }
+                        }
+                        if (convMask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
+                            convImage->data.F32[y][x] = NAN;
+                            if (inWeight) {
+                                convWeight->data.F32[y][x] = NAN;
+                            }
+                            continue;
+                        }
                     }
-                }
-                if (convMask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
-                    convImage->data.F32[y][x] = NAN;
+
+                    // Convolve the image
+                    for (int v = -size; v <= size; v++) {
+                        for (int u = -size; u <= size; u++) {
+                            convImage->data.F32[y][x] += kernelImage->kernel[v][u] *
+                                inImage->data.F32[y + v][x + u];
+                        }
+                    }
+
+                    // Convolve the weight (variance) map
                     if (inWeight) {
-                        convWeight->data.F32[y][x] = NAN;
-                    }
-                    continue;
-                }
-            }
-
-            // Convolve the image
-            for (int v = -size; v <= size; v++) {
-                for (int u = -size; u <= size; u++) {
-                    convImage->data.F32[y][x] += kernelImage->kernel[v][u] * inImage->data.F32[y + v][x + u];
-                }
-            }
-
-            // Convolve the weight (variance) map
-            if (inWeight) {
-                for (int v = -size; v <= size; v++) {
-                    for (int u = -size; u <= size; u++) {
-                        convWeight->data.F32[y][x] += kernelWeight->kernel[v][u] *
-                            inWeight->data.F32[y + v][x + u];
+                        for (int v = -size; v <= size; v++) {
+                            for (int u = -size; u <= size; u++) {
+                                convWeight->data.F32[y][x] += kernelWeight->kernel[v][u] *
+                                    inWeight->data.F32[y + v][x + u];
+                            }
+                        }
                     }
                 }