pytme 0.2.0b0__cp311-cp311-macosx_14_0_arm64.whl → 0.2.2__cp311-cp311-macosx_14_0_arm64.whl

tme/preprocessor.py

@@ -4,39 +4,19 @@
 
     Author: Valentin Maurer <valentin.maurer@embl-hamburg.de>
 """
-
+import os
+import pickle
 import inspect
 from typing import Dict, Tuple
 
 import numpy as np
-from numpy.typing import NDArray
-
-from scipy.ndimage import (
-    fourier_gaussian,
-    gaussian_filter,
-    rank_filter,
-    median_filter,
-    zoom,
-    generic_gradient_magnitude,
-    sobel,
-    prewitt,
-    laplace,
-    gaussian_laplace,
-    gaussian_gradient_magnitude,
-)
-from scipy.ndimage import mean as ndimean
-from scipy.signal import convolve, decimate
-from scipy.optimize import differential_evolution
-from pywt import wavelist, wavedecn, waverecn
-from scipy.interpolate import interp1d
-
-from .density import Density
-from .helpers import (
-    window_kaiserb,
-    window_blob,
-    apply_window_filter,
-    Ntree,
-)
+from scipy import ndimage
+from scipy.special import iv as bessel
+from scipy.interpolate import interp1d, splrep, BSpline
+from scipy.optimize import differential_evolution, minimize
+
+from .types import NDArray
+from .backends import NumpyFFTWBackend
 from .matching_utils import euler_to_rotationmatrix
 
 
@@ -47,7 +27,7 @@ class Preprocessor:
 
     def apply_method(self, method: str, parameters: Dict):
         """
-        Apply a method on the atomic structure.
+        Invoke ``Preprocessor.method`` using ``parameters``.
 
         Parameters
         ----------
@@ -69,8 +49,7 @@ class Preprocessor:
             raise NotImplementedError(
                 f"'{method}' is not supported as a filter method on this class."
             )
-        method_to_call = getattr(self, method)
-        return method_to_call(**parameters)
+        return getattr(self, method)(**parameters)
 
     def method_to_id(self, method: str, parameters: Dict) -> str:
         """
@@ -109,59 +88,11 @@ class Preprocessor:
 
         return "-".join([str(default[key]) for key in sorted(default.keys())])
 
-    @staticmethod
-    def _gaussian_fourier(template: NDArray, sigma: NDArray) -> NDArray:
-        """
-        Apply a Gaussian filter in Fourier space on the provided template.
-
-        Parameters
-        ----------
-        template : NDArray
-            The input template on which to apply the filter.
-        sigma : NDArray
-            The standard deviation for Gaussian kernel. The greater the value,
-            the more spread out is the filter.
-
-        Returns
-        -------
-        NDArray
-            The template after applying the Fourier Gaussian filter.
-        """
-        fourrier_map = fourier_gaussian(np.fft.fftn(template), sigma)
-        template = np.real(np.fft.ifftn(fourrier_map))
-
-        return template
-
-    @staticmethod
-    def _gaussian_real(
-        template: NDArray, sigma: NDArray, cutoff_value: float = 4.0
-    ) -> NDArray:
-        """
-        Apply a Gaussian filter on the provided template in real space.
-
-        Parameters
-        ----------
-        template : NDArray
-            The input template on which to apply the filter.
-        sigma : NDArray
-            The standard deviation for Gaussian kernel. The greater the value,
-            the more spread out is the filter.
-        cutoff_value : float, optional
-            The value below which the data should be ignored. Default is 4.0.
-
-        Returns
-        -------
-        NDArray
-            The template after applying the Gaussian filter in real space.
-        """
-        template = gaussian_filter(template, sigma, cval=cutoff_value)
-        return template
-
     def gaussian_filter(
         self,
         template: NDArray,
-        sigma: NDArray,
-        fourier: bool = False,
+        sigma: Tuple[float],
+        cutoff_value: float = 4.0,
     ) -> NDArray:
         """
         Convolve an atomic structure with a Gaussian kernel.
@@ -169,31 +100,19 @@ class Preprocessor:
         Parameters
         ----------
         template : NDArray
-            The input atomic structure map.
-        resolution : float, optional
-            The resolution. The product of `resolution` and `sigma_coeff` is used
-            to compute the `sigma` for the discretized Gaussian. Default is None.
-        sigma : NDArray
-            The standard deviation for Gaussian kernel. Should either be a scalar
-            or a sequence of scalars.
-        fourier : bool, optional
-            If true, applies a Fourier Gaussian filter; otherwise, applies a
-            real-space Gaussian filter. Default is False.
+            Input data.
+        sigma : float or tuple of floats
+            The standard deviation of the Gaussian kernel along one or all axes.
+        cutoff_value : float, optional
+            Truncates the Gaussian kernel at cutoff_values times sigma.
 
         Returns
         -------
         NDArray
-            The simulated electron densities after applying the Gaussian filter.
+            Gaussian filtered template.
         """
         sigma = 0 if sigma is None else sigma
-
-        if sigma <= 0:
-            return template
-
-        func = self._gaussian_real if not fourier else self._gaussian_fourier
-        template = func(template, sigma)
-
-        return template
+        return ndimage.gaussian_filter(template, sigma, cval=cutoff_value)
 
     def difference_of_gaussian_filter(
         self, template: NDArray, low_sigma: NDArray, high_sigma: NDArray
@@ -220,8 +139,8 @@ class Preprocessor:
         """
         if np.any(low_sigma > high_sigma):
             print("low_sigma should be smaller than high_sigma.")
-        im1 = self._gaussian_real(template, low_sigma)
-        im2 = self._gaussian_real(template, high_sigma)
+        im1 = self.gaussian_filter(template, low_sigma)
+        im2 = self.gaussian_filter(template, high_sigma)
         return im1 - im2
 
     def local_gaussian_alignment_filter(
@@ -372,7 +291,6 @@ class Preprocessor:
             +-------------------+------------------------------------------------+
             | 'gaussian_laplace | See scipy.ndimage.gaussian_laplace             |
             +-------------------+------------------------------------------------+
-
         reverse : bool, optional
             If true, the filterring is strong along edges. Default is False.
 
@@ -382,15 +300,15 @@ class Preprocessor:
             Simulated electron densities.
         """
         if edge_algorithm == "sobel":
-            edges = generic_gradient_magnitude(template, sobel)
+            edges = ndimage.generic_gradient_magnitude(template, ndimage.sobel)
         elif edge_algorithm == "prewitt":
-            edges = generic_gradient_magnitude(template, prewitt)
+            edges = ndimage.generic_gradient_magnitude(template, ndimage.prewitt)
         elif edge_algorithm == "laplace":
-            edges = laplace(template)
+            edges = ndimage.laplace(template)
         elif edge_algorithm == "gaussian":
-            edges = gaussian_gradient_magnitude(template, sigma / 2)
+            edges = ndimage.gaussian_gradient_magnitude(template, sigma / 2)
         elif edge_algorithm == "gaussian_laplace":
-            edges = gaussian_laplace(template, sigma / 2)
+            edges = ndimage.gaussian_laplace(template, sigma / 2)
         else:
             raise ValueError(
                 "Supported edge_algorithm values are"
@@ -399,49 +317,16 @@ class Preprocessor:
         edges[edges != 0] = 1
         edges /= edges.max()
 
-        edges = gaussian_filter(edges, sigma)
-        filter = gaussian_filter(template, sigma)
+        edges = ndimage.gaussian_filter(edges, sigma)
+        filt = ndimage.gaussian_filter(template, sigma)
 
         if not reverse:
-            res = template * edges + filter * (1 - edges)
+            res = template * edges + filt * (1 - edges)
         else:
-            res = template * (1 - edges) + filter * (edges)
+            res = template * (1 - edges) + filt * (edges)
 
         return res
 
-    def ntree_filter(
-        self,
-        template: NDArray,
-        sigma_range: Tuple[float, float],
-        target: NDArray = None,
-    ) -> NDArray:
-        """
-        Use dyadic tree to identify volume partitions in *template*
-        and filter them with respect to their occupancy.
-
-        Parameters
-        ----------
-        template : NDArray
-            The input atomic structure map.
-        sigma_range : tuple of float
-            Range of sigma values used to filter volume partitions.
-        target : NDArray, optional
-            If provided, dyadic tree is computed on target rather than template.
-
-        Returns
-        -------
-        NDArray
-            Simulated electron densities.
-        """
-        if target is None:
-            target = template
-
-        tree = Ntree(target)
-
-        filter = tree.filter_chunks(arr=template, sigma_range=sigma_range)
-
-        return filter
-
     def mean_filter(self, template: NDArray, width: NDArray) -> NDArray:
         """
         Perform mean filtering.
@@ -466,7 +351,7 @@ class Preprocessor:
         filter_width = np.repeat(width, template.ndim // width.size)
         filter_mask = np.ones(filter_width)
         filter_mask = filter_mask / np.sum(filter_mask)
-        template = convolve(template, filter_mask, mode="same")
+        template = ndimage.convolve(template, filter_mask, mode="reflect")
 
         # Sometimes scipy messes up the box sizes ...
         template = self.interpolate_box(box=interpolation_box, arr=template)
@@ -607,7 +492,7 @@ class Preprocessor:
         if size <= 1:
             size = 3
 
-        template = rank_filter(template, rank=rank, size=size)
+        template = ndimage.rank_filter(template, rank=rank, size=size)
         template = self.interpolate_box(box=interpolation_box, arr=template)
 
         return template
@@ -630,7 +515,7 @@ class Preprocessor:
         """
         interpolation_box = template.shape
 
-        template = median_filter(template, size=size)
+        template = ndimage.median_filter(template, size=size)
         template = self.interpolate_box(box=interpolation_box, arr=template)
 
         return template
@@ -655,144 +540,13 @@ class Preprocessor:
         interpolation_box = array.shape
 
         for k in range(template.ndim):
-            array = decimate(array, q=level, axis=k)
+            array = ndimage.decimate(array, q=level, axis=k)
 
-        template = zoom(array, np.divide(template.shape, array.shape))
+        template = ndimage.zoom(array, np.divide(template.shape, array.shape))
         template = self.interpolate_box(box=interpolation_box, arr=template)
 
         return template
 
-    def wavelet_filter(
-        self,
-        template: NDArray,
-        level: int,
-        wavelet: str = "bior2.2",
-    ) -> NDArray:
-        """
-        Perform dyadic wavelet decomposition.
-
-        Parameters
-        ----------
-        template : NDArray
-            The input atomic structure map.
-        level : int
-            Scale of the wavelet transform.
-        wavelet : str, optional
-            Mother wavelet used for decomposition. Default is 'bior2.2'.
-
-        Returns
-        -------
-        NDArray
-            Simulated electron densities.
-        """
-        if wavelet not in wavelist(kind="discrete"):
-            raise NotImplementedError(
-                "Print argument wavelet has to be one of the following: %s",
-                ", ".join(wavelist(kind="discrete")),
-            )
-
-        template, interpolation_box = template.copy(), template.shape
-        decomp = wavedecn(template, level=level, wavelet=wavelet)
-
-        for i in range(1, level + 1):
-            decomp[i] = {k: np.zeros_like(v) for k, v in decomp[i].items()}
-
-        template = waverecn(coeffs=decomp, wavelet=wavelet)
-        template = self.interpolate_box(box=interpolation_box, arr=template)
-
-        return template
-
-    @staticmethod
-    def molmap(
-        coordinates: NDArray,
-        weights: Tuple[float],
-        resolution: float,
-        sigma_factor: float = 1 / (np.pi * np.sqrt(2)),
-        cutoff_value: float = 5.0,
-        origin: Tuple[float] = None,
-        shape: Tuple[int] = None,
-        sampling_rate: float = None,
-    ) -> NDArray:
-        """
-        Compute the electron densities analogous to Chimera's molmap function.
-
-        Parameters
-        ----------
-        coordinates : NDArray
-            A N x 3 array containing atomic coordinates in z, y, x format.
-        weights : [float]
-            The weights to use for the entries in coordinates.
-        resolution : float
-            The product of resolution and sigma_factor gives the sigma used to
-            compute the discretized Gaussian.
-        sigma_factor : float
-            The factor used with resolution to compute sigma. Default is 1 / (π√2).
-        cutoff_value : float
-            The cutoff value for the Gaussian kernel. Default is 5.0.
-        origin : (float,)
-            The origin of the coordinate system used in coordinates. If not specified,
-            the minimum coordinate along each axis is used.
-        shape : (int,)
-            The shape of the output array. If not specified, the function computes the
-            smallest output array that contains all atoms.
-        sampling_rate : float
-            The Ångstrom per voxel of the output array. If not specified, the function
-            sets this value to resolution/3.
-
-        References
-        ----------
-        ..[1] https://www.cgl.ucsf.edu/chimera/docs/UsersGuide/midas/molmap.html
-
-        Returns
-        -------
-        NDArray
-            A numpy array containing the simulated electron densities.
-        """
-        if sampling_rate is None:
-            sampling_rate = resolution * (1.0 / 3)
-
-        coordinates = coordinates.copy()
-        if origin is None:
-            origin = coordinates.min(axis=0)
-        if shape is None:
-            positions = (coordinates - origin) / sampling_rate
-            shape = positions.max(axis=0).astype(int)[::-1] + 2
-
-        positions = (coordinates - origin) / sampling_rate
-        positions = positions[:, ::-1]
-
-        out = np.zeros(shape, dtype=np.float32)
-        sigma = sigma_factor * resolution
-        sigma_grid = sigma / sampling_rate
-        sigma_grid2 = sigma_grid * sigma_grid
-
-        starts = np.maximum(np.ceil(positions - cutoff_value * sigma_grid), 0).astype(
-            int
-        )
-        stops = np.minimum(
-            np.floor(positions + cutoff_value * sigma_grid), shape
-        ).astype(int)
-        ranges = tuple(tuple(zip(start, stop)) for start, stop in zip(starts, stops))
-
-        positions = positions.reshape(
-            *positions.shape, *tuple(1 for _ in range(positions.shape[1]))
-        )
-        for index in range(positions.shape[0]):
-            grid_index = np.meshgrid(*[range(*coord) for coord in ranges[index]])
-            distances = np.sum(
-                np.square(np.subtract(grid_index, positions[index])),
-                dtype=np.float32,
-                axis=0,
-            )
-            np.add.at(
-                out,
-                tuple(grid_index),
-                weights[index] * np.exp(-0.5 * distances / sigma_grid2),
-            )
-
-        out *= np.power(2 * np.pi, -1.5) * np.power(sigma, -3)
-        return out
-
     def interpolate_box(
         self, arr: NDArray, box: Tuple[int], kind: str = "nearest"
     ) -> NDArray:
@@ -834,79 +588,11 @@ class Preprocessor:
 
         return arr
 
-    @staticmethod
-    def fftfreqn(shape: NDArray, sampling_rate: NDArray = 1) -> NDArray:
-        """
-        Calculate the N-dimensional equivalent to the inverse fftshifted
-        absolute of numpy's fftfreq function, supporting anisotropic sampling.
-
-        Parameters
-        ----------
-        shape : NDArray
-            The shape of the N-dimensional array.
-        sampling_rate : NDArray
-            The sampling rate in the N-dimensional array.
-
-        Returns
-        -------
-        NDArray
-            A numpy array representing the norm of indices after normalization.
-
-        Examples
-        --------
-        >>> import numpy as np
-        >>> from tme import Preprocessor
-        >>> freq = Preprocessor().fftfreqn((10,), 1)
-        >>> freq_numpy = np.fft.fftfreq(10, 1)
-        >>> np.allclose(freq, np.abs(np.fft.ifftshift(freq_numpy)))
-        """
-        indices = np.indices(shape).T
-        norm = np.multiply(shape, sampling_rate)
-        indices -= np.divide(shape, 2).astype(int)
-        indices = np.divide(indices, norm)
-        return np.linalg.norm(indices, axis=-1).T
-
-    def _approximate_butterworth(
-        self,
-        radial_frequencies: NDArray,
-        lowcut: float,
-        highcut: float,
-        gaussian_sigma: float,
-    ) -> NDArray:
-        """
-        Approximate a Butterworth band-pass filter for given radial frequencies.
-        The DC component of the filter is at the origin.
-
-        Parameters
-        ----------
-        radial_frequencies : NDArray
-            The radial frequencies for which the Butterworth band-pass
-            filter is to be calculated.
-        lowcut : float
-            The lower cutoff frequency for the band-pass filter.
-        highcut : float
-            The upper cutoff frequency for the band-pass filter.
-        gaussian_sigma : float
-            The sigma value for the Gaussian smoothing applied to the filter.
-
-        Returns
-        -------
-        NDArray
-            A numpy array representing the approximate Butterworth
-            band-pass filter applied to the radial frequencies.
-        """
-        bpf = ((radial_frequencies <= highcut) & (radial_frequencies >= lowcut)) * 1.0
-        bpf = self.gaussian_filter(template=bpf, sigma=gaussian_sigma, fourier=False)
-        bpf[bpf < np.exp(-2)] = 0
-        bpf = np.fft.ifftshift(bpf)
-
-        return bpf
-
     def bandpass_filter(
         self,
         template: NDArray,
-        minimum_frequency: float,
-        maximum_frequency: float,
+        lowpass: float,
+        highpass: float,
         sampling_rate: NDArray = None,
         gaussian_sigma: float = 0.0,
     ) -> NDArray:
@@ -918,10 +604,10 @@ class Preprocessor:
         ----------
         template : NDArray
             The input numpy array on which the band-pass filter should be applied.
-        minimum_frequency : float
+        lowpass : float
             The lower boundary of the frequency range to be preserved. Lower values will
             retain broader, more global features.
-        maximum_frequency : float
+        highpass : float
             The upper boundary of the frequency range to be preserved.  Higher values
             will emphasize finer details and potentially noise.
         sampling_rate : NDarray, optional
@@ -936,8 +622,8 @@ class Preprocessor:
         """
         bpf = self.bandpass_mask(
             shape=template.shape,
-            minimum_frequency=minimum_frequency,
-            maximum_frequency=maximum_frequency,
+            lowpass=lowpass,
+            highpass=highpass,
             sampling_rate=sampling_rate,
             gaussian_sigma=gaussian_sigma,
             omit_negative_frequencies=False,
@@ -951,8 +637,8 @@ class Preprocessor:
     def bandpass_mask(
         self,
         shape: Tuple[int],
-        minimum_frequency: float,
-        maximum_frequency: float,
+        lowpass: float,
+        highpass: float,
         sampling_rate: NDArray = None,
         gaussian_sigma: float = 0.0,
         omit_negative_frequencies: bool = True,
@@ -965,7 +651,7 @@ class Preprocessor:
         ----------
         shape : tuple of ints
             Shape of the returned bandpass filter.
-        minimum_frequency : float
+        lowpass : float
             The lower boundary of the frequency range to be preserved. Lower values will
             retain broader, more global features.
         maximum_frequency : float
@@ -984,27 +670,15 @@ class Preprocessor:
         NDArray
             Bandpass filtered.
         """
-        if sampling_rate is None:
-            sampling_rate = np.ones(len(shape))
-        sampling_rate = np.asarray(sampling_rate, dtype=np.float32)
-        sampling_rate /= sampling_rate.max()
-
-        if minimum_frequency > maximum_frequency:
-            minimum_frequency, maximum_frequency = maximum_frequency, minimum_frequency
-
-        radial_freq = self.fftfreqn(shape, sampling_rate)
-        bpf = self._approximate_butterworth(
-            radial_frequencies=radial_freq,
-            lowcut=minimum_frequency,
-            highcut=maximum_frequency,
-            gaussian_sigma=gaussian_sigma,
-        )
-
-        if omit_negative_frequencies:
-            stop = 1 + (shape[-1] // 2)
-            bpf = bpf[..., :stop]
+        from .preprocessing import BandPassFilter
 
-        return bpf
+        return BandPassFilter(
+            sampling_rate=sampling_rate,
+            lowpass=lowpass,
+            highpass=highpass,
+            return_real_fourier=omit_negative_frequencies,
+            use_gaussian=gaussian_sigma == 0.0,
+        )(shape=shape)["data"]
 
     def wedge_mask(
         self,
@@ -1104,7 +778,7 @@ class Preprocessor:
                 for i in range(plane.ndim)
             )
             plane[subset] = 1
-            Density.rotate_array(
+            NumpyFFTWBackend().rigid_transform(
                 arr=plane,
                 rotation_matrix=rotation_matrix,
                 out=plane_rotated,
@@ -1113,9 +787,7 @@ class Preprocessor:
             )
             wedge_volume += plane_rotated
 
-        wedge_volume = self.gaussian_filter(
-            template=wedge_volume, sigma=sigma, fourier=False
-        )
+        wedge_volume = self.gaussian_filter(template=wedge_volume, sigma=sigma)
         wedge_volume = np.where(wedge_volume > np.exp(-2), 1, 0)
         wedge_volume = np.fft.ifftshift(wedge_volume)
 
@@ -1135,6 +807,7 @@ class Preprocessor:
         opening_axis: int = 0,
         tilt_axis: int = 2,
         sigma: float = 0,
+        weights: float = 1,
         omit_negative_frequencies: bool = True,
     ) -> NDArray:
         """
@@ -1165,6 +838,8 @@ class Preprocessor:
             - 2 for X-axis
         sigma : float, optional
             Standard deviation for Gaussian kernel used for smoothing the wedge.
+        weights : float, tuple of float
+            Weight of each element in the wedge. Defaults to one.
         omit_negative_frequencies : bool, optional
             Whether the wedge mask should omit negative frequencies, i.e. be
             applicable to symmetric Fourier transforms (see :obj:`numpy.fft.fftn`)
@@ -1188,20 +863,24 @@ class Preprocessor:
         if tilt_angles is None:
             tilt_angles = np.arange(-start_tilt, stop_tilt + tilt_step, tilt_step)
 
+        shape = tuple(int(x) for x in shape)
+        opening_axis, tilt_axis = int(opening_axis), int(tilt_axis)
+
+        weights = np.asarray(weights)
+        weights = np.repeat(weights, tilt_angles.size // weights.size)
         plane = np.zeros((shape[opening_axis], shape[tilt_axis]), dtype=np.float32)
         subset = tuple(
             slice(None) if i != 0 else slice(x // 2, x // 2 + 1)
             for i, x in enumerate(plane.shape)
         )
-        plane[subset] = 1
         plane_rotated, wedge_volume = np.zeros_like(plane), np.zeros_like(plane)
         for index in range(tilt_angles.shape[0]):
             plane_rotated.fill(0)
-
+            plane[subset] = weights[index]
             rotation_matrix = euler_to_rotationmatrix((tilt_angles[index], 0))
             rotation_matrix = rotation_matrix[np.ix_((0, 1), (0, 1))]
 
-            Density.rotate_array(
+            NumpyFFTWBackend().rigid_transform(
                 arr=plane,
                 rotation_matrix=rotation_matrix,
                 out=plane_rotated,
@@ -1210,10 +889,11 @@ class Preprocessor:
             )
             wedge_volume += plane_rotated
 
-        wedge_volume = self.gaussian_filter(
-            template=wedge_volume, sigma=sigma, fourier=False
-        )
-        wedge_volume = np.where(wedge_volume > np.exp(-2), 1, 0)
+        # Ramp filtering would be more accurate
+        np.fmin(wedge_volume, np.max(weights), wedge_volume)
+
+        if sigma > 0:
+            wedge_volume = self.gaussian_filter(template=wedge_volume, sigma=sigma)
 
         if opening_axis > tilt_axis:
             wedge_volume = np.moveaxis(wedge_volume, 1, 0)
@@ -1331,7 +1011,7 @@ class Preprocessor:
         if not infinite_plane:
             np.multiply(wedge, distances <= shape[tilt_axis] // 2, out=wedge)
 
-        wedge = self.gaussian_filter(template=wedge, sigma=sigma, fourier=False)
+        wedge = self.gaussian_filter(template=wedge, sigma=sigma)
         wedge = np.fft.ifftshift(wedge > np.exp(-2))
 
         if omit_negative_frequencies:
@@ -1340,167 +1020,531 @@ class Preprocessor:
 
         return wedge
 
-    @staticmethod
-    def _fourier_crop_mask(old_shape: NDArray, new_shape: NDArray) -> NDArray:
-        """
-        Generate a mask for Fourier cropping.
 
-        Parameters
-        ----------
-        old_shape : NDArray
-            The original shape of the array before cropping.
-        new_shape : NDArray
-            The new desired shape for the array after cropping.
+def window_kaiserb(width: int, beta: float = 3.2, order: int = 0) -> NDArray:
+    """
+    Create a Kaiser-Bessel window.
+
+    Parameters
+    ----------
+    width : int
+        Width of the window.
+    beta : float, optional
+        Beta parameter of the Kaiser-Bessel window. Default is 3.2.
+    order : int, optional
+        Order of the Bessel function. Default is 0.
+
+    Returns
+    -------
+    NDArray
+        Kaiser-Bessel window.
+
+    References
+    ----------
+    .. [1]  Sorzano, Carlos et al (Mar. 2015). Fast and accurate conversion
+            of atomic models into electron density maps. AIMS Biophysics
+            2, 8–20.
+    """
+    window = np.arange(0, width)
+    alpha = (width - 1) / 2.0
+    arr = beta * np.sqrt(1 - ((window - alpha) / alpha) ** 2.0)
 
-        Returns
-        -------
-        NDArray
-            The mask array for Fourier cropping.
-        """
-        mask = np.zeros(old_shape, dtype=bool)
-        mask[tuple(np.indices(new_shape))] = 1
-        box_shift = np.floor(np.divide(new_shape, 2)).astype(int)
-        mask = np.roll(mask, shift=-box_shift, axis=range(len(old_shape)))
-        return mask
+    return bessel(order, arr) / bessel(order, beta)
 
-    def fourier_crop(
-        self,
-        template: NDArray,
-        reciprocal_template_filter: NDArray,
-        crop_factor: float = 3 / 2,
-    ) -> NDArray:
-        """
-        Perform Fourier uncropping on a given template.
 
-        Parameters
-        ----------
-        template : NDArray
-            The original template to be uncropped.
-        reciprocal_template_filter : NDArray
-            The filter to be applied in the Fourier space.
-        crop_factor : float
-            Cropping factor over reeciprocal_template_filter boundary.
+def window_blob(width: int, beta: float = 3.2, order: int = 2) -> NDArray:
+    """
+    Generate a blob window based on Bessel functions.
+
+    Parameters
+    ----------
+    width : int
+        Width of the window.
+    beta : float, optional
+        Beta parameter. Default is 3.2.
+    order : int, optional
+        Order of the Bessel function. Default is 2.
+
+    Returns
+    -------
+    NDArray
+        Blob window.
+
+    References
+    ----------
+    .. [1]  Sorzano, Carlos et al (Mar. 2015). Fast and accurate conversion
+            of atomic models into electron density maps. AIMS Biophysics
+            2, 8–20.
+    """
+    window = np.arange(0, width)
+    alpha = (width - 1) / 2.0
+    arr = beta * np.sqrt(1 - ((window - alpha) / alpha) ** 2.0)
 
-        Returns
-        -------
-        NDArray
-            The uncropped template.
-        """
-        new_boxsize = np.zeros(template.ndim, dtype=int)
-        for i in range(template.ndim):
-            slices = tuple(
-                slice(0, 1) if j != i else slice(template.shape[i] // 2)
-                for j in range(template.ndim)
-            )
-            filt = np.squeeze(reciprocal_template_filter[slices])
-            new_boxsize[i] = np.ceil((np.max(np.where(filt > 0)) + 1) * crop_factor) * 2
+    arr = np.divide(np.power(arr, order) * bessel(order, arr), bessel(order, beta))
+    arr[arr != arr] = 0
+    return arr
+
+
+def window_sinckb(omega: float, d: float, dw: float):
+    """
+    Compute the sinc window combined with a Kaiser window.
+
+    Parameters
+    ----------
+    omega : float
+        Reduction factor.
+    d : float
+        Ripple.
+    dw : float
+        Delta w.
+
+    Returns
+    -------
+    ndarray
+        Impulse response of the low-pass filter.
+
+    References
+    ----------
+    .. [1]  Sorzano, Carlos et al (Mar. 2015). Fast and accurate conversion
+            of atomic models into electron density maps. AIMS Biophysics
+            2, 8–20.
+    """
+    kaiser = kaiser_mask(d, dw)
+    sinc_m = sinc_mask(np.zeros(kaiser.shape), omega)
 
-        if np.any(np.greater(new_boxsize, template.shape)):
-            new_boxsize = np.array(template.shape).copy()
+    mask = sinc_m * kaiser
 
-        mask = self._fourier_crop_mask(old_shape=template.shape, new_shape=new_boxsize)
-        arr_ft = np.fft.fftn(template)
-        arr_ft *= np.prod(new_boxsize) / np.prod(template.shape)
-        arr_ft = np.reshape(arr_ft[mask], new_boxsize)
-        arr_cropped = np.real(np.fft.ifftn(arr_ft))
-        return arr_cropped
+    return mask / np.sum(mask)
 
-    def fourier_uncrop(
-        self, template: NDArray, reciprocal_template_filter: NDArray
-    ) -> NDArray:
-        """
-        Perform an uncrop operation in the Fourier space.
 
-        Parameters
-        ----------
-        template : NDArray
-            The input array.
-        reciprocal_template_filter : NDArray
-            The filter to be applied in the Fourier space.
+def apply_window_filter(
+    arr: NDArray,
+    filter_window: NDArray,
+    mode: str = "reflect",
+    cval: float = 0.0,
+    origin: int = 0,
+):
+    """
+    Apply a window filter on an input array.
+
+    Parameters
+    ----------
+    arr : NDArray,
+        Input array.
+    filter_window : NDArray,
+        Window filter to apply.
+    mode : str, optional
+        Mode for the filtering, default is "reflect".
+    cval : float, optional
+        Value to fill when mode is "constant", default is 0.0.
+    origin : int, optional
+        Origin of the filter window, default is 0.
+
+    Returns
+    -------
+    NDArray,
+        Array after filtering.
 
-        Returns
-        -------
-        NDArray
-            Uncropped template with shape reciprocal_template_filter.
-        """
-        mask = self._fourier_crop_mask(
-            old_shape=reciprocal_template_filter.shape, new_shape=template.shape
+    """
+    filter_window = filter_window[::-1]
+    for axs in range(arr.ndim):
+        ndimage.correlate1d(
+            input=arr,
+            weights=filter_window,
+            axis=axs,
+            output=arr,
+            mode=mode,
+            cval=cval,
+            origin=origin,
+        )
+    return arr
+
+
+def sinc_mask(mask: NDArray, omega: float) -> NDArray:
+    """
+    Create a sinc mask.
+
+    Parameters
+    ----------
+    mask : NDArray
+        Input mask.
+    omega : float
+        Reduction factor.
+
+    Returns
+    -------
+    NDArray
+        Sinc mask.
+    """
+    # Move filter origin to the center of the mask
+    mask_origin = int((mask.size - 1) / 2)
+    dist = np.arange(-mask_origin, mask_origin + 1)
+
+    return np.multiply(omega / np.pi, np.sinc((omega / np.pi) * dist))
+
+
+def kaiser_mask(d: float, dw: float) -> NDArray:
+    """
+    Create a Kaiser mask.
+
+    Parameters
+    ----------
+    d : float
+        Ripple.
+    dw : float
+        Delta-w.
+
+    Returns
+    -------
+    NDArray
+        Kaiser mask.
+    """
+    # convert dw from a frequency normalized to 1 to a frequency normalized to pi
+    dw *= np.pi
+    A = -20 * np.log10(d)
+    M = max(1, np.ceil((A - 8) / (2.285 * dw)))
+
+    beta = 0
+    if A > 50:
+        beta = 0.1102 * (A - 8.7)
+    elif A >= 21:
+        beta = 0.5842 * np.power(A - 21, 0.4) + 0.07886 * (A - 21)
+
+    mask_values = np.abs(np.arange(-M, M + 1))
+    mask = np.sqrt(1 - np.power(mask_values / M, 2))
+
+    return np.divide(bessel(0, beta * mask), bessel(0, beta))
+
+
+def electron_factor(
+    dist: NDArray, method: str, atom: str, fourier: bool = False
+) -> NDArray:
+    """
+    Compute the electron factor.
+
+    Parameters
+    ----------
+    dist : NDArray
+        Distance.
+    method : str
+        Method name.
+    atom : str
+        Atom type.
+    fourier : bool, optional
+        Whether to compute the electron factor in Fourier space.
+
+    Returns
+    -------
+    NDArray
+        Computed electron factor.
+    """
+    data = get_scattering_factors(method)
+    n_range = len(data.get(atom, [])) // 2
+    default = np.zeros(n_range * 3)
+
+    res = 0.0
+    a_values = data.get(atom, default)[:n_range]
+    b_values = data.get(atom, default)[n_range : 2 * n_range]
+
+    if method == "dt1969":
+        b_values = data.get(atom, default)[1 : (n_range + 1)]
+
+    for i in range(n_range):
+        a = a_values[i]
+        b = b_values[i]
+
+        if fourier:
+            temp = a * np.exp(-b * np.power(dist, 2))
+        else:
+            b = b / (4 * np.power(np.pi, 2))
+            temp = a * np.sqrt(np.pi / b) * np.exp(-np.power(dist, 2) / (4 * b))
+
+        if not np.isnan(temp).any():
+            res += temp
+
+    return res / (2 * np.pi)
+
+
+def optimize_hlfp(profile, M, T, atom, method, filter_method):
+    """
+    Optimize high-low pass filter (HLFP).
+
+    Parameters
+    ----------
+    profile : NDArray
+        Input profile.
+    M : int
+        Scaling factor.
+    T : float
+        Time step.
+    atom : str
+        Atom type.
+    method : str
+        Method name.
+    filter_method : str
+        Filter method name.
+
+    Returns
+    -------
+    float
+        Fitness value.
+
+    References
+    ----------
+    .. [1]  Sorzano, Carlos et al (Mar. 2015). Fast and accurate conversion
+            of atomic models into electron density maps. AIMS Biophysics
+            2, 8–20.
+    """
+    # omega, d, dw
+    initial_params = [1.0, 0.01, 1.0 / 8.0]
+    if filter_method == "brute":
+        best_fitness = float("inf")
+        OMEGA, D, DW = np.meshgrid(
+            np.arange(0.7, 1.3, 0.015),
+            np.arange(0.01, 0.2, 0.015),
+            np.arange(0.05, 0.2, 0.015),
         )
-        ft_vol = np.zeros_like(mask)
-        ft_vol[mask] = np.fft.fftn(template).ravel()
-        ft_vol *= np.divide(np.prod(mask.shape), np.prod(template.shape)).astype(
-            ft_vol.dtype
+        for omega, d, dw in zip(OMEGA.ravel(), D.ravel(), DW.ravel()):
+            current_fitness = _hlpf_fitness([omega, d, dw], T, M, profile, atom, method)
+            if current_fitness < best_fitness:
+                best_fitness = current_fitness
+                initial_params = [omega, d, dw]
+        final_params = np.array(initial_params)
+    else:
+        res = minimize(
+            _hlpf_fitness,
+            initial_params,
+            args=tuple([T, M, profile, atom, method]),
+            method="SLSQP",
+            bounds=([0.2, 2], [1e-3, 2], [1e-3, 1]),
         )
-        reciprocal_template_filter = reciprocal_template_filter.astype(ft_vol.dtype)
-        np.multiply(ft_vol, reciprocal_template_filter, out=ft_vol)
-        ret = np.real(np.fft.ifftn(ft_vol))
-        return ret
+        final_params = res.x
+        if np.any(final_params != final_params):
+            print(f"Solver returned NAs for atom {atom} at {M}" % (atom, M))
+            final_params = final_params
 
+    final_params[0] *= np.pi / M
+    mask = window_sinckb(*final_params)
 
-class LinearWhiteningFilter:
-    @staticmethod
-    def _fftfreqn(
-        shape: Tuple[int],
-        sampling_rate: NDArray,
-        omit_negative_frequencies: bool = False,
-    ):
-        center = np.divide(shape, 2).astype(int)
-        norm = np.multiply(shape, sampling_rate)
+    if profile.shape[0] > mask.shape[0]:
+        profile_origin = int((profile.size - 1) / 2)
+        mask = window(mask, profile_origin, profile_origin)
 
-        if omit_negative_frequencies:
-            shape = (*shape[:-1], center[-1] + 1)
-            center = (*center[:-1], 0)
-
-        indices = np.indices(shape).T
-        indices -= center
-        indices = np.divide(indices, norm)
-        return indices.T
-
-    def filter(
-        self, template: NDArray, n_bins: int = None
-    ) -> Tuple[NDArray, NDArray, NDArray]:
-        max_bins = np.max(template.shape) // 2 + 1
-        n_bins = max_bins if n_bins is None else n_bins
-        n_bins = int(min(n_bins, max_bins))
-
-        grid = self._fftfreqn(
-            shape=template.shape, sampling_rate=1, omit_negative_frequencies=True
+    return mask
+
+
+def _hlpf_fitness(
+    params: Tuple[float], T: float, M: float, profile: NDArray, atom: str, method: str
+) -> float:
+    """
+    Fitness function for high-low pass filter optimization.
+
+    Parameters
+    ----------
+    params : tuple of float
+        Parameters [omega, d, dw] for optimization.
+    T : float
+        Time step.
+    M : int
+        Scaling factor.
+    profile : NDArray
+        Input profile.
+    atom : str
+        Atom type.
+    method : str
+        Method name.
+
+    Returns
+    -------
+    float
+        Fitness value.
+
+    References
+    ----------
+    .. [1]  Sorzano, Carlos et al (Mar. 2015). Fast and accurate conversion
+            of atomic models into electron density maps. AIMS Biophysics
+            2, 8–20.
+    .. [2]  https://github.com/I2PC/xmipp/blob/707f921dfd29cacf5a161535034d28153b58215a/src/xmipp/libraries/data/pdb.cpp#L1344
+    """
+    omega, d, dw = params
+
+    if not (0.7 <= omega <= 1.3) and (0 <= d <= 0.2) and (1e-3 <= dw <= 0.2):
+        return 1e38 * np.random.randint(1, 100)
+
+    mask = window_sinckb(omega=omega * np.pi / M, d=d, dw=dw)
+
+    if profile.shape[0] > mask.shape[0]:
+        profile_origin = int((profile.size - 1) / 2)
+        mask = window(mask, profile_origin, profile_origin)
+    else:
+        filter_origin = int((mask.size - 1) / 2)
+        profile = window(profile, filter_origin, filter_origin)
+
+    f_mask = ndimage.convolve(profile, mask)
+
+    orig = int((f_mask.size - 1) / 2)
+    dist = np.arange(-orig, orig + 1) * T
+    t, c, k = splrep(x=dist, y=f_mask, k=3)
+    i_max = np.ceil(np.divide(f_mask.shape, M)).astype(int)[0]
+    coarse_mask = np.arange(-i_max, i_max + 1) * M
+    spline = BSpline(t, c, k)
+    coarse_values = spline(coarse_mask)
+
+    # padding to retain longer fourier response
+    aux = window(
+        coarse_values, x0=10 * coarse_values.shape[0], xf=10 * coarse_values.shape[0]
+    )
+    f_filter = np.fft.fftn(aux)
+    f_filter_mag = np.abs(f_filter)
+    freq = np.fft.fftfreq(f_filter.size)
+    freq /= M * T
+    amplitude_f = mask.sum() / coarse_values.sum()
+
+    size_f = f_filter_mag.shape[0] * amplitude_f
+    fourier_form_f = electron_factor(dist=freq, atom=atom, method=method, fourier=True)
+
+    valid_freq_mask = freq >= 0
+    f1_values = np.log10(f_filter_mag[valid_freq_mask] * size_f)
+    f2_values = np.log10(np.divide(T, fourier_form_f[valid_freq_mask]))
+    squared_differences = np.square(f1_values - f2_values)
+    error = np.sum(squared_differences)
+    error /= np.sum(valid_freq_mask)
+
+    return error
+
+
+def window(arr, x0, xf, constant_values=0):
+    """
+    Window an array by slicing between x0 and xf and padding if required.
+
+    Parameters
+    ----------
+    arr : ndarray
+        Input array to be windowed.
+    x0 : int
+        Start of the window.
+    xf : int
+        End of the window.
+    constant_values : int or float, optional
+        The constant values to use for padding, by default 0.
+
+    Returns
+    -------
+    ndarray
+        Windowed array.
+    """
+    origin = int((arr.size - 1) / 2)
+
+    xs = origin - x0
+    xe = origin - xf
+
+    if xs >= 0 and xe <= arr.shape[0]:
+        if xs <= arr.shape[0] and xe > 0:
+            arr = arr[xs:xe]
+            xs = 0
+            xe = 0
+        elif xs <= arr.shape[0]:
+            arr = arr[xs:]
+            xs = 0
+    elif xe >= 0 and xe <= arr.shape[0]:
+        arr = arr[:xe]
+        xe = 0
+
+    xs *= -1
+    xe *= -1
+
+    return np.pad(
+        arr, (int(xs), int(xe)), mode="constant", constant_values=constant_values
+    )
+
+
+def atom_profile(
+    M, atom, T=0.08333333, method="peng1995", lfilter=True, filter_method="minimize"
+):
+    """
+    Generate an atom profile using a variety of methods.
+
+    Parameters
+    ----------
+    M : float
+        Down sampling factor.
+    atom : Any
+        Type or representation of the atom.
+    T : float, optional
+        Sampling rate in angstroms/pixel, by default 0.08333333.
+    method : str, optional
+        Method to be used for generating the profile, by default "peng1995".
+    lfilter : bool, optional
+        Whether to apply filter on the profile, by default True.
+    filter_method : str, optional
+        The method for the filter, by default "minimize".
+
+    Returns
+    -------
+    BSpline
+        A spline representation of the atom profile.
+
+    References
+    ----------
+    .. [1]  Sorzano, Carlos et al (Mar. 2015). Fast and accurate conversion
+            of atomic models into electron density maps. AIMS Biophysics
+            2, 8–20.
+    .. [2]  https://github.com/I2PC/xmipp/blob/707f921dfd29cacf5a161535034d28153b58215a/src/xmipp/libraries/data/pdb.cpp#L1344
+    """
+    M = M / T
+    imax = np.ceil(4 / T * np.sqrt(76.7309 / (2 * np.power(np.pi, 2))))
+    dist = np.arange(-imax, imax + 1) * T
+
+    profile = electron_factor(dist, method, atom)
+
+    if lfilter:
+        window = optimize_hlfp(
+            profile=profile,
+            M=M,
+            T=T,
+            atom=atom,
+            method=method,
+            filter_method=filter_method,
         )
-        frequency_grid = np.linalg.norm(grid, axis=0)
+        profile = ndimage.convolve(profile, window)
 
-        _, bin_edges = np.histogram(frequency_grid, bins=n_bins - 1)
-        bins = np.digitize(frequency_grid, bins=bin_edges, right=True)
+        indices = np.where(profile > 1e-3)
+        min_indices = np.maximum(np.amin(indices, axis=1), 0)
+        max_indices = np.minimum(np.amax(indices, axis=1) + 1, profile.shape)
+        slices = tuple(slice(*coord) for coord in zip(min_indices, max_indices))
+        profile = profile[slices]
 
-        fft_shift_axes = tuple(range(template.ndim - 1))
-        fourier_transform = np.fft.fftshift(np.fft.rfftn(template), axes=fft_shift_axes)
-        fourier_spectrum = np.abs(fourier_transform)
+    profile_origin = int((profile.size - 1) / 2)
+    dist = np.arange(-profile_origin, profile_origin + 1) * T
+    t, c, k = splrep(x=dist, y=profile, k=3)
 
-        radial_averages = ndimean(fourier_spectrum, labels=bins, index=np.unique(bins))
-        np.reciprocal(radial_averages, out=radial_averages)
-        np.divide(radial_averages, radial_averages.max(), out=radial_averages)
+    return BSpline(t, c, k)
 
-        np.multiply(fourier_transform, radial_averages[bins], out=fourier_transform)
 
-        ret = np.fft.irfftn(
-            np.fft.ifftshift(fourier_transform, axes=fft_shift_axes), s=template.shape
-        ).real
-        return ret, bin_edges, radial_averages
+def get_scattering_factors(method: str) -> Dict:
+    """
+    Retrieve scattering factors from a stored file based on the given method.
 
-    def apply(
-        self, template: NDArray, bin_edges: NDArray, radial_averages: NDArray
-    ) -> NDArray:
-        grid = self._fftfreqn(
-            shape=template.shape, sampling_rate=1, omit_negative_frequencies=True
-        )
-        frequency_grid = np.linalg.norm(grid, axis=0)
+    Parameters
+    ----------
+    method : str
+        Method name used to get the scattering factors.
 
-        fft_shift_axes = tuple(range(template.ndim - 1))
-        fourier_transform = np.fft.fftshift(np.fft.rfftn(template), axes=fft_shift_axes)
+    Returns
+    -------
+    Dict
+        Dictionary containing scattering factors for the given method.
 
-        bins = np.digitize(frequency_grid, bins=bin_edges, right=True)
-        np.multiply(fourier_transform, radial_averages[bins], out=fourier_transform)
-        ret = np.fft.irfftn(
-            np.fft.ifftshift(fourier_transform, axes=fft_shift_axes), s=template.shape
-        ).real
+    Raises
+    ------
+    ValueError
+        If the method is not found in the stored data.
 
-        return ret
+    """
+    path = os.path.join(os.path.dirname(__file__), "data", "scattering_factors.pickle")
+    with open(path, "rb") as infile:
+        data = pickle.load(infile)
+
+    if method not in data:
+        raise ValueError(f"{method} is not valid. Use {', '.join(data.keys())}.")
+    return data[method]