mask circular converts and some aspect simplified

Author: Jammy2211

autoarray/geometry/geometry_util.py

@@ -182,7 +182,7 @@ def convert_pixel_scales_2d(pixel_scales: ty.PixelScales) -> Tuple[float, float]
 
 @numba_util.jit()
 def central_pixel_coordinates_2d_from(
-    shape_native: Tuple[int, int]
+    shape_native: Tuple[int, int],
 ) -> Tuple[float, float]:
     """
     Returns the central pixel coordinates of a 2D geometry (and therefore a 2D data structure like an ``Array2D``)
@@ -477,7 +477,6 @@ def grid_pixels_2d_slim_from(
                                                            pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))
     """
 
-
     centres_scaled = central_scaled_coordinate_2d_from(
         shape_native=shape_native, pixel_scales=pixel_scales, origin=origin
     )
@@ -544,7 +543,6 @@ def grid_pixel_centres_2d_slim_from(
                                                            pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))
     """
 
-
     centres_scaled = central_scaled_coordinate_2d_from(
         shape_native=shape_native, pixel_scales=pixel_scales, origin=origin
     )
@@ -629,8 +627,10 @@ def grid_pixel_indexes_2d_slim_from(
 
     if use_jax:
         grid_pixel_indexes_2d_slim = (
-            grid_pixels_2d_slim * np.array([shape_native[1], 1])
-        ).sum(axis=1).astype(int)
+            (grid_pixels_2d_slim * np.array([shape_native[1], 1]))
+            .sum(axis=1)
+            .astype(int)
+        )
     else:
         grid_pixel_indexes_2d_slim = np.zeros(grid_pixels_2d_slim.shape[0])
 
@@ -690,7 +690,9 @@ def grid_scaled_2d_slim_from(
         centres_scaled = np.array(centres_scaled)
         pixel_scales = np.array(pixel_scales)
         sign = np.array([-1, 1])
-        grid_scaled_2d_slim = (grid_pixels_2d_slim - centres_scaled - 0.5) * pixel_scales * sign
+        grid_scaled_2d_slim = (
+            (grid_pixels_2d_slim - centres_scaled - 0.5) * pixel_scales * sign
+        )
     else:
         grid_scaled_2d_slim = np.zeros((grid_pixels_2d_slim.shape[0], 2))
 
@@ -755,7 +757,7 @@ def grid_pixel_centres_2d_from(
         centres_scaled = np.array(centres_scaled)
         pixel_scales = np.array(pixel_scales)
         sign = np.array([-1.0, 1.0])
-        grid_pixels_2d =  (
+        grid_pixels_2d = (
             (sign * grid_scaled_2d / pixel_scales) + centres_scaled + 0.5
         ).astype(int)
     else:
@@ -764,17 +766,21 @@ def grid_pixel_centres_2d_from(
         for y in range(grid_scaled_2d.shape[0]):
             for x in range(grid_scaled_2d.shape[1]):
                 grid_pixels_2d[y, x, 0] = int(
-                    (-grid_scaled_2d[y, x, 0] / pixel_scales[0]) + centres_scaled[0] + 0.5
+                    (-grid_scaled_2d[y, x, 0] / pixel_scales[0])
+                    + centres_scaled[0]
+                    + 0.5
                 )
                 grid_pixels_2d[y, x, 1] = int(
-                    (grid_scaled_2d[y, x, 1] / pixel_scales[1]) + centres_scaled[1] + 0.5
+                    (grid_scaled_2d[y, x, 1] / pixel_scales[1])
+                    + centres_scaled[1]
+                    + 0.5
                 )
 
     return grid_pixels_2d
 
 
 def extent_symmetric_from(
-    extent: Tuple[float, float, float, float]
+    extent: Tuple[float, float, float, float],
 ) -> Tuple[float, float, float, float]:
     """
     Given an input extent of the form (x_min, x_max, y_min, y_max), this function returns an extent which is

autoarray/inversion/pixelization/border_relocator.py

@@ -48,7 +48,7 @@ def sub_slim_indexes_for_slim_index_via_mask_2d_from(
     sub_mask_1d_indexes_for_mask_1d_index = sub_mask_1d_indexes_for_mask_1d_index_from(mask=mask, sub_size=2)
     """
 
-    total_pixels = mask_2d_util.total_pixels_2d_from(mask_2d=mask_2d)
+    total_pixels = np.sum(~mask_2d)
 
     sub_slim_indexes_for_slim_index = [[] for _ in range(total_pixels)]
 

autoarray/inversion/pixelization/mesh/mesh_util.py

@@ -7,7 +7,7 @@
 
 @numba_util.jit()
 def rectangular_neighbors_from(
-    shape_native: Tuple[int, int]
+    shape_native: Tuple[int, int],
 ) -> Tuple[np.ndarray, np.ndarray]:
     """
     Returns the 4 (or less) adjacent neighbors of every pixel on a rectangular pixelization as an ndarray of shape

autoarray/mask/abstract_mask.py

@@ -4,6 +4,7 @@
 import logging
 
 from autoarray.numpy_wrapper import np, use_jax
+
 if use_jax:
     import jax
 from pathlib import Path

autoarray/mask/mask_2d_util.py

@@ -8,118 +8,78 @@
 from autoarray.numpy_wrapper import use_jax, np as jnp
 
 
-@numba_util.jit()
 def mask_2d_centres_from(
-    shape_native: Tuple[int, int],
-    pixel_scales: ty.PixelScales,
-    centre: Tuple[float, float],
-) -> Tuple[float, float]:
+    shape_native: tuple[int, int],
+    pixel_scales: tuple[float, float],
+    centre: tuple[float, float],
+) -> tuple[float, float]:
     """
-    Returns the (y,x) scaled central coordinates of a mask from its shape, pixel-scales and centre.
+    Compute the (y, x) scaled central coordinates of a mask given its shape, pixel-scales, and centre.
 
-    The coordinate system is defined such that the positive y axis is up and positive x axis is right.
+    The coordinate system is defined such that the positive y-axis is up and the positive x-axis is right.
 
     Parameters
     ----------
     shape_native
-        The (y,x) shape of the 2D array the scaled centre is computed for.
+        The shape of the 2D array in pixels.
     pixel_scales
-        The (y,x) scaled units to pixel units conversion factor of the 2D array.
-    centre : (float, flloat)
-        The (y,x) centre of the 2D mask.
-
-    Returns
-    -------
-    tuple (float, float)
-        The (y,x) scaled central coordinates of the input array.
-
-    Examples
-    --------
-    centres_scaled = centres_from(shape=(5,5), pixel_scales=(0.5, 0.5), centre=(0.0, 0.0))
-    """
-    y_centre_scaled = (float(shape_native[0] - 1) / 2) - (centre[0] / pixel_scales[0])
-    x_centre_scaled = (float(shape_native[1] - 1) / 2) + (centre[1] / pixel_scales[1])
-
-    return (y_centre_scaled, x_centre_scaled)
-
-
-@numba_util.jit()
-def total_pixels_2d_from(mask_2d: np.ndarray) -> int:
-    """
-    Returns the total number of unmasked pixels in a mask.
-
-    Parameters
-    ----------
-    mask_2d
-        A 2D array of bools, where `False` values are unmasked and included when counting pixels.
+        The conversion factors from pixels to scaled units.
+    centre
+        The central coordinate of the mask in scaled units.
 
     Returns
     -------
-    int
-        The total number of pixels that are unmasked.
+    The (y, x) scaled central coordinates of the input array.
 
     Examples
     --------
-
-    mask = np.array([[True, False, True],
-                 [False, False, False]
-                 [True, False, True]])
-
-    total_regular_pixels = total_regular_pixels_from(mask=mask)
+    centres_scaled = mask_2d_centres_from(shape_native=(5, 5), pixel_scales=(0.5, 0.5), centre=(0.0, 0.0))
     """
-    if use_jax:
-        return (~mask_2d.astype(bool)).sum()
-
-    else:
-        total_regular_pixels = 0
-
-        for y in range(mask_2d.shape[0]):
-            for x in range(mask_2d.shape[1]):
-                if not mask_2d[y, x]:
-                    total_regular_pixels += 1
-
-        return total_regular_pixels
+    return (
+        0.5 * (shape_native[0] - 1) - (centre[0] / pixel_scales[0]),
+        0.5 * (shape_native[1] - 1) + (centre[1] / pixel_scales[1]),
+    )
 
 
-@numba_util.jit()
 def mask_2d_circular_from(
-    shape_native: Tuple[int, int],
-    pixel_scales: ty.PixelScales,
+    shape_native: tuple[int, int],
+    pixel_scales: tuple[float, float],
     radius: float,
-    centre: Tuple[float, float] = (0.0, 0.0),
+    centre: tuple[float, float] = (0.0, 0.0),
 ) -> np.ndarray:
     """
-    Returns a circular mask from the 2D mask array shape and radius of the circle.
+    Create a circular mask within a 2D array.
 
-    This creates a 2D array where all values within the mask radius are unmasked and therefore `False`.
+    This generates a 2D array where all values within the specified radius are unmasked (set to `False`).
 
     Parameters
     ----------
-    shape_native: Tuple[int, int]
-        The (y,x) shape of the mask in units of pixels.
+    shape_native
+        The shape of the mask array in pixels.
     pixel_scales
-        The scaled units to pixel units conversion factor of each pixel.
+        The conversion factors from pixels to scaled units.
     radius
-        The radius (in scaled units) of the circle within which pixels unmasked.
+        The radius of the circular mask in scaled units.
     centre
-            The centre of the circle used to mask pixels.
+        The central coordinate of the circle in scaled units.
 
     Returns
     -------
-    ndarray
-        The 2D mask array whose central pixels are masked as a circle.
+    The 2D mask array with the central region defined by the radius unmasked (False).
 
     Examples
     --------
-    mask = mask_circular_from(
-        shape=(10, 10), pixel_scales=0.1, radius=0.5, centre=(0.0, 0.0))
+    mask = mask_2d_circular_from(shape_native=(10, 10), pixel_scales=(0.1, 0.1), radius=0.5, centre=(0.0, 0.0))
     """
     centres_scaled = mask_2d_centres_from(shape_native, pixel_scales, centre)
-    ys, xs = np.indices(shape_native)
-    return (radius * radius) < (
-            np.square((ys - centres_scaled[0]) * pixel_scales[0]) +
-            np.square((xs - centres_scaled[1]) * pixel_scales[1])
-        )
+
+    y, x = np.ogrid[: shape_native[0], : shape_native[1]]
+    y_scaled = (y - centres_scaled[0]) * pixel_scales[0]
+    x_scaled = (x - centres_scaled[1]) * pixel_scales[1]
+
+    distances_squared = x_scaled**2 + y_scaled**2
+
+    return distances_squared >= radius**2
 
 
 @numba_util.jit()
@@ -1047,7 +1007,7 @@ def native_index_for_slim_index_2d_from(
     if use_jax:
         return jnp.stack(jnp.nonzero(~mask_2d.astype(bool))).T
     else:
-        total_pixels = total_pixels_2d_from(mask_2d=mask_2d)
+        total_pixels = np.sum(~mask_2d)
         native_index_for_slim_index_2d = np.zeros(shape=(total_pixels, 2))
         slim_index = 0
 

autoarray/operators/contour.py

@@ -58,7 +58,9 @@ def contour_array(self):
     @property
     def contour_list(self):
         # make sure to use base numpy to convert JAX array back to a normal array
-        contour_indices_list = measure.find_contours(numpy.array(self.contour_array.array), 0)
+        contour_indices_list = measure.find_contours(
+            numpy.array(self.contour_array.array), 0
+        )
 
         if len(contour_indices_list) == 0:
             return []

autoarray/operators/over_sampling/over_sample_util.py

@@ -528,9 +528,7 @@ def binned_array_2d_from(
     grid_slim = grid_2d_slim_over_sampled_via_mask_from(mask=mask, pixel_scales=(0.5, 0.5), sub_size=1, origin=(0.0, 0.0))
     """
 
-    total_pixels = mask_2d_util.total_pixels_2d_from(
-        mask_2d=mask_2d,
-    )
+    total_pixels = np.sum(~mask_2d)
 
     sub_fraction = 1.0 / sub_size**2
 

autoarray/operators/over_sampling/over_sampler.py

@@ -11,6 +11,7 @@
 
 from autofit.jax_wrapper import register_pytree_node_class
 
+
 @register_pytree_node_class
 class OverSampler:
     def __init__(self, mask: Mask2D, sub_size: Union[int, Array2D]):

autoarray/plot/multi_plotters.py

@@ -315,7 +315,7 @@ def output_to_fits(
         output_path = self.plotter_list[0].mat_plot_2d.output.output_path_from(
             format="fits_multi"
         )
-        output_fits_file = Path(output_path)/ f"{filename}.fits"
+        output_fits_file = Path(output_path) / f"{filename}.fits"
 
         if remove_fits_first:
             output_fits_file.unlink(missing_ok=True)