Changeset 19122

Timestamp:

Aug 18, 2008, 2:44:42 PM (18 years ago)

Author:

Paul Price

Message:

Need to put mutex locks on the parent images when convolving, since they are common across threads, and making a subimage involves adding to a 'children' array.

Location:

trunk/psModules/src/imcombine

Files:

• pmSubtraction.c (modified) (10 diffs)
• pmSubtraction.h (modified) (2 diffs)

trunk/psModules/src/imcombine/pmSubtraction.c

@@ -203 +203 @@
 // Convolve an image using FFT
 static void convolveFFT(psImage *target,// Place the result in here
-                        const psImage *image, // Image to convolve
-                        const psImage *mask, // Mask image
+                        psImage *image, // Image to convolve
+                        psImage *mask, // Mask image
                         psMaskType maskVal, // Value to mask
                         const psKernel *kernel, // Kernel by which to convolve
@@ -217 +217 @@
     bool threaded = pmSubtractionThreaded(); // Are we running threaded?
 
-    // Casting away const for image, mask
     if (threaded) {
-        psMutexLock((psImage*)image);
-    }
-    psImage *subImage = psImageSubset((psImage*)image, border); // Subimage to convolve
+        psMutexLock(image);
+    }
+    psImage *subImage = psImageSubset(image, border); // Subimage to convolve
     if (threaded) {
-        psMutexUnlock((psImage*)image);
-        psMutexLock((psImage*)mask);
-    }
-    psImage *subMask = mask ? psImageSubset((psImage*)mask, border) : NULL; // Subimage mask
+        psMutexUnlock(image);
+        psMutexLock(mask);
+    }
+    psImage *subMask = mask ? psImageSubset(mask, border) : NULL; // Subimage mask
     if (threaded) {
-        psMutexUnlock((psImage*)mask);
+        psMutexUnlock(mask);
     }
 
@@ -234 +233 @@
 
     if (threaded) {
-        psMutexLock((psImage*)image);
+        psMutexLock(image);
     }
     psFree(subImage);
     if (threaded) {
-        psMutexUnlock((psImage*)image);
-        psMutexLock((psImage*)mask);
+        psMutexUnlock(image);
+        psMutexLock(mask);
     }
     psFree(subMask);
     if (threaded) {
-        psMutexUnlock((psImage*)mask);
+        psMutexUnlock(mask);
     }
 
@@ -274 +273 @@
         psMutexUnlock(target);
     }
+
     return;
 }
@@ -305 +305 @@
                                   psKernel **kernelImage, // Convolution kernel for the image
                                   psKernel **kernelWeight, // Convolution kernel for the weight map, or NULL
-                                  const psImage *image, // Image to convolve
-                                  const psImage *weight, // Weight map to convolve, or NULL
-                                  const psImage *subMask, // Subtraction mask
+                                  psImage *image, // Image to convolve
+                                  psImage *weight, // Weight map to convolve, or NULL
+                                  psImage *subMask, // Subtraction mask
                                   psMaskType maskVal, // Mask value to apply in convolution
                                   const pmSubtractionKernels *kernels, // Kernels
@@ -755 +755 @@
 static bool subtractionConvolvePatch(int numCols, int numRows, int x0, int y0,
                                      pmReadout *out1, pmReadout *out2, psImage *convMask,
-                                     const pmReadout *ro1, const pmReadout *ro2, const psImage *subMask,
+                                     const pmReadout *ro1, const pmReadout *ro2, psImage *subMask,
                                      psMaskType blank, psMaskType maskSource, psMaskType maskTarget,
                                      const psRegion *region, const pmSubtractionKernels *kernels,
@@ -824 +824 @@
     const pmReadout *ro1 = args->data[7]; // Input readout 1
     const pmReadout *ro2 = args->data[8]; // Input readout 2
-    const psImage *subMask = args->data[9]; // Subtraction mask
+    psImage *subMask = args->data[9]; // Subtraction mask
     psMaskType blank = PS_SCALAR_VALUE(args->data[10], U8); // Output mask value
     psMaskType maskSource = PS_SCALAR_VALUE(args->data[11], U8); // Mask value corresponding to source image
@@ -839 +839 @@
 
 bool pmSubtractionConvolve(pmReadout *out1, pmReadout *out2, const pmReadout *ro1, const pmReadout *ro2,
-                           const psImage *subMask, psMaskType blank, const psRegion *region,
+                           psImage *subMask, psMaskType blank, const psRegion *region,
                            const pmSubtractionKernels *kernels, bool doBG, bool useFFT)
 {
@@ -938 +938 @@
     psImage *convMask = NULL;           // Convolved mask image (common to inputs 1 and 2)
     if (subMask) {
+        if (threaded) {
+            psMutexInit(subMask);
+        }
         if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
             if (!out1->mask) {
@@ -1045 +1048 @@
     }
 
+    if (subMask && threaded) {
+        psMutexDestroy(subMask);
+    }
+
     // Copy anything that wasn't convolved
     switch (kernels->mode) {

trunk/psModules/src/imcombine/pmSubtraction.h

@@ -6 +6 @@
  * @author GLG, MHPCC
  *
- * @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
- * @date $Date: 2008-08-14 03:25:55 $
+ * @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2008-08-19 00:44:42 $
  * Copyright 2004-207 Institute for Astronomy, University of Hawaii
  */
@@ -103 +103 @@
                            const pmReadout *ro1, // Input image 1
                            const pmReadout *ro2, // Input image 2
-                           const psImage *subMask, ///< Subtraction mask (or NULL)
+                           psImage *subMask, ///< Subtraction mask (or NULL)
                            psMaskType blank, ///< Mask value for blank regions
                            const psRegion *region, ///< Region to convolve (or NULL)