add new functions to Zoom2D

Author: Jammy2211

autoarray/geometry/geometry_util.py

@@ -182,7 +182,7 @@ def convert_pixel_scales_2d(pixel_scales: ty.PixelScales) -> Tuple[float, float]
 
 @numba_util.jit()
 def central_pixel_coordinates_2d_from(
-    shape_native: Tuple[int, int]
+    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``)
@@ -737,7 +737,7 @@ def grid_pixel_centres_2d_from(
 
 
 def extent_symmetric_from(
-    extent: Tuple[float, float, float, float]
+    extent: Tuple[float, float, float, float],
 ) -> Tuple[float, float, float, float]:
     """
     Given an input extent of the form (x_min, x_max, y_min, y_max), this function returns an extent which is

autoarray/inversion/inversion/abstract.py

@@ -509,12 +509,12 @@ def reconstruction(self) -> np.ndarray:
 
                 solutions = np.zeros(np.shape(self.curvature_reg_matrix)[0])
 
-                solutions[
-                    values_to_solve
-                ] = inversion_util.reconstruction_positive_only_from(
-                    data_vector=data_vector_input,
-                    curvature_reg_matrix=curvature_reg_matrix_input,
-                    settings=self.settings,
+                solutions[values_to_solve] = (
+                    inversion_util.reconstruction_positive_only_from(
+                        data_vector=data_vector_input,
+                        curvature_reg_matrix=curvature_reg_matrix_input,
+                        settings=self.settings,
+                    )
                 )
                 return solutions
             else:

autoarray/inversion/inversion/imaging/abstract.py

@@ -104,11 +104,13 @@ def operated_mapping_matrix_list(self) -> List[np.ndarray]:
         """
 
         return [
-            self.convolver.convolve_mapping_matrix(
-                mapping_matrix=linear_obj.mapping_matrix
+            (
+                self.convolver.convolve_mapping_matrix(
+                    mapping_matrix=linear_obj.mapping_matrix
+                )
+                if linear_obj.operated_mapping_matrix_override is None
+                else self.linear_func_operated_mapping_matrix_dict[linear_obj]
             )
-            if linear_obj.operated_mapping_matrix_override is None
-            else self.linear_func_operated_mapping_matrix_dict[linear_obj]
             for linear_obj in self.linear_obj_list
         ]
 
@@ -156,9 +158,9 @@ def linear_func_operated_mapping_matrix_dict(self) -> Dict:
                     mapping_matrix=linear_func.mapping_matrix
                 )
 
-            linear_func_operated_mapping_matrix_dict[
-                linear_func
-            ] = operated_mapping_matrix
+            linear_func_operated_mapping_matrix_dict[linear_func] = (
+                operated_mapping_matrix
+            )
 
         return linear_func_operated_mapping_matrix_dict
 

autoarray/inversion/pixelization/border_relocator.py

@@ -117,12 +117,12 @@ def sub_border_pixel_slim_indexes_from(
             int(border_pixel)
         ]
 
-        sub_border_pixels[
-            border_1d_index
-        ] = grid_2d_util.furthest_grid_2d_slim_index_from(
-            grid_2d_slim=sub_grid_2d_slim,
-            slim_indexes=sub_border_pixels_of_border_pixel,
-            coordinate=mask_centre,
+        sub_border_pixels[border_1d_index] = (
+            grid_2d_util.furthest_grid_2d_slim_index_from(
+                grid_2d_slim=sub_grid_2d_slim,
+                slim_indexes=sub_border_pixels_of_border_pixel,
+                coordinate=mask_centre,
+            )
         )
 
     return sub_border_pixels

autoarray/inversion/pixelization/mesh/mesh_util.py

@@ -7,7 +7,7 @@
 
 @numba_util.jit()
 def rectangular_neighbors_from(
-    shape_native: Tuple[int, int]
+    shape_native: Tuple[int, int],
 ) -> Tuple[np.ndarray, np.ndarray]:
     """
     Returns the 4 (or less) adjacent neighbors of every pixel on a rectangular pixelization as an ndarray of shape

autoarray/inversion/plot/inversion_plotters.py

@@ -215,10 +215,9 @@ def figures_2d_of_pixelization(
                         "inversion"
                     ]["reconstruction_vmax_factor"]
 
-                    self.mat_plot_2d.cmap.kwargs[
-                        "vmax"
-                    ] = reconstruction_vmax_factor * np.max(
-                        self.inversion.reconstruction
+                    self.mat_plot_2d.cmap.kwargs["vmax"] = (
+                        reconstruction_vmax_factor
+                        * np.max(self.inversion.reconstruction)
                     )
                     vmax_custom = True
 

autoarray/mask/derive/zoom_2d.py

@@ -4,6 +4,7 @@
 
 if TYPE_CHECKING:
     from autoarray.structures.arrays.uniform_2d import Array2D
+    from autoarray.mask.mask_2d import Mask2D
 
 from autoarray.structures.arrays import array_2d_util
 from autoarray.structures.grids import grid_2d_util
@@ -18,7 +19,7 @@ def __init__(self, mask: Union[np.ndarray, List]):
 
         A `Mask2D` masks values which are associated with a uniform 2D rectangular grid of pixels, where unmasked
         entries (which are `False`) are used in subsequent calculations and masked values (which are `True`) are
-        omitted (for a full description see the :meth:`Mask2D` class API 
+        omitted (for a full description see the :meth:`Mask2D` class API
         documentation <autoarray.mask.mask_2d.Mask2D.__new__>`).
 
         The `Zoom2D` object calculations many different zoomed in qu
@@ -170,7 +171,66 @@ def shape_native(self) -> Tuple[int, int]:
         region = self.region
         return (region[1] - region[0], region[3] - region[2])
 
-    def array_2d_from(self, array : Array2D, buffer: int = 1) -> Array2D:
+    def extent_from(self, buffer: int = 1) -> np.ndarray:
+        """
+        For an extracted zoomed array computed from the method *zoomed_around_mask* compute its extent in scaled
+        coordinates.
+
+        The extent of the grid in scaled units returned as an ``ndarray`` of the form [x_min, x_max, y_min, y_max].
+
+        This is used visualize zoomed and extracted arrays via the imshow() method.
+
+        Parameters
+        ----------
+        buffer
+            The number pixels around the extracted array used as a buffer.
+        """
+        from autoarray.mask.mask_2d import Mask2D
+
+        extracted_array_2d = array_2d_util.extracted_array_2d_from(
+            array_2d=np.array(self.mask),
+            y0=self.region[0] - buffer,
+            y1=self.region[1] + buffer,
+            x0=self.region[2] - buffer,
+            x1=self.region[3] + buffer,
+        )
+
+        mask = Mask2D.all_false(
+            shape_native=extracted_array_2d.shape,
+            pixel_scales=self.mask.pixel_scales,
+            origin=self.centre,
+        )
+
+        return mask.geometry.extent
+
+    def mask_2d_from(self, buffer: int = 1) -> "Mask2D":
+        """
+        Extract the 2D region of a mask corresponding to the rectangle encompassing all unmasked values.
+
+        This is used to extract and visualize only the region of an image that is used in an analysis.
+
+        Parameters
+        ----------
+        buffer
+            The number pixels around the extracted array used as a buffer.
+        """
+        from autoarray.mask.mask_2d import Mask2D
+
+        extracted_mask_2d = array_2d_util.extracted_array_2d_from(
+            array_2d=np.array(self.mask),
+            y0=self.region[0] - buffer,
+            y1=self.region[1] + buffer,
+            x0=self.region[2] - buffer,
+            x1=self.region[3] + buffer,
+        )
+
+        return Mask2D(
+            mask=extracted_mask_2d,
+            pixel_scales=self.mask.pixel_scales,
+            origin=self.mask.origin,
+        )
+
+    def array_2d_from(self, array: Array2D, buffer: int = 1) -> Array2D:
         """
         Extract the 2D region of an array corresponding to the rectangle encompassing all unmasked values.
 
@@ -192,14 +252,20 @@ def array_2d_from(self, array : Array2D, buffer: int = 1) -> Array2D:
             x1=self.region[3] + buffer,
         )
 
-        mask = Mask2D.all_false(
-            shape_native=extracted_array_2d.shape,
+        extracted_mask_2d = array_2d_util.extracted_array_2d_from(
+            array_2d=np.array(self.mask),
+            y0=self.region[0] - buffer,
+            y1=self.region[1] + buffer,
+            x0=self.region[2] - buffer,
+            x1=self.region[3] + buffer,
+        )
+
+        mask = Mask2D(
+            mask=extracted_mask_2d,
             pixel_scales=array.pixel_scales,
             origin=array.mask.mask_centre,
         )
 
-        arr = array_2d_util.convert_array_2d(
-            array_2d=extracted_array_2d, mask_2d=mask
-        )
+        arr = array_2d_util.convert_array_2d(array_2d=extracted_array_2d, mask_2d=mask)
 
-        return Array2D(values=arr, mask=mask, header=array.header)
+        return Array2D(values=arr, mask=mask, header=array.header)

autoarray/mask/mask_1d_util.py

@@ -80,4 +80,4 @@ def native_index_for_slim_index_1d_from(
             native_index_for_slim_index_1d[slim_index] = x
             slim_index += 1
 
-    return native_index_for_slim_index_1d
+    return native_index_for_slim_index_1d

autoarray/mask/mask_2d_util.py

@@ -316,9 +316,7 @@ def elliptical_radius_from(
     y_scaled_elliptical = r_scaled * np.sin(theta_rotated)
     x_scaled_elliptical = r_scaled * np.cos(theta_rotated)
 
-    return np.sqrt(
-        x_scaled_elliptical**2.0 + (y_scaled_elliptical / axis_ratio) ** 2.0
-    )
+    return np.sqrt(x_scaled_elliptical**2.0 + (y_scaled_elliptical / axis_ratio) ** 2.0)
 
 
 @numba_util.jit()

autoarray/operators/convolver.py

@@ -215,12 +215,12 @@ def __init__(self, mask, kernel):
                         mask_index_array=self.mask_index_array,
                         kernel_2d=np.array(self.kernel.native[:, :]),
                     )
-                    self.image_frame_1d_indexes[
-                        mask_1d_index, :
-                    ] = image_frame_1d_indexes
-                    self.image_frame_1d_kernels[
-                        mask_1d_index, :
-                    ] = image_frame_1d_kernels
+                    self.image_frame_1d_indexes[mask_1d_index, :] = (
+                        image_frame_1d_indexes
+                    )
+                    self.image_frame_1d_kernels[mask_1d_index, :] = (
+                        image_frame_1d_kernels
+                    )
                     self.image_frame_1d_lengths[mask_1d_index] = image_frame_1d_indexes[
                         image_frame_1d_indexes >= 0
                     ].shape[0]
@@ -257,15 +257,15 @@ def __init__(self, mask, kernel):
                         mask_index_array=np.array(self.mask_index_array),
                         kernel_2d=np.array(self.kernel.native),
                     )
-                    self.blurring_frame_1d_indexes[
-                        mask_1d_index, :
-                    ] = image_frame_1d_indexes
-                    self.blurring_frame_1d_kernels[
-                        mask_1d_index, :
-                    ] = image_frame_1d_kernels
-                    self.blurring_frame_1d_lengths[
-                        mask_1d_index
-                    ] = image_frame_1d_indexes[image_frame_1d_indexes >= 0].shape[0]
+                    self.blurring_frame_1d_indexes[mask_1d_index, :] = (
+                        image_frame_1d_indexes
+                    )
+                    self.blurring_frame_1d_kernels[mask_1d_index, :] = (
+                        image_frame_1d_kernels
+                    )
+                    self.blurring_frame_1d_lengths[mask_1d_index] = (
+                        image_frame_1d_indexes[image_frame_1d_indexes >= 0].shape[0]
+                    )
                     mask_1d_index += 1
 
     @staticmethod