convolve_image_no_blurring

Author: Jammy2211

autoarray/structures/arrays/kernel_2d.py

@@ -527,4 +527,41 @@ def convolve_image(self, image, blurring_image, jax_method="fft"):
 
         convolved_array_1d = convolve_native[slim_to_native]
 
+        return Array2D(values=convolved_array_1d, mask=image.mask)
+
+    def convolve_image_no_blurring(self, image, jax_method="fft"):
+        """
+        For a given 1D array and blurring array, convolve the two using this convolver.
+
+        Parameters
+        ----------
+        image
+            1D array of the values which are to be blurred with the convolver's PSF.
+        blurring_image
+            1D array of the blurring values which blur into the array after PSF convolution.
+        jax_method
+            If JAX is enabled this keyword will indicate what method is used for the PSF
+            convolution. Can be either `direct` to calculate it in real space or `fft`
+            to calculated it via a fast Fourier transform. `fft` is typically faster for
+            kernels that are more than about 5x5. Default is `fft`.
+        """
+
+        slim_to_native = jnp.nonzero(
+            jnp.logical_not(image.mask.array), size=image.shape[0]
+        )
+
+        expanded_array_native = jnp.zeros(image.mask.shape)
+
+        expanded_array_native = expanded_array_native.at[slim_to_native].set(
+            image.array
+        )
+
+        kernel = np.array(self.native.array)
+
+        convolve_native = jax.scipy.signal.convolve(
+            expanded_array_native, kernel, mode="same", method=jax_method
+        )
+
+        convolved_array_1d = convolve_native[slim_to_native]
+
         return Array2D(values=convolved_array_1d, mask=image.mask)

test_autoarray/structures/arrays/test_kernel_2d.py

@@ -398,22 +398,23 @@ def test__convolve_image():
     assert blurred_masked_image_via_scipy == pytest.approx(blurred_masked_im_1.array, 1e-4)
 
 
-def test__compare_to_full_2d_convolution__no_blurring_image():
+def test__convolve_image_no_blurring():
     # Setup a blurred data, using the PSF to perform the convolution in 2D, then masks it to make a 1d array.
 
-    import scipy.signal
-
     mask = aa.Mask2D.circular(
         shape_native=(30, 30), pixel_scales=(1.0, 1.0), radius=4.0
     )
-    kernel = aa.Kernel2D.no_mask(values=np.arange(49).reshape(7, 7), pixel_scales=1.0)
-    image = aa.Array2D.no_mask(values=np.arange(900).reshape(30, 30), pixel_scales=1.0)
+
+    import scipy.signal
+
+    kernel = np.arange(49).reshape(7, 7)
+    image = np.arange(900).reshape(30, 30)
 
     blurring_mask = mask.derive_mask.blurring_from(
-        kernel_shape_native=kernel.shape_native
+        kernel_shape_native=kernel.shape
     )
     blurred_image_via_scipy = scipy.signal.convolve2d(
-        image.native * blurring_mask, kernel.native, mode="same"
+        image * blurring_mask, kernel, mode="same"
     )
     blurred_image_via_scipy = aa.Array2D.no_mask(
         values=blurred_image_via_scipy, pixel_scales=1.0
@@ -424,11 +425,14 @@ def test__compare_to_full_2d_convolution__no_blurring_image():
 
     # Now reproduce this data using the frame convolver_image
 
+    kernel = aa.Kernel2D.no_mask(values=np.arange(49).reshape(7, 7), pixel_scales=1.0)
+    image = aa.Array2D.no_mask(values=np.arange(900).reshape(30, 30), pixel_scales=1.0)
+
     masked_image = aa.Array2D(values=image.native, mask=mask)
 
     blurred_masked_im_1 = kernel.convolve_image_no_blurring(image=masked_image)
 
-    assert blurred_masked_image_via_scipy == pytest.approx(blurred_masked_im_1, 1e-4)
+    assert blurred_masked_image_via_scipy == pytest.approx(blurred_masked_im_1.array, 1e-4)
 
 
 def test__convolve_mapping_matrix():