move and fix max pixel functions, fully remove mapper valued

Author: Jammy2211

autoarray/__init__.py

@@ -34,7 +34,6 @@
 from .inversion.inversion.abstract import AbstractInversion
 from .inversion.regularization.abstract import AbstractRegularization
 from .inversion.inversion.factory import inversion_from as Inversion
-from .inversion.inversion.mapper_valued import MapperValued
 from .inversion.inversion.dataset_interface import DatasetInterface
 from .inversion.pixelization.border_relocator import BorderRelocator
 from .inversion.pixelization.pixelization import Pixelization

autoarray/inversion/inversion/abstract.py

@@ -14,6 +14,7 @@
 from autoarray.inversion.inversion.settings import SettingsInversion
 from autoarray.preloads import Preloads
 from autoarray.structures.arrays.uniform_2d import Array2D
+from autoarray.structures.grids.irregular_2d import Grid2DIrregular
 from autoarray.structures.visibilities import Visibilities
 
 from autoarray.util import misc_util
@@ -756,7 +757,7 @@ def mapper_operated_mapping_matrix_dict(self) -> Dict:
         raise NotImplementedError
 
     def max_pixel_list_from(
-        self, total_pixels: int = 1, filter_neighbors: bool = False
+        self, total_pixels: int = 1, filter_neighbors: bool = False, mapper_index : int = 0
     ) -> List[List[int]]:
         """
         Returns a list of lists of the maximum cell or pixel values in the mapper.
@@ -782,23 +783,26 @@ def max_pixel_list_from(
         -------
 
         """
+        mapper = self.cls_list_from(cls=AbstractMapper)[mapper_index]
+        reconstruction = self.reconstruction_dict[mapper]
+
         max_pixel_list = []
 
         pixel_list = []
 
-        pixels_ascending_list = list(reversed(np.argsort(self.values_masked)))
+        pixels_ascending_list = list(reversed(np.argsort(reconstruction)))
 
         for pixel in range(total_pixels):
             pixel_index = pixels_ascending_list[pixel]
 
             add_pixel = True
 
             if filter_neighbors:
-                pixel_neighbors = self.mapper.neighbors[pixel_index]
+                pixel_neighbors = mapper.neighbors[pixel_index]
                 pixel_neighbors = pixel_neighbors[pixel_neighbors >= 0]
 
-                max_value = self.values_masked[pixel_index]
-                max_value_neighbors = self.values_masked[pixel_neighbors]
+                max_value = reconstruction[pixel_index]
+                max_value_neighbors = reconstruction[pixel_neighbors]
 
                 if max_value < np.max(max_value_neighbors):
                     add_pixel = False
@@ -810,19 +814,21 @@ def max_pixel_list_from(
 
         return max_pixel_list
 
-    @property
-    def max_pixel_centre(self) -> Grid2DIrregular:
+    def max_pixel_centre(self, mapper_index : int = 0) -> Grid2DIrregular:
         """
         Returns the centre of the brightest pixel in the mapper values.
 
         Returns
         -------
         The centre of the brightest pixel in the mapper values.
         """
-        max_pixel = np.argmax(self.values_masked)
+        mapper = self.cls_list_from(cls=AbstractMapper)[mapper_index]
+        reconstruction = self.reconstruction_dict[mapper]
+
+        max_pixel = np.argmax(reconstruction)
 
         max_pixel_centre = Grid2DIrregular(
-            values=[self.mapper.source_plane_mesh_grid.array[max_pixel]]
+            values=[mapper.source_plane_mesh_grid.array[max_pixel]]
         )
 
         return max_pixel_centre

autoarray/inversion/inversion/mapper_valued.py

@@ -9,7 +9,6 @@
 from autoarray.plot.auto_labels import AutoLabels
 from autoarray.structures.arrays.uniform_2d import Array2D
 from autoarray.inversion.inversion.abstract import AbstractInversion
-from autoarray.inversion.inversion.mapper_valued import MapperValued
 from autoarray.inversion.plot.mapper_plotters import MapperPlotter
 
 
@@ -414,12 +413,10 @@ def subplot_mappings(
 
         mapper = self.inversion.cls_list_from(cls=AbstractMapper)[pixelization_index]
 
-        mapper_valued = MapperValued(
-            values=self.inversion.reconstruction_dict[mapper], mapper=mapper
-        )
-
-        pix_indexes = mapper_valued.max_pixel_list_from(
-            total_pixels=total_pixels, filter_neighbors=True
+        pix_indexes = self.inversion.max_pixel_list_from(
+            total_pixels=total_pixels,
+            filter_neighbors=True,
+            mapper_index=pixelization_index
         )
 
         indexes = mapper.slim_indexes_for_pix_indexes(pix_indexes=pix_indexes)

autoarray/inversion/plot/inversion_plotters.py

@@ -523,19 +523,21 @@ def test__max_pixel_list_from_and_centre():
         )
     )
 
-    mapper_valued = aa.MapperValued(
-        values=np.array([2.0, 3.0, 5.0, 0.0]), mapper=mapper
+    inversion = aa.m.MockInversion(
+        reconstruction=np.array([2.0, 3.0, 5.0, 0.0]),
+        linear_obj_list=[mapper]
     )
 
-    assert mapper_valued.max_pixel_list_from(total_pixels=2)[0] == [
+    assert inversion.max_pixel_list_from(total_pixels=2)[0] == [
         2,
         1,
     ]
 
-    assert mapper_valued.max_pixel_centre.in_list == [(5.0, 6.0)]
+    assert inversion.max_pixel_centre().in_list == [(5.0, 6.0)]
 
 
 def test__max_pixel_list_from__filter_neighbors():
+
     mapper = aa.m.MockMapper(
         source_plane_mesh_grid=aa.Mesh2DDelaunay(
             [
@@ -552,11 +554,12 @@ def test__max_pixel_list_from__filter_neighbors():
         )
     )
 
-    mapper_valued = aa.MapperValued(
-        values=np.array([5.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]), mapper=mapper
+    inversion = aa.m.MockInversion(
+        reconstruction=np.array([5.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]),
+        linear_obj_list=[mapper]
     )
 
-    pixel_list = mapper_valued.max_pixel_list_from(
+    pixel_list = inversion.max_pixel_list_from(
         total_pixels=9, filter_neighbors=True
     )