pytme 0.2.3__cp311-cp311-macosx_14_0_arm64.whl → 0.2.4__cp311-cp311-macosx_14_0_arm64.whl

tme/external/bindings.cpp

@@ -0,0 +1,332 @@
+/*  Pybind extensions for template matching score space analyzers.
+
+    Copyright (c) 2023 European Molecular Biology Laboratory
+
+    Author: Valentin Maurer <valentin.maurer@embl-hamburg.de>
+*/
+
+#include <vector>
+#include <iostream>
+#include <limits>
+
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+template <typename T>
+void absolute_minimum_deviation(
+    py::array_t<T, py::array::c_style> coordinates,
+    py::array_t<T, py::array::c_style> output) {
+    auto coordinates_data = coordinates.data();
+    auto output_data = output.mutable_data();
+    int n = coordinates.shape(0);
+    int k = coordinates.shape(1);
+    int ik, jk, in, jn;
+
+    for (int i = 0; i < n; ++i) {
+        ik = i * k;
+        in = i * n;
+        for (int j = i + 1; j < n; ++j) {
+            jk = j * k;
+            jn = j * n;
+            T min_distance = std::abs(coordinates_data[ik] - coordinates_data[jk]);
+            for (int p = 1; p < k; ++p) {
+                min_distance = std::min(min_distance,
+                    std::abs(coordinates_data[ik + p] - coordinates_data[jk + p]));
+            }
+            output_data[in + j] = min_distance;
+            output_data[jn + i] = min_distance;
+        }
+        output_data[in + i] = 0;
+    }
+}
+
+template <typename T>
+std::pair<double, std::pair<int, int>> max_euclidean_distance(
+    py::array_t<T, py::array::c_style> coordinates) {
+    auto coordinates_data = coordinates.data();
+    int n = coordinates.shape(0);
+    int k = coordinates.shape(1);
+
+    double distance = 0.0;
+    double difference = 0.0;
+    double max_distance = -1;
+    double squared_distances = 0.0;
+
+    int ik, jk;
+    int max_i = -1, max_j = -1;
+
+    for (int i = 0; i < n; ++i) {
+        ik = i * k;
+        for (int j = i + 1; j < n; ++j) {
+            jk = j * k;
+            squared_distances = 0.0;
+            for (int p = 0; p < k; ++p) {
+                difference = static_cast<double>(
+                    coordinates_data[ik + p] - coordinates_data[jk + p]
+                );
+                squared_distances += (difference * difference);
+            }
+            distance = std::sqrt(squared_distances);
+            if (distance > max_distance) {
+                max_distance = distance;
+                max_i = i;
+                max_j = j;
+            }
+        }
+    }
+
+    return std::make_pair(max_distance, std::make_pair(max_i, max_j));
+}
+
+
+template <typename T>
+inline py::array_t<int, py::array::c_style> find_candidate_indices(
+    py::array_t<T, py::array::c_style> coordinates,
+    T min_distance) {
+    auto coordinates_data = coordinates.data();
+    int n = coordinates.shape(0);
+    int k = coordinates.shape(1);
+    int ik, jk;
+
+    std::vector<int> candidate_indices;
+    candidate_indices.reserve(n / 2);
+    candidate_indices.push_back(0);
+
+    for (int i = 1; i < n; ++i) {
+        bool is_candidate = true;
+        ik = i * k;
+        for (int candidate_index : candidate_indices) {
+            jk = candidate_index * k;
+            T distance = std::pow(coordinates_data[ik] - coordinates_data[jk], 2);
+            for (int p = 1; p < k; ++p) {
+                distance += std::pow(coordinates_data[ik + p] - coordinates_data[jk + p], 2);
+            }
+            distance = std::sqrt(distance);
+            if (distance <= min_distance) {
+                is_candidate = false;
+                break;
+            }
+        }
+        if (is_candidate) {
+            candidate_indices.push_back(i);
+        }
+    }
+
+    py::array_t<int, py::array::c_style> output({(int)candidate_indices.size()});
+    auto output_data = output.mutable_data();
+
+    for (size_t i = 0; i < candidate_indices.size(); ++i) {
+        output_data[i] = candidate_indices[i];
+    }
+
+    return output;
+}
+
+template <typename T>
+py::array_t<T, py::array::c_style> find_candidate_coordinates(
+    py::array_t<T, py::array::c_style> coordinates,
+    T min_distance) {
+
+    py::array_t<int, py::array::c_style> candidate_indices_array = find_candidate_indices(
+        coordinates, min_distance);
+    auto candidate_indices_data = candidate_indices_array.data();
+    int num_candidates = candidate_indices_array.shape(0);
+    int k = coordinates.shape(1);
+    auto coordinates_data = coordinates.data();
+
+    py::array_t<T, py::array::c_style> output({num_candidates, k});
+    auto output_data = output.mutable_data();
+
+    for (int i = 0; i < num_candidates; ++i) {
+        int candidate_index = candidate_indices_data[i] * k;
+        std::copy(
+            coordinates_data + candidate_index,
+            coordinates_data + candidate_index + k,
+            output_data + i * k
+        );
+    }
+
+    return output;
+}
+
+template <typename U, typename T>
+py::dict max_index_by_label(
+    py::array_t<U, py::array::c_style> labels,
+    py::array_t<T, py::array::c_style> scores
+    ) {
+
+    const U* labels_ptr = labels.data();
+    const T* scores_ptr = scores.data();
+
+    std::unordered_map<U, std::pair<T, ssize_t>> max_scores;
+
+    U label;
+    T score;
+    for (ssize_t i = 0; i < labels.size(); ++i) {
+        label = labels_ptr[i];
+        score = scores_ptr[i];
+
+        auto it = max_scores.insert({label, {score, i}});
+
+        if (score > it.first->second.first) {
+            it.first->second = {score, i};
+        }
+    }
+
+    py::dict ret;
+    for (auto& item: max_scores) {
+        ret[py::cast(item.first)] = py::cast(item.second.second);
+    }
+
+    return ret;
+}
+
+
+template <typename T>
+py::tuple online_statistics(
+    py::array_t<T, py::array::c_style> arr,
+    unsigned long long int n = 0,
+    double rmean = 0,
+    double ssqd = 0,
+    T reference = 0) {
+
+    auto in = arr.data();
+    int size = arr.size();
+
+    T max_value = std::numeric_limits<T>::lowest();
+    T min_value = std::numeric_limits<T>::max();
+    double delta, delta_prime;
+
+    unsigned long long int nbetter_or_equal = 0;
+
+    for(int i = 0; i < size; i++){
+        n++;
+        delta = in[i] - rmean;
+        rmean += delta / n;
+        delta_prime = in[i] - rmean;
+        ssqd += delta * delta_prime;
+
+        max_value = std::max(in[i], max_value);
+        min_value = std::min(in[i], min_value);
+        if (in[i] >= reference)
+            nbetter_or_equal++;
+    }
+
+    return py::make_tuple(n, rmean, ssqd, nbetter_or_equal, max_value, min_value);
+}
+
+PYBIND11_MODULE(extensions, m) {
+
+    m.def("absolute_minimum_deviation", absolute_minimum_deviation<double>,
+        "Compute pairwise absolute minimum deviation for a set of coordinates (float64).",
+        py::arg("coordinates"), py::arg("output"));
+    m.def("absolute_minimum_deviation", absolute_minimum_deviation<float>,
+        "Compute pairwise absolute minimum deviation for a set of coordinates (float32).",
+        py::arg("coordinates"), py::arg("output"));
+    m.def("absolute_minimum_deviation", absolute_minimum_deviation<int64_t>,
+        "Compute pairwise absolute minimum deviation for a set of coordinates (int64).",
+        py::arg("coordinates"), py::arg("output"));
+    m.def("absolute_minimum_deviation", absolute_minimum_deviation<int32_t>,
+        "Compute pairwise absolute minimum deviation for a set of coordinates (int32).",
+        py::arg("coordinates"), py::arg("output"));
+
+
+    m.def("max_euclidean_distance", max_euclidean_distance<double>,
+        "Identify pair of points with maximal euclidean distance (float64).",
+        py::arg("coordinates"));
+    m.def("max_euclidean_distance", max_euclidean_distance<float>,
+        "Identify pair of points with maximal euclidean distance (float32).",
+          py::arg("coordinates"));
+    m.def("max_euclidean_distance", max_euclidean_distance<int64_t>,
+        "Identify pair of points with maximal euclidean distance (int64).",
+          py::arg("coordinates"));
+    m.def("max_euclidean_distance", max_euclidean_distance<int32_t>,
+        "Identify pair of points with maximal euclidean distance (int32).",
+          py::arg("coordinates"));
+
+
+    m.def("find_candidate_indices", &find_candidate_indices<double>,
+          "Finds candidate indices with minimum distance (float64).",
+          py::arg("coordinates"), py::arg("min_distance"));
+    m.def("find_candidate_indices", &find_candidate_indices<float>,
+          "Finds candidate indices with minimum distance (float32).",
+          py::arg("coordinates"), py::arg("min_distance"));
+    m.def("find_candidate_indices", &find_candidate_indices<int64_t>,
+          "Finds candidate indices with minimum distance (int64).",
+          py::arg("coordinates"), py::arg("min_distance"));
+    m.def("find_candidate_indices", &find_candidate_indices<int32_t>,
+          "Finds candidate indices with minimum distance (int32).",
+          py::arg("coordinates"), py::arg("min_distance"));
+
+
+    m.def("find_candidate_coordinates", &find_candidate_coordinates<double>,
+          "Finds candidate coordinates with minimum distance (float64).",
+          py::arg("coordinates"), py::arg("min_distance"));
+    m.def("find_candidate_coordinates", &find_candidate_coordinates<float>,
+          "Finds candidate coordinates with minimum distance (float32).",
+          py::arg("coordinates"), py::arg("min_distance"));
+    m.def("find_candidate_coordinates", &find_candidate_coordinates<int64_t>,
+          "Finds candidate coordinates with minimum distance (int64).",
+          py::arg("coordinates"), py::arg("min_distance"));
+    m.def("find_candidate_coordinates", &find_candidate_coordinates<int32_t>,
+          "Finds candidate coordinates with minimum distance (int32).",
+          py::arg("coordinates"), py::arg("min_distance"));
+
+
+    m.def("max_index_by_label", &max_index_by_label<double, double>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<double, float>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<double, int64_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<double, int32_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+
+    m.def("max_index_by_label", &max_index_by_label<float, double>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<float, float>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<float, int64_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<float, int32_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+
+    m.def("max_index_by_label", &max_index_by_label<int64_t, double>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<int64_t, float>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<int64_t, int64_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<int64_t, int32_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+
+    m.def("max_index_by_label", &max_index_by_label<int32_t, double>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<int32_t, float>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<int32_t, int64_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+    m.def("max_index_by_label", &max_index_by_label<int32_t, int32_t>,
+          "Maximum value by label", py::arg("labels"), py::arg("scores"));
+
+
+    m.def("online_statistics", &online_statistics<double>, py::arg("arr"),
+          py::arg("n") = 0, py::arg("rmean") = 0,
+          py::arg("ssqd") = 0, py::arg("reference") = 0,
+          "Compute running online statistics on a numpy array.");
+    m.def("online_statistics", &online_statistics<float>, py::arg("arr"),
+          py::arg("n") = 0, py::arg("rmean") = 0,
+          py::arg("ssqd") = 0, py::arg("reference") = 0,
+          "Compute running online statistics on a numpy array.");
+    m.def("online_statistics", &online_statistics<int64_t>, py::arg("arr"),
+          py::arg("n") = 0, py::arg("rmean") = 0,
+          py::arg("ssqd") = 0, py::arg("reference") = 0,
+          "Compute running online statistics on a numpy array.");
+    m.def("online_statistics", &online_statistics<int32_t>, py::arg("arr"),
+          py::arg("n") = 0, py::arg("rmean") = 0,
+          py::arg("ssqd") = 0, py::arg("reference") = 0,
+          "Compute running online statistics on a numpy array.");
+}

tme/matching_data.py

@@ -450,7 +450,7 @@ class MatchingData:
         template_shape: NDArray,
         batch_mask: NDArray = None,
         pad_fourier: bool = False,
-    ) -> Tuple[Tuple, Tuple, Tuple]:
+    ) -> Tuple[Tuple, Tuple, Tuple, Tuple]:
         """
         Determines an efficient shape for Fourier transforms considering zero-padding.
         """
@@ -479,11 +479,6 @@ class MatchingData:
             np.subtract(target_shape, template_shape), 1 - batch_mask
         )
         if np.sum(shape_diff < 0):
-            warnings.warn(
-                "Template is larger than target and padding is turned off. Consider "
-                "swapping them or activate padding. Correcting the shift for now."
-            )
-
             shape_shift = np.divide(shape_diff, 2)
             offset = np.mod(shape_diff, 2)
             if pad_fourier:
@@ -491,6 +486,11 @@ class MatchingData:
                     offset,
                     np.logical_and(np.mod(target_shape, 2) == 0, template_mod == 1),
                 )
+            else:
+                warnings.warn(
+                    "Template is larger than target and padding is turned off. Consider "
+                    "swapping them or activate padding. Correcting the shift for now."
+                )
 
             shape_shift = np.add(shape_shift, offset)
             fourier_shift = np.subtract(fourier_shift, shape_shift).astype(int)
@@ -498,7 +498,9 @@ class MatchingData:
         fourier_shift = tuple(fourier_shift.astype(int))
         return tuple(conv_shape), tuple(fast_shape), tuple(fast_ft_shape), fourier_shift
 
-    def fourier_padding(self, pad_fourier: bool = False) -> Tuple[Tuple, Tuple, Tuple]:
+    def fourier_padding(
+        self, pad_fourier: bool = False
+    ) -> Tuple[Tuple, Tuple, Tuple, Tuple]:
         """
         Computes efficient shape four Fourier transforms and potential associated shifts.
 
@@ -510,8 +512,8 @@ class MatchingData:
 
         Returns
         -------
-        Tuple[tuple of int, tuple of int, tuple of int]
-            Tuple with real and complex Fourier transform shape, and corresponding shift.
+        Tuple[tuple of int, tuple of int, tuple of int, tuple of int]
+            Tuple with convolution, forward FT, inverse FT shape and corresponding shift.
         """
         return self._fourier_padding(
             target_shape=be.to_numpy_array(self._output_target_shape),

tme/matching_exhaustive.py

@@ -82,13 +82,14 @@ def _setup_template_filter_apply_target_filter(
     fastt_shape, fastt_ft_shape = fast_shape, filter_shape
     if filter_template and not pad_template_filter:
         # FFT shape acrobatics for faster filter application
-        _, fastt_shape, _, _ = matching_data._fourier_padding(
-            target_shape=be.to_numpy_array(matching_data._template.shape),
-            template_shape=be.to_numpy_array(
-                [1 for _ in matching_data._template.shape]
-            ),
-            pad_fourier=False,
-        )
+        # _, fastt_shape, _, _ = matching_data._fourier_padding(
+        #     target_shape=be.to_numpy_array(matching_data._template.shape),
+        #     template_shape=be.to_numpy_array(
+        #         [1 for _ in matching_data._template.shape]
+        #     ),
+        #     pad_fourier=False,
+        # )
+        fastt_shape = matching_data._template.shape
         matching_data.template = be.reverse(
             be.topleft_pad(matching_data.template, fastt_shape)
         )
@@ -399,7 +400,8 @@ def scan_subsets(
     The template matching procedure is determined by ``matching_setup`` and
     ``matching_score``, which are unique to each score. In the following,
     we will be using the `FLCSphericalMask` score, which is composed of
-    :py:meth:`flcSphericalMask_setup` and :py:meth:`corr_scoring`
+    :py:meth:`tme.matching_scores.flcSphericalMask_setup` and
+    :py:meth:`tme.matching_scores.corr_scoring`
 
     >>> from tme.matching_exhaustive import MATCHING_EXHAUSTIVE_REGISTER
     >>> funcs = MATCHING_EXHAUSTIVE_REGISTER.get("FLCSphericalMask")

tme/matching_utils.py

@@ -645,6 +645,7 @@ def get_rotation_matrices(
         dets = np.linalg.det(ret)
         neg_dets = dets < 0
         ret[neg_dets, :, -1] *= -1
+        ret[0] = np.eye(dim, dtype = ret.dtype)
     return ret
 
 

tme/preprocessing/_utils.py

@@ -19,8 +19,8 @@ def compute_tilt_shape(shape: Tuple[int], opening_axis: int, reduce_dim: bool =
     """
     Given an opening_axis, computes the shape of the remaining dimensions.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     shape : Tuple[int]
         The shape of the input array.
     opening_axis : int
@@ -28,8 +28,8 @@ def compute_tilt_shape(shape: Tuple[int], opening_axis: int, reduce_dim: bool =
     reduce_dim : bool, optional (default=False)
         Whether to reduce the dimensionality after tilting.
 
-    Returns:
-    --------
+    Returns
+    -------
     Tuple[int]
         The shape of the array after tilting.
     """
@@ -44,13 +44,13 @@ def centered_grid(shape: Tuple[int]) -> NDArray:
     """
     Generate an integer valued grid centered around size // 2
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     shape : Tuple[int]
         The shape of the grid.
 
-    Returns:
-    --------
+    Returns
+    -------
     NDArray
         The centered grid.
     """
@@ -70,8 +70,8 @@ def frequency_grid_at_angle(
     """
     Generate a frequency grid from 0 to 1/(2 * sampling_rate) in each axis.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     shape : Tuple[int]
         The shape of the grid.
     angle : float
@@ -128,8 +128,8 @@ def fftfreqn(
     """
     Generate the n-dimensional discrete Fourier transform sample frequencies.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     shape : Tuple[int]
         The shape of the data.
     sampling_rate : float or Tuple[float]
@@ -180,8 +180,8 @@ def crop_real_fourier(data: BackendArray) -> BackendArray:
     """
     Crop the real part of a Fourier transform.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     data : BackendArray
         The Fourier transformed data.
 

tme/preprocessing/composable_filter.py

@@ -20,7 +20,6 @@ class ComposableFilter(ABC):
 
         Parameters
         ----------
-
         *args : tuple
             Variable length argument list.
         **kwargs : dict
@@ -28,7 +27,6 @@ class ComposableFilter(ABC):
 
         Returns
         -------
-
         Dict
             A dictionary representing the result of the filtering operation.
         """

tme/preprocessing/compose.py

@@ -17,13 +17,13 @@ class Compose:
     This class allows composing multiple transformations together. Each transformation
     is expected to be a callable that accepts keyword arguments and returns metadata.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     transforms : Tuple[object]
         A tuple containing transformation objects.
 
-    Returns:
-    --------
+    Returns
+    -------
     Dict
         Metadata resulting from the composed transformations.
 

tme/preprocessing/frequency_filters.py

@@ -18,12 +18,10 @@ from ._utils import fftfreqn, crop_real_fourier, shift_fourier, compute_fourier_
 
 class BandPassFilter:
     """
-    This class provides methods to generate bandpass filters in Fourier space,
-    either by directly specifying the frequency cutoffs (discrete_bandpass) or
-    by using Gaussian functions (gaussian_bandpass).
+    Generate bandpass filters in Fourier space.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     lowpass : float, optional
         The lowpass cutoff, defaults to None.
     highpass : float, optional
@@ -67,8 +65,8 @@ class BandPassFilter:
         """
         Generate a bandpass filter using discrete frequency cutoffs.
 
-        Parameters:
-        -----------
+        Parameters
+        ----------
         shape : tuple of int
             The shape of the bandpass filter.
         lowpass : float
@@ -84,8 +82,8 @@ class BandPassFilter:
         **kwargs : dict
             Additional keyword arguments.
 
-        Returns:
-        --------
+        Returns
+        -------
         BackendArray
             The bandpass filter in Fourier space.
         """
@@ -98,17 +96,18 @@ class BandPassFilter:
             shape_is_real_fourier=shape_is_real_fourier,
             compute_euclidean_norm=True,
         )
-
-        lowpass = 0 if lowpass is None else lowpass
-        highpass = 1e10 if highpass is None else highpass
+        grid = be.to_backend_array(grid)
+        sampling_rate = be.to_backend_array(sampling_rate)
 
         highcut = grid.max()
-        if lowpass > 0:
-            highcut = np.max(2 * sampling_rate / lowpass)
-        lowcut = np.max(2 * sampling_rate / highpass)
+        if lowpass is not None:
+            highcut = be.max(2 * sampling_rate / lowpass)
 
-        bandpass_filter = ((grid <= highcut) & (grid >= lowcut)) * 1.0
+        lowcut = 0
+        if highpass is not None:
+            lowcut = be.max(2 * sampling_rate / highpass)
 
+        bandpass_filter = ((grid <= highcut) & (grid >= lowcut)) * 1.0
         bandpass_filter = shift_fourier(
             data=bandpass_filter, shape_is_real_fourier=shape_is_real_fourier
         )
@@ -129,10 +128,10 @@ class BandPassFilter:
         **kwargs,
     ) -> BackendArray:
         """
-        Generate a bandpass filter using Gaussian functions.
+        Generate a bandpass filter using Gaussians.
 
-        Parameters:
-        -----------
+        Parameters
+        ----------
         shape : tuple of int
             The shape of the bandpass filter.
         lowpass : float
@@ -148,8 +147,8 @@ class BandPassFilter:
         **kwargs : dict
             Additional keyword arguments.
 
-        Returns:
-        --------
+        Returns
+        -------
         BackendArray
             The bandpass filter in Fourier space.
         """
@@ -216,15 +215,13 @@ class BandPassFilter:
 
 class LinearWhiteningFilter:
     """
-    This class provides methods to compute the spectrum of the input data and
-    apply linear whitening to the Fourier coefficients.
+    Compute Fourier power spectrums and perform whitening.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     **kwargs : Dict, optional
         Additional keyword arguments.
 
-
     References
     ----------
     .. [1] de Teresa-Trueba, I.; Goetz, S. K.; Mattausch, A.; Stojanovska, F.; Zimmerli, C. E.;
@@ -243,10 +240,10 @@ class LinearWhiteningFilter:
         data_rfft: BackendArray, n_bins: int = None, batch_dimension: int = None
     ) -> Tuple[BackendArray, BackendArray]:
         """
-        Compute the spectrum of the input data.
+        Compute the power spectrum of the input data.
 
-        Parameters:
-        -----------
+        Parameters
+        ----------
         data_rfft : BackendArray
             The Fourier transform of the input data.
         n_bins : int, optional
@@ -254,8 +251,8 @@ class LinearWhiteningFilter:
         batch_dimension : int, optional
             Batch dimension to average over.
 
-        Returns:
-        --------
+        Returns
+        -------
         bins : BackendArray
             Array containing the bin indices for the spectrum.
         radial_averages : BackendArray
@@ -330,8 +327,8 @@ class LinearWhiteningFilter:
         """
         Apply linear whitening to the data and return the result.
 
-        Parameters:
-        -----------
+        Parameters
+        ----------
         data : BackendArray, optional
             The input data, defaults to None.
         data_rfft : BackendArray, optional
@@ -345,8 +342,8 @@ class LinearWhiteningFilter:
         **kwargs : Dict
             Additional keyword arguments.
 
-        Returns:
-        --------
+        Returns
+        -------
         Dict
            Filter data and associated parameters.
         """