pytme 0.2.9__cp311-cp311-macosx_15_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/filters/__init__.py

@@ -0,0 +1,6 @@
+from .ctf import CTF
+from .compose import Compose, ComposableFilter
+from .bandpass import BandPassFilter
+from .whitening import LinearWhiteningFilter
+from .wedge import Wedge, WedgeReconstructed
+from .reconstruction import ReconstructFromTilt

tme/filters/_utils.py

@@ -0,0 +1,311 @@
+""" Utilities for the generation of frequency grids.
+
+    Copyright (c) 2024 European Molecular Biology Laboratory
+
+    Author: Valentin Maurer <valentin.maurer@embl-hamburg.de>
+"""
+
+from typing import Tuple, List, Dict
+
+import numpy as np
+
+from ..backends import backend as be
+from ..backends import NumpyFFTWBackend
+from ..types import BackendArray, NDArray
+from ..rotations import euler_to_rotationmatrix
+
+
+def compute_tilt_shape(shape: Tuple[int], opening_axis: int, reduce_dim: bool = False):
+    """
+    Given an opening_axis, computes the shape of the remaining dimensions.
+
+    Parameters
+    ----------
+    shape : Tuple[int]
+        The shape of the input array.
+    opening_axis : int
+        The axis along which the array will be tilted.
+    reduce_dim : bool, optional (default=False)
+        Whether to reduce the dimensionality after tilting.
+
+    Returns
+    -------
+    Tuple[int]
+        The shape of the array after tilting.
+    """
+    tilt_shape = tuple(x if i != opening_axis else 1 for i, x in enumerate(shape))
+    if reduce_dim:
+        tilt_shape = tuple(x for i, x in enumerate(shape) if i != opening_axis)
+
+    return tilt_shape
+
+
+def centered_grid(shape: Tuple[int]) -> NDArray:
+    """
+    Generate an integer valued grid centered around size // 2
+
+    Parameters
+    ----------
+    shape : Tuple[int]
+        The shape of the grid.
+
+    Returns
+    -------
+    NDArray
+        The centered grid.
+    """
+    index_grid = np.array(
+        np.meshgrid(*[np.arange(size) - size // 2 for size in shape], indexing="ij")
+    )
+    return index_grid
+
+
+def frequency_grid_at_angle(
+    shape: Tuple[int],
+    angle: float,
+    sampling_rate: Tuple[float],
+    opening_axis: int = None,
+    tilt_axis: int = None,
+) -> NDArray:
+    """
+    Generate a frequency grid from 0 to 1/(2 * sampling_rate) in each axis.
+
+    Parameters
+    ----------
+    shape : Tuple[int]
+        The shape of the grid.
+    angle : float
+        The angle at which to generate the grid.
+    sampling_rate : Tuple[float]
+        The sampling rate for each dimension.
+    opening_axis : int, optional
+        The axis to be opened, defaults to None.
+    tilt_axis : int, optional
+        The axis along which the grid is tilted, defaults to None.
+
+    Returns:
+    --------
+    NDArray
+        The frequency grid.
+    """
+    sampling_rate = np.array(sampling_rate)
+    sampling_rate = np.repeat(sampling_rate, len(shape) // sampling_rate.size)
+
+    tilt_shape = compute_tilt_shape(
+        shape=shape, opening_axis=opening_axis, reduce_dim=False
+    )
+
+    if angle == 0:
+        sampling_rate = compute_tilt_shape(
+            shape=sampling_rate, opening_axis=opening_axis, reduce_dim=True
+        )
+        index_grid = fftfreqn(
+            tuple(x for x in tilt_shape if x != 1),
+            sampling_rate=sampling_rate,
+            compute_euclidean_norm=True,
+        )
+
+    if angle != 0:
+        aspect_ratio = shape[opening_axis] / shape[tilt_axis]
+        angle = np.degrees(np.arctan(np.tan(np.radians(angle)) * aspect_ratio))
+
+        angles = np.zeros(len(shape))
+        angles[tilt_axis] = angle
+        rotation_matrix = euler_to_rotationmatrix(np.roll(angles, opening_axis - 1))
+
+        index_grid = fftfreqn(tilt_shape, sampling_rate=None)
+        index_grid = np.einsum("ij,j...->i...", rotation_matrix, index_grid)
+        norm = np.multiply(sampling_rate, shape).astype(int)
+
+        index_grid = np.divide(index_grid.T, norm).T
+        index_grid = np.squeeze(index_grid)
+        index_grid = np.linalg.norm(index_grid, axis=(0))
+
+    return index_grid
+
+
+def fftfreqn(
+    shape: Tuple[int],
+    sampling_rate: Tuple[float],
+    compute_euclidean_norm: bool = False,
+    shape_is_real_fourier: bool = False,
+    return_sparse_grid: bool = False,
+) -> NDArray:
+    """
+    Generate the n-dimensional discrete Fourier transform sample frequencies.
+
+    Parameters
+    ----------
+    shape : Tuple[int]
+        The shape of the data.
+    sampling_rate : float or Tuple[float]
+        The sampling rate.
+    compute_euclidean_norm : bool, optional
+        Whether to compute the Euclidean norm, defaults to False.
+    shape_is_real_fourier : bool, optional
+        Whether the shape corresponds to a real Fourier transform, defaults to False.
+
+    Returns:
+    --------
+    NDArray
+        The sample frequencies.
+    """
+    # There is no real need to have these operations on GPU right now
+    np_be = NumpyFFTWBackend()
+    norm = np_be.full(len(shape), fill_value=1, dtype=np_be._float_dtype)
+    center = np_be.astype(np_be.divide(shape, 2), np_be._int_dtype)
+    if sampling_rate is not None:
+        norm = np_be.astype(np_be.multiply(shape, sampling_rate), int)
+
+    if shape_is_real_fourier:
+        center[-1], norm[-1] = 0, 1
+        if sampling_rate is not None:
+            norm[-1] = (shape[-1] - 1) * 2 * sampling_rate
+
+    grids = []
+    for i, x in enumerate(shape):
+        baseline_dims = tuple(1 if i != t else x for t in range(len(shape)))
+        grid = (np_be.arange(x, dtype=np_be._int_dtype) - center[i]) / norm[i]
+        grid = np_be.astype(grid, np_be._float_dtype)
+        grids.append(np_be.reshape(grid, baseline_dims))
+
+    if compute_euclidean_norm:
+        grids = sum(np_be.square(x) for x in grids)
+        grids = np_be.sqrt(grids, out=grids)
+        return grids
+
+    if return_sparse_grid:
+        return grids
+
+    grid_flesh = np_be.full(shape, fill_value=1, dtype=np_be._float_dtype)
+    grids = np_be.stack(tuple(grid * grid_flesh for grid in grids))
+
+    return grids
+
+
+def crop_real_fourier(data: BackendArray) -> BackendArray:
+    """
+    Crop the real part of a Fourier transform.
+
+    Parameters
+    ----------
+    data : BackendArray
+        The Fourier transformed data.
+
+    Returns:
+    --------
+    BackendArray
+        The cropped data.
+    """
+    stop = 1 + (data.shape[-1] // 2)
+    return data[..., :stop]
+
+
+def compute_fourier_shape(
+    shape: Tuple[int], shape_is_real_fourier: bool = False
+) -> List[int]:
+    if shape_is_real_fourier:
+        return shape
+    shape = [int(x) for x in shape]
+    shape[-1] = 1 + shape[-1] // 2
+    return shape
+
+
+def shift_fourier(
+    data: BackendArray, shape_is_real_fourier: bool = False
+) -> BackendArray:
+    comp = be
+    if isinstance(data, np.ndarray):
+        comp = NumpyFFTWBackend()
+    shape = comp.to_backend_array(data.shape)
+    shift = comp.add(comp.divide(shape, 2), comp.mod(shape, 2))
+    shift = [int(x) for x in shift]
+    if shape_is_real_fourier:
+        shift[-1] = 0
+
+    data = comp.roll(data, shift, tuple(i for i in range(len(shift))))
+    return data
+
+
+def create_reconstruction_filter(
+    filter_shape: Tuple[int], filter_type: str, **kwargs: Dict
+):
+    """Create a reconstruction filter of given filter_type.
+
+    Parameters
+    ----------
+    filter_shape : tuple of int
+        Shape of the returned filter.
+    filter_type: str
+        The type of created filter, available options are:
+
+        +---------------+----------------------------------------------------+
+        | ram-lak       | Returns |w|                                        |
+        +---------------+----------------------------------------------------+
+        | ramp-cont     | Principles of Computerized Tomographic Imaging Avin|
+        |               | ash C. Kak and Malcolm Slaney Chap 3 Eq. 61 [1]_   |
+        +---------------+----------------------------------------------------+
+        | ramp          | Like ramp-cont but considering tilt angles         |
+        +---------------+----------------------------------------------------+
+        | shepp-logan   | |w| * sinc(|w| / 2) [2]_                           |
+        +---------------+----------------------------------------------------+
+        | cosine        | |w| * cos(|w| * pi / 2) [2]_                       |
+        +---------------+----------------------------------------------------+
+        | hamming       | |w| * (.54 + .46 ( cos(|w| * pi))) [2]_            |
+        +---------------+----------------------------------------------------+
+    kwargs: Dict
+        Keyword arguments for particular filter_types.
+
+    Returns
+    -------
+    NDArray
+        Reconstruction filter
+
+    References
+    ----------
+    .. [1]  Principles of Computerized Tomographic Imaging Avinash C. Kak and Malcolm Slaney Chap 3 Eq. 61
+    .. [2]  https://odlgroup.github.io/odl/index.html
+    """
+    filter_type = str(filter_type).lower()
+    freq = fftfreqn(filter_shape, sampling_rate=0.5, compute_euclidean_norm=True)
+
+    if filter_type == "ram-lak":
+        ret = np.copy(freq)
+    elif filter_type == "ramp-cont":
+        ret, ndim = None, len(filter_shape)
+        for dim, size in enumerate(filter_shape):
+            n = np.concatenate(
+                (
+                    np.arange(1, size / 2 + 1, 2, dtype=int),
+                    np.arange(size / 2 - 1, 0, -2, dtype=int),
+                )
+            )
+            ret1d = np.zeros(size)
+            ret1d[0] = 0.25
+            ret1d[1::2] = -1 / (np.pi * n) ** 2
+            ret1d_shape = tuple(size if i == dim else 1 for i in range(ndim))
+            ret1d = ret1d.reshape(ret1d_shape)
+            if ret is None:
+                ret = ret1d
+            else:
+                ret = ret * ret1d
+        ret = 2 * np.fft.fftshift(np.real(np.fft.fftn(ret)))
+    elif filter_type == "ramp":
+        tilt_angles = kwargs.get("tilt_angles", False)
+        if tilt_angles is False:
+            raise ValueError("'ramp' filter requires specifying tilt angles.")
+        size = filter_shape[0]
+        ret = fftfreqn((size,), sampling_rate=1, compute_euclidean_norm=True)
+        min_increment = np.radians(np.min(np.abs(np.diff(np.sort(tilt_angles)))))
+        ret *= min_increment * size
+        np.fmin(ret, 1, out=ret)
+    elif filter_type == "shepp-logan":
+        ret = freq * np.sinc(freq / 2)
+    elif filter_type == "cosine":
+        ret = freq * np.cos(freq * np.pi / 2)
+    elif filter_type == "hamming":
+        ret = freq * (0.54 + 0.46 * np.cos(freq * np.pi))
+    else:
+        raise ValueError("Unsupported filter type")
+
+    return ret