updated to use new zoom API

Author: Jammy2211

autoarray/config/visualize/general.yaml

@@ -4,7 +4,6 @@ general:
   log10_min_value: 1.0e-4               # If negative values are being plotted on a log10 scale, values below this value are rounded up to it (e.g. to remove negative values).
   log10_max_value: 1.0e99               # If positive values are being plotted on a log10 scale, values above this value are rounded down to it (e.g. to prevent white blobs).
   zoom_around_mask: true                # If True, plots of data structures with a mask automatically zoom in the masked region.
-  disable_zoom_for_fits: true           # If True, the zoom-in around the masked region is disabled when outputting .fits files, which is useful to retain the same dimensions as the input data.
 inversion:
   reconstruction_vmax_factor: 0.5
   total_mappings_pixels : 8                 # The number of source pixels used when plotting the subplot_mappings of a pixelization.

autoarray/mask/derive/zoom_2d.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 import numpy as np
-from typing import List, Tuple, Union
+from typing import TYPE_CHECKING, List, Tuple, Union
 
+if TYPE_CHECKING:
+    from autoarray.structures.arrays.uniform_2d import Array2D
+
+from autoarray.structures.arrays import array_2d_util
 from autoarray.structures.grids import grid_2d_util
 
 
@@ -50,6 +54,17 @@ def __init__(self, mask: Union[np.ndarray, List]):
 
     @property
     def centre(self) -> Tuple[float, float]:
+        """
+        Returns the centre of the zoomed in region, which is the average of the maximum and minimum y and x pixel values
+        of the unmasked region.
+
+        The y and x pixel values are the pixel coordinates of the unmasked region, which are derived from the
+        `Mask2D` object. The pixel coordinates are in the same units as the pixel scales of the `Mask2D` object.
+
+        Returns
+        -------
+        The centre of the zoomed in region.
+        """
         from autoarray.structures.grids.uniform_2d import Grid2D
 
         grid = grid_2d_util.grid_2d_slim_via_mask_from(
@@ -73,6 +88,17 @@ def centre(self) -> Tuple[float, float]:
 
     @property
     def offset_pixels(self) -> Tuple[float, float]:
+        """
+        Returns the offset of the centred of the zoomed in region from the centre of the `Mask2D` object in pixel
+        units.
+
+        This is computed by subtracting the pixel coordinates of the `Mask2D` object from the pixel coordinates of
+        the zoomed in region.
+
+        Returns
+        -------
+        The offset of the zoomed in region from the centre of the `Mask2D` object in pixel units.
+        """
         if self.mask.pixel_scales is None:
             return self.mask.geometry.central_pixel_coordinates
 
@@ -83,6 +109,17 @@ def offset_pixels(self) -> Tuple[float, float]:
 
     @property
     def offset_scaled(self) -> Tuple[float, float]:
+        """
+        Returns the offset of the centred of the zoomed in region from the centre of the `Mask2D` object in scaled
+        units.
+
+        This is computed by subtracting the pixel coordinates of the `Mask2D` object from the pixel coordinates of
+        the zoomed in region.
+
+        Returns
+        -------
+        The offset of the zoomed in region from the centre of the `Mask2D` object in scaled units.
+        """
         return (
             -self.mask.pixel_scales[0] * self.offset_pixels[0],
             self.mask.pixel_scales[1] * self.offset_pixels[1],
@@ -91,10 +128,12 @@ def offset_scaled(self) -> Tuple[float, float]:
     @property
     def region(self) -> List[int]:
         """
-        The zoomed rectangular region corresponding to the square encompassing all unmasked values. This zoomed
-        extraction region is a squuare, even if the mask is rectangular.
+        The zoomed region corresponding to the square encompassing all unmasked values.
 
         This is used to zoom in on the region of an image that is used in an analysis for visualization.
+
+        This zoomed extraction region is a square, even if the mask is rectangular, so that extraction regions are
+        always squares which is important for ensuring visualization does not have aspect ratio issues.
         """
 
         where = np.array(np.where(np.invert(self.mask.astype("bool"))))
@@ -119,22 +158,48 @@ def region(self) -> List[int]:
 
     @property
     def shape_native(self) -> Tuple[int, int]:
+        """
+        The shape of the zoomed in region in pixels.
+
+        This is computed by subtracting the minimum and maximum y and x pixel values of the unmasked region.
+
+        Returns
+        -------
+        The shape of the zoomed in region in pixels.
+        """
         region = self.region
         return (region[1] - region[0], region[3] - region[2])
 
-    @property
-    def mask_unmasked(self) -> "Mask2D":
+    def array_2d_from(self, array : Array2D, buffer: int = 1) -> Array2D:
         """
-        The scaled-grid of (y,x) coordinates of every pixel.
+        Extract the 2D region of an array corresponding to the rectangle encompassing all unmasked values.
 
-        This is defined from the top-left corner, such that the first pixel at location [0, 0] will have a negative x
-        value y value in scaled units.
-        """
+        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.structures.arrays.uniform_2d import Array2D
         from autoarray.mask.mask_2d import Mask2D
 
-        return Mask2D.all_false(
-            shape_native=self.shape_native,
-            pixel_scales=self.mask.pixel_scales,
-            origin=self.offset_scaled,
+        extracted_array_2d = array_2d_util.extracted_array_2d_from(
+            array_2d=np.array(array.native),
+            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=array.pixel_scales,
+            origin=array.mask.mask_centre,
         )
+
+        arr = array_2d_util.convert_array_2d(
+            array_2d=extracted_array_2d, mask_2d=mask
+        )
+
+        return Array2D(values=arr, mask=mask, header=array.header)

autoarray/plot/mat_plot/two_d.py

@@ -9,6 +9,7 @@
 )
 from autoarray.inversion.pixelization.mappers.delaunay import MapperDelaunay
 from autoarray.inversion.pixelization.mappers.voronoi import MapperVoronoi
+from autoarray.mask.derive.zoom_2d import Zoom2D
 from autoarray.plot.mat_plot.abstract import AbstractMatPlot
 from autoarray.plot.auto_labels import AutoLabels
 from autoarray.plot.visuals.two_d import Visuals2D
@@ -255,11 +256,15 @@ def plot_array(
                 "a pixel scales attribute."
             )
 
-        if conf.instance["visualize"]["general"]["general"]["zoom_around_mask"]:
+        if conf.instance["visualize"]["general"]["general"][
+            "zoom_around_mask"
+        ]:
+
+            zoom = Zoom2D(mask=array.mask)
 
             buffer = 0 if array.mask.is_all_false else 1
 
-            array = array.zoomed_around_mask(buffer=buffer)
+            array = zoom.array_2d_from(array=array, buffer=buffer)
 
         extent = array.geometry.extent
 

autoarray/plot/wrap/two_d/array_overlay.py

@@ -1,6 +1,7 @@
 import matplotlib.pyplot as plt
 
 from autoarray.plot.wrap.two_d.abstract import AbstractMatWrap2D
+from autoarray.mask.derive.zoom_2d import Zoom2D
 
 
 class ArrayOverlay(AbstractMatWrap2D):
@@ -17,9 +18,9 @@ class ArrayOverlay(AbstractMatWrap2D):
 
     def overlay_array(self, array, figure):
         aspect = figure.aspect_from(shape_native=array.shape_native)
-        array_zoom = array.zoomed_around_mask(buffer=0)
+
+        zoom = Zoom2D(mask=array.mask)
+        array_zoom = zoom.array_2d_from(array=array, buffer=0)
         extent = array_zoom.geometry.extent
 
-        plt.imshow(
-            X=array.native._array, aspect=aspect, extent=extent, **self.config_dict
-        )
+        plt.imshow(X=array.native, aspect=aspect, extent=extent, **self.config_dict)

autoarray/structures/arrays/uniform_2d.py

@@ -288,6 +288,31 @@ def native(self) -> "Array2D":
             values=self, mask=self.mask, header=self.header, store_native=True
         )
 
+    @property
+    def native_for_fits(self) -> "Array2D":
+        """
+        Return a `Array2D` for output to a .fits file, where the data is stored in its `native` representation,
+        which is an ``ndarray`` of shape [total_y_pixels, total_x_pixels].
+
+        Depending on configuration files, this array could be zoomed in on such that only the unmasked region
+        of the image is included in the .fits file, to save hard-disk space. Alternatively, the original `shape_native`
+        of the data can be retained.
+
+        If it is already stored in its `native` representation it is return as it is. If not, it is mapped from
+        `slim` to `native` and returned as a new `Array2D`.
+        """
+        if conf.instance["visualize"]["plots"]["fits_are_zoomed"]:
+
+            zoom = Zoom2D(mask=self.mask)
+
+            buffer = 0 if self.mask.is_all_false else 1
+
+            return zoom.array_2d_from(array=self, buffer=buffer)
+
+        return Array2D(
+            values=self, mask=self.mask, header=self.header, store_native=True
+        )
+
     @property
     def native_skip_mask(self) -> "Array2D":
         """
@@ -447,40 +472,6 @@ def brightest_sub_pixel_coordinate_in_region_from(
             pixel_coordinates_2d=(subpixel_y, subpixel_x)
         )
 
-    def zoomed_around_mask(self, buffer: int = 1) -> "Array2D":
-        """
-        Extract the 2D region of an array 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.
-        """
-
-        zoom = Zoom2D(mask=self.mask)
-
-        extracted_array_2d = array_2d_util.extracted_array_2d_from(
-            array_2d=np.array(self.native),
-            y0=zoom.region[0] - buffer,
-            y1=zoom.region[1] + buffer,
-            x0=zoom.region[2] - buffer,
-            x1=zoom.region[3] + buffer,
-        )
-
-        mask = Mask2D.all_false(
-            shape_native=extracted_array_2d.shape,
-            pixel_scales=self.pixel_scales,
-            origin=self.mask.mask_centre,
-        )
-
-        array = array_2d_util.convert_array_2d(
-            array_2d=extracted_array_2d, mask_2d=mask
-        )
-
-        return Array2D(values=array, mask=mask, header=self.header)
-
     def resized_from(
         self, new_shape: Tuple[int, int], mask_pad_value: int = 0.0
     ) -> "Array2D":

test_autoarray/mask/derive/test_zoom_2d.py

@@ -146,3 +146,107 @@ def test__mask_unmasked():
         mask_unmasked == np.array([[False, False], [False, False], [False, False]])
     ).all()
     assert mask_unmasked.origin == (0.0, -2.0)
+
+
+def test__array_2d_from():
+    array_2d = [
+        [1.0, 2.0, 3.0, 4.0],
+        [5.0, 6.0, 7.0, 8.0],
+        [9.0, 10.0, 11.0, 12.0],
+        [13.0, 14.0, 15.0, 16.0],
+    ]
+
+    mask = aa.Mask2D(
+        mask=[
+            [True, True, True, True],
+            [True, False, False, True],
+            [True, False, False, True],
+            [True, True, True, True],
+        ],
+        pixel_scales=(1.0, 1.0),
+    )
+
+    arr = aa.Array2D(values=array_2d, mask=mask)
+    zoom = aa.Zoom2D(mask=mask)
+    arr_zoomed = zoom.array_2d_from(array=arr, buffer=0)
+
+    assert (arr_zoomed.native == np.array([[6.0, 7.0], [10.0, 11.0]])).all()
+
+    mask = aa.Mask2D(
+        mask=np.array(
+            [
+                [True, True, True, True],
+                [True, False, False, True],
+                [False, False, False, True],
+                [True, True, True, True],
+            ]
+        ),
+        pixel_scales=(1.0, 1.0),
+    )
+
+    arr = aa.Array2D(values=array_2d, mask=mask)
+    zoom = aa.Zoom2D(mask=mask)
+    arr_zoomed = zoom.array_2d_from(array=arr, buffer=0)
+
+    assert (arr_zoomed.native == np.array([[0.0, 6.0, 7.0], [9.0, 10.0, 11.0]])).all()
+
+    mask = aa.Mask2D(
+        mask=np.array(
+            [
+                [True, False, True, True],
+                [True, False, False, True],
+                [True, False, False, True],
+                [True, True, True, True],
+            ]
+        ),
+        pixel_scales=(1.0, 1.0),
+    )
+
+    arr = aa.Array2D(values=array_2d, mask=mask)
+    zoom = aa.Zoom2D(mask=mask)
+    arr_zoomed = zoom.array_2d_from(array=arr, buffer=0)
+
+    assert (arr_zoomed.native == np.array([[2.0, 0.0], [6.0, 7.0], [10.0, 11.0]])).all()
+
+    array_2d = np.ones(shape=(4, 4))
+
+    mask = aa.Mask2D(
+        mask=np.array(
+            [
+                [True, True, True, True],
+                [True, False, False, True],
+                [True, False, False, True],
+                [True, True, True, True],
+            ]
+        ),
+        pixel_scales=(1.0, 1.0),
+    )
+
+    arr = aa.Array2D(values=array_2d, mask=mask)
+    zoom = aa.Zoom2D(mask=mask)
+    arr_zoomed = zoom.array_2d_from(array=arr, buffer=0)
+
+    assert arr_zoomed.mask.origin == (0.0, 0.0)
+
+    array_2d = np.ones(shape=(6, 6))
+
+    mask = aa.Mask2D(
+        mask=np.array(
+            [
+                [True, True, True, True, True, True],
+                [True, True, True, True, True, True],
+                [True, True, True, False, False, True],
+                [True, True, True, False, False, True],
+                [True, True, True, True, True, True],
+                [True, True, True, True, True, True],
+            ]
+        ),
+        pixel_scales=(1.0, 1.0),
+    )
+
+    arr = aa.Array2D(values=array_2d, mask=mask)
+    zoom = aa.Zoom2D(mask=mask)
+    arr_zoomed = zoom.array_2d_from(array=arr, buffer=0)
+
+    assert arr_zoomed.mask.origin == (0.0, 1.0)
+

test_autoarray/plot/wrap/base/test_ticks.py

@@ -60,7 +60,8 @@ def test__yticks__set():
     units = aplt.Units(use_scaled=True, ticks_convert_factor=None)
 
     yticks = aplt.YTicks(fontsize=34)
-    array_zoom = array.zoomed_around_mask(buffer=1)
+    zoom = aa.Zoom2D(mask=array.mask)
+    array_zoom = zoom.array_2d_from(array=array, buffer=1)
     extent = array_zoom.geometry.extent
     yticks.set(min_value=extent[2], max_value=extent[3], units=units)
 
@@ -106,7 +107,8 @@ def test__xticks__set():
     array = aa.Array2D.ones(shape_native=(2, 2), pixel_scales=1.0)
     units = aplt.Units(use_scaled=True, ticks_convert_factor=None)
     xticks = aplt.XTicks(fontsize=34)
-    array_zoom = array.zoomed_around_mask(buffer=1)
+    zoom = aa.Zoom2D(mask=array.mask)
+    array_zoom = zoom.array_2d_from(array=array, buffer=1)
     extent = array_zoom.geometry.extent
     xticks.set(min_value=extent[0], max_value=extent[1], units=units)