nabu 2024.1.0rc3__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/tests/test_deringer.py

@@ -0,0 +1,220 @@
+import numpy as np
+import pytest
+from nabu.reconstruction.rings_cuda import CudaSinoMeanDeringer
+from nabu.testutils import compare_arrays, get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.reconstruction.rings import MunchDeringer, SinoMeanDeringer, VoDeringer, __has_algotom__
+from nabu.thirdparty.pore3d_deringer_munch import munchetal_filter
+from nabu.cuda.utils import __has_pycuda__, get_cuda_context
+
+if __has_pycuda__:
+    import pycuda.gpuarray as garray
+    from nabu.processing.fft_cuda import get_available_fft_implems
+    from nabu.reconstruction.rings_cuda import (
+        CudaMunchDeringer,
+        can_use_cuda_deringer,
+        CudaVoDeringer,
+        __have_tomocupy_deringer__,
+    )
+
+    __has_cuda_deringer__ = can_use_cuda_deringer()
+else:
+    __has_cuda_deringer__ = False
+    __have_tomocupy_deringer__ = False
+
+fw_scenarios = generate_tests_scenarios(
+    {
+        "levels": [4],
+        "sigma": [1.0],
+        "wname": ["db15"],
+        "padding": [(100, 100)],
+        "fft_implem": ["skcuda"],
+    }
+)
+if __do_long_tests__:
+    fw_scenarios = generate_tests_scenarios(
+        {
+            "levels": [4, 2],
+            "sigma": [1.0, 2.0],
+            "wname": ["db15", "haar", "rbio4.4"],
+            "padding": [None, (100, 100), (50, 71)],
+            "fft_implem": ["skcuda", "vkfft"],
+        }
+    )
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.sino = get_data("mri_sino500.npz")["data"]
+    cls.sino2 = get_data("sino_bamboo_hercules.npz")["data"]
+    cls.tol = 5e-3
+    cls.rings = {150: 0.5, -150: 0.5}
+    if __has_pycuda__:
+        cls.ctx = get_cuda_context(cleanup_at_exit=False)
+        cls._available_fft_implems = get_available_fft_implems()
+    yield
+    if __has_pycuda__:
+        cls.ctx.pop()
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestMunchDeringer:
+    @staticmethod
+    def add_stripes_to_sino(sino, rings_desc):
+        """
+        Create a new sinogram by adding synthetic stripes to an existing one.
+
+        Parameters
+        ----------
+        sino: array-like
+            Sinogram.
+        rings_desc: dict
+            Dictionary describing the stripes locations and intensity.
+            The location is an integer in [0, N[ where N is the number of columns.
+            The intensity is a float: percentage of the current column mean value.
+        """
+        sino_out = np.copy(sino)
+        for loc, intensity in rings_desc.items():
+            sino_out[:, loc] += sino[:, loc].mean() * intensity
+        return sino_out
+
+    @staticmethod
+    def get_fourier_wavelets_reference_result(sino, config):
+        # Reference destriping with pore3d "munchetal_filter"
+        padding = config.get("padding", None)
+        if padding is not None:
+            sino = np.pad(sino, ((0, 0), padding), mode="edge")
+        ref = munchetal_filter(sino, config["levels"], config["sigma"], wname=config["wname"])
+        if config["padding"] is not None:
+            ref = ref[:, padding[0] : -padding[1]]
+        return ref
+
+    @pytest.mark.skipif(munchetal_filter is None, reason="Need PyWavelets for this test")
+    @pytest.mark.parametrize("config", fw_scenarios)
+    def test_munch_deringer(self, config):
+        deringer = MunchDeringer(
+            config["sigma"], self.sino.shape, levels=config["levels"], wname=config["wname"], padding=config["padding"]
+        )
+        sino = self.add_stripes_to_sino(self.sino, self.rings)
+        ref = self.get_fourier_wavelets_reference_result(sino, config)
+        # Wrapping with DeRinger
+        res = np.zeros((1,) + sino.shape, dtype=np.float32)
+        deringer.remove_rings(sino, output=res)
+
+        err_max = np.max(np.abs(res[0] - ref))
+        assert err_max < self.tol, "Max error is too high"
+
+    @pytest.mark.skipif(
+        not (__has_cuda_deringer__) or munchetal_filter is None,
+        reason="Need pycuda, pycudwt and (scikit-cuda or pyvkfft) for this test",
+    )
+    @pytest.mark.parametrize("config", fw_scenarios)
+    def test_cuda_munch_deringer(self, config):
+        fft_implem = config["fft_implem"]
+        if fft_implem not in self._available_fft_implems:
+            pytest.skip("FFT implementation %s is not available" % fft_implem)
+        sino = self.add_stripes_to_sino(self.sino, self.rings)
+        deringer = CudaMunchDeringer(
+            config["sigma"],
+            self.sino.shape,
+            levels=config["levels"],
+            wname=config["wname"],
+            padding=config["padding"],
+            fft_backend=fft_implem,
+            cuda_options={"ctx": self.ctx},
+        )
+        d_sino = garray.to_gpu(sino)
+        deringer.remove_rings(d_sino)
+        res = d_sino.get()
+
+        ref = self.get_fourier_wavelets_reference_result(sino, config)
+
+        err_max = np.max(np.abs(res - ref))
+        assert err_max < 1e-1, "Max error is too high with configuration %s" % (str(config))
+
+    @pytest.mark.skipif(
+        not (__has_algotom__),
+        reason="Need algotom for this test",
+    )
+    def test_vo_deringer(self):
+        deringer = VoDeringer(self.sino.shape)
+        sino_deringed = deringer.remove_rings_sinogram(self.sino)
+        sinos = np.tile(self.sino, (10, 1, 1))
+        sinos_deringed = deringer.remove_rings_sinograms(sinos)
+        # TODO check result. The generated test sinogram is "too synthetic" for this kind of deringer
+
+    @pytest.mark.skipif(
+        not (__have_tomocupy_deringer__),
+        reason="Need cupy for this test",
+    )
+    def test_cuda_vo_deringer(self):
+        # Beware, this deringer seems to be buggy for "too-small" sinograms
+        # (NaNs on the edges and in some regions). To be investigated
+
+        deringer = CudaVoDeringer(self.sino2.shape)
+        d_sino = garray.to_gpu(self.sino2)
+        deringer.remove_rings_sinogram(d_sino)
+        sino = d_sino.get()
+
+        if __has_algotom__:
+            vo_deringer = VoDeringer(self.sino2.shape)
+            sino_deringed = vo_deringer.remove_rings_sinogram(self.sino2)
+
+            assert (
+                np.max(np.abs(sino - sino_deringed)) < 2e-3
+            ), "Cuda implementation of Vo deringer does not yield the same results as base implementation"
+
+    def test_mean_deringer(self):
+        deringer_no_filtering = SinoMeanDeringer(self.sino.shape, mode="subtract")
+
+        sino = self.sino.copy()
+        deringer_no_filtering.remove_rings_sinogram(sino)
+
+        sino = self.sino.copy()
+        deringer_with_filtering = SinoMeanDeringer(self.sino.shape, mode="subtract", filter_cutoff=(0, 30))
+        deringer_with_filtering.remove_rings_sinogram(sino)
+        # TODO check results
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for this test")
+    def test_cuda_mean_deringer(self):
+        cuda_deringer = CudaSinoMeanDeringer(
+            self.sino.shape,
+            mode="subtract",
+            filter_cutoff=(
+                0,
+                10,
+            ),
+            ctx=self.ctx,
+        )
+        deringer = SinoMeanDeringer(
+            self.sino.shape,
+            mode="subtract",
+            filter_cutoff=(
+                0,
+                10,
+            ),
+        )
+
+        d_sino = cuda_deringer.processing.to_device("sino", self.sino)
+        cuda_deringer.remove_rings_sinogram(d_sino)
+
+        sino = self.sino.copy()
+        sino_d = deringer.remove_rings_sinogram(sino)
+
+        dirac = np.zeros(self.sino.shape[-1], "f")
+        dirac[dirac.size // 2] = 1
+        deringer_filter_response = deringer._apply_filter(dirac)
+
+        d_dirac = cuda_deringer.processing.to_device("dirac", dirac)
+        cuda_deringer_filter_response = cuda_deringer._apply_filter(d_dirac)
+
+        is_close, residual = compare_arrays(
+            deringer_filter_response, cuda_deringer_filter_response.get(), 1e-7, return_residual=True
+        )
+        assert is_close, "Cuda deringer does not have the correct filter response: max_error=%.2e" % residual
+
+        # There is a rather large discrepancy between the vertical_mean kernel and numpy.mean(). Not sure who is right
+        is_close, residual = compare_arrays(sino_d, d_sino.get(), 1e-1, return_residual=True)
+        assert is_close, (
+            "Cuda deringer does not yield the same result as base implementation: max_error=%.2e" % residual
+        )

build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/tests/test_fbp.py

@@ -0,0 +1,252 @@
+import numpy as np
+import pytest
+from scipy.ndimage import shift
+from nabu.pipeline.params import fbp_filters
+from nabu.utils import clip_circle
+from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.cuda.utils import get_cuda_context, __has_pycuda__
+from nabu.opencl.utils import get_opencl_context, __has_pyopencl__
+
+from nabu.processing.fft_cuda import has_skcuda, has_vkfft as has_vkfft_cu
+from nabu.processing.fft_opencl import has_vkfft as has_vkfft_cl
+
+__has_pycuda__ = __has_pycuda__ and (has_skcuda() or has_vkfft_cu())
+__has_pyopencl__ = __has_pyopencl__ and has_vkfft_cl()
+
+if __has_pycuda__:
+    from nabu.reconstruction.fbp import CudaBackprojector
+if __has_pyopencl__:
+    from nabu.reconstruction.fbp_opencl import OpenCLBackprojector
+
+
+scenarios = generate_tests_scenarios({"backend": ["cuda", "opencl"]})
+if __do_long_tests__:
+    scenarios = generate_tests_scenarios(
+        {
+            "backend": ["cuda", "opencl"],
+            "input_on_gpu": [False, True],
+            "output_on_gpu": [False, True],
+            "use_textures": [True, False],
+        }
+    )
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.sino_512 = get_data("mri_sino500.npz")["data"]
+    cls.ref_512 = get_data("mri_rec_astra.npz")["data"]
+    # always use contiguous arrays
+    cls.sino_511 = np.ascontiguousarray(cls.sino_512[:, :-1])
+    # Could be set to 5.0e-2 when using textures. When not using textures, interpolation slightly differs
+    cls.tol = 5.1e-2
+
+    if __has_pycuda__:
+        cls.cuda_ctx = get_cuda_context(cleanup_at_exit=False)
+    if __has_pyopencl__:
+        cls.opencl_ctx = get_opencl_context("all")
+    yield
+    if __has_pycuda__:
+        cls.cuda_ctx.pop()
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestFBP:
+    @staticmethod
+    def clip_to_inner_circle(img, radius_factor=0.99):
+        radius = int(radius_factor * max(img.shape) / 2)
+        return clip_circle(img, radius=radius)
+
+    def _get_backprojector(self, config, *bp_args, **bp_kwargs):
+        if config["backend"] == "cuda":
+            if not (__has_pycuda__):
+                pytest.skip("Need pycuda + (scikit-cuda or pyvkfft)")
+            Backprojector = CudaBackprojector
+            ctx = self.cuda_ctx
+        else:
+            if not (__has_pyopencl__):
+                pytest.skip("Need pyopencl + pyvkfft")
+            Backprojector = OpenCLBackprojector
+            ctx = self.opencl_ctx
+        if config.get("use_textures", True) is False:
+            # patch "extra_options"
+            extra_options = bp_kwargs.pop("extra_options", {})
+            extra_options["use_textures"] = False
+            bp_kwargs["extra_options"] = extra_options
+        return Backprojector(*bp_args, **bp_kwargs, backend_options={"ctx": ctx})
+
+    @staticmethod
+    def apply_fbp(config, backprojector, sinogram):
+        if config.get("input_on_gpu", False):
+            sinogram = backprojector._processing.set_array("sinogram", sinogram)
+        if config.get("output_on_gpu", False):
+            output = backprojector._processing.allocate_array("output", backprojector.slice_shape, dtype="f")
+        else:
+            output = None
+        res = backprojector.fbp(sinogram, output=output)
+        if config.get("output_on_gpu", False):
+            res = res.get()
+        return res
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_fbp_512(self, config):
+        """
+        Simple test of a FBP on a 512x512 slice
+        """
+        B = self._get_backprojector(config, (500, 512))
+        res = self.apply_fbp(config, B, self.sino_512)
+
+        delta_clipped = self.clip_to_inner_circle(res - self.ref_512)
+        err_max = np.max(np.abs(delta_clipped))
+
+        assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_fbp_511(self, config):
+        """
+        Test FBP of a 511x511 slice where the rotation axis is at (512-1)/2.0
+        """
+        B = self._get_backprojector(config, (500, 511), rot_center=255.5)
+        res = self.apply_fbp(config, B, self.sino_511)
+        ref = self.ref_512[:-1, :-1]
+
+        delta_clipped = self.clip_to_inner_circle(res - ref)
+        err_max = np.max(np.abs(delta_clipped))
+
+        assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_fbp_roi(self, config):
+        """
+        Test FBP in region of interest
+        """
+        sino = self.sino_511
+
+        B0 = self._get_backprojector(config, sino.shape, rot_center=255.5)
+        ref = B0.fbp(sino)
+
+        def backproject_roi(roi, reference):
+            B = self._get_backprojector(config, sino.shape, rot_center=255.5, slice_roi=roi)
+            res = self.apply_fbp(config, B, sino)
+            err_max = np.max(np.abs(res - reference))
+            return err_max
+
+        cases = {
+            # Test 1: use slice_roi=(0, -1, 0, -1), i.e plain FBP of whole slice
+            1: [(0, None, 0, None), ref],
+            # Test 2: horizontal strip
+            2: [(0, None, 50, 55), ref[50:55, :]],
+            # Test 3: vertical strip
+            3: [(60, 65, 0, None), ref[:, 60:65]],
+            # Test 4: rectangular inner ROI
+            4: [(157, 162, 260, -10), ref[260:-10, 157:162]],
+        }
+        for roi, ref in cases.values():
+            err_max = backproject_roi(roi, ref)
+            assert err_max < self.tol, "Something wrong with ROI = %s for config=%s" % (
+                str(roi),
+                str(config),
+            )
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_fbp_axis_corr(self, config):
+        """
+        Test the "axis correction" feature
+        """
+        sino = self.sino_512
+
+        # Create a sinogram with a drift in the rotation axis
+        def create_drifted_sino(sino, drifts):
+            out = np.zeros_like(sino)
+            for i in range(sino.shape[0]):
+                out[i] = shift(sino[i], drifts[i])
+            return out
+
+        drifts = np.linspace(0, 20, sino.shape[0])
+        sino = create_drifted_sino(sino, drifts)
+
+        B = self._get_backprojector(config, sino.shape, extra_options={"axis_correction": drifts})
+        res = self.apply_fbp(config, B, sino)
+
+        delta_clipped = clip_circle(res - self.ref_512, radius=200)
+        err_max = np.max(np.abs(delta_clipped))
+        # Max error is relatively high, migh be due to interpolation of scipy shift in sinogram
+        assert err_max < 10.0, "Max error is too high"
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_fbp_clip_circle(self, config):
+        """
+        Test the "clip outer circle" parameter in (extra options)
+        """
+        sino = self.sino_512
+        tol = 1e-5
+
+        for rot_center in [None, sino.shape[1] / 2.0 - 10, sino.shape[1] / 2.0 + 15]:
+            B = self._get_backprojector(
+                config, sino.shape, rot_center=rot_center, extra_options={"clip_outer_circle": True}
+            )
+            res = self.apply_fbp(config, B, sino)
+
+            B0 = self._get_backprojector(
+                config, sino.shape, rot_center=rot_center, extra_options={"clip_outer_circle": False}
+            )
+            res_noclip = B0.fbp(sino)
+            ref = self.clip_to_inner_circle(res_noclip, radius_factor=1)
+
+            abs_diff = np.abs(res - ref)
+            err_max = np.max(abs_diff)
+            assert err_max < tol, "Max error is too high for rot_center=%s ; %s" % (str(rot_center), str(config))
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_fbp_centered_axis(self, config):
+        """
+        Test the "centered_axis" parameter (in extra options)
+        """
+        sino = np.pad(self.sino_512, ((0, 0), (100, 0)))
+        rot_center = (self.sino_512.shape[1] - 1) / 2.0 + 100
+
+        B0 = self._get_backprojector(config, self.sino_512.shape)
+        ref = B0.fbp(self.sino_512)
+
+        # Check that "centered_axis" worked
+
+        B = self._get_backprojector(config, sino.shape, rot_center=rot_center, extra_options={"centered_axis": True})
+        res = self.apply_fbp(config, B, sino)
+        # The outside region (outer circle) is different as "res" is a wider slice
+        diff = self.clip_to_inner_circle(res[50:-50, 50:-50] - ref)
+        err_max = np.max(np.abs(diff))
+        assert err_max < 5e-2, "centered_axis without clip_circle: something wrong"
+
+        # Check that "clip_outer_circle" works when used jointly with "centered_axis"
+        B = self._get_backprojector(
+            config,
+            sino.shape,
+            rot_center=rot_center,
+            extra_options={
+                "centered_axis": True,
+                "clip_outer_circle": True,
+            },
+        )
+        res2 = self.apply_fbp(config, B, sino)
+        diff = res2 - self.clip_to_inner_circle(res, radius_factor=1)
+        err_max = np.max(np.abs(diff))
+        assert err_max < 1e-5, "centered_axis with clip_circle: something wrong"
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_fbp_filters(self, config):
+        for filter_name in set(fbp_filters.values()):
+            if filter_name in [None, "ramlak"]:
+                continue
+            B = self._get_backprojector(config, self.sino_512.shape, filter_name=filter_name)
+            self.apply_fbp(config, B, self.sino_512)
+            # not sure what to check in this case
+
+    @pytest.mark.parametrize("config", scenarios)
+    def test_differentiated_backprojection(self, config):
+        # test Hilbert + DBP
+        sino_diff = np.diff(self.sino_512, axis=1, prepend=0).astype("f")
+        # Need to translate the axis a little bit, because of non-centered differentiation.
+        # prepend -> +0.5 ; append -> -0.5
+        B = self._get_backprojector(config, sino_diff.shape, filter_name="hilbert", rot_center=255.5 + 0.5)
+        rec = self.apply_fbp(config, B, sino_diff)
+        # Looks good, but all frequencies are not recovered. Use a metric like SSIM or FRC ?

build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/tests/test_filtering.py

@@ -0,0 +1,133 @@
+import numpy as np
+import pytest
+from nabu.reconstruction.filtering import SinoFilter, filter_sinogram
+from nabu.cuda.utils import __has_pycuda__
+from nabu.opencl.utils import __has_pyopencl__
+from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
+
+if __has_pycuda__:
+    from nabu.cuda.utils import get_cuda_context
+    from nabu.reconstruction.filtering_cuda import CudaSinoFilter
+    import pycuda.gpuarray as garray
+if __has_pyopencl__:
+    import pyopencl.array as parray
+    from nabu.opencl.processing import OpenCLProcessing
+    from nabu.reconstruction.filtering_opencl import OpenCLSinoFilter, __has_vkfft__
+
+filters_to_test = ["ramlak", "shepp-logan", "tukey"]
+padding_modes_to_test = ["constant", "edge"]
+if __do_long_tests__:
+    filters_to_test = ["ramlak", "shepp-logan", "cosine", "hamming", "hann", "tukey", "lanczos"]
+    padding_modes_to_test = SinoFilter.available_padding_modes
+
+tests_scenarios = generate_tests_scenarios(
+    {
+        "filter_name": filters_to_test,
+        "padding_mode": padding_modes_to_test,
+        "output_provided": [True, False],
+    }
+)
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.sino = get_data("mri_sino500.npz")["data"]
+    if __has_pycuda__:
+        cls.ctx_cuda = get_cuda_context(cleanup_at_exit=False)
+        cls.sino_cuda = garray.to_gpu(cls.sino)
+    if __has_pyopencl__:
+        cls.cl = OpenCLProcessing(device_type="all")
+        cls.sino_cl = parray.to_device(cls.cl.queue, cls.sino)
+
+    yield
+
+    if __has_pycuda__:
+        cls.ctx_cuda.pop()
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestSinoFilter:
+    @pytest.mark.parametrize("config", tests_scenarios)
+    def test_filter(self, config):
+        sino = self.sino
+
+        sino_filter = SinoFilter(
+            sino.shape,
+            filter_name=config["filter_name"],
+            padding_mode=config["padding_mode"],
+        )
+        if config["output_provided"]:
+            output = np.zeros_like(sino)
+        else:
+            output = None
+        res = sino_filter.filter_sino(sino, output=output)
+        if output is not None:
+            assert id(res) == id(output), "when providing output, return value must not change"
+
+        ref = filter_sinogram(
+            sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+        )
+
+        assert np.allclose(res, ref, atol=1e-6)
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need Cuda + pycuda to use CudaSinoFilter")
+    @pytest.mark.parametrize("config", tests_scenarios)
+    def test_cuda_filter(self, config):
+        sino = self.sino_cuda
+
+        sino_filter = CudaSinoFilter(
+            sino.shape,
+            filter_name=config["filter_name"],
+            padding_mode=config["padding_mode"],
+            cuda_options={"ctx": self.ctx_cuda},
+        )
+        if config["output_provided"]:
+            output = garray.zeros(sino.shape, "f")
+        else:
+            output = None
+        res = sino_filter.filter_sino(sino, output=output)
+        if output is not None:
+            assert id(res) == id(output), "when providing output, return value must not change"
+
+        ref = filter_sinogram(
+            self.sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+        )
+
+        if not np.allclose(res.get(), ref, atol=6e-5):
+            from spire.utils import ims
+
+            ims([res.get(), ref, res.get() - ref])
+
+        assert np.allclose(res.get(), ref, atol=6e-5), "test_cuda_filter: something wrong with config=%s" % (
+            str(config)
+        )
+
+    @pytest.mark.skipif(
+        not (__has_pyopencl__ and __has_vkfft__), reason="Need OpenCL + pyopencl + pyvkfft to use OpenCLSinoFilter"
+    )
+    @pytest.mark.parametrize("config", tests_scenarios)
+    def test_opencl_filter(self, config):
+        sino = self.sino_cl
+
+        sino_filter = OpenCLSinoFilter(
+            sino.shape,
+            filter_name=config["filter_name"],
+            padding_mode=config["padding_mode"],
+            opencl_options={"ctx": self.cl.ctx},
+        )
+        if config["output_provided"]:
+            output = parray.zeros(self.cl.queue, sino.shape, "f")
+        else:
+            output = None
+        res = sino_filter.filter_sino(sino, output=output)
+        if output is not None:
+            assert id(res) == id(output), "when providing output, return value must not change"
+
+        ref = filter_sinogram(
+            self.sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+        )
+
+        assert np.allclose(res.get(), ref, atol=6e-5), "test_opencl_filter: something wrong with config=%s" % (
+            str(config)
+        )