nabu 2025.1.0.dev13__py3-none-any.whl → 2025.1.0rc1__py3-none-any.whl

nabu/preproc/ccd.py

@@ -1,5 +1,6 @@
 import numpy as np
 from ..utils import check_supported
+from scipy.ndimage import binary_dilation
 from silx.math.medianfilter import medfilt2d
 
 
@@ -13,6 +14,7 @@ class CCDFilter:
     def __init__(
         self,
         radios_shape: tuple,
+        kernel_size: int = 3,
         correction_type: str = "median_clip",
         median_clip_thresh: float = 0.1,
         abs_diff=False,
@@ -26,6 +28,9 @@ class CCDFilter:
         radios_shape: tuple
             A tuple describing the shape of the radios stack, in the form
             `(n_radios, n_z, n_x)`.
+        kernel_size: int
+            Size of the kernel for the median filter.
+            Default is 3.
         correction_type: str
             Correction type for radios ("median_clip", "sigma_clip", ...)
         median_clip_thresh: float, optional
@@ -48,6 +53,7 @@ class CCDFilter:
              then this pixel value is set to the median value.
         """
         self._set_radios_shape(radios_shape)
+        self.kernel_size = kernel_size
         check_supported(correction_type, self._supported_ccd_corrections, "CCD correction mode")
         self.correction_type = correction_type
         self.median_clip_thresh = median_clip_thresh
@@ -67,11 +73,11 @@ class CCDFilter:
         self.shape = (n_z, n_x)
 
     @staticmethod
-    def median_filter(img):
+    def median_filter(img, kernel_size=3):
         """
         Perform a median filtering on an image.
         """
-        return medfilt2d(img, (3, 3), mode="reflect")
+        return medfilt2d(img, (kernel_size, kernel_size), mode="reflect")
 
     def median_clip_mask(self, img, return_medians=False):
         """
@@ -85,7 +91,7 @@ class CCDFilter:
         return_medians: bool, optional
             Whether to return the median values additionally to the mask.
         """
-        median_values = self.median_filter(img)
+        median_values = self.median_filter(img, kernel_size=self.kernel_size)
         if not self.abs_diff:
             invalid_mask = img >= median_values + self.median_clip_thresh
         else:
@@ -124,6 +130,50 @@ class CCDFilter:
 
         return output
 
+    def dezinger_correction(self, radios, dark=None, nsigma=5, output=None):
+        """
+        Compute the median clip correction on a radios stack, and propagates the invalid pixels into vert and horiz directions.
+
+        Parameters
+        ----------
+        radios: numpy.ndarray
+            A radios stack.
+        dark: numpy.ndarray, optional
+            A dark image. Default is None. If not None, it is subtracted from the radios.
+        nsigma: float, optional
+            Number of standard deviations to use for the zinger detection.
+            Default is 5.
+        output: numpy.ndarray, optional
+            Output array
+        """
+        if radios.shape[1:] != self.radios_shape[1:]:
+            raise ValueError(f"Expected radios shape {self.radios_shape}, got {radios.shape}")
+
+        if output is None:
+            output = np.copy(radios)
+        else:
+            output[:] = radios[:]
+
+        n_radios = radios.shape[0]
+        for i in range(n_radios):
+            if dark is None:
+                dimg = radios[i]
+            elif dark.shape == radios.shape[1:]:
+                dimg = radios[i] - dark
+            else:
+                raise ValueError("Dark image shape does not match radios shape.")
+
+            dimg = radios[i] - dark
+            med = self.median_filter(dimg, self.kernel_size)
+            err = dimg - med
+            ds0 = err.std()
+            msk = err > ds0 * nsigma
+            gromsk = binary_dilation(msk)
+
+            output[i] = np.where(gromsk, med, radios[i])
+
+        return output
+
 
 class Log:
     """

nabu/preproc/flatfield.py

@@ -1,8 +1,11 @@
+import os
 from multiprocessing.pool import ThreadPool
 from bisect import bisect_left
 import numpy as np
+from tomoscan.io import HDF5File
 from ..io.reader import load_images_from_dataurl_dict
 from ..utils import check_supported, deprecated_class, get_num_threads
+from .ccd import CCDFilter
 
 
 class FlatFieldArrays:
@@ -102,7 +105,7 @@ class FlatFieldArrays:
         self._precompute_flats_indices_weights()
         self._configure_srcurrent_normalization(radios_srcurrent, flats_srcurrent)
         self.distortion_correction = distortion_correction
-        self.n_threads = min(1, get_num_threads(n_threads) // 2)
+        self.n_threads = max(1, get_num_threads(n_threads) // 2)
 
     def _set_parameters(self, radios_shape, radios_indices, interpolation, nan_value):
         self._set_radios_shape(radios_shape)
@@ -450,3 +453,305 @@ class FlatFieldDataUrls(FlatField):
             radios_srcurrent=radios_srcurrent,
             flats_srcurrent=flats_srcurrent,
         )
+
+
+class PCAFlatsNormalizer:
+    """This class implement a flatfield normalization based on a PCA of a series of acauired flatfields.
+    The PCA decomposition is handled by a PCAFlatsDecomposer object.
+
+    This implementation was proposed by Jailin C. et al in https://doi.org/10.1107/S1600577516015812.
+
+    Code initially written by ID11 @ ESRF staff.
+    Jonathan Wright - Implementation based on research paper
+    Pedro D. Resende - Added saving and loading from file capabilities
+
+    Jerome Lesaint - Integrated the solution in Nabu.
+
+    """
+
+    def __init__(self, components, dark, mean):
+        """Initializes all variables needed to perform the flatfield normalization.
+
+        Parameters
+        -----------
+        components: ndarray
+            The components of the PCA decomposition.
+        dark: ndarray
+            The dark image. Should be one single 2D image.
+        mean: ndarray
+            The mean image of the series of flats.
+        """
+        ones = np.ones_like(components[0], dtype=np.float32)[np.newaxis]  # This comp will account for I0
+        self.components = np.concatenate([ones, components], axis=0)
+        self.dark = dark
+        self.mean = mean
+        self.n_threads = max(1, get_num_threads() // 2)
+        self._setmask()
+        self.ccdfilter = CCDFilter(mean.shape)
+
+    def _form_lsq_matrix(self):
+        """This function form the Least Square matrix, based on the flats components and the mask."""
+        self.Amat = np.stack([gg for gg in self.g], axis=1)  # JL: this is the matrix for the fit
+
+    def _setmask(self, prop=0.125):
+        """Sets the mask to select where the model is going to be fitted.
+
+        Parameters
+        ----------
+        prop: float, default: 0.125
+            The proportion of the image width to take on each side of the image as a mask.
+
+            By default it sets the strips on each side of the frame in the form:
+                mask[:, lim:] = True
+                mask[:, -lim:] = True
+            Where lim = prop * flat.shape[1]
+
+        If you need a custom mask, see update_mask() method.
+        """
+
+        lim = int(prop * self.mean.shape[1])
+        self.mask = np.zeros(self.mean.shape, dtype=bool)
+        self.mask[:, :lim] = True
+        self.mask[:, -lim:] = True
+        self.g = []
+        for component in self.components:
+            self.g.append(component[self.mask])
+
+        self._form_lsq_matrix()
+
+    def update_mask(self, mask: np.ndarray):
+        """Method to update the mask with a custom mask in the form of a boolean 2+D array.
+
+        Paramters
+        =========
+        mask: np.ndarray of Boolean;
+            The array of boolean allows the selection of the region of the image that will be used to fit against the components.
+
+        It will set the mask, replacing the standard mask created with setmask().
+        """
+        if mask.dtype == bool:
+            self.mask = mask
+            self.g = []
+            for component in self.components:
+                self.g.append(component[self.mask])
+
+            self._form_lsq_matrix()
+        else:
+            raise TypeError("Not a boolean array. Will keep the default mask")
+
+    def normalize_radios(self, projections, mask=None, prop=0.125):
+        """This is to keep the flatfield API in the pipeline."""
+        self.correct_stack(projections, mask=mask, prop=prop)
+
+    def correct_stack(
+        self,
+        projections: np.ndarray,
+        mask: np.ndarray = None,
+        prop: float = 0.125,
+    ):
+        """This functions normalizes the stack of projections.
+
+        Performs correction on a stack of projections based on the calculated decomposition.
+        The normalizations is done in-place. The previous projections before normalization are lost.
+
+        Parameters
+        ----------
+        projections: ndarray
+            Stack of projections to normalize.
+
+        prop: float (default: {0.125})
+            Fraction to mask on the horizontal field of view, assuming vertical rotation axis
+
+        mask: np.ndarray (default: None)
+            Custom mask if your data requires it.
+
+        Returns
+        -------
+        corrected projections: np.ndarray
+            Flat field corrected images. Note that the returned projections are exp-transformed to fit the pipeline (e.g. to allow for phase retrieval).
+        """
+        self.projections = self.ccdfilter.dezinger_correction(projections, self.dark)
+
+        if mask is not None:
+            self.update_mask(mask=mask)
+        else:
+            self._setmask(prop=prop)
+
+        with ThreadPool(self.n_threads) as tp:
+            for i, cor, sol in tp.map(self._readcorrect1, range(len(projections))):
+                # solution[i] = sol
+                projections[i] = np.exp(-cor)
+
+    def _readcorrect1(self, ii):
+        """Method to allow parallelization of the normalization."""
+        corr, s = self.correctproj(self.projections[ii])
+        return ii, corr, s
+
+    def correctproj(self, projection):
+        """Performs the correction on one projection of the stack.
+
+        Parameters
+        ----------
+        projection: np.ndarray, float
+            Radiograph from the acquisition stack.
+
+        Returns
+        -------
+        The fitted projection.
+        """
+        logp = np.log(projection.astype(np.float32) - self.dark)
+        corr = self.mean - logp
+        # model to be fitted !!
+        return self.fit(corr)
+
+    def fit(self, corr):
+        """Fit the (masked) projection to the (masked) components of the PCA decomposition.
+
+        This is for each projection, so worth optimising ...
+        """
+        y = corr[self.mask]
+        solution = np.linalg.lstsq(self.Amat, y, rcond=None)[0]
+        correction = np.einsum("ijk,i->jk", self.components, solution)
+        return corr - correction, solution
+
+
+class PCAFlatsDecomposer:
+    """This class implements a PCA decomposition of a serie of acquired flatfields.
+    The PCA decomposition is used to normalize the projections through a PCAFLatNormalizer object.
+
+    This implementation was proposed by Jailin C. et al in https://doi.org/10.1107/S1600577516015812.
+
+    Code initially written by ID11 @ ESRF staff.
+    Jonathan Wright - Implementation based on research paper
+    Pedro D. Resende - Added saving and loading from file capabilities
+
+    Jerome Lesaint - Integrated the solution in Nabu.
+    """
+
+    def __init__(self, flats: np.ndarray, darks: np.ndarray, nsigma=3):
+        """
+
+        Parameters
+        -----------
+        flats: np.ndarray
+            A stack of darks corrected flat field images
+        darks: np.ndarray
+            An image or stack of images of the dark current images of the camera.
+
+        Does the log scaling.
+        Subtracts mean and does eigenvector decomposition.
+        """
+        self.n_threads = max(1, get_num_threads() // 2)
+        self.flats = np.empty(flats.shape, dtype=np.float32)
+
+        darks = darks.astype(np.float32)
+        if darks.ndim == 3:
+            self.dark = np.median(darks, axis=0)
+        else:
+            self.dark = darks.copy()
+        del darks
+
+        self.nsigma = nsigma
+        self.ccdfilter = CCDFilter(self.dark.shape)
+        self._ccdfilter_and_log(flats)  # Log is taken here (after dezinger)
+
+        self.mean = np.mean(self.flats, axis=0)  # average
+
+        self.flats = self.flats - self.mean  # makes a copy
+        self.cov = self.compute_correlation_matrix()
+        self.compute_pca()
+        self.generate_pca_flats(nsigma=nsigma)  # Default nsigma=3
+
+    def __str__(self):
+
+        return f"PCA decomposition from flat images. \nThere are {self.components} components created at {self.sigma} level."
+
+    def _ccdfilter_and_log(self, flats: np.ndarray):
+        """Dezinger (substract dark, apply median filter) and takes log of the flat stack"""
+
+        self.ccdfilter.dezinger_correction(flats, self.dark, nsigma=self.nsigma)
+
+        with ThreadPool(self.n_threads) as tp:
+            for i, frame in enumerate(tp.map(np.log, flats)):
+                self.flats[i] = frame
+
+    @staticmethod
+    def ccij(args):
+        """Compute the covariance (img[i]*img[j]).sum() / npixels
+        It is a wrapper for threading.
+        args == i, j, npixels, imgs
+        """
+
+        i, j, NY, imgs = args
+        return i, j, np.einsum("ij,ij", imgs[i], imgs[j]) / NY
+
+    def compute_correlation_matrix(self):
+        """Computes an (nflats x nflats) correlation matrix"""
+
+        N = len(self.flats)
+        CC = np.zeros((N, N), float)
+        args = [(i, j, N, self.flats) for i in range(N) for j in range(i + 1)]
+        with ThreadPool(self.n_threads) as tp:
+            for i, j, result in tp.map(self.ccij, args):
+                CC[i, j] = CC[j, i] = result
+        return CC
+
+    def compute_pca(self):
+        """Gets eigenvectors and eigenvalues and sorts them into order"""
+
+        self.eigenvalues, self.eigenvectors = np.linalg.eigh(
+            self.cov
+        )  # Not sure why the eigh is needed. eig should be enough.
+        order = np.argsort(abs(self.eigenvalues))[::-1]  # high to low
+        self.eigenvalues = self.eigenvalues[order]
+        self.eigenvectors = self.eigenvectors[:, order]
+
+    def generate_pca_flats(self, nsigma=3):
+        """Projects the eigenvectors back into image space.
+
+        Parameters
+        ----------
+        nsigma: int (default: 3)
+        """
+
+        self.sigma = nsigma
+        av = abs(self.eigenvalues)
+        N = (av > (av[-2] * nsigma)).sum()  # Go for 3 sigma
+        self.components = [
+            None,
+        ] * N
+
+        def calculate(ii):
+            calc = np.einsum("i,ijk->jk", self.eigenvectors[:, ii], self.flats)
+            norm = (calc**2).sum()
+            return ii, calc / np.sqrt(norm)
+
+        with ThreadPool(self.n_threads) as tp:
+            for ii, result in tp.map(calculate, range(N)):
+                self.components[ii] = result
+
+        # simple gradients
+        r, c = self.components[0].shape
+        self.components.append(np.outer(np.ones(r), np.linspace(-1 / c, 1 / c, c)))
+        self.components.append(np.outer(np.linspace(-1 / r, 1 / r, r), np.ones(c)))
+
+    def save_decomposition(self, path="PCA_flats.h5", overwrite=True, entry="entry0000"):
+        """Saves the basic information of a PCA decomposition in view of the normalization of projections.
+
+        Parameters
+        ----------
+        path: str (default: "PCA_flats.h5")
+            Full path to the h5 file you want to save your results. It will overwrite!! Be careful.
+        """
+
+        file_exists = os.path.exists(path)
+        if overwrite or not file_exists:
+            with HDF5File(path, "w") as hout:
+                group = hout.create_group(entry)
+                group["eigenvalues"] = self.eigenvalues
+                group["dark"] = self.dark.astype(np.float32)
+                group["p_mean"] = self.mean.astype(np.float32)
+                group["p_components"] = np.array(self.components)
+                hout.flush()
+        else:
+            raise OSError(f"The file {path} already exists and you chose to NOT overwrite.")

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/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")