Changeset 15320

Timestamp:

Oct 16, 2007, 1:31:03 PM (19 years ago)

Author:

Paul Price

Message:

Adding psImageConvolveMaskFFT to use FFT convolution to convolve mask --- should be faster than direct convolution for large kernels.

Location:

trunk/psLib/src/imageops

Files:

• psImageConvolve.c (modified) (3 diffs)
• psImageConvolve.h (modified) (2 diffs)

trunk/psLib/src/imageops/psImageConvolve.c

@@ -7 +7 @@
 /// @author Eugene Magnier, IfA
 ///
-/// @version $Revision: 1.57 $ $Name: not supported by cvs2svn $
-/// @date $Date: 2007-09-17 20:49:51 $
+/// @version $Revision: 1.58 $ $Name: not supported by cvs2svn $
+/// @date $Date: 2007-10-16 23:31:03 $
 ///
 /// Copyright 2004-2007 Institute for Astronomy, University of Hawaii
@@ -313 +313 @@
 }
 
-psImage *psImageConvolveMask(const psImage *mask, psMaskType maskVal, const psKernel *kernel)
+psImage *psImageConvolveMaskDirect(const psImage *mask, psMaskType maskVal, const psKernel *kernel)
 {
     PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
@@ -491 +491 @@
 
     return out;
+}
+
+
+psImage *psImageConvolveMaskFFT(const psImage *mask, psMaskType maskVal, const psKernel *kernel, float thresh)
+{
+    PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
+    PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
+    PS_ASSERT_PTR_NON_NULL(kernel, NULL);
+    PS_ASSERT_PTR_NON_NULL(kernel->kernel, NULL);
+    PS_ASSERT_FLOAT_LARGER_THAN(thresh, 0.0, NULL);
+    PS_ASSERT_FLOAT_LESS_THAN(thresh, 1.0, NULL);
+
+    int numRows = mask->numRows, numCols = mask->numCols; // Size of image
+
+    psImage *onoff = (psImage*)psBinaryOp(NULL, (const psPtr)mask, "&", // Casting away const so I can use
+                                          psScalarAlloc(maskVal, PS_TYPE_MASK)); // Pixels on or off
+    psImage *copy = psImageCopy(NULL, onoff, PS_TYPE_F32); // Floating-point copy
+    psImage *convolved = psImageConvolveFFT(copy, NULL, 0, kernel, 0.0);
+    psFree(copy);
+
+    thresh *= maskVal;
+    for (int y = 0; y < numRows; y++) {
+        for (int x = 0; x < numCols; x++) {
+            onoff->data.PS_TYPE_MASK_DATA[y][x] = (convolved->data.F32[y][x] >= thresh) ?
+                (mask->data.PS_TYPE_MASK_DATA[y][x] | maskVal) : mask->data.PS_TYPE_MASK_DATA[y][x];
+        }
+    }
+
+    psFree(convolved);
+
+    return onoff;
 }
 

trunk/psLib/src/imageops/psImageConvolve.h

@@ -5 +5 @@
  * @author Robert DeSonia, MHPCC
  *
- * @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-09-17 20:49:51 $
+ * @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-10-16 23:31:03 $
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  */
@@ -153 +153 @@
 );
 
-/// Convolve a mask image with a kernel
+/// Convolve a mask image with a kernel, using direct convolution
 ///
 /// Returns a mask, grown by the supplied kernel.  Only those pixels specified by the maskVal are grown; the
 /// rest are simply propagated.
-psImage *psImageConvolveMask(const psImage *mask, ///< Mask to convolve
-                             psMaskType maskVal, ///< Mask value to convolve
-                             const psKernel *kernel ///< Kernel by which to convolve
+psImage *psImageConvolveMaskDirect(const psImage *mask, ///< Mask to convolve
+                                   psMaskType maskVal, ///< Mask value to convolve
+                                   const psKernel *kernel ///< Kernel by which to convolve
+    );
+
+/// Convolve a mask image with a kernel, using the FFT
+///
+/// Returns a mask, grown by the supplied kernel.  Only those pixels specified by the maskVal are grown; the
+/// rest are simply propagated.  Uses psImageConvolveFFT to convolve the mask, and then thresholds at the
+/// specified level.
+psImage *psImageConvolveMaskFFT(const psImage *mask, ///< Mask to convolve
+                                psMaskType maskVal, ///< Mask value to convolve
+                                const psKernel *kernel, ///< Kernel by which to convolve
+                                float thresh ///< Threshold (0..1) for convolved floating-point image
     );