nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

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

@@ -1,220 +0,0 @@
-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/nabu/reconstruction/tests/test_fbp.py

@@ -1,252 +0,0 @@
-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/nabu/reconstruction/tests/test_filtering.py

@@ -1,133 +0,0 @@
-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)
-        )