remove reconstructed image API

Author: Jammy2211

autoarray/config/visualize/plots.yaml

@@ -27,7 +27,7 @@ inversion:                                 # Settings for plots of inversions (e
   sub_pixels_per_image_pixels: false       # Plot the number of sub pixels per masked data pixels?
   mesh_pixels_per_image_pixels: false      # Plot the number of image-plane mesh pixels per masked data pixels?
   image_pixels_per_mesh_pixels: false      # Plot the number of image pixels in each pixel of the mesh?
-  reconstructed_image: false               # Plot image of the reconstructed data (e.g. in the image-plane)?
+  reconstructed_operated_data: false               # Plot image of the reconstructed data (e.g. in the image-plane)?
   reconstruction: false                    # Plot the reconstructed inversion (e.g. the pixelization's mesh in the source-plane)?
   regularization_weights: false            # Plot the effective regularization weight of every inversion mesh pixel?
 fit_interferometer:                        # Settings for plots of fits to interferometer datasets (e.g. FitInterferometerPlotter).

autoarray/inversion/inversion/abstract.py

@@ -517,22 +517,6 @@ def source_quantity_dict_from(
     def mapped_reconstructed_operated_data_dict(self) -> Dict[LinearObj, Array2D]:
         raise NotImplementedError
 
-    @property
-    def mapped_reconstructed_image_dict(self) -> Dict[LinearObj, Array2D]:
-        """
-        Using the reconstructed source pixel fluxes we map each source pixel flux back to the image plane and
-        reconstruct the image data.
-
-        This uses the unique mappings of every source pixel to image pixels, which is a quantity that is already
-        computed when using the w-tilde formalism.
-
-        Returns
-        -------
-        Array2D
-            The reconstructed image data which the inversion fits.
-        """
-        return self.mapped_reconstructed_operated_data_dict
-
     @property
     def mapped_reconstructed_data(self) -> Union[Array2D, Visibilities]:
         """
@@ -565,22 +549,6 @@ def mapped_reconstructed_operated_data(self) -> Union[Array2D, Visibilities]:
         """
         return sum(self.mapped_reconstructed_operated_data_dict.values())
 
-    @property
-    def mapped_reconstructed_image(self) -> Array2D:
-        """
-        Using the reconstructed source pixel fluxes we map each source pixel flux back to the image plane and
-        reconstruct the image data.
-
-        This uses the unique mappings of every source pixel to image pixels, which is a quantity that is already
-        computed when using the w-tilde formalism.
-
-        Returns
-        -------
-        Array2D
-            The reconstructed image data which the inversion fits.
-        """
-        return sum(self.mapped_reconstructed_image_dict.values())
-
     @property
     def data_subtracted_dict(self) -> Dict[LinearObj, Array2D]:
         """
@@ -605,7 +573,7 @@ def data_subtracted_dict(self) -> Dict[LinearObj, Array2D]:
                 if linear_obj != linear_obj_other:
                     data_subtracted_dict[
                         linear_obj
-                    ] -= self.mapped_reconstructed_image_dict[linear_obj_other]
+                    ] -= self.mapped_reconstructed_operated_data_dict[linear_obj_other]
 
         return data_subtracted_dict
 

autoarray/inversion/inversion/imaging/abstract.py

@@ -75,6 +75,22 @@ def __init__(
     def psf(self):
         return self.dataset.psf
 
+    @property
+    def mapping_matrix_list(self) -> List[np.ndarray]:
+        """
+        The `mapping_matrix` of a linear object describes the mappings between the observed data's values and
+        the linear objects model, before a operation like a convolution is applied.
+
+        This is used to construct the simultaneous linear equations which reconstruct the data.
+
+        This property returns the a list of each linear object's blurred mapping matrix, which is computed by
+        blurring each linear object's `mapping_matrix` property with the `psf` operator.
+
+        A linear object may have a `operated_mapping_matrix_override` property, which bypasses  the `mapping_matrix`
+        computation and convolution operator and is directly placed in the `operated_mapping_matrix_list`.
+        """
+        return [linear_obj.mapping_matrix for linear_obj in self.linear_obj_list]
+
     @property
     def operated_mapping_matrix_list(self) -> List[np.ndarray]:
         """

autoarray/inversion/inversion/imaging/inversion_imaging_util.py

@@ -277,7 +277,7 @@ def curvature_matrix_with_added_to_diag_from(
         return curvature_matrix.at[inds, inds].add(value)
 
 
-def mapped_reconstructed_image_via_sparse_operator_from(
+def mapped_reconstructed_operated_data_via_sparse_operator_from(
     reconstruction,  # (S,)
     rows,
     cols,

autoarray/inversion/inversion/imaging/mapping.py

@@ -118,20 +118,20 @@ def _mapped_reconstructed_data_dict_from(
         for index, linear_obj in enumerate(self.linear_obj_list):
             reconstruction = reconstruction_dict[linear_obj]
 
-            mapped_reconstructed_image = (
+            mapped_reconstructed_operated_data = (
                 inversion_util.mapped_reconstructed_data_via_mapping_matrix_from(
                     mapping_matrix=mapping_matrix_list[index],
                     reconstruction=reconstruction,
                     xp=self._xp,
                 )
             )
 
-            mapped_reconstructed_image = Array2D(
-                values=mapped_reconstructed_image,
+            mapped_reconstructed_operated_data = Array2D(
+                values=mapped_reconstructed_operated_data,
                 mask=self.mask,
             )
 
-            mapped_reconstructed_data_dict[linear_obj] = mapped_reconstructed_image
+            mapped_reconstructed_data_dict[linear_obj] = mapped_reconstructed_operated_data
 
         return mapped_reconstructed_data_dict
 

autoarray/inversion/inversion/imaging/sparse.py

@@ -508,7 +508,7 @@ def _mapped_reconstructed_data_dict_from(
 
                 rows, cols, vals = linear_obj.sparse_triplets_curvature
 
-                mapped = inversion_imaging_util.mapped_reconstructed_image_via_sparse_operator_from(
+                mapped = inversion_imaging_util.mapped_reconstructed_operated_data_via_sparse_operator_from(
                     reconstruction=reconstruction,
                     rows=rows,
                     cols=cols,

autoarray/inversion/inversion/interferometer/abstract.py

@@ -71,7 +71,7 @@ def operated_mapping_matrix_list(self) -> List[np.ndarray]:
         ]
 
     @property
-    def mapped_reconstructed_image_dict(
+    def mapped_reconstructed_data_dict(
         self,
     ) -> Dict[LinearObj, Array2D]:
         """
@@ -97,7 +97,7 @@ def mapped_reconstructed_image_dict(
             The reconstruction (in the source frame) whose values are mapped to a dictionary of values for each
             individual mapper (in the image-plane).
         """
-        mapped_reconstructed_image_dict = {}
+        mapped_reconstructed_data_dict = {}
 
         reconstruction_dict = self.source_quantity_dict_from(
             source_quantity=self.reconstruction
@@ -106,21 +106,21 @@ def mapped_reconstructed_image_dict(
         for linear_obj in self.linear_obj_list:
             reconstruction = reconstruction_dict[linear_obj]
 
-            mapped_reconstructed_image = (
+            mapped_reconstructed_data = (
                 inversion_util.mapped_reconstructed_data_via_mapping_matrix_from(
                     mapping_matrix=linear_obj.mapping_matrix,
                     reconstruction=reconstruction,
                     xp=self._xp,
                 )
             )
 
-            mapped_reconstructed_image = Array2D(
-                values=mapped_reconstructed_image, mask=self.mask
+            mapped_reconstructed_data = Array2D(
+                values=mapped_reconstructed_data, mask=self.mask
             )
 
-            mapped_reconstructed_image_dict[linear_obj] = mapped_reconstructed_image
+            mapped_reconstructed_data_dict[linear_obj] = mapped_reconstructed_data
 
-        return mapped_reconstructed_image_dict
+        return mapped_reconstructed_data_dict
 
     @property
     def fast_chi_squared(self):

autoarray/inversion/inversion/interferometer/sparse.py

@@ -137,7 +137,7 @@ def mapped_reconstructed_operated_data_dict(
         """
         mapped_reconstructed_operated_data_dict = {}
 
-        image_dict = self.mapped_reconstructed_image_dict
+        image_dict = self.mapped_reconstructed_data_dict
 
         for linear_obj in self.linear_obj_list:
             visibilities = self.transformer.visibilities_from(

autoarray/inversion/mock/mock_inversion.py

@@ -22,9 +22,8 @@ def __init__(
         curvature_reg_matrix=None,
         reconstruction: np.ndarray = None,
         reconstruction_dict: List[np.ndarray] = None,
-        mapped_reconstructed_operated_data_dict=None,
         mapped_reconstructed_data_dict=None,
-        mapped_reconstructed_image_dict=None,
+        mapped_reconstructed_operated_data_dict=None,
         reconstruction_noise_map: np.ndarray = None,
         reconstruction_noise_map_dict: List[np.ndarray] = None,
         regularization_term=None,
@@ -57,11 +56,10 @@ def __init__(
         self._reconstruction = reconstruction
         self._reconstruction_dict = reconstruction_dict
 
+        self._mapped_reconstructed_data_dict = mapped_reconstructed_data_dict
         self._mapped_reconstructed_operated_data_dict = (
             mapped_reconstructed_operated_data_dict
         )
-        self._mapped_reconstructed_data_dict = mapped_reconstructed_data_dict
-        self._mapped_reconstructed_image_dict = mapped_reconstructed_image_dict
 
         self._reconstruction_noise_map = reconstruction_noise_map
         self._reconstruction_noise_map_dict = reconstruction_noise_map_dict
@@ -175,26 +173,6 @@ def mapped_reconstructed_operated_data_dict(self):
 
         return self._mapped_reconstructed_operated_data_dict
 
-    @property
-    def mapped_reconstructed_image_dict(self):
-        """
-        Using the reconstructed source pixel fluxes we map each source pixel flux back to the image plane and
-        reconstruct the image image.
-
-        This uses the unique mappings of every source pixel to image pixels, which is a quantity that is already
-        computed when using the w-tilde formalism.
-
-        Returns
-        -------
-        Array2D
-            The reconstructed image image which the inversion fits.
-        """
-
-        if self._mapped_reconstructed_image_dict is None:
-            return super().mapped_reconstructed_image_dict
-
-        return self._mapped_reconstructed_image_dict
-
     @property
     def reconstruction_noise_map(self):
         if self._reconstruction_noise_map is None:

autoarray/inversion/plot/inversion_plotters.py

@@ -66,7 +66,7 @@ def mapper_plotter_from(self, mapper_index: int) -> MapperPlotter:
             visuals_2d=self.visuals_2d,
         )
 
-    def figures_2d(self, reconstructed_image: bool = False):
+    def figures_2d(self, reconstructed_operated_data: bool = False):
         """
         Plots the individual attributes of the plotter's `Inversion` object in 2D.
 
@@ -75,23 +75,23 @@ def figures_2d(self, reconstructed_image: bool = False):
 
         Parameters
         ----------
-        reconstructed_image
+        reconstructed_operated_data
             Whether to make a 2D plot (via `imshow`) of the reconstructed image data.
         """
-        if reconstructed_image:
+        if reconstructed_operated_data:
             self.mat_plot_2d.plot_array(
-                array=self.inversion.mapped_reconstructed_image,
+                array=self.inversion.mapped_reconstructed_operated_data,
                 visuals_2d=self.visuals_2d,
                 auto_labels=AutoLabels(
-                    title="Reconstructed Image", filename="reconstructed_image"
+                    title="Reconstructed Image", filename="reconstructed_operated_data"
                 ),
             )
 
     def figures_2d_of_pixelization(
         self,
         pixelization_index: int = 0,
         data_subtracted: bool = False,
-        reconstructed_image: bool = False,
+        reconstructed_operated_data: bool = False,
         reconstruction: bool = False,
         reconstruction_noise_map: bool = False,
         signal_to_noise_map: bool = False,
@@ -112,7 +112,7 @@ def figures_2d_of_pixelization(
         ----------
         pixelization_index
             The index of the `Mapper` in the `Inversion`'s `linear_obj_list` that is plotted.
-        reconstructed_image
+        reconstructed_operated_data
             Whether to make a 2D plot (via `imshow`) of the mapper's reconstructed image data.
         reconstruction
             Whether to make a 2D plot (via `imshow` or `fill`) of the mapper's source-plane reconstruction.
@@ -160,8 +160,8 @@ def figures_2d_of_pixelization(
             except AttributeError:
                 pass
 
-        if reconstructed_image:
-            array = self.inversion.mapped_reconstructed_image_dict[
+        if reconstructed_operated_data:
+            array = self.inversion.mapped_reconstructed_operated_data_dict[
                 mapper_plotter.mapper
             ]
 
@@ -170,7 +170,7 @@ def figures_2d_of_pixelization(
                 visuals_2d=self.visuals_2d,
                 grid_indexes=mapper_plotter.mapper.over_sampler.uniform_over_sampled,
                 auto_labels=AutoLabels(
-                    title="Reconstructed Image", filename="reconstructed_image"
+                    title="Reconstructed Image", filename="reconstructed_operated_data"
                 ),
             )
 
@@ -320,14 +320,14 @@ def subplot_of_mapper(
         )
 
         self.figures_2d_of_pixelization(
-            pixelization_index=mapper_index, reconstructed_image=True
+            pixelization_index=mapper_index, reconstructed_operated_data=True
         )
 
         self.mat_plot_2d.use_log10 = True
         self.mat_plot_2d.contour = False
 
         self.figures_2d_of_pixelization(
-            pixelization_index=mapper_index, reconstructed_image=True
+            pixelization_index=mapper_index, reconstructed_operated_data=True
         )
 
         self.mat_plot_2d.use_log10 = False
@@ -340,7 +340,7 @@ def subplot_of_mapper(
 
         self.set_title(label="Mesh Pixel Grid Overlaid")
         self.figures_2d_of_pixelization(
-            pixelization_index=mapper_index, reconstructed_image=True
+            pixelization_index=mapper_index, reconstructed_operated_data=True
         )
         self.set_title(label=None)
 
@@ -424,7 +424,7 @@ def subplot_mappings(
         self.visuals_2d.indexes = indexes
 
         self.figures_2d_of_pixelization(
-            pixelization_index=pixelization_index, reconstructed_image=True
+            pixelization_index=pixelization_index, reconstructed_operated_data=True
         )
 
         self.figures_2d_of_pixelization(