nabu 2024.2.4__py3-none-any.whl → 2025.1.0.dev4__py3-none-any.whl

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/cone.py

@@ -1,10 +1,11 @@
+import logging
 from math import sqrt
 import numpy as np
 
 from ..cuda.kernel import CudaKernel
 from ..cuda.processing import CudaProcessing
 from ..reconstruction.filtering_cuda import CudaSinoFilter
-from ..utils import get_cuda_srcfile
+from ..utils import get_cuda_srcfile, updiv
 
 try:
     import astra
@@ -14,6 +15,9 @@ except ImportError:
     __have_astra__ = False
 
 
+_logger = logging.getLogger(__name__)
+
+
 class ConebeamReconstructor:
     """
     A reconstructor for cone-beam geometry using the astra toolbox.
@@ -159,7 +163,9 @@ class ConebeamReconstructor:
     def _init_fdk(self, padding_mode, filter_name):
         self.padding_mode = padding_mode
         self._use_astra_fdk = bool(self.extra_options.get("use_astra_fdk", True))
-        self._use_astra_fdk &= padding_mode in ["zeros", "constant", None, "none"]
+        if self._use_astra_fdk and padding_mode not in ["zeros", "constant", None, "none"]:
+            self._use_astra_fdk = False
+            _logger.warning("padding_mode was set to %s, cannot use native astra FDK" % padding_mode)
         if self._use_astra_fdk:
             return
         self.sino_filter = CudaSinoFilter(
@@ -386,12 +392,11 @@ def fdk_preweighting(d_sinos, proj_geom, relative_z_position=0.0, cor_shift=0.0)
         signature="Piiifffffiii",
     )
 
-    # n_angles, n_z, n_x = d_sinos.shape
     n_z, n_angles, n_x = d_sinos.shape
     det_origin = sqrt(proj_geom["DistanceOriginDetector"] ** 2 + cor_shift**2)
 
     block = (32, 16, 1)
-    grid = (((n_x + 32 - 1) // 32) * ((n_z + 32 - 1) // 32), (n_angles + 16 - 1) // 16, 1)
+    grid = (updiv(n_x, block[0]), updiv(n_angles, block[1]), 1)
 
     preweight_kernel(
         d_sinos,

nabu/reconstruction/fbp_base.py

@@ -82,7 +82,7 @@ class BackprojectorBase:
         backend_options: dict, optional
             OpenCL/Cuda options passed to the OpenCLProcessing or CudaProcessing class.
 
-        Other parameters
+        Other Parameters
         -----------------
         extra_options: dict, optional
             Dictionary with a set of advanced options. The default are the following:
@@ -354,7 +354,7 @@ class BackprojectorBase:
 
     def backproj(self, sino, output=None, do_checks=True):
         if self.halftomo and self.rot_center < self.dwidth:
-            self.sino_mult.prepare_sino(sino)
+            sino = self.sino_mult.prepare_sino(sino)
         self._transfer_to_texture(sino)
         d_slice = self._set_output(output, check=do_checks)
         self._set_kernel_slice_arg(d_slice)

nabu/reconstruction/filtering_cuda.py

@@ -7,7 +7,7 @@ from .filtering import SinoFilter
 
 
 class CudaSinoFilter(SinoFilter):
-    default_extra_options = {**SinoFilter.default_extra_options, **{"fft_backend": "vkfft"}}
+    default_extra_options = {**SinoFilter.default_extra_options, "fft_backend": "vkfft"}
 
     def __init__(
         self,

nabu/reconstruction/hbp.py

@@ -1,3 +1,15 @@
+# Generalized Hierarchical Backprojection (GHBP)
+# for fast tomographic reconstruction from ultra high resolution images at non-negligible fan angles.
+#
+# Authors/Contributions:
+# - Jonas Graetz, Fraunhofer IIS / Universität Würzburg: Algorithm Design and original OpenCL/Python implementation.
+# - Alessandro Mirone, ESRF: CUDA translation, ESRF / BM18 integration, testing <mirone@esrf.fr>
+# - Pierre Paleo, ESRF: ESRF / BM18 integration, testing <pierre.paleo@esrf.fr>
+#
+# JG was funded by the German Federal Ministry of Education and Research (BMBF), grant 05E2019,
+# funding the development of BM18 at ESRF in collaboration with the Fraunhofer Gesellschaft,
+# the Julius-Maximilians-Universität Würzburg, and the University of Passau
+
 import math
 import numpy as np
 
@@ -12,6 +24,7 @@ from .fbp import CudaBackprojector
 
 
 try:
+    # ruff: noqa: F401
     import pycuda.driver as cuda
     from pycuda import gpuarray as garray
 
@@ -138,7 +151,7 @@ class HierarchicalBackprojector(CudaBackprojector):
 
         N = self.slice_shape[1] * fac
 
-        angularRange = abs(self.angles.ptp()) / self.sino_shape[0] * reductionFactor
+        angularRange = abs(np.ptp(self.angles)) / self.sino_shape[0] * reductionFactor
 
         ngrids = int(math.ceil(self.sino_shape[0] / reductionFactor))
 
@@ -331,7 +344,7 @@ class HierarchicalBackprojector(CudaBackprojector):
             )
 
         else:
-            for leg in list(range(0, self.legs)):
+            for leg in list(range(self.legs)):
                 gridOffset = leg * self.grids[0][2]
                 projOffset = gridOffset * self.reductionFactors[0]
                 gws = getGridSize(self.grids[0], lws)
@@ -418,7 +431,7 @@ def get_max_grid_size(grids):
 
 
 def getGridSize(minimum, local):
-    m, l = np.array(minimum), np.array(local)
+    m, l = np.array(minimum), np.array(local)  # noqa: E741
     new = (m // l) * l
     new[new < m] += l[new < m]
     return tuple(map(int, new // l))

nabu/reconstruction/mlem.py

@@ -32,7 +32,6 @@ class MLEMReconstructor:
         n_iterations=50,
         extra_options=None,
     ):
-        """ """
         if not (__have_corrct__):
             raise ImportError("Need corrct package")
         self.angles_rad = angles_rad

nabu/reconstruction/projection.py

@@ -32,7 +32,6 @@ class Projector:
 
         Parameters
         -----------
-
         slice_shape: tuple
             Shape of the slice: (num_rows, num_columns).
         angles: int or sequence
@@ -198,10 +197,9 @@ class Projector:
         if image.dtype != np.dtype("f"):
             raise ValueError("Expected float32 data type, got %s" % str(image.dtype))
         if not isinstance(image, (np.ndarray, garray.GPUArray)):
-            raise ValueError("Expected either numpy.ndarray or pyopencl.array.Array")
-        if isinstance(image, np.ndarray):
-            if not image.flags["C_CONTIGUOUS"]:
-                raise ValueError("Please use C-contiguous arrays")
+            raise TypeError("Expected either numpy.ndarray or pyopencl.array.Array")
+        if isinstance(image, np.ndarray) and not image.flags["C_CONTIGUOUS"]:
+            raise ValueError("Please use C-contiguous arrays")
 
     def set_image(self, image, check=True):
         if check:

nabu/reconstruction/sinogram.py

@@ -290,7 +290,7 @@ def match_half_sinos_parts(sino, angles, output=None):
     """
     n_a = angles.size
     n_a_2 = n_a // 2
-    sino_part1 = sino[:n_a_2, :]
+    # sino_part1 = sino[:n_a_2, :]
     sino_part2 = sino[n_a_2:, :]
     angles = np.rad2deg(angles)  # more numerically stable ?
     angles_1 = angles[:n_a_2]

nabu/reconstruction/sinogram_cuda.py

@@ -212,7 +212,6 @@ class CudaSinoNormalization(SinoNormalization):
         else:
             # This kernel seems to have an issue on arrays that are not C-contiguous.
             # We have to process image per image.
-            nz = np.int32(1)
             nthreadsperblock = (1, 32, 1)  # TODO tune
             nblocks = (1, int(updiv(self.n_angles, nthreadsperblock[1])), 1)
             for i in range(sinos.shape[0]):

nabu/reconstruction/tests/test_cone.py

@@ -1,7 +1,9 @@
+import logging
 import pytest
 import numpy as np
 from scipy.ndimage import gaussian_filter, shift
 from nabu.utils import subdivide_into_overlapping_segment, clip_circle
+from nabu.testutils import __do_long_tests__, generate_tests_scenarios
 
 try:
     import astra
@@ -387,6 +389,77 @@ class TestCone:
                 str(roi)
             )
 
+    def test_fdk_preweight(self, caplog):
+        """
+        Check that nabu's FDK pre-weighting give the same results as astra
+        """
+        shapes = [
+            {"n_z": 256, "n_x": 256, "n_a": 500},
+            # {"n_z": 250, "n_x": 340, "n_a": 250}, # Astra reconstruction is incorrect in this case!
+        ]
+        src_orig_dist = 1000
+        orig_det_dist = 50
+
+        rot_centers_from_middle = [0]
+        if __do_long_tests__:
+            rot_centers_from_middle.extend([10, -15])
+
+        params_list = generate_tests_scenarios({"shape": shapes, "rot_center": rot_centers_from_middle})
+
+        for params in params_list:
+            n_z = params["shape"]["n_z"]
+            n_x = n_y = params["shape"]["n_x"]
+            n_a = params["shape"]["n_a"]
+            rc = params["rot_center"]
+            volume, cone_data = generate_hollow_cube_cone_sinograms(
+                vol_shape=(n_z, n_y, n_x),
+                n_angles=n_a,
+                src_orig_dist=src_orig_dist,
+                orig_det_dist=orig_det_dist,
+                apply_filter=False,
+                rot_center_shift=rc,
+            )
+
+            reconstructor_args = [(n_z, n_a, n_x), src_orig_dist, orig_det_dist]
+            reconstructor_kwargs_base = {
+                "volume_shape": volume.shape,
+                "rot_center": (n_x - 1) / 2 + rc,
+                "cuda_options": {"ctx": self.ctx},
+            }
+            reconstructor_kwargs_astra = {"padding_mode": "zeros", "extra_options": {"use_astra_fdk": True}}
+            reconstructor_kwargs_nabu = {"padding_mode": "zeros", "extra_options": {"use_astra_fdk": False}}
+            reconstructor_astra = ConebeamReconstructor(
+                *reconstructor_args, **{**reconstructor_kwargs_base, **reconstructor_kwargs_astra}
+            )
+            assert reconstructor_astra._use_astra_fdk is True, "reconstructor_astra should use native astra FDK"
+            reconstructor_nabu = ConebeamReconstructor(
+                *reconstructor_args, **{**reconstructor_kwargs_base, **reconstructor_kwargs_nabu}
+            )
+            ref = reconstructor_astra.reconstruct(cone_data)
+            res = reconstructor_nabu.reconstruct(cone_data)
+
+            reconstructor_kwargs_nabu = {"padding_mode": "edges", "extra_options": {"use_astra_fdk": False}}
+            cb_ep = ConebeamReconstructor(
+                *reconstructor_args, **{**reconstructor_kwargs_base, **reconstructor_kwargs_nabu}
+            )
+            res_ep = cb_ep.reconstruct(cone_data)  # noqa: F841
+
+            assert np.max(np.abs(res - ref)) < 2e-3, "Wrong FDK results for parameters: %s" % (str(params))
+
+            # Test with edges padding - only nabu can do that
+            reconstructor_kwargs_nabu["padding_mode"] = "edges"
+            reconstructor_nabu = ConebeamReconstructor(
+                *reconstructor_args, **{**reconstructor_kwargs_base, **reconstructor_kwargs_nabu}
+            )
+            reconstructor_nabu.reconstruct(cone_data)
+            # result is slightly different than "res" in the borders, which is expected
+            # it would be good to test it as well, but it's outside of the scope of this test
+
+            with caplog.at_level(logging.WARNING):
+                reconstructor_kwargs_nabu = {"padding_mode": "edges", "extra_options": {"use_astra_fdk": True}}
+                ConebeamReconstructor(*reconstructor_args, **{**reconstructor_kwargs_base, **reconstructor_kwargs_nabu})
+                assert "cannot use native astra FDK" in caplog.text
+
 
 def generate_hollow_cube_cone_sinograms(
     vol_shape,
@@ -403,13 +476,13 @@ def generate_hollow_cube_cone_sinograms(
     vol_geom = astra.create_vol_geom(n_y, n_x, n_z)
 
     prj_width = prj_width or n_x
-    prj_height = n_z
+    # prj_height = n_z
     angles = np.linspace(0, 2 * np.pi, n_angles, True)
 
-    proj_geom = astra.create_proj_geom("cone", 1.0, 1.0, prj_width, prj_width, angles, src_orig_dist, orig_det_dist)
+    proj_geom = astra.create_proj_geom("cone", 1.0, 1.0, n_z, prj_width, angles, src_orig_dist, orig_det_dist)
     if rot_center_shift is not None:
         proj_geom = astra.geom_postalignment(proj_geom, (-rot_center_shift, 0))
-    magnification = 1 + orig_det_dist / src_orig_dist
+    # magnification = 1 + orig_det_dist / src_orig_dist
 
     # hollow cube
     cube = np.zeros(astra.geom_size(vol_geom), dtype="f")

nabu/reconstruction/tests/test_deringer.py

@@ -139,9 +139,9 @@ class TestDeringer:
     )
     def test_vo_deringer(self):
         deringer = VoDeringer(self.sino.shape)
-        sino_deringed = deringer.remove_rings_sinogram(self.sino)
+        sino_deringed = deringer.remove_rings_sinogram(self.sino)  # noqa: F841
         sinos = np.tile(self.sino, (10, 1, 1))
-        sinos_deringed = deringer.remove_rings_sinograms(sinos)
+        sinos_deringed = deringer.remove_rings_sinograms(sinos)  # noqa: F841
         # TODO check result. The generated test sinogram is "too synthetic" for this kind of deringer
 
     @pytest.mark.skipif(

nabu/reconstruction/tests/test_fbp.py

@@ -262,7 +262,7 @@ class TestFBP:
         # 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)
+        rec = self.apply_fbp(config, B, sino_diff)  # noqa: F841
         # Looks good, but all frequencies are not recovered. Use a metric like SSIM or FRC ?
 
 

nabu/reconstruction/tests/test_halftomo.py

@@ -99,10 +99,36 @@ class TestHalftomo:
         rot_center = sino.shape[-1] - 1 - self.rot_center
         return self.test_halftomo_right_side(config, sino=sino, rot_center=rot_center)
 
+    def test_halftomo_plain_backprojection(self, config):
+        backprojector = self._get_backprojector(
+            config,
+            self.sino.shape,
+            rot_center=self.rot_center,
+            halftomo=True,
+            padding_mode="edges",
+            extra_options={"centered_axis": True},
+        )
+        d_sino_filtered = backprojector.sino_filter.filter_sino(self.sino)  # device array
+        h_sino_filtered = d_sino_filtered.get()
+        reference_fbp = backprojector.fbp(self.sino)
+
+        def _check(rec, array_type):
+            assert (
+                np.max(np.abs(rec - reference_fbp)) < 1e-7
+            ), "Something wrong with halftomo backproj using %s array and configuration %s" % (array_type, str(config))
+
+        # Test with device array
+        rec_from_already_filtered_sino = backprojector.backproj(d_sino_filtered)
+        _check(rec_from_already_filtered_sino, "device")
+
+        # Test with numpy array
+        rec_from_already_filtered_sino = backprojector.backproj(h_sino_filtered)
+        _check(rec_from_already_filtered_sino, "numpy")
+
     def test_halftomo_cor_outside_fov(self, config):
         sino = np.ascontiguousarray(self.sino[:, : self.sino.shape[-1] // 2])
         backprojector = self._get_backprojector(config, sino.shape, rot_center=self.rot_center, halftomo=True)
-        res = backprojector.fbp(sino)
+        res = backprojector.fbp(sino)  # noqa: F841
         # Just check that it runs, but no reference results. Who does this anyway ?!
 
     @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda")

nabu/reconstruction/tests/test_mlem.py

@@ -1,6 +1,6 @@
 import pytest
 import numpy as np
-from nabu.testutils import get_data, __do_long_tests__
+from nabu.testutils import get_data
 
 from nabu.cuda.utils import __has_pycuda__
 from nabu.reconstruction.mlem import MLEMReconstructor, __have_corrct__
@@ -27,7 +27,8 @@ class TestMLEM:
     """These tests test the general MLEM reconstruction algorithm
     and the behavior of the reconstruction with respect to horizontal shifts.
     Only horizontal shifts are tested here because vertical shifts are handled outside
-    the reconstruction object, but in the embedding reconstruction pipeline. See FullFieldReconstructor"""
+    the reconstruction object, but in the embedding reconstruction pipeline. See FullFieldReconstructor
+    """
 
     def _create_MLEM_reconstructor(self, shifts_uv=None):
         return MLEMReconstructor(

nabu/reconstruction/tests/test_projector.py

@@ -3,14 +3,17 @@ import pytest
 from nabu.testutils import get_data
 from nabu.cuda.utils import __has_pycuda__
 
+textures_available = False
 if __has_pycuda__:
     import pycuda.gpuarray as garray
 
     # from pycuda.cumath import fabs
     from pycuda.elementwise import ElementwiseKernel
-    from nabu.cuda.utils import get_cuda_context
+    from nabu.cuda.utils import get_cuda_context, check_textures_availability
     from nabu.reconstruction.projection import Projector
     from nabu.reconstruction.fbp import Backprojector
+
+    textures_available = check_textures_availability()
 try:
     import astra
 
@@ -30,6 +33,7 @@ def bootstrap(request):
         cls.ctx = get_cuda_context()
 
 
+@pytest.mark.skipif(not (textures_available), reason="Textures not supported")
 @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for this test")
 @pytest.mark.usefixtures("bootstrap")
 class TestProjection:
@@ -63,7 +67,8 @@ class TestProjection:
     def test_odd_size(self):
         image = self.image[:511, :]
         P = Projector(image.shape, self.n_angles - 1)
-        res = P(image)
+        res = P(image)  # noqa: F841
+        # TODO check
 
     @pytest.mark.skipif(not (__has_astra__), reason="Need astra-toolbox for this test")
     def test_against_astra(self):

nabu/reconstruction/tests/test_sino_normalization.py

@@ -1,4 +1,3 @@
-import os.path as path
 import numpy as np
 import pytest
 from nabu.testutils import get_data

nabu/resources/dataset_analyzer.py

@@ -311,15 +311,15 @@ class EDFDatasetAnalyzer(DatasetAnalyzer):
         #  (eg. subsampling, binning, distortion correction...)
         # (3) The following spawns one reader instance per file, which is not elegant,
         #   but in principle there are typically 1-2 reduced flats in a scan
-        readers = {k: EDFStackReader([self.raw_flats[k].file_path()], **reader_kwargs) for k in self.raw_flats.keys()}
-        return {k: readers[k].load_data()[0] for k in self.raw_flats.keys()}
+        readers = {k: EDFStackReader([self.raw_flats[k].file_path()], **reader_kwargs) for k in self.raw_flats}
+        return {k: readers[k].load_data()[0] for k in self.raw_flats}
 
     def get_reduced_darks(self, **reader_kwargs):
         # See notes in get_reduced_flats() above
         if self.raw_darks in [None, {}]:
             raise FileNotFoundError("No reduced dark ('darkend.edf' or 'dark.edf') found in %s" % self.location)
-        readers = {k: EDFStackReader([self.raw_darks[k].file_path()], **reader_kwargs) for k in self.raw_darks.keys()}
-        return {k: readers[k].load_data()[0] for k in self.raw_darks.keys()}
+        readers = {k: EDFStackReader([self.raw_darks[k].file_path()], **reader_kwargs) for k in self.raw_darks}
+        return {k: readers[k].load_data()[0] for k in self.raw_darks}
 
     @property
     def files(self):