Changeset 15443 for trunk/psModules/src/imcombine/pmSubtraction.h

Timestamp:

Nov 2, 2007, 4:28:24 PM (19 years ago)

Author:

Paul Price

Message:

Adding function pmSubtractionOrder (choice of name is probably not the best) to determine which of the two images under consideration should be convolved to match the other. Originally was doing this by solving for a RING kernel of width 1, going both ways, and comparing the deviations for each. However, when doing stacks this didn't work (convolving the wider fake Gaussian image gave smaller deviations than convolving the narrower input image), so have settled on measuring the second moments for each stamp, and using the ratio of moments between the two images to determine which is wider; this seems to work for both subtracting and stacking images. In the process, plugged a few memory leaks, and added code to support convolving either way (or both ways; this will be useful when it comes time to code the dual convolution algorithm).

File:

• trunk/psModules/src/imcombine/pmSubtraction.h (modified) (7 diffs)

trunk/psModules/src/imcombine/pmSubtraction.h

@@ -6 +6 @@
  * @author GLG, MHPCC
  *
- * @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-10-17 02:45:40 $
+ * @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-11-03 02:28:24 $
  *
  * Copyright 2004-207 Institute for Astronomy, University of Hawaii
@@ -16 +16 @@
 
 #include <pslib.h>
-#include "pmSubtractionKernels.h"
-#include "pmSubtractionStamps.h"
+
+#include <pmHDU.h>
+#include <pmFPA.h>
+#include <pmSubtractionKernels.h>
+#include <pmSubtractionStamps.h>
 
 /// @addtogroup imcombine Image Combinations
 /// @{
 
+/// Mask values for the subtraction mask
 typedef enum {
-    PM_SUBTRACTION_MASK_CLEAR     = 0x00, // No masking
-    PM_SUBTRACTION_MASK_REF       = 0x01, // Reference image is bad
-    PM_SUBTRACTION_MASK_INPUT     = 0x02, // Input image is bad
-    PM_SUBTRACTION_MASK_CONVOLVE  = 0x04, // If convolved, would be bad
-    PM_SUBTRACTION_MASK_FOOTPRINT = 0x08, // Bad pixel within the stamp footprint
-    PM_SUBTRACTION_MASK_BORDER    = 0x10, // Image border
-    PM_SUBTRACTION_MASK_REJ       = 0x20, // Previously tried as a stamp, and rejected
+    PM_SUBTRACTION_MASK_CLEAR       = 0x00, // No masking
+    PM_SUBTRACTION_MASK_BAD_1       = 0x01, // Image 1 is bad
+    PM_SUBTRACTION_MASK_BAD_2       = 0x02, // Image 2 is bad
+    PM_SUBTRACTION_MASK_CONVOLVE_1  = 0x04, // If image 1 is convolved, would be bad
+    PM_SUBTRACTION_MASK_CONVOLVE_2  = 0x08, // If image 2 is convolved, would be bad
+    PM_SUBTRACTION_MASK_FOOTPRINT_1 = 0x10, // Bad pixel within the stamp footprint of image 1
+    PM_SUBTRACTION_MASK_FOOTPRINT_2 = 0x20, // Bad pixel within the stamp footprint of image 2
+    PM_SUBTRACTION_MASK_BORDER      = 0x40, // Image border
+    PM_SUBTRACTION_MASK_REJ         = 0x80, // Previously tried as a stamp, and rejected
 } pmSubtractionMasks;
 
@@ -45 +51 @@
 bool pmSubtractionConvolveStamp(pmSubtractionStamp *stamp, ///< Stamp to convolve
                                 const pmSubtractionKernels *kernels, ///< Kernel parameters
-                                int footprint ///< Half-size of region over which to calculate equation
+                                int footprint, ///< Half-size of region over which to calculate equation
+                                pmSubtractionMode mode ///< Mode for subtraction (which to convolve)
     );
 
@@ -51 +58 @@
 bool pmSubtractionCalculateEquation(pmSubtractionStampList *stamps, ///< Stamps
                                     const pmSubtractionKernels *kernels, ///< Kernel parameters
-                                    int footprint ///< Half-size of region over which to calculate equation
+                                    int footprint, ///< Half-size of region over which to calculate equation
+                                    pmSubtractionMode mode ///< Mode for subtraction (which to convolve)
                                     );
 
@@ -59 +67 @@
                                      );
 
+/// Calculate deviations
+psVector *pmSubtractionCalculateDeviations(pmSubtractionStampList *stamps, ///< Stamps
+                                           const psVector *solution, ///< Solution vector
+                                           int footprint, ///< Half-size of stamp
+                                           const pmSubtractionKernels *kernels, ///< Kernel parameters
+                                           pmSubtractionMode mode ///< Mode for subtraction
+    );
+
 /// Reject stamps
 int pmSubtractionRejectStamps(pmSubtractionStampList *stamps, ///< Stamps
+                              const psVector *deviations, ///< Deviations for each stamp
                               psImage *subMask, ///< Subtraction mask
-                              const psVector *solution, ///< Solution vector
-                              int footprint, ///< Region to mask if stamp is bad
                               float sigmaRej, ///< Number of RMS deviations above zero at which to reject
-                              const pmSubtractionKernels *kernels ///< Kernel parameters
+                              int footprint ///< Half-size of stamp
     );
 
@@ -81 +96 @@
 
 /// Convolve image in preparation for subtraction
-bool pmSubtractionConvolve(psImage **outImage, ///< Output image
-                           psImage **outWeight, ///< Output weight map (or NULL)
-                           psImage **outMask, ///< Output mask (or NULL)
-                           const psImage *inImage, ///< Input image
-                           const psImage *inWeight, ///< Input weight map (or NULL)
+bool pmSubtractionConvolve(pmReadout *out, ///< Output image
+                           const pmReadout *ro1, // Input image 1
+                           const pmReadout *ro2, // Input image 2
                            const psImage *subMask, ///< Subtraction mask (or NULL)
                            psMaskType blank, ///< Mask value for blank regions
@@ -91 +104 @@
                            const psVector *solution, ///< The solution vector
                            const pmSubtractionKernels *kernels, ///< Kernel parameters
+                           pmSubtractionMode mode, ///< Mode for subtraction
                            bool useFFT  ///< Use Fast Fourier Transform for the convolution?
     );