Mask out invalid pixels in the polar view

This makes it so that any invalid pixels (as defined by the detector's
panel buffer) do not have an effect on the resulting polar image and
lineout. Any polar view pixels that were interpolated with an invalid
pixel will be nan.

The intended usage is as follows:

```python
img = pv.warp_image(image_dict, pad_with_nans=True,
                    do_interpolation=True)
cake = np.mean(img, axis=0)
```

The `img` that is returned from the warp image is a masked array,
with all invalid pixels being masked out. If `np.mean(img, axis=0)` is
applied to this, it ignores all masked out pixels when computing the
mean along the axis (which is the behavior we want). This is preferred
over doing something like `np.sum(img.filled(0), axis=0)`, since columns
with invalid pixels will be reduced in value.

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

Author: psavery

hexrd/projections/polar.py

@@ -6,6 +6,7 @@
     _project_on_detector_cylinder,
     _project_on_detector_plane,
 )
+from hexrd.utils.panel_buffer import panel_buffer_as_2d_array
 
 
 class PolarView:
@@ -325,10 +326,25 @@ def _warp_image_from_coordinate_map(
             coordinate_map: dict[str, dict[str, np.ndarray]],
             pad_with_nans: bool = False,
             do_interpolation=True) -> np.ma.MaskedArray:
+
+        panel_buffer_fill_value = np.nan
         img_dict = dict.fromkeys(self.detectors)
         nan_mask = None
         for detector_id, panel in self.detectors.items():
-            img = image_dict[detector_id]
+            # Make a copy since we may modify
+            img = image_dict[detector_id].copy()
+
+            # Before warping, mask out any pixels that are invalid,
+            # so that they won't affect the results.
+            buffer = panel_buffer_as_2d_array(panel)
+            if (np.issubdtype(type(panel_buffer_fill_value), np.floating) and
+                    not np.issubdtype(img.dtype, np.floating)):
+                # Convert to float. This is especially important
+                # for nan, since it is a float...
+                img = img.astype(float)
+
+            img[~buffer] = panel_buffer_fill_value
+
             xypts = coordinate_map[detector_id]['xypts']
             on_panel = coordinate_map[detector_id]['on_panel']
 

hexrd/utils/panel_buffer.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+from hexrd.instrument.detector import Detector
+
+
+def panel_buffer_as_2d_array(panel: Detector) -> np.ndarray:
+    # Take whatever the panel buffer is and convert it to a 2D array
+    if panel.panel_buffer is None:
+        # Just make a panel buffer with all True values
+        return np.ones(panel.shape, dtype=bool)
+    elif panel.panel_buffer.shape == (2,):
+        # The two floats are specifying the borders in mm for x and y.
+        # Convert to pixel borders. Swap x and y so we have i, j in pixels.
+        borders = np.round([
+            panel.panel_buffer[1] / panel.pixel_size_row,
+            panel.panel_buffer[0] / panel.pixel_size_col,
+        ]).astype(int)
+
+        # Convert to array
+        panel_buffer = np.zeros(panel.shape, dtype=bool)
+
+        # We can't do `-borders[i]` since that doesn't work for 0,
+        # so we must do `panel.shape[i] - borders[i]` instead.
+        panel_buffer[borders[0]:panel.shape[0] - borders[0],
+                     borders[1]:panel.shape[1] - borders[1]] = True
+        return panel_buffer
+    elif panel.panel_buffer.ndim == 2:
+        return panel.panel_buffer
+
+    raise NotImplementedError(panel.panel_buffer.ndim)