Apply all corrections after SNIP in polar

We will just now combine all intensity corrections together, warp
them to the polar view, and apply them after SNIP...

Signed-off-by: Patrick Avery <patrick.avery@kitware.com>

Author: psavery

hexrdgui/calibration/polarview.py

@@ -5,6 +5,7 @@
 from skimage.transform import warp
 
 from hexrd.transforms.xfcapi import mapAngle
+from hexrd.utils.warnings import ignore_warnings
 
 from hexrd import constants as ct
 from hexrd.xrdutil import (
@@ -54,11 +55,14 @@ def __init__(self, instrument, distortion_instrument=None):
         else:
             # Use an image dict with the panel buffers applied.
             # This keeps invalid pixels from bleeding out in the polar view
-            self.images_dict = HexrdConfig().images_dict
+            self.images_dict = HexrdConfig().raw_images_dict
             # 0 is a better fill value because it results in fewer nans in
             # the final image.
             HexrdConfig().apply_panel_buffer_to_images(self.images_dict, 0)
 
+            # Update the intensity corrections. They'll be used later.
+            self.update_intensity_corrections()
+
         self.warp_dict = {}
 
         self.raw_img = None
@@ -395,8 +399,8 @@ def apply_image_processing(self):
         img = self.raw_img.data
         img = self.apply_snip(img)
 
-        # Always apply absorption correction after snip
-        img = self.apply_absorption_correction(img)
+        # Always apply intensity corrections after snip
+        img = self.apply_intensity_corrections(img)
 
         # cache this step so we can just re-apply masks if needed
         self.snipped_img = img
@@ -444,21 +448,35 @@ def apply_snip(self, img):
 
         return img
 
-    def apply_absorption_correction(self, img):
-        if not HexrdConfig().apply_absorption_correction:
+    def apply_intensity_corrections(self, img):
+        if not HexrdConfig().any_intensity_corrections:
+            # No corrections
             return img
 
-        # Warp the absorption correction images to the polar view,
-        # sum them, and apply.
-        absorption_corrections = HexrdConfig().absorption_corrections_dict
+        # Warp the intensity corrections to polar, mean them, and apply
+        intensity_corrections = HexrdConfig().intensity_corrections_dict
 
         output = {}
         for det_key, panel in self.detectors.items():
-            corrections = absorption_corrections[det_key]
+            corrections = intensity_corrections[det_key]
             output[det_key] = self.warp_image(corrections, panel)
 
-        correction_field = np.ma.sum(np.ma.stack(output.values()), axis=0)
-        return img * correction_field.data
+        stacked = np.ma.stack(output.values()).filled(np.nan)
+
+        # It's okay to have all nan-slices here, but it produces a warning.
+        # Just ignore the warning.
+        with ignore_warnings(RuntimeWarning):
+            # In case there are overlapping detectors, we do nanmean for
+            # the intensities instead of nansum. This would produce a
+            # somewhat more reasonable intensity.
+            correction_field = np.nanmean(stacked, axis=0)
+
+        img *= correction_field
+
+        if HexrdConfig().intensity_subtract_minimum:
+            img -= np.nanmin(img)
+
+        return img
 
     def apply_visible_masks(self, img):
         # Apply user-specified masks if they are present
@@ -530,16 +548,16 @@ def warp_all_images(self):
         # Generate the final image
         self.generate_image()
 
-    def update_images_dict(self):
+    def update_intensity_corrections(self):
         if HexrdConfig().any_intensity_corrections:
-            self.images_dict = HexrdConfig().images_dict
+            HexrdConfig().create_intensity_corrections_dict()
 
     def update_detectors(self, detectors):
         self.reset_cached_distortion_fields()
 
         # If there are intensity corrections and the detector transform
-        # has been modified, we need to update the images dict.
-        self.update_images_dict()
+        # has been modified, we need to update the intensity corrections.
+        self.update_intensity_corrections()
 
         # First, convert to the "None" angle convention
         iconfig = HexrdConfig().instrument_config_none_euler_convention

hexrdgui/hexrd_config.py

@@ -325,7 +325,7 @@ def __init__(self):
         self._physics_package = None
         self._detector_coatings = {}
         self._instrument_rigid_body_params = {}
-        self.absorption_corrections_dict = {}
+        self.intensity_corrections_dict = {}
 
         # Make sure that the matplotlib font size matches the application
         self.font_size = self.font_size
@@ -912,75 +912,88 @@ def raw_images_dict(self):
     def intensity_corrected_images_dict(self):
         """Performs intensity corrections, if any, before returning"""
         images_dict = self.raw_images_dict
-
         if not self.any_intensity_corrections:
             # No intensity corrections. Return.
             return images_dict
 
+        # Create this corrections dict, even if we don't use it, because
+        # it updates the `intensity_corrections_dict` that may be used
+        # elsewhere.
+        corrections_dict = self.create_intensity_corrections_dict()
+        if (
+            self.image_mode not in
+            (constants.ViewType.polar, constants.ViewType.stereo)
+        ):
+            # If it's not polar or stereo, go ahead and apply the
+            # corrections
+            for name in images_dict:
+                images_dict[name] *= corrections_dict[name]
+
+            # In the polar view, minimum will be subtracted later
+            if self.intensity_subtract_minimum:
+                minimum = min([np.nanmin(x) for x in images_dict.values()])
+                for name in images_dict:
+                    images_dict[name] -= minimum
+
+        return images_dict
+
+    def create_intensity_corrections_dict(self) -> dict:
+        # The corrections dict is both stored in `intensity_corrections_dict`
+        # and returned from this function.
+        corrections_dict = self.intensity_corrections_dict
+        corrections_dict.clear()
+
         # Some methods require an instrument. Go ahead and create one.
         from hexrdgui.create_hedm_instrument import create_hedm_instrument
         instr = create_hedm_instrument()
 
-        if HexrdConfig().apply_pixel_solid_angle_correction:
-            sangle = dict.fromkeys(images_dict.keys())
+        # Initialize the intensity corrections dict as ones
+        for det_key, panel in instr.detectors.items():
+            corrections_dict[det_key] = np.ones(panel.shape)
+
+        if not self.any_intensity_corrections:
+            return corrections_dict
+
+        if self.apply_pixel_solid_angle_correction:
+            sangle = dict.fromkeys(instr.detectors)
             mi = np.finfo(np.float64).max # largest floating point number
             # normalize by minimum of the entire instrument
             # not each detector individually
-            for name, img in images_dict.items():
-                panel = instr.detectors[name]
+            for name, panel in instr.detectors.items():
                 sangle[name] = panel.pixel_solid_angles
                 mi = np.min((mi, sangle[name].min()))
-            for name, img in images_dict.items():
-                images_dict[name] = mi * img / sangle[name]
 
-        if HexrdConfig().apply_polarization_correction:
+            for name in sangle:
+                corrections_dict[name] *= mi / sangle[name]
+
+        if self.apply_polarization_correction:
             options = self.config['image']['polarization']
             kwargs = {
                 'unpolarized': options['unpolarized'],
                 'f_hor': options['f_hor'],
                 'f_vert': options['f_vert'],
             }
 
-            for name, img in images_dict.items():
-                panel = instr.detectors[name]
+            for name, panel in instr.detectors.items():
                 factor = panel.polarization_factor(**kwargs)
-                images_dict[name] = img / factor
+                corrections_dict[name] /= factor
 
-        if HexrdConfig().apply_lorentz_correction:
-            for name, img in images_dict.items():
-                panel = instr.detectors[name]
+        if self.apply_lorentz_correction:
+            for name, panel in instr.detectors.items():
                 factor = panel.lorentz_factor()
-                images_dict[name] = img / factor
-
-        HexrdConfig().absorption_corrections_dict.clear()
-        if HexrdConfig().apply_absorption_correction:
-            absorption_corrections = HexrdConfig().absorption_corrections_dict
+                corrections_dict[name] /= factor
 
+        if self.apply_absorption_correction:
             transmissions = instr.calc_transmission()
             max_transmission = max(
                 [np.nanmax(v) for v in transmissions.values()])
 
-            for name, img in images_dict.items():
-                transmission = transmissions[name]
+            for name, transmission in transmissions.items():
                 # normalize by maximum of the entire instrument
                 transmission /= max_transmission
-                absorption_corrections[name] = 1 / transmission
-
-            if (
-                HexrdConfig().image_mode not in
-                (constants.ViewType.polar, constants.ViewType.stereo)
-            ):
-                # If it's not polar or stereo, go ahead and apply the
-                # corrections
-                for name, img in images_dict.items():
-                    images_dict[name] = img * absorption_corrections[name]
-
-        if HexrdConfig().intensity_subtract_minimum:
-            minimum = min([np.nanmin(x) for x in images_dict.values()])
-            for name, img in images_dict.items():
-                images_dict[name] = img - minimum
+                corrections_dict[name] /= transmission
 
-        return images_dict
+        return corrections_dict
 
     @property
     def images_dict(self):