merge

Author: Jammy2211

autoarray/geometry/geometry_util.py

@@ -2,8 +2,6 @@
 import numpy as np
 from typing import Tuple, Union
 
-
-from autoarray import numba_util
 from autoarray import type as ty
 
 
@@ -178,70 +176,6 @@ def convert_pixel_scales_2d(pixel_scales: ty.PixelScales) -> Tuple[float, float]
     return pixel_scales
 
 
-@numba_util.jit()
-def central_pixel_coordinates_2d_numba_from(
-    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``)
-    from the shape of that data structure.
-
-    Examples of the central pixels are as follows:
-
-    - For a 3x3 image, the central pixel is pixel [1, 1].
-    - For a 4x4 image, the central pixel is [1.5, 1.5].
-
-    Parameters
-    ----------
-    shape_native
-        The dimensions of the data structure, which can be in 1D, 2D or higher dimensions.
-
-    Returns
-    -------
-    The central pixel coordinates of the data structure.
-    """
-    return (float(shape_native[0] - 1) / 2, float(shape_native[1] - 1) / 2)
-
-
-@numba_util.jit()
-def central_scaled_coordinate_2d_numba_from(
-    shape_native: Tuple[int, int],
-    pixel_scales: ty.PixelScales,
-    origin: Tuple[float, float] = (0.0, 0.0),
-) -> Tuple[float, float]:
-    """
-    Returns the central scaled coordinates of a 2D geometry (and therefore a 2D data structure like an ``Array2D``)
-    from the shape of that data structure.
-
-    This is computed by using the data structure's shape and converting it to scaled units using an input
-    pixel-coordinates to scaled-coordinate conversion factor `pixel_scales`.
-
-    The origin of the scaled grid can also be input and moved from (0.0, 0.0).
-
-    Parameters
-    ----------
-    shape_native
-        The 2D shape of the data structure whose central scaled coordinates are computed.
-    pixel_scales
-        The (y,x) scaled units to pixel units conversion factor of the 2D data structure.
-    origin
-        The (y,x) scaled units origin of the coordinate system the central scaled coordinate is computed on.
-
-    Returns
-    -------
-    The central coordinates of the 2D data structure in scaled units.
-    """
-
-    central_pixel_coordinates = central_pixel_coordinates_2d_numba_from(
-        shape_native=shape_native
-    )
-
-    y_pixel = central_pixel_coordinates[0] + (origin[0] / pixel_scales[0])
-    x_pixel = central_pixel_coordinates[1] - (origin[1] / pixel_scales[1])
-
-    return (y_pixel, x_pixel)
-
-
 def central_pixel_coordinates_2d_from(
     shape_native: Tuple[int, int],
 ) -> Tuple[float, float]:
@@ -294,7 +228,7 @@ def central_scaled_coordinate_2d_from(
     The central coordinates of the 2D data structure in scaled units.
     """
 
-    central_pixel_coordinates = central_pixel_coordinates_2d_numba_from(
+    central_pixel_coordinates = central_pixel_coordinates_2d_from(
         shape_native=shape_native
     )
 
@@ -367,7 +301,6 @@ def pixel_coordinates_2d_from(
     return (y_pixel, x_pixel)
 
 
-@numba_util.jit()
 def scaled_coordinates_2d_from(
     pixel_coordinates_2d: Tuple[float, float],
     shape_native: Tuple[int, int],
@@ -411,7 +344,7 @@ def scaled_coordinates_2d_from(
         origin=(0.0, 0.0)
     )
     """
-    central_scaled_coordinates = central_scaled_coordinate_2d_numba_from(
+    central_scaled_coordinates = central_scaled_coordinate_2d_from(
         shape_native=shape_native, pixel_scales=pixel_scales, origin=origins
     )
 

autoarray/inversion/inversion/abstract.py

@@ -74,6 +74,18 @@ def __init__(
             A dictionary which contains timing of certain functions calls which is used for profiling.
         """
 
+        try:
+            import numba
+        except ModuleNotFoundError:
+            raise exc.InversionException(
+                "Inversion functionality (linear light profiles, pixelized reconstructions) is "
+                "disabled if numba is not installed.\n\n"
+                "This is because the run-times without numba are too slow.\n\n"
+                "Please install numba, which is described at the following web page:\n\n"
+                "https://pyautolens.readthedocs.io/en/latest/installation/overview.html"
+            )
+
+
         self.dataset = dataset
 
         self.linear_obj_list = linear_obj_list

autoarray/operators/over_sampling/over_sample_util.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from collections import defaultdict
 import numpy as np
 from typing import TYPE_CHECKING, Union
 from typing import List, Tuple
@@ -8,7 +9,6 @@
 if TYPE_CHECKING:
     from autoarray.structures.grids.uniform_2d import Grid2D
 
-from autoarray.geometry import geometry_util
 from autoarray.mask.mask_2d import Mask2D
 
 from autoarray import numba_util
@@ -49,7 +49,6 @@ def over_sample_size_convert_to_array_2d_from(
     return Array2D(values=np.array(over_sample_size).astype("int"), mask=mask)
 
 
-@numba_util.jit()
 def total_sub_pixels_2d_from(sub_size: np.ndarray) -> int:
     """
     Returns the total number of sub-pixels in unmasked pixels in a mask.
@@ -115,14 +114,15 @@ def slim_index_for_sub_slim_index_via_mask_2d_from(
     n_unmasked = unmasked_indices.shape[0]
 
     # Step 2: Compute total number of sub-pixels
-    sub_pixels_per_pixel = sub_size ** 2
+    sub_pixels_per_pixel = sub_size**2
 
     # Step 3: Repeat slim indices for each sub-pixel
     slim_indices = np.arange(n_unmasked)
     slim_index_for_sub_slim_index = np.repeat(slim_indices, sub_pixels_per_pixel)
 
     return slim_index_for_sub_slim_index
 
+
 def sub_size_radial_bins_from(
     radial_grid: np.ndarray,
     sub_size_list: np.ndarray,
@@ -169,7 +169,6 @@ def sub_size_radial_bins_from(
     return sub_size_list[bin_indices]
 
 
-# @numba_util.jit()
 def grid_2d_slim_over_sampled_via_mask_from(
     mask_2d: np.ndarray,
     pixel_scales: ty.PixelScales,
@@ -215,120 +214,58 @@ def grid_2d_slim_over_sampled_via_mask_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_sub_pixels = np.sum(sub_size**2)
-
-    grid_slim = np.zeros(shape=(total_sub_pixels, 2))
-
-    centres_scaled = geometry_util.central_scaled_coordinate_2d_numba_from(
-        shape_native=mask_2d.shape, pixel_scales=pixel_scales, origin=origin
-    )
-
-    index = 0
-    sub_index = 0
-
-    for y in range(mask_2d.shape[0]):
-        for x in range(mask_2d.shape[1]):
-            if not mask_2d[y, x]:
-                sub = sub_size[index]
-
-                y_sub_half = pixel_scales[0] / 2
-                y_sub_step = pixel_scales[0] / (sub)
-
-                x_sub_half = pixel_scales[1] / 2
-                x_sub_step = pixel_scales[1] / (sub)
-
-                y_scaled = (y - centres_scaled[0]) * pixel_scales[0]
-                x_scaled = (x - centres_scaled[1]) * pixel_scales[1]
-
-                for y1 in range(sub):
-                    for x1 in range(sub):
-                        grid_slim[sub_index, 0] = -(
-                            y_scaled - y_sub_half + y1 * y_sub_step + (y_sub_step / 2.0)
-                        )
-                        grid_slim[sub_index, 1] = (
-                            x_scaled - x_sub_half + x1 * x_sub_step + (x_sub_step / 2.0)
-                        )
-                        sub_index += 1
-
-                index += 1
-
-    return grid_slim
-
-
-@numba_util.jit()
-def binned_array_2d_from(
-    array_2d: np.ndarray,
-    mask_2d: np.ndarray,
-    sub_size: np.ndarray,
-) -> np.ndarray:
-    """
-    For a sub-grid, every unmasked pixel of its 2D mask with shape (total_y_pixels, total_x_pixels) is divided into
-    a finer uniform grid of shape (total_y_pixels*sub_size, total_x_pixels*sub_size). This routine computes the (y,x)
-    scaled coordinates a the centre of every sub-pixel defined by this 2D mask array.
-
-    The sub-grid is returned on an array of shape (total_unmasked_pixels*sub_size**2, 2). y coordinates are
-    stored in the 0 index of the second dimension, x coordinates in the 1 index. Masked coordinates are therefore
-    removed and not included in the slimmed grid.
-
-    Grid2D are defined from the top-left corner, where the first unmasked sub-pixel corresponds to index 0.
-    Sub-pixels that are part of the same mask array pixel are indexed next to one another, such that the second
-    sub-pixel in the first pixel has index 1, its next sub-pixel has index 2, and so forth.
-
-    Parameters
-    ----------
-    mask_2d
-        A 2D array of bools, where `False` values are unmasked and therefore included as part of the calculated
-        sub-grid.
-    pixel_scales
-        The (y,x) scaled units to pixel units conversion factor of the 2D mask array.
-    sub_size
-        The size of the sub-grid that each pixel of the 2D mask array is divided into.
-    origin
-        The (y,x) origin of the 2D array, which the sub-grid is shifted around.
-
-    Returns
-    -------
-    ndarray
-        A slimmed sub grid of (y,x) scaled coordinates at the centre of every pixel unmasked pixel on the 2D mask
-        array. The sub grid array has dimensions (total_unmasked_pixels*sub_size**2, 2).
-
-    Examples
-    --------
-    mask = np.array([[True, False, True],
-                     [False, False, False]
-                     [True, False, True]])
-    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 = np.sum(~mask_2d)
-
-    sub_fraction = 1.0 / sub_size**2
-
-    binned_array_2d_slim = np.zeros(shape=total_pixels)
-
-    index = 0
-    sub_index = 0
-
-    for y in range(mask_2d.shape[0]):
-        for x in range(mask_2d.shape[1]):
-            if not mask_2d[y, x]:
-                sub = sub_size[index]
-
-                for y1 in range(sub):
-                    for x1 in range(sub):
-                        # if use_jax:
-                        #     binned_array_2d_slim = binned_array_2d_slim.at[index].add(
-                        #         array_2d[sub_index] * sub_fraction[index]
-                        #     )
-                        # else:
-                        binned_array_2d_slim[index] += (
-                            array_2d[sub_index] * sub_fraction[index]
-                        )
-                        sub_index += 1
-
-                index += 1
-
-    return binned_array_2d_slim
+    H, W = mask_2d.shape
+    sy, sx = pixel_scales
+    oy, ox = origin
+
+    # 1) Find unmasked pixels in row-major order
+    rows, cols = np.nonzero(~mask_2d)
+    Npix = rows.size
+
+    # 2) Normalize sub_size input
+    sub_arr = np.asarray(sub_size)
+    sub_arr = np.full(Npix, sub_arr, dtype=int) if sub_arr.size == 1 else sub_arr
+
+    # 3) Pixel centers in physical coords, y↑up
+    cy = (H - 1) / 2.0
+    cx = (W - 1) / 2.0
+    y_pix = (cy - rows) * sy + oy
+    x_pix = (cols - cx) * sx + ox
+
+    # Pre‐group pixel indices by sub_size
+    groups = defaultdict(list)
+    for i, s in enumerate(sub_arr):
+        groups[s].append(i)
+
+    # Prepare output
+    total = np.sum(sub_arr * sub_arr)
+    coords = np.empty((total, 2), float)
+    idx = 0
+
+    for s, pix_indices in groups.items():
+        # Compute offsets once for this sub_size
+        dy, dx = sy / s, sx / s
+        y_off = np.linspace(+sy / 2 - dy / 2, -sy / 2 + dy / 2, s)
+        x_off = np.linspace(-sx / 2 + dx / 2, +sx / 2 - dx / 2, s)
+        y_sub, x_sub = np.meshgrid(y_off, x_off, indexing="ij")
+        y_sub = y_sub.ravel()
+        x_sub = x_sub.ravel()
+        n_sub = s * s
+
+        # Now vectorize over all pixels in this group
+        pix_idx = np.array(pix_indices)
+        y_centers = y_pix[pix_idx]
+        x_centers = x_pix[pix_idx]
+
+        # Repeat‐tile to shape (len(pix_idx)*n_sub,)
+        all_y = np.repeat(y_centers, n_sub) + np.tile(y_sub, len(pix_idx))
+        all_x = np.repeat(x_centers, n_sub) + np.tile(x_sub, len(pix_idx))
+
+        coords[idx : idx + all_y.size, 0] = all_y
+        coords[idx : idx + all_x.size, 1] = all_x
+        idx += all_y.size
+
+    return coords
 
 
 def over_sample_size_via_radial_bins_from(

autoarray/operators/over_sampling/over_sampler.py

@@ -230,6 +230,20 @@ def binned_array_2d_from(self, array: Array2D) -> "Array2D":
         In **PyAutoCTI** all `Array2D` objects are used in their `native` representation without sub-gridding.
         Significant memory can be saved by only store this format, thus the `native_binned_only` config override
         can force this behaviour. It is recommended users do not use this option to avoid unexpected behaviour.
+
+        Old docstring:
+
+        For a sub-grid, every unmasked pixel of its 2D mask with shape (total_y_pixels, total_x_pixels) is divided into
+        a finer uniform grid of shape (total_y_pixels*sub_size, total_x_pixels*sub_size). This routine computes the (y,x)
+        scaled coordinates a the centre of every sub-pixel defined by this 2D mask array.
+
+        The sub-grid is returned on an array of shape (total_unmasked_pixels*sub_size**2, 2). y coordinates are
+        stored in the 0 index of the second dimension, x coordinates in the 1 index. Masked coordinates are therefore
+        removed and not included in the slimmed grid.
+
+        Grid2D are defined from the top-left corner, where the first unmasked sub-pixel corresponds to index 0.
+        Sub-pixels that are part of the same mask array pixel are indexed next to one another, such that the second
+        sub-pixel in the first pixel has index 1, its next sub-pixel has index 2, and so forth.
         """
         if conf.instance["general"]["structures"]["native_binned_only"]:
             return self
@@ -258,7 +272,6 @@ def binned_array_2d_from(self, array: Array2D) -> "Array2D":
             mask=self.mask,
         )
 
-
     @cached_property
     def slim_for_sub_slim(self) -> np.ndarray:
         """