all of inversion tests pass

Author: Jammy2211

autoarray/__init__.py

@@ -43,6 +43,7 @@
 from .inversion.pixelization.mappers.rectangular import MapperRectangular
 from .inversion.pixelization.mappers.delaunay import MapperDelaunay
 from .inversion.pixelization.mappers.voronoi import MapperVoronoi
+from .inversion.pixelization.mappers.rectangular_uniform import MapperRectangularUniform
 from .inversion.pixelization.image_mesh.abstract import AbstractImageMesh
 from .inversion.pixelization.mesh.abstract import AbstractMesh
 from .inversion.inversion.imaging.mapping import InversionImagingMapping
@@ -75,6 +76,7 @@
 from .operators.over_sampling.over_sampler import OverSampler
 from .structures.grids.irregular_2d import Grid2DIrregular
 from .structures.mesh.rectangular_2d import Mesh2DRectangular
+from .structures.mesh.rectangular_2d_uniform import Mesh2DRectangularUniform
 from .structures.mesh.voronoi_2d import Mesh2DVoronoi
 from .structures.mesh.delaunay_2d import Mesh2DDelaunay
 from .structures.arrays.kernel_2d import Kernel2D

autoarray/fixtures.py

@@ -421,7 +421,7 @@ def make_rectangular_mapper_7x7_3x3():
         adapt_data=aa.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1),
     )
 
-    return aa.MapperRectangular(
+    return aa.MapperRectangularUniform(
         mapper_grids=mapper_grids,
         border_relocator=make_border_relocator_2d_7x7(),
         regularization=make_regularization_constant(),

autoarray/inversion/pixelization/mappers/factory.py

@@ -4,6 +4,7 @@
 from autoarray.inversion.pixelization.border_relocator import BorderRelocator
 from autoarray.inversion.regularization.abstract import AbstractRegularization
 from autoarray.structures.mesh.rectangular_2d import Mesh2DRectangular
+from autoarray.structures.mesh.rectangular_2d_uniform import Mesh2DRectangularUniform
 from autoarray.structures.mesh.delaunay_2d import Mesh2DDelaunay
 from autoarray.structures.mesh.voronoi_2d import Mesh2DVoronoi
 
@@ -39,10 +40,19 @@ def mapper_from(
     from autoarray.inversion.pixelization.mappers.rectangular import (
         MapperRectangular,
     )
+    from autoarray.inversion.pixelization.mappers.rectangular_uniform import (
+        MapperRectangularUniform,
+    )
     from autoarray.inversion.pixelization.mappers.delaunay import MapperDelaunay
     from autoarray.inversion.pixelization.mappers.voronoi import MapperVoronoi
 
-    if isinstance(mapper_grids.source_plane_mesh_grid, Mesh2DRectangular):
+    if isinstance(mapper_grids.source_plane_mesh_grid, Mesh2DRectangularUniform):
+        return MapperRectangularUniform(
+            mapper_grids=mapper_grids,
+            border_relocator=border_relocator,
+            regularization=regularization,
+        )
+    elif isinstance(mapper_grids.source_plane_mesh_grid, Mesh2DRectangular):
         return MapperRectangular(
             mapper_grids=mapper_grids,
             border_relocator=border_relocator,

autoarray/inversion/pixelization/mappers/mapper_util.py

@@ -161,8 +161,6 @@ def inv_full(U):
         return inv_transform(U) * scale + mu
 
     pixel_edges = inv_full(jnp.stack([pixel_edges_1d, pixel_edges_1d]).T)
-
-    # lengths along each axis
     pixel_lengths = jnp.diff(pixel_edges, axis=0).squeeze()  # shape (N_source, 2)
 
     dy = pixel_lengths[:, 0]

autoarray/inversion/pixelization/mappers/rectangular_uniform.py

@@ -0,0 +1,106 @@
+import jax.numpy as jnp
+
+from autoconf import cached_property
+
+from autoarray.inversion.pixelization.mappers.rectangular import MapperRectangular
+from autoarray.inversion.pixelization.mappers.abstract import PixSubWeights
+
+from autoarray.inversion.pixelization.mappers import mapper_util
+
+
+class MapperRectangularUniform(MapperRectangular):
+    """
+    To understand a `Mapper` one must be familiar `Mesh` objects and the `mesh` and `pixelization` packages, where
+    the four grids grouped in a `MapperGrids` object are explained (`image_plane_data_grid`, `source_plane_data_grid`,
+    `image_plane_mesh_grid`,`source_plane_mesh_grid`)
+
+    If you are unfamliar withe above objects, read through the docstrings of the `pixelization`, `mesh` and
+    `mapper_grids` packages.
+
+    A `Mapper` determines the mappings between the masked data grid's pixels (`image_plane_data_grid` and
+    `source_plane_data_grid`) and the mesh's pixels (`image_plane_mesh_grid` and `source_plane_mesh_grid`).
+
+    The 1D Indexing of each grid is identical in the `data` and `source` frames (e.g. the transformation does not
+    change the indexing, such that `source_plane_data_grid[0]` corresponds to the transformed value
+    of `image_plane_data_grid[0]` and so on).
+
+    A mapper therefore only needs to determine the index mappings between the `grid_slim` and `mesh_grid`,
+    noting that associations are made by pairing `source_plane_mesh_grid` with `source_plane_data_grid`.
+
+    Mappings are represented in the 2D ndarray `pix_indexes_for_sub_slim_index`, whereby the index of
+    a pixel on the `mesh_grid` maps to the index of a pixel on the `grid_slim` as follows:
+
+    - pix_indexes_for_sub_slim_index[0, 0] = 0: the data's 1st sub-pixel maps to the mesh's 1st pixel.
+    - pix_indexes_for_sub_slim_index[1, 0] = 3: the data's 2nd sub-pixel maps to the mesh's 4th pixel.
+    - pix_indexes_for_sub_slim_index[2, 0] = 1: the data's 3rd sub-pixel maps to the mesh's 2nd pixel.
+
+    The second dimension of this array (where all three examples above are 0) is used for cases where a
+    single pixel on the `grid_slim` maps to multiple pixels on the `mesh_grid`. For example, a
+    `Delaunay` triangulation, where every `grid_slim` pixel maps to three Delaunay pixels (the corners of the
+    triangles) with varying interpolation weights .
+
+    For a `Rectangular` mesh every pixel in the masked data maps to only one pixel, thus the second
+    dimension of `pix_indexes_for_sub_slim_index` is always of size 1.
+
+    The mapper allows us to create a mapping matrix, which is a matrix representing the mapping between every
+    unmasked data pixel annd the pixels of a mesh. This matrix is the basis of performing an `Inversion`,
+    which reconstructs the data using the `source_plane_mesh_grid`.
+
+    Parameters
+    ----------
+    mapper_grids
+        An object containing the data grid and mesh grid in both the data-frame and source-frame used by the
+        mapper to map data-points to linear object parameters.
+    regularization
+        The regularization scheme which may be applied to this linear object in order to smooth its solution,
+        which for a mapper smooths neighboring pixels on the mesh.
+    """
+
+    @cached_property
+    def pix_sub_weights(self) -> PixSubWeights:
+        """
+        Computes the following three quantities describing the mappings between of every sub-pixel in the masked data
+        and pixel in the `Rectangular` mesh.
+
+        - `pix_indexes_for_sub_slim_index`: the mapping of every data pixel (given its `sub_slim_index`)
+        to mesh pixels (given their `pix_indexes`).
+
+        - `pix_sizes_for_sub_slim_index`: the number of mappings of every data pixel to mesh pixels.
+
+        - `pix_weights_for_sub_slim_index`: the interpolation weights of every data pixel's mesh
+        pixel mapping
+
+        These are packaged into the class `PixSubWeights` with attributes `mappings`, `sizes` and `weights`.
+
+        The `sub_slim_index` refers to the masked data sub-pixels and `pix_indexes` the mesh pixel indexes,
+        for example:
+
+        - `pix_indexes_for_sub_slim_index[0, 0] = 2`: The data's first (index 0) sub-pixel maps to the Rectangular
+        mesh's third (index 2) pixel.
+
+        - `pix_indexes_for_sub_slim_index[2, 0] = 4`: The data's third (index 2) sub-pixel maps to the Rectangular
+        mesh's fifth (index 4) pixel.
+
+        The second dimension of the array `pix_indexes_for_sub_slim_index`, which is 0 in both examples above, is used
+        for cases where a data pixel maps to more than one mesh pixel (for example a `Delaunay` triangulation
+        where each data pixel maps to 3 Delaunay triangles with interpolation weights). The weights of multiple mappings
+        are stored in the array `pix_weights_for_sub_slim_index`.
+
+        For a Rectangular pixelization each data sub-pixel maps to a single mesh pixel, thus the second
+        dimension of the array `pix_indexes_for_sub_slim_index` 1 and all entries in `pix_weights_for_sub_slim_index`
+        are equal to 1.0.
+        """
+
+        mappings, weights = (
+            mapper_util.rectangular_mappings_weights_via_interpolation_from(
+                shape_native=self.shape_native,
+                source_plane_mesh_grid=self.source_plane_mesh_grid.array,
+                source_plane_data_grid=self.source_plane_data_grid.over_sampled,
+            )
+        )
+
+        return PixSubWeights(
+            mappings=mappings,
+            sizes=4 * jnp.ones(len(mappings), dtype="int"),
+            weights=weights,
+        )

autoarray/inversion/pixelization/mesh/__init__.py

@@ -1,4 +1,5 @@
 from .abstract import AbstractMesh as Mesh
 from .rectangular import Rectangular
+from .rectangular_uniform import RectangularUniform
 from .voronoi import Voronoi
 from .delaunay import Delaunay

autoarray/inversion/pixelization/mesh/rectangular.py

@@ -1,5 +1,5 @@
 import numpy as np
-from typing import Dict, Optional, Tuple
+from typing import Optional, Tuple
 
 
 from autoarray.structures.grids.uniform_2d import Grid2D

autoarray/inversion/pixelization/mesh/rectangular_uniform.py

@@ -0,0 +1,31 @@
+from autoarray.inversion.pixelization.mesh.rectangular import Rectangular
+
+from typing import Optional
+
+
+from autoarray.structures.grids.uniform_2d import Grid2D
+from autoarray.structures.mesh.rectangular_2d_uniform import Mesh2DRectangularUniform
+
+class RectangularUniform(Rectangular):
+
+    def mesh_grid_from(
+        self,
+        source_plane_data_grid: Optional[Grid2D] = None,
+        source_plane_mesh_grid: Optional[Grid2D] = None,
+    ) -> Mesh2DRectangularUniform:
+        """
+        Return the rectangular `source_plane_mesh_grid` as a `Mesh2DRectangular` object, which provides additional
+        functionality for perform operatons that exploit the geometry of a rectangular pixelization.
+
+        Parameters
+        ----------
+        source_plane_data_grid
+            The (y,x) grid of coordinates over which the rectangular pixelization is overlaid, where this grid may have
+            had exterior pixels relocated to its edge via the border.
+        source_plane_mesh_grid
+            Not used for a rectangular pixelization, because the pixelization grid in the `source` frame is computed
+            by overlaying the `source_plane_data_grid` with the rectangular pixelization.
+        """
+        return Mesh2DRectangularUniform.overlay_grid(
+            shape_native=self.shape, grid=source_plane_data_grid.over_sampled
+        )

autoarray/plot/mat_plot/two_d.py

@@ -568,64 +568,71 @@ def _plot_rectangular_mapper(
 
         if pixel_values is not None:
 
-            # self.plot_array(
-            #     array=pixel_values,
-            #     visuals_2d=visuals_2d,
-            #     auto_labels=auto_labels,
-            #     bypass=True,
-            # )
-
-            norm = self.cmap.norm_from(
-                array=pixel_values.array, use_log10=self.use_log10
-            )
+            from autoarray.inversion.pixelization.mappers.rectangular_uniform import MapperRectangularUniform
+            from autoarray.inversion.pixelization.mappers.rectangular import MapperRectangular
 
-            edges_transformed = mapper.edges_transformed
+            if isinstance(mapper, MapperRectangularUniform):
 
-            edges_transformed_dense = np.moveaxis(
-                np.stack(np.meshgrid(*edges_transformed.T)), 0, 2
-            )
+                self.plot_array(
+                    array=pixel_values,
+                    visuals_2d=visuals_2d,
+                    auto_labels=auto_labels,
+                    bypass=True,
+                )
 
-            plt.pcolormesh(
-                edges_transformed_dense[..., 0],
-                edges_transformed_dense[..., 1],
-                pixel_values.array.reshape(shape_native),
-                shading="flat",
-                norm=norm,
-                cmap=self.cmap.cmap,
-            )
+            else:
 
-            if self.colorbar is not False:
+                norm = self.cmap.norm_from(
+                    array=pixel_values.array, use_log10=self.use_log10
+                )
 
-                cb = self.colorbar.set(
-                    units=self.units,
-                    ax=ax,
+                edges_transformed = mapper.edges_transformed
+
+                edges_transformed_dense = np.moveaxis(
+                    np.stack(np.meshgrid(*edges_transformed.T)), 0, 2
+                )
+
+                plt.pcolormesh(
+                    edges_transformed_dense[..., 0],
+                    edges_transformed_dense[..., 1],
+                    pixel_values.array.reshape(shape_native),
+                    shading="flat",
                     norm=norm,
-                    cb_unit=auto_labels.cb_unit,
-                    use_log10=self.use_log10,
+                    cmap=self.cmap.cmap,
                 )
-                self.colorbar_tickparams.set(cb=cb)
 
-        extent_axis = self.axis.config_dict.get("extent")
+                if self.colorbar is not False:
 
-        if extent_axis is None:
-            extent_axis = extent
+                    cb = self.colorbar.set(
+                        units=self.units,
+                        ax=ax,
+                        norm=norm,
+                        cb_unit=auto_labels.cb_unit,
+                        use_log10=self.use_log10,
+                    )
+                    self.colorbar_tickparams.set(cb=cb)
 
-        self.axis.set(extent=extent_axis)
+                extent_axis = self.axis.config_dict.get("extent")
 
-        self.tickparams.set()
-        self.yticks.set(
-            min_value=extent_axis[2],
-            max_value=extent_axis[3],
-            units=self.units,
-            pixels=shape_native[0],
-        )
+                if extent_axis is None:
+                    extent_axis = extent
 
-        self.xticks.set(
-            min_value=extent_axis[0],
-            max_value=extent_axis[1],
-            units=self.units,
-            pixels=shape_native[1],
-        )
+                self.axis.set(extent=extent_axis)
+
+                self.tickparams.set()
+                self.yticks.set(
+                    min_value=extent_axis[2],
+                    max_value=extent_axis[3],
+                    units=self.units,
+                    pixels=shape_native[0],
+                )
+
+                self.xticks.set(
+                    min_value=extent_axis[0],
+                    max_value=extent_axis[1],
+                    units=self.units,
+                    pixels=shape_native[1],
+                )
 
         if not isinstance(self.text, list):
             self.text.set()

autoarray/structures/mesh/rectangular_2d.py

@@ -109,7 +109,7 @@ def overlay_grid(
             origin=origin,
         )
 
-        return Mesh2DRectangular(
+        return cls(
             values=grid_slim,
             shape_native=shape_native,
             pixel_scales=pixel_scales,