simplify image mesh tests to not use SettingsInversion

Author: Jammy2211

autoarray/inversion/mock/mock_image_mesh.py

@@ -14,7 +14,7 @@ def __init__(self, image_plane_mesh_grid=None):
         self.image_plane_mesh_grid = image_plane_mesh_grid
 
     def image_plane_mesh_grid_from(
-        self, mask: Mask2D, adapt_data: Optional[np.ndarray], settings=None
+        self, mask: Mask2D, adapt_data: Optional[np.ndarray],
     ) -> Grid2DIrregular:
         if adapt_data is not None and self.image_plane_mesh_grid is not None:
             return adapt_data * self.image_plane_mesh_grid

autoarray/inversion/mock/mock_mesh.py

@@ -37,7 +37,6 @@ def image_plane_mesh_grid_from(
         self,
         mask: Mask2D,
         adapt_data,
-        settings=None,
     ):
         if adapt_data is not None and self.image_plane_mesh_grid is not None:
             return adapt_data * self.image_plane_mesh_grid

autoarray/inversion/mock/mock_pixelization.py

@@ -10,9 +10,7 @@ def __init__(
         mapper=None,
         image_plane_mesh_grid=None,
     ):
-        super().__init__(
-            mesh=mesh, regularization=regularization
-        )
+        super().__init__(mesh=mesh, regularization=regularization)
 
         self.mapper = mapper
         self.image_plane_mesh_grid = image_plane_mesh_grid

autoarray/inversion/pixelization/image_mesh/abstract.py

@@ -30,7 +30,6 @@ def image_plane_mesh_grid_from(
         self,
         mask: Mask2D,
         adapt_data: Optional[np.ndarray] = None,
-        settings: SettingsInversion = None,
     ) -> Grid2DIrregular:
         raise NotImplementedError
 

autoarray/inversion/pixelization/image_mesh/hilbert.py

@@ -300,9 +300,14 @@ def image_plane_mesh_grid_from(
 
         return mesh_grid
 
-
     def check_mesh_pixels_per_image_pixels(
-        self, mask: Mask2D, mesh_grid: Grid2DIrregular, settings: SettingsInversion
+        self,
+        mask: Mask2D,
+        mesh_grid: Grid2DIrregular,
+        image_mesh_min_mesh_pixels_per_pixel=None,
+        image_mesh_min_mesh_number: int = 5,
+        image_mesh_adapt_background_percent_threshold: float = None,
+        image_mesh_adapt_background_percent_check: float = 0.8,
     ):
         """
         Checks the number of mesh pixels in every image pixel and raises an `InversionException` if there are fewer
@@ -315,12 +320,12 @@ def check_mesh_pixels_per_image_pixels(
 
         1) Compute the 2D array of the number of mesh pixels in every masked data image pixel.
         2) Find the number of mesh pixels in the N data pixels with the larger number of mesh pixels, where N is
-           given by `settings.image_mesh_min_mesh_number`. For example, if `settings.image_mesh_min_mesh_number=5` then
+           given by `image_mesh_min_mesh_number`. For example, if `image_mesh_min_mesh_number=5` then
            the number of mesh pixels in the 5 data pixels with the most data pixels is computed.
-        3) Compare the lowest value above to the value `settings.image_mesh_min_mesh_pixels_per_pixel`. If the value is
+        3) Compare the lowest value above to the value `image_mesh_min_mesh_pixels_per_pixel`. If the value is
            below this value, raise an `InversionException`.
 
-        Therefore, by settings `settings.image_mesh_min_mesh_pixels_per_pixel` to a value above 1 the code is forced
+        Therefore, by settings `image_mesh_min_mesh_pixels_per_pixel` to a value above 1 the code is forced
         to adapt the image mesh enough to put many mesh pixels in the brightest image pixels.
 
         Parameters
@@ -340,19 +345,19 @@ def check_mesh_pixels_per_image_pixels(
             return
 
         if settings is not None:
-            if settings.image_mesh_min_mesh_pixels_per_pixel 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
                 )
 
                 indices_of_highest_values = np.argsort(mesh_pixels_per_image_pixels)[
-                    -settings.image_mesh_min_mesh_number :
+                    -image_mesh_min_mesh_number:
                 ]
                 lowest_mesh_pixels = np.min(
                     mesh_pixels_per_image_pixels[indices_of_highest_values]
                 )
 
-                if lowest_mesh_pixels < settings.image_mesh_min_mesh_pixels_per_pixel:
+                if lowest_mesh_pixels < image_mesh_min_mesh_pixels_per_pixel:
                     raise exc.InversionException()
 
         return mesh_grid
@@ -362,7 +367,10 @@ def check_adapt_background_pixels(
         mask: Mask2D,
         mesh_grid: Grid2DIrregular,
         adapt_data: Optional[np.ndarray],
-        settings: SettingsInversion,
+        image_mesh_min_mesh_pixels_per_pixel=None,
+        image_mesh_min_mesh_number: int = 5,
+        image_mesh_adapt_background_percent_threshold: float = None,
+        image_mesh_adapt_background_percent_check: float = 0.8,
     ):
         """
         Checks the number of mesh pixels in the background of the image-mesh and raises an `InversionException` if
@@ -375,15 +383,15 @@ def check_adapt_background_pixels(
         The check works as follows:
 
         1) Find all pixels in the background of the `adapt_data`, which are N pixels with the lowest values, where N is
-           a percentage given by `settings.image_mesh_adapt_background_percent_check`. If N is 50%, then the half of
+           a percentage given by `image_mesh_adapt_background_percent_check`. If N is 50%, then the half of
             pixels in `adapt_data` with the lowest values will be checked.
         2) Sum the total number of mesh pixels in these background pixels, thereby estimating the number of mesh pixels
             assigned to background pixels.
         3) Compare this value to the total number of mesh pixels multiplied
-           by `settings.image_mesh_adapt_background_percent_threshold` and raise an `InversionException` if the number
+           by `image_mesh_adapt_background_percent_threshold` and raise an `InversionException` if the number
            of mesh pixels is below this value, meaning the background did not have sufficient mesh pixels in it.
 
-        Therefore, by setting `settings.image_mesh_adapt_background_percent_threshold` the code is forced
+        Therefore, by setting `image_mesh_adapt_background_percent_threshold` the code is forced
         to adapt the image mesh in a way that places many mesh pixels in the background regions.
 
         Parameters
@@ -405,11 +413,11 @@ def check_adapt_background_pixels(
             return
 
         if settings is not None:
-            if settings.image_mesh_adapt_background_percent_threshold is not None:
+            if image_mesh_adapt_background_percent_threshold is not None:
                 pixels = mesh_grid.shape[0]
 
                 pixels_in_background = int(
-                    mask.shape_slim * settings.image_mesh_adapt_background_percent_check
+                    mask.shape_slim * image_mesh_adapt_background_percent_check
                 )
 
                 indices_of_lowest_values = np.argsort(adapt_data)[:pixels_in_background]
@@ -425,6 +433,6 @@ def check_adapt_background_pixels(
                 )
 
                 if mesh_pixels_in_background < (
-                    pixels * settings.image_mesh_adapt_background_percent_threshold
+                    pixels * image_mesh_adapt_background_percent_threshold
                 ):
                     raise exc.InversionException()

autoarray/inversion/pixelization/image_mesh/kmeans.py

@@ -52,7 +52,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 a KMeans clustering algorithm on the weight map.

autoarray/inversion/pixelization/image_mesh/overlay.py

@@ -186,7 +186,6 @@ def image_plane_mesh_grid_from(
         self,
         mask: Mask2D,
         adapt_data: Optional[np.ndarray] = None,
-        settings: SettingsInversion = None,
     ) -> Grid2DIrregular:
         """
         Returns an image-mesh by overlaying a uniform grid of (y,x) coordinates over the masked image that the

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: np.ndarray = None,
         linear_light_profile_blurred_mapping_matrix=None,
     ):
         """

autoarray/structures/grids/uniform_2d.py

@@ -197,7 +197,9 @@ def over_sampler(self):
 
         from autoarray.operators.over_sampling.over_sampler import OverSampler
 
-        self._over_sampler = OverSampler(sub_size=self.over_sample_size.array.astype("int"), mask=self.mask)
+        self._over_sampler = OverSampler(
+            sub_size=self.over_sample_size.array.astype("int"), mask=self.mask
+        )
 
         return self._over_sampler
 

test_autoarray/inversion/pixelization/image_mesh/test_abstract.py

@@ -44,33 +44,28 @@ def test__mesh_pixels_per_image_pixels_from(mask, mesh_grid, image_mesh):
 
 def test__check_mesh_pixels_per_image_pixels(mask, mesh_grid, image_mesh):
     image_mesh.check_mesh_pixels_per_image_pixels(
-        mask=mask, mesh_grid=mesh_grid, settings=None
+        mask=mask, mesh_grid=mesh_grid,
     )
 
     image_mesh.check_mesh_pixels_per_image_pixels(
         mask=mask,
         mesh_grid=mesh_grid,
-        settings=aa.SettingsInversion(
-            image_mesh_min_mesh_pixels_per_pixel=3, image_mesh_min_mesh_number=1
-        ),
+        image_mesh_min_mesh_pixels_per_pixel=3,
+        image_mesh_min_mesh_number=1
     )
 
     with pytest.raises(aa.exc.InversionException):
         image_mesh.check_mesh_pixels_per_image_pixels(
             mask=mask,
             mesh_grid=mesh_grid,
-            settings=aa.SettingsInversion(
-                image_mesh_min_mesh_pixels_per_pixel=5, image_mesh_min_mesh_number=1
-            ),
+            image_mesh_min_mesh_pixels_per_pixel=5, image_mesh_min_mesh_number=1
         )
 
     with pytest.raises(aa.exc.InversionException):
         image_mesh.check_mesh_pixels_per_image_pixels(
             mask=mask,
             mesh_grid=mesh_grid,
-            settings=aa.SettingsInversion(
-                image_mesh_min_mesh_pixels_per_pixel=3, image_mesh_min_mesh_number=2
-            ),
+            image_mesh_min_mesh_pixels_per_pixel=3, image_mesh_min_mesh_number=2
         )
 
 
@@ -88,19 +83,15 @@ def test__check_adapt_background_pixels(mask, mesh_grid, image_mesh):
         mask=mask,
         mesh_grid=mesh_grid,
         adapt_data=adapt_data,
-        settings=aa.SettingsInversion(
-            image_mesh_adapt_background_percent_threshold=0.05,
-            image_mesh_adapt_background_percent_check=0.9,
-        ),
+        image_mesh_adapt_background_percent_threshold=0.05,
+        image_mesh_adapt_background_percent_check=0.9,
     )
 
     with pytest.raises(aa.exc.InversionException):
         image_mesh.check_adapt_background_pixels(
             mask=mask,
             mesh_grid=mesh_grid,
             adapt_data=adapt_data,
-            settings=aa.SettingsInversion(
-                image_mesh_adapt_background_percent_threshold=0.8,
-                image_mesh_adapt_background_percent_check=0.5,
-            ),
+            image_mesh_adapt_background_percent_threshold=0.8,
+            image_mesh_adapt_background_percent_check=0.5,
         )