image mesh refactor all unit tests pass

Author: Jammy2211

autoarray/inversion/pixelization/image_mesh/hilbert.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 import numpy as np
+import os
 
 from typing import Optional
 
@@ -238,7 +239,6 @@ def image_plane_mesh_grid_from(
         self,
         mask: Mask2D,
         adapt_data: Optional[np.ndarray],
-        settings: SettingsInversion = None,
     ) -> Grid2DIrregular:
         """
         Returns an image mesh by running the Hilbert curve on the weight map.
@@ -290,14 +290,6 @@ def image_plane_mesh_grid_from(
 
         mesh_grid = Grid2DIrregular(values=np.stack((drawn_y, drawn_x), axis=-1))
 
-        self.check_mesh_pixels_per_image_pixels(
-            mask=mask, mesh_grid=mesh_grid, settings=settings
-        )
-
-        self.check_adapt_background_pixels(
-            mask=mask, mesh_grid=mesh_grid, adapt_data=adapt_data, settings=settings
-        )
-
         return mesh_grid
 
     def check_mesh_pixels_per_image_pixels(
@@ -344,21 +336,20 @@ def check_mesh_pixels_per_image_pixels(
         if os.environ.get("PYAUTOFIT_TEST_MODE") == "1":
             return
 
-        if settings is not None:
-            if image_mesh_min_mesh_pixels_per_pixel is not None:
-                mesh_pixels_per_image_pixels = self.mesh_pixels_per_image_pixels_from(
-                    mask=mask, mesh_grid=mesh_grid
-                )
+        if image_mesh_min_mesh_pixels_per_pixel is not None:
+            mesh_pixels_per_image_pixels = self.mesh_pixels_per_image_pixels_from(
+                mask=mask, mesh_grid=mesh_grid
+            )
 
-                indices_of_highest_values = np.argsort(mesh_pixels_per_image_pixels)[
-                    -image_mesh_min_mesh_number:
-                ]
-                lowest_mesh_pixels = np.min(
-                    mesh_pixels_per_image_pixels[indices_of_highest_values]
-                )
+            indices_of_highest_values = np.argsort(mesh_pixels_per_image_pixels)[
+                -image_mesh_min_mesh_number:
+            ]
+            lowest_mesh_pixels = np.min(
+                mesh_pixels_per_image_pixels[indices_of_highest_values]
+            )
 
-                if lowest_mesh_pixels < image_mesh_min_mesh_pixels_per_pixel:
-                    raise exc.InversionException()
+            if lowest_mesh_pixels < image_mesh_min_mesh_pixels_per_pixel:
+                raise exc.InversionException()
 
         return mesh_grid
 
@@ -412,27 +403,26 @@ def check_adapt_background_pixels(
         if os.environ.get("PYAUTOFIT_TEST_MODE") == "1":
             return
 
-        if settings is not None:
-            if image_mesh_adapt_background_percent_threshold is not None:
-                pixels = mesh_grid.shape[0]
+        if image_mesh_adapt_background_percent_threshold is not None:
+            pixels = mesh_grid.shape[0]
 
-                pixels_in_background = int(
-                    mask.shape_slim * image_mesh_adapt_background_percent_check
-                )
+            pixels_in_background = int(
+                mask.shape_slim * image_mesh_adapt_background_percent_check
+            )
 
-                indices_of_lowest_values = np.argsort(adapt_data)[:pixels_in_background]
-                mask_background = np.zeros_like(adapt_data, dtype=bool)
-                mask_background[indices_of_lowest_values] = True
+            indices_of_lowest_values = np.argsort(adapt_data)[:pixels_in_background]
+            mask_background = np.zeros_like(adapt_data, dtype=bool)
+            mask_background[indices_of_lowest_values] = True
 
-                mesh_pixels_per_image_pixels = self.mesh_pixels_per_image_pixels_from(
-                    mask=mask, mesh_grid=mesh_grid
-                )
+            mesh_pixels_per_image_pixels = self.mesh_pixels_per_image_pixels_from(
+                mask=mask, mesh_grid=mesh_grid
+            )
 
-                mesh_pixels_in_background = sum(
-                    mesh_pixels_per_image_pixels[mask_background]
-                )
+            mesh_pixels_in_background = sum(
+                mesh_pixels_per_image_pixels[mask_background]
+            )
 
-                if mesh_pixels_in_background < (
-                    pixels * image_mesh_adapt_background_percent_threshold
-                ):
-                    raise exc.InversionException()
+            if mesh_pixels_in_background < (
+                pixels * image_mesh_adapt_background_percent_threshold
+            ):
+                raise exc.InversionException()

autoarray/preloads.py

@@ -22,7 +22,7 @@ def __init__(
         self,
         mapper_indices: np.ndarray = None,
         source_pixel_zeroed_indices: np.ndarray = None,
-        image_plane_mesh_grid: np.ndarray = None,
+        image_plane_mesh_grid_list: np.ndarray = None,
         linear_light_profile_blurred_mapping_matrix=None,
     ):
         """
@@ -37,6 +37,29 @@ def __init__(
         the source model is fixed (e.g. when fitting only the lens light), sections of the curvature matrix do not
         change and can be reused, avoiding redundant computation.
 
+        Returns a list of image-plane mesh-grids, which are image-plane grids defining the centres of the pixels of
+        the pixelization's mesh (e.g. the centres of Voronoi pixels).
+
+        The `image_mesh` attribute of the pixelization object defines whether the centre of each mesh pixel are
+        determined in the image-plane. When this is the case, the pixelization therefore has an image-plane mesh-grid,
+        which needs to be computed before the inversion is performed.
+
+        This function iterates over all galaxies with pixelizations, determines which pixelizations have an
+        `image_mesh` and for these pixelizations computes the image-plane mesh-grid.
+
+        It returns a list of all image-plane mesh-grids, which in the functions `mapper_from` and `mapper_galaxy_dict`
+        are grouped into a `Mapper` object with other information required to perform the inversion using the
+        pixelization.
+
+        The order of this list is not important, because the `linear_obj_galaxy_dict` function associates each
+        mapper object (and therefore image-plane mesh-grid) with the galaxy it belongs to and is therefore used
+        elsewhere in the code (e.g. the fit module) to match inversion results to galaxies.
+
+        Certain image meshes adapt their pixels to the dataset, for example congregating the pixels to the brightest
+        regions of the image. This requires that `adapt_images` are used when setting up the image-plane mesh-grid.
+        This function uses the `adapt_images` attribute of the `GalaxiesToInversion` object pass these images and
+        raise an error if they are not present.
+
         Parameters
         ----------
         mapper_indices
@@ -77,9 +100,16 @@ def __init__(
 
             self.source_pixel_zeroed_indices_to_keep = np.where(values_to_solve)[0]
 
-        if image_plane_mesh_grid is not None:
+        if image_plane_mesh_grid_list is not None:
+
+            self.image_plane_mesh_grid_list = []
+
+            for image_plane_mesh_grid in image_plane_mesh_grid_list:
 
-            self.image_plane_mesh_grid = np.array(image_plane_mesh_grid)
+                if image_plane_mesh_grid is not None:
+                    self.image_plane_mesh_grid_list.append(np.array(image_plane_mesh_grid))
+                else:
+                    self.image_plane_mesh_grid_list.append(None)
 
         if linear_light_profile_blurred_mapping_matrix is not None:
 

test_autoarray/inversion/pixelization/image_mesh/test_abstract.py

@@ -76,7 +76,7 @@ def test__check_adapt_background_pixels(mask, mesh_grid, image_mesh):
     )
 
     image_mesh.check_adapt_background_pixels(
-        mask=mask, mesh_grid=mesh_grid, adapt_data=adapt_data, settings=None
+        mask=mask, mesh_grid=mesh_grid, adapt_data=adapt_data,
     )
 
     image_mesh.check_adapt_background_pixels(