enforce odd x odd or even x even

Author: Jammy2211

autoarray/dataset/grids.py

@@ -104,6 +104,8 @@ def blurring(self):
                 kernel_shape_native=self.psf.kernel.shape_native, allow_padding=True
             )
 
+            blurring_mask = blurring_mask.resized_from(new_shape=(120, 120))
+
             self._blurring = Grid2D.from_mask(
                 mask=blurring_mask,
                 over_sample_size=1,

autoarray/mask/mask_2d_util.py

@@ -461,13 +461,21 @@ def min_false_distance_to_edge(mask: np.ndarray) -> Tuple[int, int]:
     return min(top_dist, bottom_dist), min(left_dist, right_dist)
 
 
-def blurring_mask_required_shape_from(
+import warnings
+from typing import Tuple
+
+import numpy as np
+from scipy.ndimage import binary_dilation
+
+
+def required_shape_for_kernel(
     mask_2d: np.ndarray,
     kernel_shape_native: Tuple[int, int],
 ) -> Tuple[int, int]:
     """
     Return the minimal shape the mask must be padded to so that a kernel with the given
-    footprint can be applied without sampling beyond the array edge.
+    footprint can be applied without sampling beyond the array edge, while preserving
+    parity (odd->odd, even->even) in each dimension.
 
     Parameters
     ----------
@@ -480,7 +488,8 @@ def blurring_mask_required_shape_from(
     -------
     required_shape
         The minimal (ny, nx) shape such that the minimum distance from any unmasked
-        pixel to the array edge is at least (ky//2, kx//2).
+        pixel to the array edge is at least (ky//2, kx//2), and each dimension keeps
+        the same parity as the input mask.
     """
     mask_2d = np.asarray(mask_2d, dtype=bool)
 
@@ -496,7 +505,16 @@ def blurring_mask_required_shape_from(
     extra_y = max(0, pad_y - y_distance)
     extra_x = max(0, pad_x - x_distance)
 
-    return (mask_2d.shape[0] + 2 * extra_y, mask_2d.shape[1] + 2 * extra_x)
+    new_y = mask_2d.shape[0] + 2 * extra_y
+    new_x = mask_2d.shape[1] + 2 * extra_x
+
+    # Preserve parity per axis: odd->odd, even->even
+    if (new_y % 2) != (mask_2d.shape[0] % 2):
+        new_y += 1
+    if (new_x % 2) != (mask_2d.shape[1] % 2):
+        new_x += 1
+
+    return new_y, new_x
 
 
 def blurring_mask_2d_from(
@@ -511,7 +529,13 @@ def blurring_mask_2d_from(
     - False = unmasked (included)
     - True  = masked   (excluded)
 
-    The returned *blurring mask* is a mask where the blurring-region pixels are unmasked (False).
+    The returned blurring mask is a *mask* where the blurring-region pixels are
+    unmasked (False) and all other pixels are masked (True).
+
+    If the input mask is too small for the kernel footprint:
+    - allow_padding=False (default): raises an exception.
+    - allow_padding=True: pads the mask symmetrically with masked pixels (True) to the
+      minimal required shape (with parity preserved) and emits a warning.
 
     Parameters
     ----------
@@ -520,17 +544,18 @@ def blurring_mask_2d_from(
     kernel_shape_native
         (ky, kx) kernel footprint.
     allow_padding
-        If False (default), raises an exception when the mask is too small
-        for the kernel footprint.
-        If True, pads the mask symmetrically with masked pixels (True) to the
-        minimal required shape and emits a warning.
+        If False, raise if padding is required. If True, pad and warn.
+
+    Returns
+    -------
+    blurring_mask
+        Boolean mask of the same shape as the (possibly padded) input.
     """
     mask_2d = np.asarray(mask_2d, dtype=bool)
 
-    required_shape = blurring_mask_required_shape_from(mask_2d, kernel_shape_native)
+    required_shape = required_shape_for_kernel(mask_2d, kernel_shape_native)
 
     if required_shape != mask_2d.shape:
-
         if not allow_padding:
             raise exc.MaskException(
                 "The input mask is too small for the kernel shape. "
@@ -540,7 +565,7 @@ def blurring_mask_2d_from(
 
         warnings.warn(
             f"Mask padded from {mask_2d.shape} to {required_shape} "
-            f"to support kernel footprint {kernel_shape_native}.",
+            f"(parity preserved) to support kernel footprint {kernel_shape_native}.",
             UserWarning,
         )
 
@@ -559,36 +584,45 @@ def blurring_mask_2d_from(
             constant_values=True,  # outside is masked
         )
 
+    # (Optional) hard invariant: parity preserved after any padding
+    if (mask_2d.shape[0] % 2) != (required_shape[0] % 2) or (mask_2d.shape[1] % 2) != (
+        required_shape[1] % 2
+    ):
+        raise RuntimeError(
+            f"Parity invariant violated: got {mask_2d.shape}, expected parity of {required_shape}."
+        )
+
     ky, kx = kernel_shape_native
     pad_y, pad_x = ky // 2, kx // 2
     structure = np.ones((ky, kx), dtype=bool)
 
     # Unmasked region (True where unmasked)
     unmasked = ~mask_2d
 
-    # Pad so outside behaves as masked
+    # Explicit padding so outside behaves as masked => outside is NOT unmasked
     unmasked_padded = np.pad(
         unmasked,
         pad_width=((pad_y, pad_y), (pad_x, pad_x)),
         mode="constant",
         constant_values=False,
     )
 
+    # Pixels within kernel footprint of any unmasked pixel
     near_unmasked_padded = binary_dilation(unmasked_padded, structure=structure)
-
     near_unmasked = near_unmasked_padded[
         pad_y : pad_y + mask_2d.shape[0],
         pad_x : pad_x + mask_2d.shape[1],
     ]
 
+    # Blurring region: masked pixels near unmasked pixels
     blurring_region = mask_2d & near_unmasked
 
+    # Return as a mask: blurring region is unmasked (False), everything else masked (True)
     blurring_mask = np.ones_like(mask_2d, dtype=bool)
     blurring_mask[blurring_region] = False
 
     return blurring_mask
 
-
 def mask_slim_indexes_from(
     mask_2d: np.ndarray, return_masked_indexes: bool = True
 ) -> np.ndarray: