nabu 2025.1.0.dev14__py3-none-any.whl → 2025.1.0rc2__py3-none-any.whl

nabu/preproc/shift.py

@@ -51,7 +51,7 @@ class VerticalShift:
         assert np.max(iangles) < len(self.interp_infos)
         assert len(iangles) == radios.shape[0]
 
-    def apply_vertical_shifts(self, radios, iangles, output=None):
+    def apply_vertical_shifts(self, radios, iangles=None, output=None):
         """
         Parameters
         ----------
@@ -65,6 +65,8 @@ class VerticalShift:
             If given, it will be modified to contain the shifted radios.
             Must be of the same shape of `radios`.
         """
+        if iangles is None:
+            iangles = np.arange(radios.shape[0])
         self._check(radios, iangles)
 
         newradio = np.zeros_like(radios[0])

nabu/preproc/tests/test_pcaflats.py

@@ -0,0 +1,154 @@
+import os
+import numpy as np
+import pytest
+
+import h5py
+from nabu.testutils import utilstest
+from nabu.preproc.flatfield import (
+    PCAFlatsDecomposer,
+    PCAFlatsNormalizer,
+)
+
+
+@pytest.fixture(scope="class")
+def bootstrap_pcaflats(request):
+    cls = request.cls
+    # TODO: these tolerances for having the tests passed should be tighter.
+    # Discrepancies between id11 code and nabu code are still mysterious.
+    cls.mean_abs_tol = 1e-1
+    cls.comps_abs_tol = 1e-2
+    cls.projs, cls.flats, cls.darks = get_pcaflats_data("test_pcaflats.npz")
+    cls.raw_projs = cls.projs.copy()  # Needed because flat correction is done inplace.
+    ref_data = get_pcaflats_refdata("ref_pcaflats.npz")
+    cls.mean = ref_data["mean"]
+    cls.components_3 = ref_data["components_3"]
+    cls.components_15 = ref_data["components_15"]
+    cls.dark = ref_data["dark"]
+    cls.normalized_projs_3 = ref_data["normalized_projs_3"]
+    cls.normalized_projs_15 = ref_data["normalized_projs_15"]
+    cls.normalized_projs_custom_mask = ref_data["normalized_projs_custom_mask"]
+    cls.test_normalize_projs_custom_prop = ref_data["normalized_projs_custom_prop"]
+
+    cls.h5_filename_3 = get_h5_pcaflats("pcaflat_3.h5")
+    cls.h5_filename_15 = get_h5_pcaflats("pcaflat_15.h5")
+
+
+def get_pcaflats_data(*dataset_path):
+    """
+    Get a dataset file from silx.org/pub/nabu/data
+    dataset_args is a list describing a nested folder structures, ex.
+    ["path", "to", "my", "dataset.h5"]
+    """
+    dataset_relpath = os.path.join(*dataset_path)
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    data = np.load(dataset_downloaded_path)
+    projs = data["projs"].astype(np.float32)
+    flats = data["flats"].astype(np.float32)
+    darks = data["darks"].astype(np.float32)
+
+    return projs, flats, darks
+
+
+def get_h5_pcaflats(*dataset_path):
+    """
+    Get a dataset file from silx.org/pub/nabu/data
+    dataset_args is a list describing a nested folder structures, ex.
+    ["path", "to", "my", "dataset.h5"]
+    """
+    dataset_relpath = os.path.join(*dataset_path)
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+
+    return dataset_downloaded_path
+
+
+def get_pcaflats_refdata(*dataset_path):
+    """
+    Get a dataset file from silx.org/pub/nabu/data
+    dataset_args is a list describing a nested folder structures, ex.
+    ["path", "to", "my", "dataset.h5"]
+    """
+    dataset_relpath = os.path.join(*dataset_path)
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    data = np.load(dataset_downloaded_path)
+
+    return data
+
+
+def get_decomposition(filename):
+    with h5py.File(filename, "r") as f:
+        # Load the dataset
+        p_comps = f["entry0000/p_components"][()]
+        p_mean = f["entry0000/p_mean"][()]
+        dark = f["entry0000/dark"][()]
+    return p_comps, p_mean, dark
+
+
+@pytest.mark.usefixtures("bootstrap_pcaflats")
+class TestPCAFlatsDecomposer:
+    def test_decompose_flats(self):
+        # Build 3-sigma basis
+        pca = PCAFlatsDecomposer(self.flats, self.darks, nsigma=3)
+        message = f"Found a discrepency between computed mean flat and reference."
+        assert np.allclose(self.mean, pca.mean, atol=self.mean_abs_tol), message
+        message = f"Found a discrepency between computed components and reference ones if nsigma=3."
+        assert np.allclose(self.components_3, np.array(pca.components), atol=self.comps_abs_tol), message
+
+        # Build 1.5-sigma basis
+        pca = PCAFlatsDecomposer(self.flats, self.darks, nsigma=1.5)
+        message = f"Found a discrepency between computed components and reference ones, if nsigma=1.5."
+        assert np.allclose(self.components_15, np.array(pca.components), atol=self.comps_abs_tol), message
+
+    def test_save_load_decomposition(self):
+        pca = PCAFlatsDecomposer(self.flats, self.darks, nsigma=3)
+        tmp_path = os.path.join(os.path.dirname(self.h5_filename_3), "PCA_Flats.h5")
+        pca.save_decomposition(path=tmp_path)
+        p_comps, p_mean, dark = get_decomposition(tmp_path)
+        message = f"Found a discrepency between saved and loaded mean flat."
+        assert np.allclose(self.mean, p_mean, atol=self.mean_abs_tol), message
+        message = f"Found a discrepency between saved and loaded components if nsigma=3."
+        assert np.allclose(self.components_3, p_comps, atol=self.comps_abs_tol), message
+        message = f"Found a discrepency between saved and loaded dark."
+        assert np.allclose(self.dark, dark, atol=self.comps_abs_tol), message
+        # Clean up
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+
+@pytest.mark.usefixtures("bootstrap_pcaflats")
+class TestPCAFlatsNormalizer:
+    def test_load_pcaflats(self):
+        """Tests that the structure of the output PCAFlat h5 file is correct."""
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+        # Check the shape of the loaded data
+        assert p_comps.shape[1:] == p_mean.shape
+        assert p_comps.shape[1:] == dark.shape
+
+    def test_normalize_projs(self):
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs)
+        assert np.allclose(projs, self.normalized_projs_3, atol=1e-2)
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_15)
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs)
+        assert np.allclose(projs, self.normalized_projs_15, atol=1e-2)
+
+    def test_use_custom_mask(self):
+        mask = np.zeros(self.mean.shape, dtype=bool)
+        mask[:, :10] = True
+        mask[:, -10:] = True
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs, mask=mask)
+        assert np.allclose(projs, self.normalized_projs_custom_mask, atol=1e-2)
+
+    def test_change_mask_prop(self):
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs, prop=0.05)
+        assert np.allclose(projs, self.test_normalize_projs_custom_prop, atol=1e-2)

nabu/processing/rotation_cuda.py

@@ -1,7 +1,7 @@
 import numpy as np
 from .rotation import Rotation
 from ..utils import get_cuda_srcfile, updiv
-from ..cuda.utils import __has_pycuda__, copy_array
+from ..cuda.utils import __has_pycuda__, copy_array, check_textures_availability
 from ..cuda.processing import CudaProcessing
 
 if __has_pycuda__:
@@ -11,6 +11,8 @@ if __has_pycuda__:
 
 class CudaRotation(Rotation):
     def __init__(self, shape, angle, center=None, mode="edge", reshape=False, cuda_options=None, **sk_kwargs):
+        if not (check_textures_availability()):
+            raise RuntimeError("Need cuda textures for this class")
         if center is None:
             center = ((shape[1] - 1) / 2.0, (shape[0] - 1) / 2.0)
         super().__init__(shape, angle, center=center, mode=mode, reshape=reshape, **sk_kwargs)

nabu/processing/tests/test_rotation.py

@@ -3,7 +3,7 @@ import pytest
 from nabu.testutils import generate_tests_scenarios
 from nabu.processing.rotation_cuda import Rotation
 from nabu.processing.rotation import __have__skimage__
-from nabu.cuda.utils import __has_pycuda__, get_cuda_context
+from nabu.cuda.utils import __has_pycuda__, get_cuda_context, check_textures_availability
 
 if __have__skimage__:
     from skimage.transform import rotate
@@ -68,7 +68,9 @@ class TestRotation:
         res = R(self.image)
         self._check_result(res, config, 1e-6)
 
-    @pytest.mark.skipif(not (__has_pycuda__), reason="Need cuda rotation")
+    @pytest.mark.skipif(
+        not (__has_pycuda__) or not (check_textures_availability()), reason="Need cuda rotation (and textures)"
+    )
     @pytest.mark.parametrize("config", scenarios)
     def test_cuda_rotation(self, config):
         R = CudaRotation(

nabu/reconstruction/astra.py

@@ -0,0 +1,245 @@
+# ruff: noqa
+try:
+    import astra
+
+    __have_astra__ = True
+except ImportError:
+    __have_astra__ = False
+    astra = None
+
+
+class AstraReconstructor:
+    """
+    Base class for reconstructors based on the Astra toolbox
+    """
+
+    default_extra_options = {
+        "axis_correction": None,
+        "clip_outer_circle": False,
+        "scale_factor": None,
+        "filter_cutoff": 1.0,
+        "outer_circle_value": 0.0,
+    }
+
+    def __init__(
+        self,
+        sinos_shape,
+        angles=None,
+        volume_shape=None,
+        rot_center=None,
+        pixel_size=None,
+        padding_mode="zeros",
+        filter_name=None,
+        slice_roi=None,
+        cuda_options=None,
+        extra_options=None,
+    ):
+        self._configure_extra_options(extra_options)
+        self._init_cuda(cuda_options)
+        self._set_sino_shape(sinos_shape)
+        self._orig_prog_geom = None
+        self._init_geometry(
+            source_origin_dist,
+            origin_detector_dist,
+            pixel_size,
+            angles,
+            volume_shape,
+            rot_center,
+            relative_z_position,
+            slice_roi,
+        )
+        self._init_fdk(padding_mode, filter_name)
+        self._alg_id = None
+        self._vol_id = None
+        self._proj_id = None
+
+    def _configure_extra_options(self, extra_options):
+        self.extra_options = self.default_extra_options.copy()
+        self.extra_options.update(extra_options or {})
+
+    def _init_cuda(self, cuda_options):
+        cuda_options = cuda_options or {}
+        self.cuda = CudaProcessing(**cuda_options)
+
+    def _set_sino_shape(self, sinos_shape):
+        if len(sinos_shape) != 3:
+            raise ValueError("Expected a 3D shape")
+        self.sinos_shape = sinos_shape
+        self.n_sinos, self.n_angles, self.prj_width = sinos_shape
+
+    def _set_pixel_size(self, pixel_size):
+        if pixel_size is None:
+            det_spacing_y = det_spacing_x = 1
+        elif np.iterable(pixel_size):
+            det_spacing_y, det_spacing_x = pixel_size
+        else:
+            # assuming scalar
+            det_spacing_y = det_spacing_x = pixel_size
+        self._det_spacing_y = det_spacing_y
+        self._det_spacing_x = det_spacing_x
+
+    def _set_slice_roi(self, slice_roi):
+        self.slice_roi = slice_roi
+        self._vol_geom_n_x = self.n_x
+        self._vol_geom_n_y = self.n_y
+        self._crop_data = True
+        if slice_roi is None:
+            return
+        start_x, end_x, start_y, end_y = slice_roi
+        if roi_is_centered(self.volume_shape[1:], (slice(start_y, end_y), slice(start_x, end_x))):
+            # Astra can only reconstruct subregion centered around the origin
+            self._vol_geom_n_x = self.n_x - start_x * 2
+            self._vol_geom_n_y = self.n_y - start_y * 2
+        else:
+            raise NotImplementedError(
+                "Astra supports only slice_roi centered around origin (got slice_roi=%s with n_x=%d, n_y=%d)"
+                % (str(slice_roi), self.n_x, self.n_y)
+            )
+
+    def _init_geometry(
+        self,
+        source_origin_dist,
+        origin_detector_dist,
+        pixel_size,
+        angles,
+        volume_shape,
+        rot_center,
+        relative_z_position,
+        slice_roi,
+    ):
+        if angles is None:
+            self.angles = np.linspace(0, 2 * np.pi, self.n_angles, endpoint=True)
+        else:
+            self.angles = angles
+        if volume_shape is None:
+            volume_shape = (self.sinos_shape[0], self.sinos_shape[2], self.sinos_shape[2])
+        self.volume_shape = volume_shape
+        self.n_z, self.n_y, self.n_x = self.volume_shape
+        self.source_origin_dist = source_origin_dist
+        self.origin_detector_dist = origin_detector_dist
+        self.magnification = 1 + origin_detector_dist / source_origin_dist
+        self._set_slice_roi(slice_roi)
+        self.vol_geom = astra.create_vol_geom(self._vol_geom_n_y, self._vol_geom_n_x, self.n_z)
+        self.vol_shape = astra.geom_size(self.vol_geom)
+        self._cor_shift = 0.0
+        self.rot_center = rot_center
+        if rot_center is not None:
+            self._cor_shift = (self.sinos_shape[-1] - 1) / 2.0 - rot_center
+        self._set_pixel_size(pixel_size)
+        self._axis_corrections = self.extra_options.get("axis_correction", None)
+        self._create_astra_proj_geometry(relative_z_position)
+
+    def _create_astra_proj_geometry(self, relative_z_position):
+        # This object has to be re-created each time, because once the modifications below are done,
+        # it is no more a "cone" geometry but a "cone_vec" geometry, and cannot be updated subsequently
+        # (see astra/functions.py:271)
+        self.proj_geom = astra.create_proj_geom(
+            "cone",
+            self._det_spacing_x,
+            self._det_spacing_y,
+            self.n_sinos,
+            self.prj_width,
+            self.angles,
+            self.source_origin_dist,
+            self.origin_detector_dist,
+        )
+        self.relative_z_position = relative_z_position or 0.0
+        # This will turn the geometry of type "cone" into a geometry of type "cone_vec"
+        if self._orig_prog_geom is None:
+            self._orig_prog_geom = self.proj_geom
+        self.proj_geom = astra.geom_postalignment(self.proj_geom, (self._cor_shift, 0))
+        # (src, detector_center, u, v) = (srcX, srcY, srcZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ)
+        vecs = self.proj_geom["Vectors"]
+
+        # To adapt the center of rotation:
+        # dX = cor_shift * cos(theta) - origin_detector_dist * sin(theta)
+        # dY = origin_detector_dist * cos(theta) + cor_shift * sin(theta)
+        if self._axis_corrections is not None:
+            # should we check that dX and dY match the above formulas ?
+            cor_shifts = self._cor_shift + self._axis_corrections
+            vecs[:, 3] = cor_shifts * np.cos(self.angles) - self.origin_detector_dist * np.sin(self.angles)
+            vecs[:, 4] = self.origin_detector_dist * np.cos(self.angles) + cor_shifts * np.sin(self.angles)
+
+        # To adapt the z position:
+        # Component 2 of vecs is the z coordinate of the source, component 5 is the z component of the detector position
+        # We need to re-create the same inclination of the cone beam, thus we need to keep the inclination of the two z positions.
+        # The detector is centered on the rotation axis, thus moving it up or down, just moves it out of the reconstruction volume.
+        # We can bring back the detector in the correct volume position, by applying a rigid translation of both the detector and the source.
+        # The translation is exactly the amount that brought the detector up or down, but in the opposite direction.
+        vecs[:, 2] = -self.relative_z_position
+
+    def _set_output(self, volume):
+        if volume is not None:
+            expected_shape = self.vol_shape  # if not (self._crop_data) else self._output_cropped_shape
+            self.cuda.check_array(volume, expected_shape)
+            self.cuda.set_array("output", volume)
+        if volume is None:
+            self.cuda.allocate_array("output", self.vol_shape)
+        d_volume = self.cuda.get_array("output")
+        z, y, x = d_volume.shape
+        self._vol_link = astra.data3d.GPULink(d_volume.ptr, x, y, z, d_volume.strides[-2])
+        self._vol_id = astra.data3d.link("-vol", self.vol_geom, self._vol_link)
+
+    def _set_input(self, sinos):
+        self.cuda.check_array(sinos, self.sinos_shape)
+        self.cuda.set_array("sinos", sinos)  # self.cuda.sinos is now a GPU array
+        # TODO don't create new link/proj_id if ptr is the same ?
+        # But it seems Astra modifies the input sinogram while doing FDK, so this might be not relevant
+        d_sinos = self.cuda.get_array("sinos")
+
+        # self._proj_data_link = astra.data3d.GPULink(d_sinos.ptr, self.prj_width, self.n_angles, self.n_z, sinos.strides[-2])
+        self._proj_data_link = astra.data3d.GPULink(
+            d_sinos.ptr, self.prj_width, self.n_angles, self.n_sinos, d_sinos.strides[-2]
+        )
+        self._proj_id = astra.data3d.link("-sino", self.proj_geom, self._proj_data_link)
+
+    def _preprocess_data(self):
+        d_sinos = self.cuda.sinos
+        for i in range(d_sinos.shape[0]):
+            self.sino_filter.filter_sino(d_sinos[i], output=d_sinos[i])
+
+    def _update_reconstruction(self):
+        cfg = astra.astra_dict("BP3D_CUDA")
+        cfg["ReconstructionDataId"] = self._vol_id
+        cfg["ProjectionDataId"] = self._proj_id
+        if self._alg_id is not None:
+            astra.algorithm.delete(self._alg_id)
+        self._alg_id = astra.algorithm.create(cfg)
+
+    def reconstruct(self, sinos, output=None, relative_z_position=None):
+        """
+        sinos: numpy.ndarray or pycuda.gpuarray
+            Sinograms, with shape (n_sinograms, n_angles, width)
+        output: pycuda.gpuarray, optional
+            Output array. If not provided, a new numpy array is returned
+        relative_z_position: int, optional
+            Position of the central slice of the slab, with respect to the full stack of slices.
+            By default it is set to zero, meaning that the current slab is assumed in the middle of the stack
+        """
+        self._create_astra_proj_geometry(relative_z_position)
+        self._set_input(sinos)
+        self._set_output(output)
+        self._preprocess_data()
+        self._update_reconstruction()
+        astra.algorithm.run(self._alg_id)
+        #
+        # NB: Could also be done with
+        # from astra.experimental import direct_BP3D
+        # projector_id = astra.create_projector("cuda3d", self.proj_geom, self.vol_geom, options=None)
+        # direct_BP3D(projector_id, self._vol_link, self._proj_data_link)
+        #
+        result = self.cuda.get_array("output")
+        if output is None:
+            result = result.get()
+        if self.extra_options.get("scale_factor", None) is not None:
+            result *= np.float32(self.extra_options["scale_factor"])  # in-place for pycuda
+        self.cuda.recover_arrays_references(["sinos", "output"])
+        return result
+
+    def __del__(self):
+        if getattr(self, "_alg_id", None) is not None:
+            astra.algorithm.delete(self._alg_id)
+        if getattr(self, "_vol_id", None) is not None:
+            astra.data3d.delete(self._vol_id)
+        if getattr(self, "_proj_id", None) is not None:
+            astra.data3d.delete(self._proj_id)

nabu/reconstruction/fbp.py

@@ -86,6 +86,13 @@ class CudaBackprojector(BackprojectorBase):
             self.sino_mult = CudaSinoMult(self.sino_shape, self.rot_center, ctx=self._processing.ctx)
         self._prepare_textures()  # has to be done after compilation for Cuda (to bind texture to built kernel)
 
+    def _get_filter_init_extra_options(self):
+        return {
+            "cuda_options": {
+                "ctx": self._processing.ctx,
+            },
+        }
+
     def _transfer_to_texture(self, sino, do_checks=True):
         if do_checks and not (sino.flags.c_contiguous):
             raise ValueError("Expected C-Contiguous array")

nabu/reconstruction/fbp_base.py

@@ -7,6 +7,19 @@ from .sinogram import SinoMult
 from .sinogram import get_extended_sinogram_width
 
 
+def rot_center_is_in_middle_of_roi(rot_center, roi, tol=2.0):
+    # NB. tolerance should be at least 2,
+    # because in halftomo the extended sinogram width is 2*sino_width - int(2 * XXXX)
+    #   (where  XXX depends on whether the CoR is on the left or on the right)
+    #  because of the int(2 * stuff), we can have a jump of at most two pixels.
+    #
+    start_x, end_x, start_y, end_y = roi
+    return (
+        abs((start_x + end_x - 1) / 2 - rot_center) - 0.5 < tol
+        and abs((start_y + end_y - 1) / 2 - rot_center) - 0.5 < tol
+    )
+
+
 class BackprojectorBase:
     """
     Base class for backprojectors.
@@ -162,9 +175,6 @@ class BackprojectorBase:
         self.axis_pos = self.rot_center
         self._set_angles(angles, n_angles)
         self._set_slice_roi(slice_roi)
-        #
-        # offset = start - move
-        # move = 0 if not(centered_axis) else start + (n-1)/2. - c
         if self.extra_options["centered_axis"]:
             self.offsets = {
                 "x": self.rot_center - (self.n_x - 1) / 2.0,
@@ -210,6 +220,19 @@ class BackprojectorBase:
         end_x = convert_index(end_x, self.n_x, self.n_x)
         end_y = convert_index(end_y, self.n_y, self.n_y)
         self.slice_shape = (end_y - start_y, end_x - start_x)
+        if self.extra_options["centered_axis"] and not (
+            rot_center_is_in_middle_of_roi(self.rot_center, (start_x, end_x, start_y, end_y))
+        ):
+            warnings.warn(
+                "Using 'centered_axis' when doing a non-centered ROI reconstruction might have side effects: 'start_xy' and 'end_xy' have a different meaning",
+                RuntimeWarning,
+            )
+            # self.extra_options["centered_axis"] = False
+        if self.extra_options.get("clip_outer_circle", False) and (
+            start_x > 2 or start_y > 2 or abs(end_y - self.n_y) > 2 or abs(end_y - self.n_y) > 2
+        ):
+            warnings.warn("clip_outer_circle is not supported when doing RoI reconstruction", RuntimeWarning)
+            self.extra_options["clip_outer_circle"] = False
         self.n_x = self.slice_shape[-1]
         self.n_y = self.slice_shape[-2]
         self.offsets = {"x": start_x, "y": start_y}
@@ -239,19 +262,20 @@ class BackprojectorBase:
         self._axis_correction = np.zeros((1, self.n_angles), dtype=np.float32)
         self._axis_correction[0, :] = axcorr[:]  # pylint: disable=E1136
 
+    def _get_filter_init_extra_options(self):
+        return {}
+
     def _init_filter(self, filter_name):
         self.filter_name = filter_name
         if filter_name in ["None", "none"]:
             self.sino_filter = None
             return
-        sinofilter_other_kwargs = {}
-        if self.backend != "numpy":
-            sinofilter_other_kwargs["%s_options" % self.backend] = {"ctx": self._processing.ctx}
-        sinofilter_other_kwargs["crop_filtered_data"] = self.extra_options.get("crop_filtered_data", True)
+
         # TODO
         if not (self.extra_options.get("crop_filtered_data", True)):
             warnings.warn("crop_filtered_data = False is not supported for FBP yet", RuntimeWarning)
         #
+        sinofilter_other_kwargs = self._get_filter_init_extra_options()
         self.sino_filter = self.SinoFilterClass(
             self.sino_shape,
             filter_name=self.filter_name,

nabu/reconstruction/fbp_opencl.py

@@ -74,5 +74,13 @@ class OpenCLBackprojector(BackprojectorBase):
                 return
             return cl.enqueue_copy(self._processing.queue, self._d_sino.data, sino.data)
 
+    def _get_filter_init_extra_options(self):
+        return {
+            "opencl_options": {
+                "ctx": self._processing.ctx,
+                "queue": self._processing.queue,  # !!!!
+            },
+        }
+
     def _set_kernel_slice_arg(self, d_slice):
         self.kern_proj_args[1] = d_slice

nabu/reconstruction/filtering_opencl.py

@@ -33,6 +33,8 @@ class OpenCLSinoFilter(SinoFilter):
             crop_filtered_data=crop_filtered_data,
             extra_options=extra_options,
         )
+        if not (crop_filtered_data):
+            raise NotImplementedError  # TODO
         self._init_kernels()
 
     def _init_fft(self):