Merge pull request #147 from lsst-camera-dh/LSSTTD-1606_superbias_subtraction_w_rowcol

Lssttd 1606 superbias subtraction w rowcol

Author: jchiang87

python/lsst/eotest/image_utils.py

@@ -500,7 +500,11 @@ def unbias_and_trim(im, overscan, imaging=None, dxmin=5, dxmax=2, bias_method='r
     if bias_method == 'rowcol':
         serial_overscan = kwargs['serial_overscan']
         parallel_overscan = kwargs['parallel_overscan']
-        im -= bias_image_rowcol(im, serial_overscan, parallel_overscan)
+        parallel_bbox = lsst.geom.Box2I(
+            lsst.geom.Point2I(0, parallel_overscan.getMin().y),
+            parallel_overscan.getMax())
+        im -= bias_image_rowcol(im, serial_overscan=serial_overscan,
+                                parallel_overscan=parallel_bbox)
     else:
         im -= bias_image(im, overscan, dxmin=dxmin, dxmax=dxmax,
                          bias_method=bias_method, **kwargs)

python/lsst/eotest/sensor/MaskedCCD.py

@@ -60,9 +60,14 @@ def __init__(self, imfile, mask_files=(), bias_frame=None,
             self.setAllMasks()
         self.bias_frame = None
         self.ccd_pcas = None
-        if bias_frame == 'rowcol':
+        self.bias_method = None
+        if isinstance(bias_frame, (tuple, list)) and bias_frame[0] == 'rowcol':
             # Use parallel+serial overscan model to do bias subtraction.
-            self.bias_frame = 'rowcol'
+            # The second element of bias_frame should be the superbias file
+            # for this CCD.
+            self.bias_method = 'rowcol'
+            self.bias_frame = (MaskedCCD(bias_frame[1], all_amps=all_amps)
+                               if bias_frame[1] is not None else None)
         elif bias_frame is not None:
             if isinstance(bias_frame, MaskedCCD):
                 self.bias_frame = bias_frame
@@ -169,35 +174,43 @@ def write_bias_subtracted_MEF(self, outfile, gains=None, overwrite=True):
 
 
     def bias_image_using_overscan(self, amp, overscan=None, **kwargs):
-        """
-        Generate a bias image containing offset values calculated from
-        bias(), bias_row(), bias_func() or bias_spline(). The default bias method
-        is set to bias_row() in image_utils.py. Keyword arguments can be passed
-        depending on which bias method is used.
+        """Generate a bias image containing offset values calculated from
+        bias(), bias_row(), bias_func() or bias_spline(). The default
+        bias method is set to bias_row() in image_utils.py. Keyword
+        arguments can be passed depending on which bias method is
+        used.
 
         Keyword Arguments:
-        fit_order: The order of the polynomial. This only needs to be specified when
-            using the 'func' method. The default is: 1.
-        k: The degree of the spline fit. This only needs to be specified when using
-            the 'spline' method. The default is: 3.
-        s: The amount of smoothing to be applied to the fit. This only needs to be
-            specified when using the 'spline' method. The default is: 18000.
-        t: The number of knots. If None, finds the number of knots to use for a given
-            smoothing factor, s. This only needs to be specified when using the 'spline'
-            method. The default is: None.
+        fit_order: The order of the polynomial. This only needs to be
+            specified when using the 'func' method. The default is: 1.
+        k: The degree of the spline fit. This only needs to be specified
+           when using the 'spline' method. The default is: 3.
+        s: The amount of smoothing to be applied to the fit. This only needs
+           to be specified when using the 'spline' method.
+           The default is: 18000.
+        t: The number of knots. If None, finds the number of knots to use
+           for a given smoothing factor, s. This only needs to be specified
+           when using the 'spline' method. The default is: None.
         """
         if overscan is None:
             overscan = self.amp_geom.serial_overscan
         try:
             if 'bias_method' in kwargs:
                 if kwargs['bias_method'] == 'rowcol':
-                    serial_overscan   = self.amp_geom.serial_overscan
+                    serial_overscan = self.amp_geom.serial_overscan
                     parallel_overscan = self.amp_geom.parallel_overscan
-                    parallel_bbox = lsst.geom.Box2I(lsst.geom.Point2I(0, \
-                                                    parallel_overscan.getMin().y), parallel_overscan.getMax())
-                    return imutils.bias_image_rowcol(self._deep_copy(amp), \
-                                                     serial_overscan=serial_overscan, parallel_overscan=parallel_bbox, **kwargs)
-            return imutils.bias_image(self._deep_copy(amp), overscan=overscan, **kwargs)
+                    parallel_bbox = lsst.geom.Box2I(
+                        lsst.geom.Point2I(0, parallel_overscan.getMin().y),
+                        parallel_overscan.getMax())
+                    bias_image = imutils.bias_image_rowcol(
+                        self._deep_copy(amp),
+                        serial_overscan=serial_overscan,
+                        parallel_overscan=parallel_bbox, **kwargs)
+                    if self.bias_frame is not None:
+                        bias_image += self.bias_frame[amp].getImage()
+                    return bias_image
+            return imutils.bias_image(self._deep_copy(amp), overscan=overscan,
+                                      **kwargs)
         except pexExcept.RuntimeError as eobj:
             raise MaskedCCDBiasImageException("DM stack error generating bias "
                                               + "image from overscan region:\n"
@@ -207,25 +220,33 @@ def _deep_copy(self, amp):
         return self[amp].Factory(self[amp], deep=True)
 
     def bias_image(self, amp, overscan=None, **kwargs):
-        """
-        Use separately stored metadata to determine file-specified
+        """Use separately stored metadata to determine file-specified
         overscan region. If bias_frame is not given, then calculate
-        the bias image using bias(), bias_row(), bias_func() or bias_spline().
-        The default bias method is set to bias_row() in image_utils.py.
-        Keyword arguments can be passed depending on which bias method is used.
+        the bias image using bias(), bias_row(), bias_func() or
+        bias_spline().  The default bias method is set to bias_row()
+        in image_utils.py.  Keyword arguments can be passed depending
+        on which bias method is used.
 
         Keyword Arguments:
-        fit_order: The order of the polynomial. This only needs to be specified when
-            using the 'func' method. The default is: 1.
-        k: The degree of the spline fit. This only needs to be specified when using
-            the 'spline' method. The default is: 3.
-        s: The amount of smoothing to be applied to the fit. This only needs to be
-            specified when using the 'spline' method. The default is: 18000.
-        t: The number of knots. If None, finds the number of knots to use for a given
-            smoothing factor, s. This only needs to be specified when using the 'spline'
-            method. The default is: None.
+
+        fit_order: The order of the polynomial. This only needs to be
+            specified when using the 'func' method. The default is: 1.
+
+        k: The degree of the spline fit. This only needs to be
+            specified when using the 'spline' method. The default is:
+            3.
+
+        s: The amount of smoothing to be applied to the fit. This only
+            needs to be specified when using the 'spline' method. The
+            default is: 18000.
+
+        t: The number of knots. If None, finds the number of knots to
+            use for a given smoothing factor, s. This only needs to be
+            specified when using the 'spline' method. The default is:
+            None.
+
         """
-        if self.bias_frame != 'rowcol' and self.bias_frame is not None:
+        if self.bias_method != 'rowcol' and self.bias_frame is not None:
             #
             # Use bias frame, if available, instead of overscan region
             #
@@ -237,27 +258,36 @@ def bias_image(self, amp, overscan=None, **kwargs):
     def bias_subtracted_image(self, amp, overscan=None,
                               max_pca_reduced_chisq=None,
                               **kwargs):
-        """
-        Subtract a bias image to correct for the offset. A bias correction is also
-        applied if a base_frame is passed. The bias image with the offset values is
-        generated using either of the bias(), bias_row(), bias_func() or bias_spline()
-        methods from image_utils.py. The default bias method is set to bias_row().
-        Keyword arguments can be passed depending on which bias method is used.
+        """Subtract a bias image to correct for the offset. A bias
+        correction is also applied if a base_frame is passed. The bias
+        image with the offset values is generated using either of the
+        bias(), bias_row(), bias_func() or bias_spline() methods from
+        image_utils.py. The default bias method is set to bias_row().
+        Keyword arguments can be passed depending on which bias method
+        is used.
 
         Keyword Arguments:
-        fit_order: The order of the polynomial. This only needs to be specified when
-            using the 'func' method. The default is: 1.
-        k: The degree of the spline fit. This only needs to be specified when using
-            the 'spline' method. The default is: 3.
-        s: The amount of smoothing to be applied to the fit. This only needs to be
-            specified when using the 'spline' method. The default is: 18000.
-        t: The number of knots. If None, finds the number of knots to use for a given
-            smoothing factor, s. This only needs to be specified when using the 'spline'
-            method. The default is: None.
+
+        fit_order: The order of the polynomial. This only needs to be
+            specified when using the 'func' method. The default is: 1.
+
+        k: The degree of the spline fit. This only needs to be
+            specified when using the 'spline' method. The default is:
+            3.
+
+        s: The amount of smoothing to be applied to the fit. This only
+            needs to be specified when using the 'spline' method. The
+            default is: 18000.
+
+        t: The number of knots. If None, finds the number of knots to
+            use for a given smoothing factor, s. This only needs to be
+            specified when using the 'spline' method. The default is:
+            None.
+
         """
         # Make a local copy to process and return.
         my_image = self._deep_copy(amp)
-        if self.bias_frame == 'rowcol':
+        if self.bias_method == 'rowcol':
             # This overrides any bias_method options.
             my_image -= self.bias_image(amp, bias_method='rowcol')
         elif self.bias_frame is not None:

python/lsst/eotest/sensor/brightPixelsTask.py

@@ -55,7 +55,7 @@ def run(self, sensor_id, dark_files, mask_files, gains, bias_frame=None,
                                                      imutils.dm_hdu(amp))
         medfile = os.path.join(self.config.output_dir,
                                '%s_median_dark_bp.fits' % sensor_id)
-        if not isinstance(bias_frame, str):
+        if not isinstance(bias_frame, str) and bias_frame[0] != 'rowcol':
             # Assume `bias_frame` is a tuple containing the
             # CCD_bias_PCA filenames so do a bias correction on the
             # median image using that model so that the FITS file

python/lsst/eotest/sensor/cteTask.py

@@ -16,6 +16,7 @@
 import lsst.afw.math as afwMath
 import lsst.pex.config as pexConfig
 import lsst.pipe.base as pipeBase
+import lsst.geom
 
 def pca_bias_subtracted_image(image, bias_frame, amp):
     my_image = image.Factory(image, deep=True)
@@ -44,19 +45,31 @@ def superflat(files, bias_frame=None, outfile='superflat.fits', bitpix=None,
     and median-ing them together.
     """
     use_pca_bias = os.environ.get('LCATR_USE_PCA_BIAS_FIT', 'True') == 'True'
-    # Get overscan region.
+    use_rowcol = False
+    # Get overscan regions.
     amp_geom = makeAmplifierGeometry(files[0])
-    overscan = amp_geom.serial_overscan
+    serial_overscan = amp_geom.serial_overscan
+    parallel_overscan = amp_geom.parallel_overscan
+    parallel_overscan = lsst.geom.Box2I(
+        lsst.geom.Point2I(0, parallel_overscan.getMin().y),
+        parallel_overscan.getMax())
+    superbias = None
     output_images = dict()
+    if isinstance(bias_frame, (tuple, list)) and bias_frame[0] == 'rowcol':
+        use_rowcol = True
+        if bias_frame[1] is not None:
+            superbias = fits.open(bias_frame[1])
     for amp in imutils.allAmps(files[0]):
         images = []
         for infile in files:
             image = afwImage.ImageF(infile, imutils.dm_hdu(amp))
             if bias_subtract:
-                if bias_frame == 'rowcol':
+                if use_rowcol:
                     image -= imutils\
-                        .bias_image_rowcol(image, amp_geom.serial_overscan,
-                                           amp_geom.parallel_overscan)
+                        .bias_image_rowcol(image, serial_overscan,
+                                           parallel_overscan)
+                    if superbias is not None:
+                        image.array -= superbias[amp].data
                 elif bias_frame:
                     if use_pca_bias:
                         image = pca_bias_subtracted_image(image, bias_frame,
@@ -65,15 +78,19 @@ def superflat(files, bias_frame=None, outfile='superflat.fits', bitpix=None,
                         bias_image = afwImage.ImageF(bias_frame,
                                                      imutils.dm_hdu(amp))
                         image = bias_subtracted_image(image, bias_image,
-                                                      overscan, bias_method)
+                                                      serial_overscan,
+                                                      bias_method)
                 else:
-                    image -= imutils.bias_image(im=image, overscan=overscan,
+                    image -= imutils.bias_image(im=image,
+                                                overscan=serial_overscan,
                                                 bias_method=bias_method)
             images.append(image)
         if lsst.afw.__version__.startswith('12.0'):
             images = afwImage.vectorImageF(images)
         output_images[amp] = afwMath.statisticsStack(images, afwMath.MEDIAN)
     imutils.writeFits(output_images, outfile, files[0])
+    if superbias is not None:
+        superbias.close()
     return outfile