pytme 0.3.1.post2__cp311-cp311-macosx_15_0_arm64.whl → 0.3.2.dev0__cp311-cp311-macosx_15_0_arm64.whl

tme/filters/ctf.py

@@ -19,9 +19,7 @@ from ..parser import StarParser, XMLParser, MDOCParser
 from ._utils import (
     frequency_grid_at_angle,
     compute_tilt_shape,
-    crop_real_fourier,
     fftfreqn,
-    shift_fourier,
     pad_to_length,
 )
 
@@ -31,21 +29,17 @@ __all__ = ["CTF", "CTFReconstructed", "create_ctf"]
 @dataclass
 class CTF(ComposableFilter):
     """
-    Generate a per-tilt contrast transfer function mask.
+    Generate per-tilt contrast transfer function filter.
     """
 
-    #: The shape of the to-be created mask.
-    shape: Tuple[int] = None
     #: The defocus in x direction (in units of sampling rate).
     defocus_x: Tuple[float] = None
-    #: The tilt angles.
+    #: The tilt angles in degrees.
     angles: Tuple[float] = None
     #: The microscope projection axis, defaults to 2 (z).
     opening_axis: int = 2
     #: The axis along which the tilt is applied, defaults to 0 (x).
     tilt_axis: int = 0
-    #: Whether to correct defocus gradient, defaults False.
-    correct_defocus_gradient: bool = False
     #: The sampling rate, defaults to 1 Ångstrom / voxel.
     sampling_rate: Tuple[float] = 1
     #: The acceleration voltage in Volts, defaults to 300e3.
@@ -54,16 +48,14 @@ class CTF(ComposableFilter):
     spherical_aberration: Tuple[float] = 2.7e7
     #: The amplitude contrast, defaults to 0.07.
     amplitude_contrast: Tuple[float] = 0.07
-    #: The phase shift in degrees, defaults to 0.
+    #: The phase shift in radians, defaults to 0.
     phase_shift: Tuple[float] = 0
-    #: The defocus angle in degrees, defaults to 0.
+    #: The defocus angle in radians, defaults to 0.
     defocus_angle: Tuple[float] = 0
     #: The defocus value in y direction, defaults to None (in units of sampling rate).
     defocus_y: Tuple[float] = None
     #: Whether the returned CTF should be phase-flipped, defaults to True.
     flip_phase: bool = True
-    #: Whether to return a ctf mask for rfft (for :py:class:`CTFReconstructed`).
-    return_real_fourier: bool = False
 
     @classmethod
     def from_file(cls, filename: str, **kwargs) -> "CTF":
@@ -99,7 +91,6 @@ class CTF(ComposableFilter):
 
         # Pixel size needs to be overwritten by pixel size the ctf is generated for
         init_kwargs = {
-            "shape": None,
             "angles": data.get("angles", None),
             "defocus_x": data["defocus_1"],
             "sampling_rate": data["pixel_size"],
@@ -114,31 +105,17 @@ class CTF(ComposableFilter):
             if k in init_kwargs and init_kwargs.get(k) is None:
                 init_kwargs[k] = v
         init_kwargs = {k: v for k, v in init_kwargs.items() if v is not None}
-        return cls(**init_kwargs)
-
-    def __post_init__(self):
-        self.defocus_angle = np.radians(self.defocus_angle)
-        self.phase_shift = np.radians(self.phase_shift)
 
-    def __call__(self, **kwargs) -> NDArray:
-        """
-        Returns a CTF stack of chosen parameters with DC component in the center.
-        """
-        func_args = vars(self).copy()
-        func_args.update(kwargs)
-
-        ret = self.weight(**func_args)
-        ret = be.astype(be.to_backend_array(ret), be._float_dtype)
-        return {
-            "data": ret,
-            "shape": func_args["shape"],
-            "return_real_fourier": func_args.get("return_real_fourier"),
-            "is_multiplicative_filter": True,
-        }
+        # Moved format conversion from __post__init
+        if "phase_shift" in init_kwargs:
+            init_kwargs["phase_shift"] = np.radians(init_kwargs["phase_shift"])
+        if "defocus_angle" in init_kwargs:
+            init_kwargs["defocus_angle"] = np.radians(init_kwargs["defocus_angle"])
+        return cls(**init_kwargs)
 
-    def weight(
+    def _evaluate(
         self,
-        shape: Tuple[int],
+        shape: Tuple[int, ...],
         defocus_x: Tuple[float],
         angles: Tuple[float],
         opening_axis: int = 2,
@@ -147,15 +124,13 @@ class CTF(ComposableFilter):
         phase_shift: Tuple[float] = 0,
         defocus_angle: Tuple[float] = 0,
         defocus_y: Tuple[float] = None,
-        correct_defocus_gradient: bool = False,
         sampling_rate: Tuple[float] = 1,
         acceleration_voltage: float = 300e3,
-        spherical_aberration: float = 2.7e3,
+        spherical_aberration: float = 2.7e7,
         flip_phase: bool = True,
-        return_real_fourier: bool = False,
         cutoff_frequency: float = 0.5,
         **kwargs: Dict,
-    ) -> NDArray:
+    ) -> Dict:
         """
         Compute the CTF weight tilt stack.
 
@@ -164,38 +139,31 @@ class CTF(ComposableFilter):
         shape : tuple of int
             The shape of the CTF.
         defocus_x : tuple of float
-            The defocus in x direction (in units of sampling rate).
+            Defocus along the first principal axis in spatial units of sampling rate.
         angles : tuple of float
-            The tilt angles.
+            The tilt angles in degrees.
         opening_axis : int, optional
             The axis around which the wedge is opened, defaults to 2.
         tilt_axis : int, optional
             The axis along which the tilt is applied, defaults to 0.
         amplitude_contrast : tuple of float, optional
-            The amplitude contrast, defaults to 0.07.
+            Amplitude contrast of microscope, defaults to 0.07.
         phase_shift : tuple of float, optional
-            The phase shift in radians, defaults to 0.
+           CTF phase shift in radians, defaults to 0.
         defocus_angle : tuple of float, optional
-            The defocus angle in radians, defaults to 0.
+            Astigmatism angle in radians, defaults to 0.
         defocus_y : tuple of float, optional
-            The defocus in x direction (in units of sampling rate).
-        correct_defocus_gradient : bool, optional
-            Whether to correct defocus gradient, defaults to False.
+            Defocus along the second principal axis in spatial units of sampling rate.
         sampling_rate : tuple of float, optional
             The sampling rate, defaults to 1.
         acceleration_voltage : float, optional
             The acceleration voltage in electron microscopy, defaults to 300e3.
         spherical_aberration : float, optional
-            The spherical aberration coefficient, defaults to 2.7e3.
+            Spherical aberration of microscope in units of sampling rate.
         flip_phase : bool, optional
             Whether the returned CTF should be phase-flipped, defaults to True.
         **kwargs : Dict
             Additional keyword arguments.
-
-        Returns
-        -------
-        NDArray
-            A stack containing the CTF weight.
         """
         angles = np.atleast_1d(angles)
         defoci_x = pad_to_length(defocus_x, angles.size)
@@ -219,7 +187,6 @@ class CTF(ComposableFilter):
                 corrected_tilt_axis -= 1
 
         for index, angle in enumerate(angles):
-            correction = correct_defocus_gradient and angle is not None
             chi = create_ctf(
                 angle=angle,
                 shape=ctf_shape,
@@ -227,7 +194,6 @@ class CTF(ComposableFilter):
                 defocus_y=defoci_y[index],
                 sampling_rate=sampling_rate,
                 acceleration_voltage=acceleration_voltage[index],
-                correct_defocus_gradient=correction,
                 spherical_aberration=spherical_aberration[index],
                 cutoff_frequency=cutoff_frequency,
                 phase_shift=phase_shift[index],
@@ -244,16 +210,16 @@ class CTF(ComposableFilter):
         stack = np.negative(stack, out=stack)
         if flip_phase:
             stack = np.abs(stack, out=stack)
-        return be.to_backend_array(np.squeeze(stack))
+        return {"data": be.to_backend_array(stack), "shape": shape}
 
 
+@dataclass
 class CTFReconstructed(CTF):
     """
-    Create a simple contrast transfer function mask without the ability to specify
-    per-tilt parameters like in :py:class:`CTF`.
+    Generate CTF filter for reconstructions.
     """
 
-    def weight(
+    def _evaluate(
         self,
         shape: Tuple[int],
         defocus_x: Tuple[float],
@@ -265,10 +231,9 @@ class CTFReconstructed(CTF):
         acceleration_voltage: float = 300e3,
         spherical_aberration: float = 2.7e3,
         flip_phase: bool = True,
-        return_real_fourier: bool = False,
         cutoff_frequency: float = 0.5,
         **kwargs: Dict,
-    ) -> NDArray:
+    ) -> Dict:
         """
         Compute the CTF weight tilt stack.
 
@@ -277,17 +242,17 @@ class CTFReconstructed(CTF):
         shape : tuple of int
             The shape of the CTF.
         defocus_x : tuple of float
-            The defocus in x direction in units of sampling rate.
+            Defocus along the first principal axis in spatial units of sampling rate.
         opening_axis : int, optional
             The axis around which the wedge is opened, defaults to 2.
         amplitude_contrast : float, optional
             The amplitude contrast, defaults to 0.07.
         phase_shift : tuple of float, optional
-            The phase shift in radians, defaults to 0.
+           CTF phase shift in radians, defaults to 0.
         defocus_angle : tuple of float, optional
             The defocus angle in radians, defaults to 0.
         defocus_y : tuple of float, optional
-            The defocus in y direction in units of sampling rate.
+            Defocus along the second principal axis in spatial units of sampling rate.
         sampling_rate : tuple of float, optional
             The sampling rate, defaults to 1.
         acceleration_voltage : float, optional
@@ -310,7 +275,6 @@ class CTFReconstructed(CTF):
             defocus_y=defocus_y,
             sampling_rate=np.max(sampling_rate),
             acceleration_voltage=self.acceleration_voltage,
-            correct_defocus_gradient=False,
             spherical_aberration=spherical_aberration,
             cutoff_frequency=cutoff_frequency,
             phase_shift=phase_shift,
@@ -318,14 +282,10 @@ class CTFReconstructed(CTF):
             amplitude_contrast=amplitude_contrast,
         )
         # Avoid contrast inversion
-        np.negative(stack, out=stack)
+        stack = np.negative(stack, out=stack)
         if flip_phase:
-            np.abs(stack, out=stack)
-
-        stack = shift_fourier(data=stack, shape_is_real_fourier=False)
-        if return_real_fourier:
-            stack = crop_real_fourier(stack)
-        return be.to_backend_array(np.squeeze(stack))
+            stack = np.abs(stack, out=stack)
+        return {"data": be.to_backend_array(stack), "shape": shape}
 
 
 def _from_xml(filename: str) -> Dict:
@@ -501,7 +461,7 @@ def _from_mdoc(filename: str) -> Dict:
     return output
 
 
-def _compute_electron_wavelength(acceleration_voltage: int = None):
+def _compute_electron_wavelength(acceleration_voltage: int = 300e3):
     """Computes the wavelength of an electron in angstrom."""
 
     # Physical constants expressed in SI units
@@ -524,14 +484,13 @@ def _compute_electron_wavelength(acceleration_voltage: int = None):
 def create_ctf(
     shape: Tuple[int],
     defocus_x: float,
-    acceleration_voltage: float = 300,
+    acceleration_voltage: float = 300e3,
     defocus_angle: float = 0,
     phase_shift: float = 0,
     defocus_y: float = None,
     sampling_rate: float = 1,
     spherical_aberration: float = 2.7e7,
     amplitude_contrast: float = 0.07,
-    correct_defocus_gradient: bool = False,
     cutoff_frequency: float = 0.5,
     angle: float = None,
     tilt_axis: int = 0,
@@ -546,15 +505,16 @@ def create_ctf(
     shape : Tuple[int]
         Shape of the returned CTF mask.
     defocus_x : float
-        Defocus in x in units of sampling rate, e.g. 30000 Angstrom.
+        Defocus along the first principal axis in spatial units of sampling rate,
+        e.g. 30000 Angstrom.
     acceleration_voltage : float, optional
-        Acceleration voltage in keV, defaults to 300.
+        Acceleration voltage in keV, defaults to 300e3.
     defocus_angle : float, optional
-        Astigmatism in radians, defaults to 0.
+        Astigmatism angle in radians, defaults to 0.
     phase_shift : float, optional
-       Phase shift from phase plate in radians, defaults to 0.
+       CTF phase shift in radians, defaults to 0.
     defocus_y : float, optional
-        Defocus in y in units of sampling rate.
+        Defocus along the second principal axis in spatial units of sampling rate.
     tilt_axis : int, optional
         Axes the specimen was tilted over, defaults to 0 (x-axis).
     sampling_rate : float or tuple of floats
@@ -564,7 +524,7 @@ def create_ctf(
     spherical_aberration : float, optional
         Spherical aberration of microscope in units of sampling rate.
     angle : float, optional
-        Assume the created CTF is a projection over opening_axis observed at angle.
+        Assume the created CTF is a projection observed at angle degrees.
     opening_axis : int, optional
         Projection axis, only relevant if angle is given.
     full_shape : tuple of ints
@@ -589,31 +549,18 @@ def create_ctf(
 
     defocus_x = defocus_x / sampling_rate if defocus_x is not None else None
     defocus_y = defocus_y / sampling_rate if defocus_y is not None else None
-    if correct_defocus_gradient or defocus_y is not None:
+    if defocus_y is not None:
         if len(shape) < 2:
             raise ValueError(f"Length of shape needs to be at least 2, got {shape}")
 
-        # Axial distance from grid center in multiples of sampling rate
-        sampling = tuple(float(x) for x in np.divide(sampling_rate, shape))
+        # Axial distance from grid center in voxels
         grid = fftfreqn(
             shape=shape,
-            sampling_rate=sampling,
+            sampling_rate=None,
             return_sparse_grid=True,
+            fftshift=False,
         )
 
-    # This should be done after defocus_x computation
-    if correct_defocus_gradient:
-        if angle is None:
-            raise ValueError("Cannot correct for defocus gradient without angle.")
-
-        angle_rad = np.radians(angle)
-        defocus_gradient = np.multiply(grid[tilt_axis], np.sin(angle_rad))
-
-        if tilt_axis == 0:
-            defocus_x = np.add(defocus_x, defocus_gradient)
-        elif tilt_axis == 1 and defocus_y is not None:
-            defocus_y = np.add(defocus_y, defocus_gradient)
-
     # 0.5 * (dx + dy) + cos(2 * (azimuth - astigmatism) * (dx - dy))
     if defocus_y is not None:
         defocus_sum = np.add(defocus_x, defocus_y)
@@ -628,7 +575,9 @@ def create_ctf(
         defocus_x = np.add(defocus_sum, defocus_difference)
         defocus_x *= 0.5
 
-    frequency_grid = fftfreqn(shape, sampling_rate=1, compute_euclidean_norm=True)
+    frequency_grid = fftfreqn(
+        shape, sampling_rate=1, compute_euclidean_norm=True, fftshift=False
+    )
     if angle is not None and opening_axis is not None and full_shape is not None:
         frequency_grid = frequency_grid_at_angle(
             shape=full_shape,
@@ -636,8 +585,9 @@ def create_ctf(
             opening_axis=opening_axis,
             angle=angle,
             sampling_rate=1,
+            fftshift=False,
         )
-    frequency_mask = frequency_grid < cutoff_frequency
+    frequency_mask = frequency_grid <= cutoff_frequency
 
     # k^2*π*λ(dx - 0.5 * sph_abb * λ^2 * k^2) + phase_shift + ampl_contrast_term)
     frequency_grid = np.square(frequency_grid, out=frequency_grid)
@@ -652,5 +602,4 @@ def create_ctf(
         )
     )
     chi = np.sin(-chi, out=chi)
-    chi = np.multiply(chi, frequency_mask, out=chi)
-    return chi
+    return np.multiply(chi, frequency_mask, out=chi)

tme/filters/reconstruction.py

@@ -1,22 +1,22 @@
 """
-Defines filters on tomographic tilt series.
+Implements class ReconstructFromTilt and ShiftFourier.
 
 Copyright (c) 2024 European Molecular Biology Laboratory
 
 Author: Valentin Maurer <valentin.maurer@embl-hamburg.de>
 """
 
-from typing import Tuple
+from typing import Tuple, Dict
 from dataclasses import dataclass
 
 import numpy as np
 
+from ..types import BackendArray
 from ..backends import backend as be
-from ..types import NDArray, BackendArray
 
 from .compose import ComposableFilter
 from ..rotations import euler_to_rotationmatrix
-from ._utils import crop_real_fourier, shift_fourier, create_reconstruction_filter
+from ._utils import shift_fourier, create_reconstruction_filter
 
 __all__ = ["ReconstructFromTilt", "ShiftFourier"]
 
@@ -24,45 +24,56 @@ __all__ = ["ReconstructFromTilt", "ShiftFourier"]
 @dataclass
 class ReconstructFromTilt(ComposableFilter):
     """
-    Reconstruct a d+1 array from a d-dimensional input projection using weighted
-    backprojection (WBP).
+    Place Fourier transforms of d-dimensional inputs into a d+1-dimensional array
+    aking of weighted backprojection using direct fourier inversion.
+
+    This class is used to reconstruct the output of ComposableFilter instances for
+    individual tilts to be applied to query templates.
+
+    See Also
+    --------
+    :py:class:`tme.filters.CTF`
+    :py:class:`tme.filters.Wedge`
+    :py:class:`tme.filters.BandPass`
+
     """
 
-    #: Shape of the reconstruction.
-    shape: Tuple[int] = None
-    #: Angle of each individual tilt.
+    #: Angle of each individual tilt in degrees.
     angles: Tuple[float] = None
     #: Projection axis, defaults to 2 (z).
     opening_axis: int = 2
     #: Tilt axis, defaults to 0 (x).
     tilt_axis: int = 0
-    #: Whether to return a share compliant with rfftn.
-    return_real_fourier: bool = True
     #: Interpolation order used for rotation
     interpolation_order: int = 1
     #: Filter window applied during reconstruction.
     reconstruction_filter: str = None
 
-    def __call__(self, return_real_fourier: bool = False, **kwargs):
+    @staticmethod
+    def _evaluate(
+        data: BackendArray,
+        shape: Tuple[int, ...],
+        angles: Tuple[float],
+        opening_axis: int = 2,
+        tilt_axis: int = 0,
+        interpolation_order: int = 1,
+        reconstruction_filter: str = None,
+        **kwargs,
+    ) -> Dict:
         """
-        Reconstruct a  d+1 array from a d-dimensional input using WBP.
+        Reconstruct a 3-dimensional array from n 2-dimensional inputs using WBP.
 
         Parameters
         ----------
-        shape : tuple of int
-            The shape of the reconstruction volume.
         data : BackendArray
             D-dimensional image stack with shape (n, ...). The data is assumed to be
-            a Fourier transform of the stack you are trying to reconstruct with
-            DC component in the center.
+            the Fourier transform of the stack you are trying to reconstruct with
+            DC component at the origin. Notably, the data needs to be the output of
+            np.fft.fftn not the reduced np.fft.rffn.
+        shape : tuple of int
+            The shape of the reconstruction volume.
         angles : tuple of float
-            Angle of each individual tilt.
-        return_real_fourier : bool, optional
-            Return a shape compliant
-        return_real_fourier : tuple of int
-            Return a shape compliant with rfft, i.e., omit the negative frequencies
-            terms resulting in a return shape (*shape[:-1], shape[-1]//2+1). Defaults
-            to False.
+            Angle to place individual slices at in degrees.
         reconstruction_filter : bool, optional
            Filter window applied during reconstruction.
            See :py:meth:`create_reconstruction_filter` for available options.
@@ -70,80 +81,21 @@ class ReconstructFromTilt(ComposableFilter):
             Axis the plane is tilted over, defaults to 0 (x).
         opening_axis : int
             The projection axis, defaults to 2 (z).
-
-        Returns
-        -------
-        dict
-            data: BackendArray
-                The filter mask.
-            shape: tuple of ints
-                The requested filter shape
-            return_real_fourier: bool
-                Whether data is compliant with rfftn.
-            is_multiplicative_filter: bool
-                Whether the filter is multiplicative in Fourier space.
-        """
-
-        func_args = vars(self).copy()
-        func_args.update(kwargs)
-
-        ret = self.reconstruct(**func_args)
-
-        ret = shift_fourier(data=ret, shape_is_real_fourier=False)
-        if return_real_fourier:
-            ret = crop_real_fourier(ret)
-
-        return {
-            "data": ret,
-            "shape": func_args["shape"],
-            "return_real_fourier": return_real_fourier,
-            "is_multiplicative_filter": False,
-        }
-
-    @staticmethod
-    def reconstruct(
-        data: NDArray,
-        shape: Tuple[int],
-        angles: Tuple[float],
-        opening_axis: int,
-        tilt_axis: int,
-        interpolation_order: int = 1,
-        reconstruction_filter: str = None,
-        **kwargs,
-    ):
         """
-        Reconstruct a volume from a tilt series.
-
-        Parameters
-        ----------
-        data : NDArray
-            The Fourier transform of tilt series data.
-        shape : tuple of int
-            Shape of the reconstruction.
-        angles : tuple of float
-            Angle of each individual tilt.
-        opening_axis : int
-            The axis around which the volume is opened.
-        tilt_axis : int
-            Axis the plane is tilted over.
-        interpolation_order : int, optional
-            Interpolation order used for rotation, defaults to 1.
-        reconstruction_filter : bool, optional
-           Filter window applied during reconstruction.
-           See :py:meth:`create_reconstruction_filter` for available options.
 
-        Returns
-        -------
-        NDArray
-            The reconstructed volume.
-        """
         if data.shape == shape:
             return data
 
-        data = be.to_backend_array(data)
+        # Composable filters use frequency grids centered at the origin
+        # Here we require them to be centered at subset.shape // 2
+        for i in range(data.shape[0]):
+            data_shifted = shift_fourier(
+                data[i], shape_is_real_fourier=False, ifftshift=False
+            )
+            data = be.at(data, i, data_shifted)
+
         volume_temp = be.zeros(shape, dtype=data.dtype)
-        volume_temp_rotated = be.zeros(shape, dtype=data.dtype)
-        volume = be.zeros(shape, dtype=data.dtype)
+        rec = be.zeros(shape, dtype=data.dtype)
 
         slices = tuple(slice(a // 2, (a // 2) + 1) for a in shape)
         subset = tuple(
@@ -162,58 +114,51 @@ class ReconstructFromTilt(ComposableFilter):
                 filter_type=reconstruction_filter,
                 filter_shape=(shape[tilt_axis],),
                 tilt_angles=angles,
+                fftshift=True,
             )
             rec_shape = tuple(1 if i != tilt_axis else x for i, x in enumerate(shape))
             rec_filter = be.to_backend_array(rec_filter)
             rec_filter = be.reshape(rec_filter, rec_shape)
 
         angles = be.to_backend_array(angles)
+        axis_index = min(
+            tuple(i for i in range(len(shape)) if i not in (tilt_axis, opening_axis))
+        )
         for index in range(len(angles)):
             angles_loop = be.fill(angles_loop, 0)
             volume_temp = be.fill(volume_temp, 0)
-            volume_temp_rotated = be.fill(volume_temp_rotated, 0)
 
             # Jax compatibility
             volume_temp = be.at(volume_temp, subset, wedges[index] * rec_filter)
-            angles_loop = be.at(angles_loop, tilt_axis, angles[index])
+            angles_loop = be.at(angles_loop, axis_index, angles[index])
 
-            angles_loop = be.roll(angles_loop, (opening_axis - 1,), axis=0)
-            rotation_matrix = euler_to_rotationmatrix(be.to_numpy_array(angles_loop))
-            rotation_matrix = be.to_backend_array(rotation_matrix)
+            # We want a push rotation but rigid transform assumes pull
+            rotation_matrix = euler_to_rotationmatrix(
+                be.to_numpy_array(angles_loop), seq="xyz"
+            ).T
 
-            volume_temp_rotated, _ = be.rigid_transform(
+            volume_temp, _ = be.rigid_transform(
                 arr=volume_temp,
-                rotation_matrix=rotation_matrix,
-                out=volume_temp_rotated,
+                rotation_matrix=be.to_backend_array(rotation_matrix),
                 use_geometric_center=True,
                 order=interpolation_order,
             )
-            volume = be.add(volume, volume_temp_rotated, out=volume)
+            rec = be.add(rec, volume_temp, out=rec)
 
-        return volume
+        # Shift DC component back to origin
+        rec = shift_fourier(rec, shape_is_real_fourier=False, ifftshift=True)
+        return {"data": rec, "shape": shape, "is_multiplicative_filter": False}
 
 
 class ShiftFourier(ComposableFilter):
-    def __call__(
-        self,
-        data: BackendArray,
-        shape_is_real_fourier: bool = False,
-        return_real_fourier: bool = True,
-        **kwargs,
-    ):
+    def _evaluate(self, shape: Tuple[int, ...], data: BackendArray, **kwargs) -> Dict:
         ret = []
         for index in range(data.shape[0]):
-            mask = be.to_numpy_array(data[index])
-
-            mask = shift_fourier(data=mask, shape_is_real_fourier=shape_is_real_fourier)
-            if return_real_fourier:
-                mask = crop_real_fourier(mask)
+            mask = shift_fourier(
+                data=data[index],
+                shape_is_real_fourier=kwargs.get("return_real_fourier", False),
+            )
             ret.append(mask[None])
-        ret = np.concatenate(ret, axis=0)
-
-        return {
-            "data": ret,
-            "shape": kwargs.get("shape"),
-            "return_real_fourier": return_real_fourier,
-            "is_multiplicative_filter": False,
-        }
+
+        ret = be.concatenate(ret, axis=0)
+        return {"data": ret, "shape": shape, "is_multiplicative_filter": False}