mapper now comes from factory as required

Author: Jammy2211

autoarray/inversion/pixelization/mappers/factory.py

@@ -8,6 +8,7 @@
 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.knn_delaunay_2d import Mesh2DDelaunayKNN
 
 
 def mapper_from(
@@ -49,6 +50,7 @@ def mapper_from(
         MapperRectangularUniform,
     )
     from autoarray.inversion.pixelization.mappers.delaunay import MapperDelaunay
+    from autoarray.inversion.pixelization.mappers.knn import MapperKNNInterpolator
 
     if isinstance(mapper_grids.source_plane_mesh_grid, Mesh2DRectangularUniform):
         return MapperRectangularUniform(
@@ -77,3 +79,12 @@ def mapper_from(
             preloads=preloads,
             xp=xp,
         )
+    elif isinstance(mapper_grids.source_plane_mesh_grid, Mesh2DDelaunayKNN):
+        return MapperKNNInterpolator(
+            mapper_grids=mapper_grids,
+            border_relocator=border_relocator,
+            regularization=regularization,
+            settings=settings,
+            preloads=preloads,
+            xp=xp,
+        )

autoarray/inversion/pixelization/mappers/knn.py

@@ -11,27 +11,16 @@ class MapperKNNInterpolator(AbstractMapper):
     Mapper using kNN + compact Wendland kernel interpolation (partition of unity).
     """
 
-    # ---- You almost certainly want these as configurable attributes somewhere ----
-    # If your Mesh / Pixelization already stores these, read them from self.mesh instead.
-    @property
-    def k_neighbors(self) -> int:
-        # e.g. return self.pixelization.k_neighbors or self.mesh.k_neighbors
-        return getattr(self.pixelization, "k_neighbors", 10)
-
-    @property
-    def kernel(self) -> str:
-        return getattr(self.pixelization, "kernel", "wendland_c4")
-
-    @property
-    def radius_scale(self) -> float:
-        return getattr(self.pixelization, "radius_scale", 1.5)
-
     def _pix_sub_weights_from_query_points(self, query_points) -> PixSubWeights:
         """
         Compute PixSubWeights for arbitrary query points using the kNN kernel module.
         Arrays are created in self._xp (numpy or jax.numpy) from the start.
         """
 
+        k_neighbors = 10
+        kernel = 'wendland_c4'
+        radius_scale = 1.5
+
         xp = self._xp  # numpy or jax.numpy
 
         # ------------------------------------------------------------------
@@ -53,9 +42,9 @@ def _pix_sub_weights_from_query_points(self, query_points) -> PixSubWeights:
         weights_jax, indices_jax, _ = get_interpolation_weights(
             points=points,
             query_points=query_points,
-            k_neighbors=int(self.k_neighbors),
-            kernel=self.kernel,
-            radius_scale=float(self.radius_scale),
+            k_neighbors=int(k_neighbors),
+            kernel=kernel,
+            radius_scale=float(radius_scale),
         )
 
         # ------------------------------------------------------------------

autoarray/inversion/pixelization/mesh/knn.py

@@ -259,7 +259,12 @@ def body_fun(i, out_acc):
 
 class KNNInterpolator(Delaunay):
 
-    def __init__(self):
+    def __init__(self,  k_neighbors=10, kernel='wendland_c4',
+                              radius_scale=1.5):
+
+        self.k_neighbors = k_neighbors
+        self.kernel = kernel
+        self.radius_scale = radius_scale
 
         super().__init__()
 

autoarray/structures/mesh/knn_delaunay_2d.py

@@ -0,0 +1,34 @@
+from autoarray.structures.mesh.delaunay_2d import Mesh2DDelaunay
+
+class Mesh2DDelaunayKNN(Mesh2DDelaunay):
+
+    def mesh_grid_from(
+        self,
+        source_plane_data_grid=None,
+        source_plane_mesh_grid=None,
+        preloads=None,
+        xp=np,
+    ):
+        """
+        Return the Delaunay ``source_plane_mesh_grid`` as a ``Mesh2DDelaunay`` object, which provides additional
+        functionality for performing operations that exploit the geometry of a Delaunay mesh.
+
+        Parameters
+        ----------
+        source_plane_data_grid
+            A 2D grid of (y,x) coordinates associated with the unmasked 2D data after it has been transformed to the
+            ``source`` reference frame.
+        source_plane_mesh_grid
+            The centres of every Delaunay pixel in the ``source`` frame, which are initially derived by computing a sparse
+            set of (y,x) coordinates computed from the unmasked data in the image-plane and applying a transformation
+            to this.
+        settings
+            Settings controlling the pixelization for example if a border is used to relocate its exterior coordinates.
+        """
+
+        return Mesh2DDelaunayKNN(
+            values=source_plane_mesh_grid,
+            source_plane_data_grid_over_sampled=source_plane_data_grid,
+            preloads=preloads,
+            _xp=xp,
+        )