now havce option to pad blurring mask

Author: Jammy2211

autoarray/dataset/grids.py

@@ -101,7 +101,7 @@ def blurring(self):
         else:
 
             blurring_mask = self.mask.derive_mask.blurring_from(
-                kernel_shape_native=self.psf.kernel.shape_native
+                kernel_shape_native=self.psf.kernel.shape_native, allow_padding=True
             )
 
             self._blurring = Grid2D.from_mask(

autoarray/inversion/mesh/interpolator/knn.py

@@ -149,7 +149,10 @@ def _mappings_sizes_weights(self):
         try:
             query_points = self.data_grid.over_sampled.array
         except AttributeError:
-            query_points = self.data_grid.array
+            try:
+                query_points = self.data_grid.array
+            except AttributeError:
+                query_points = self.data_grid
 
         mappings, weights, _ = get_interpolation_weights(
             points=self.mesh_grid_xy,

autoarray/mask/derive/mask_2d.py

@@ -139,7 +139,9 @@ def all_false(self) -> Mask2D:
             origin=self.mask.origin,
         )
 
-    def blurring_from(self, kernel_shape_native: Tuple[int, int]) -> Mask2D:
+    def blurring_from(
+        self, kernel_shape_native: Tuple[int, int], allow_padding: bool = False
+    ) -> Mask2D:
         """
         Returns a blurring ``Mask2D``, representing all masked pixels (given by ``True``) whose values are blurred
         into unmasked pixels (given by ``False``) when a 2D convolution is performed.
@@ -201,6 +203,7 @@ def blurring_from(self, kernel_shape_native: Tuple[int, int]) -> Mask2D:
         blurring_mask = mask_2d_util.blurring_mask_2d_from(
             mask_2d=self.mask,
             kernel_shape_native=kernel_shape_native,
+            allow_padding=allow_padding,
         )
 
         return Mask2D(

autoarray/mask/mask_2d_util.py

@@ -461,8 +461,48 @@ 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(
+    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.
+
+    Parameters
+    ----------
+    mask_2d
+        2D boolean array where False is unmasked and True is masked.
+    kernel_shape_native
+        (ky, kx) footprint of the convolution kernel.
+
+    Returns
+    -------
+    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).
+    """
+    mask_2d = np.asarray(mask_2d, dtype=bool)
+
+    ky, kx = kernel_shape_native
+    if ky <= 0 or kx <= 0:
+        raise ValueError(
+            f"kernel_shape_native must be positive, got {kernel_shape_native}."
+        )
+
+    pad_y, pad_x = ky // 2, kx // 2
+    y_distance, x_distance = min_false_distance_to_edge(mask_2d)
+
+    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)
+
+
 def blurring_mask_2d_from(
-    mask_2d: np.ndarray, kernel_shape_native: Tuple[int, int]
+    mask_2d: np.ndarray,
+    kernel_shape_native: Tuple[int, int],
+    allow_padding: bool = False,
 ) -> np.ndarray:
     """
     Return the blurring mask for a 2D mask and kernel footprint.
@@ -472,51 +512,79 @@ def blurring_mask_2d_from(
     - True  = masked   (excluded)
 
     The returned *blurring mask* is a mask where the blurring-region pixels are unmasked (False).
+
+    Parameters
+    ----------
+    mask_2d
+        2D boolean mask.
+    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.
     """
     mask_2d = np.asarray(mask_2d, dtype=bool)
 
-    ky, kx = kernel_shape_native
-    if ky <= 0 or kx <= 0:
-        raise ValueError(
-            f"kernel_shape_native must be positive, got {kernel_shape_native}."
+    required_shape = blurring_mask_required_shape_from(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. "
+                f"Current shape: {mask_2d.shape}, required shape: {required_shape}. "
+                "Set allow_padding=True to pad automatically."
+            )
+
+        warnings.warn(
+            f"Mask padded from {mask_2d.shape} to {required_shape} "
+            f"to support kernel footprint {kernel_shape_native}.",
+            UserWarning,
         )
 
-    # Keep your existing guard (optional)
-    y_distance, x_distance = min_false_distance_to_edge(mask_2d)
-    if (y_distance < ky // 2) or (x_distance < kx // 2):
-        raise exc.MaskException(
-            "The input mask is too small for the kernel shape. "
-            "Please pad the mask before computing the blurring mask."
+        dy = required_shape[0] - mask_2d.shape[0]
+        dx = required_shape[1] - mask_2d.shape[1]
+
+        pad_top = dy // 2
+        pad_bottom = dy - pad_top
+        pad_left = dx // 2
+        pad_right = dx - pad_left
+
+        mask_2d = np.pad(
+            mask_2d,
+            pad_width=((pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=True,  # outside is masked
         )
 
-    # Kernel footprint (support only)
+    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
 
-    # Explicit padding: outside-of-array is masked => outside is NOT unmasked (False)
-    pad_y, pad_x = ky // 2, kx // 2
+    # Pad so outside behaves as masked
     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 that are near unmasked pixels
-    blurring_region = mask_2d & near_unmasked  # True on the ring (in region-space)
+    blurring_region = mask_2d & near_unmasked
 
-    # Convert region -> mask semantics: ring should be unmasked (False)
-    blurring_mask = np.ones_like(mask_2d, dtype=bool)  # start fully masked
-    blurring_mask[blurring_region] = False  # unmask the ring
+    blurring_mask = np.ones_like(mask_2d, dtype=bool)
+    blurring_mask[blurring_region] = False
 
     return blurring_mask