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

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

@@ -0,0 +1,100 @@
+import numpy as np
+import pytest
+from nabu.testutils import get_data, generate_tests_scenarios, compare_shifted_images
+from nabu.cuda.utils import get_cuda_context, __has_pycuda__, __has_cufft__
+from nabu.opencl.utils import get_opencl_context, __has_pyopencl__
+from nabu.thirdparty.algotom_convert_sino import extend_sinogram
+
+__has_pycuda__ = __has_pycuda__ and __has_cufft__  # need both for using Cuda backprojector
+
+
+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"]})
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    file_desc = get_data("sino_halftomo.npz")
+    cls.sino = file_desc["sinogram"] * 1e4
+    cls.rot_center = file_desc["rot_center"]
+    cls.tol = 5e-3
+    if __has_pycuda__:
+        cls.cuda_ctx = get_cuda_context()
+    if __has_pyopencl__:
+        cls.opencl_ctx = get_opencl_context("all")
+
+
+@pytest.mark.usefixtures("bootstrap")
+@pytest.mark.parametrize("config", scenarios)
+class TestHalftomo:
+    def _get_backprojector(self, config, *bp_args, **bp_kwargs):
+        if config["backend"] == "cuda":
+            if not (__has_pycuda__):
+                pytest.skip("Need pycuda + scikit-cuda")
+            Backprojector = CudaBackprojector
+            ctx = self.cuda_ctx
+        else:
+            if not (__has_pyopencl__):
+                pytest.skip("Need pyopencl")
+            Backprojector = OpenCLBackprojector
+            ctx = self.opencl_ctx
+            if config.get("opencl_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})
+
+    def test_halftomo_right_side(self, config, sino=None, rot_center=None):
+        if sino is None:
+            sino = self.sino
+        if rot_center is None:
+            rot_center = self.rot_center
+
+        sino_extended, rot_center_ext = extend_sinogram(sino, rot_center, apply_log=False)
+        sino_extended *= 2  # compat. with nabu normalization
+
+        backprojector_extended = self._get_backprojector(
+            config,
+            sino_extended.shape,
+            rot_center=rot_center_ext,
+            halftomo=False,
+            padding_mode="edges",
+            angles=np.linspace(0, 2 * np.pi, sino.shape[0], True),
+            extra_options={"centered_axis": True},
+        )
+        ref = backprojector_extended.fbp(sino_extended)
+
+        backprojector = self._get_backprojector(
+            config,
+            sino.shape,
+            rot_center=rot_center,
+            halftomo=True,
+            padding_mode="edges",
+            extra_options={"centered_axis": True},
+        )
+        res = backprojector.fbp(sino)
+
+        # The approach in algotom (used as reference) slightly differers:
+        #   - altogom extends the sinogram with padding, so that it's ready-to-use for FBP
+        #   - nabu filters the sinogram first, and then does the "half-tomo preparation".
+        #     Filtering the sinogram first is better to avoid artefacts due to sharp transition in the borders
+        metric, upper_bound = compare_shifted_images(res, ref, return_upper_bound=True)
+        assert metric < 5, "Something wrong for halftomo with backend %s" % (config["backend"])
+
+    def test_halftomo_left_side(self, config):
+        sino = np.ascontiguousarray(self.sino[:, ::-1])
+        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_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)
+        # Just check that it runs, but no reference results. Who does this anyway ?!

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

@@ -0,0 +1,164 @@
+import numpy as np
+import pytest
+from nabu.testutils import get_data
+from nabu.cuda.utils import __has_pycuda__
+
+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.reconstruction.projection import Projector
+    from nabu.reconstruction.fbp import Backprojector
+try:
+    import astra
+
+    __has_astra__ = True
+except ImportError:
+    __has_astra__ = False
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.image = get_data("brain_phantom.npz")["data"]
+    cls.sino_ref = get_data("mri_sino500.npz")["data"]
+    cls.n_angles, cls.dwidth = cls.sino_ref.shape
+    cls.rtol = 1e-3
+    if __has_pycuda__:
+        cls.ctx = get_cuda_context()
+
+
+@pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for this test")
+@pytest.mark.usefixtures("bootstrap")
+class TestProjection:
+    def check_result(self, img1, img2, err_msg):
+        max_diff = np.max(np.abs(img1 - img2))
+        assert max_diff / img1.max() < self.rtol, err_msg + " : max diff = %.3e" % max_diff
+
+    def test_proj_simple(self):
+        P = Projector(self.image.shape, self.n_angles)
+        res = P(self.image)
+        self.check_result(res, self.sino_ref, "Something wrong with simple projection")
+
+    def test_input_output_kinds(self):
+        P = Projector(self.image.shape, self.n_angles)
+
+        # input on GPU, output on CPU
+        d_img = garray.to_gpu(self.image)
+        res = P(d_img)
+        self.check_result(res, self.sino_ref, "Something wrong: input GPU, output CPU")
+
+        # input on CPU, output on GPU
+        out = garray.zeros(P.sino_shape, "f")
+        res = P(self.image, output=out)
+        self.check_result(out.get(), self.sino_ref, "Something wrong: input CPU, output GPU")
+
+        # input and output on GPU
+        out.fill(0)
+        P(d_img, output=out)
+        self.check_result(out.get(), self.sino_ref, "Something wrong: input GPU, output GPU")
+
+    def test_odd_size(self):
+        image = self.image[:511, :]
+        P = Projector(image.shape, self.n_angles - 1)
+        res = P(image)
+
+    @pytest.mark.skipif(not (__has_astra__), reason="Need astra-toolbox for this test")
+    def test_against_astra(self):
+        def proj_astra(img, angles, rot_center=None):
+            vol_geom = astra.create_vol_geom(img.shape)
+            if np.isscalar(angles):
+                angles = np.linspace(0, np.pi, angles, False)
+            proj_geom = astra.create_proj_geom("parallel", 1.0, img.shape[-1], angles)
+            if rot_center is not None:
+                cor_shift = (img.shape[-1] - 1) / 2.0 - rot_center
+                proj_geom = astra.geom_postalignment(proj_geom, cor_shift)
+
+            projector_id = astra.create_projector("cuda", proj_geom, vol_geom)
+            sinogram_id, sinogram = astra.create_sino(img, projector_id)
+
+            astra.data2d.delete(sinogram_id)
+            astra.projector.delete(projector_id)
+            return sinogram
+
+        # Center of rotation to test
+        cors = [None, 255.5, 256, 260, 270.2, 300, 150]
+
+        for cor in cors:
+            res_astra = proj_astra(self.image, 500, rot_center=cor)
+            res_nabu = Projector(self.image.shape, 500, rot_center=cor).projection(self.image)
+            self.check_result(res_nabu, res_astra, "Projection with CoR = %s" % str(cor))
+
+    @pytest.mark.skipif(not (__has_astra__), reason="Need astra-toolbox for this test")
+    def test_em_reconstruction(self):
+        """
+        Test iterative reconstruction: Maximum Likelyhood Expectation Maximization (MLEM)
+        """
+
+        subsampling = 5
+        sino = self.sino_ref[::subsampling, :]
+
+        P = Projector(self.image.shape, sino.shape[0])
+        B = Backprojector(sino.shape, padding_mode="edge", extra_options={"centered_axis": True})
+
+        d_sino = garray.to_gpu(np.ascontiguousarray(sino))
+
+        def EM(sino, P, B, n_it, eps=1e-6):
+            ones = np.ones(sino.shape, "f")
+            oinv = garray.to_gpu((1.0 / B.backproj(ones)).astype("f"))
+            x = garray.ones_like(oinv)
+            y = garray.zeros_like(x)
+            proj = garray.zeros_like(sino)
+            proj_inv = sino.copy()
+
+            update_projection = ElementwiseKernel(
+                "float* proj_inv, float* proj, float* proj_data, float eps",
+                "proj_inv[i] = proj_data[i] / ((fabsf(proj[i]) > eps) ? (proj[i]) : (1.0f))",
+                "update_projection",
+            )
+            for k in range(n_it):
+                # proj = P(x)
+                P.projection(x, output=proj)
+
+                update_projection(proj_inv, proj, sino, eps)
+
+                # x *= B(proj_inv) * oinv
+                B.backproj(proj_inv, output=y)
+                x *= y
+                x *= oinv
+            return x
+
+        rec = EM(d_sino, P, B, 50)
+
+        def EM_astra(sino, rec_shape, n_it):
+            vol_geom = astra.create_vol_geom(rec_shape)
+            proj_geom = astra.create_proj_geom(
+                "parallel", 1.0, sino.shape[-1], np.linspace(0, np.pi, sino.shape[0], False)
+            )
+
+            rec_id = astra.data2d.create("-vol", vol_geom)
+            sinogram_id = astra.data2d.create("-sino", proj_geom)
+            astra.data2d.store(sinogram_id, sino)
+            astra.data2d.store(rec_id, np.ones(rec_shape, "f"))  # !
+
+            cfg = astra.astra_dict("EM_CUDA")
+            cfg["ReconstructionDataId"] = rec_id
+            cfg["ProjectionDataId"] = sinogram_id
+
+            alg_id = astra.algorithm.create(cfg)
+            astra.algorithm.run(alg_id, n_it)
+
+            rec = astra.data2d.get(rec_id)
+
+            astra.algorithm.delete(alg_id)
+            astra.data2d.delete(rec_id)
+            astra.data2d.delete(sinogram_id)
+
+            return rec
+
+        ref = EM_astra(sino, self.image.shape, 50)
+
+        err_max = np.max(np.abs(rec.get() - ref))
+        assert err_max < 0.2, "Discrepancy between EM and EM_astra"

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

@@ -0,0 +1,93 @@
+import numpy as np
+import pytest
+from nabu.testutils import (
+    get_big_data,
+    __big_testdata_dir__,
+    compare_arrays,
+    generate_tests_scenarios,
+    __do_long_tests__,
+)
+from nabu.cuda.utils import __has_pycuda__, __has_cufft__, get_cuda_context
+
+__has_cuda_fbp__ = __has_cufft__ and __has_pycuda__
+if __has_cuda_fbp__:
+    from nabu.reconstruction.reconstructor_cuda import CudaReconstructor
+    from nabu.reconstruction.fbp import Backprojector as CudaBackprojector
+    import pycuda.gpuarray as garray
+
+
+scenarios = generate_tests_scenarios(
+    {
+        "axis": ["z", "y", "x"],
+        "vol_type": ["sinograms", "projections"],
+        "indices": [(300, 310)],  # reconstruct 10 slices
+        "slices_roi": [None, (None, None, 200, 400), (250, 300, None, None), (120, 330, 301, 512)],
+    }
+)
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.projs = get_big_data("MRI512_projs.npy")
+    if __has_cuda_fbp__:
+        cls.ctx = get_cuda_context()
+        cls.d_projs = garray.to_gpu(cls.projs)
+    cls.ref = None
+    cls.tol = 5e-2
+
+
+@pytest.mark.skipif(
+    __big_testdata_dir__ is None or not (__do_long_tests__),
+    reason="need environment variable NABU_BIGDATA_DIR and NABU_LONG_TESTS=1",
+)
+@pytest.mark.usefixtures("bootstrap")
+class TestReconstructor:
+    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and scikit-cuda")
+    @pytest.mark.parametrize("config", scenarios)
+    def test_cuda_reconstructor(self, config):
+        data = self.projs
+        d_data = self.d_projs
+        if config["vol_type"] == "sinograms":
+            data = np.moveaxis(self.projs, 1, 0)
+            d_data = self.d_projs.transpose(axes=(1, 0, 2))  # view
+        reconstructor = CudaReconstructor(
+            data.shape,
+            config["indices"],
+            axis=config["axis"],
+            vol_type=config["vol_type"],
+            slices_roi=config["slices_roi"],
+        )
+        res = reconstructor.reconstruct(d_data)
+        ref = self.get_ref()
+        ref = self.crop_array(ref, config)
+        err_max = np.max(np.abs(res - ref))
+        assert err_max < self.tol, "something wrong with reconstructor, config = %s" % str(config)
+
+    def get_ref(self):
+        if self.ref is not None:
+            return self.ref
+        if __has_cuda_fbp__:
+            fbp_cls = CudaBackprojector
+        ref = np.zeros((512, 512, 512), "f")
+        fbp = fbp_cls((self.projs.shape[0], self.projs.shape[-1]))
+        for i in range(512):
+            ref[i] = fbp.fbp(self.d_projs[:, i, :])
+        self.ref = ref
+        return self.ref
+
+    @staticmethod
+    def crop_array(arr, config):
+        indices = config["indices"]
+        axis = config["axis"]
+        slices_roi = config["slices_roi"] or (None, None, None, None)
+        i_slice = slice(*indices)
+        u_slice = slice(*slices_roi[:2])
+        v_slice = slice(*slices_roi[-2:])
+        if axis == "z":
+            z_slice, y_slice, x_slice = i_slice, v_slice, u_slice
+        if axis == "y":
+            z_slice, y_slice, x_slice = v_slice, i_slice, u_slice
+        if axis == "x":
+            z_slice, y_slice, x_slice = v_slice, u_slice, i_slice
+        return arr[z_slice, y_slice, x_slice]

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

@@ -0,0 +1,85 @@
+import os.path as path
+import numpy as np
+import pytest
+from nabu.testutils import get_data
+from nabu.cuda.utils import __has_pycuda__
+from nabu.reconstruction.sinogram import SinoNormalization
+
+if __has_pycuda__:
+    from nabu.reconstruction.sinogram_cuda import CudaSinoNormalization
+    import pycuda.gpuarray as garray
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.sino = get_data("sino_refill.npy")
+    cls.tol = 1e-7
+    cls.norm_array_1D = np.arange(cls.sino.shape[-1]) + 1
+    cls.norm_array_2D = np.arange(cls.sino.size).reshape(cls.sino.shape) + 1
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestSinoNormalization:
+    def test_sino_normalization(self):
+        sino_proc = SinoNormalization(kind="chebyshev", sinos_shape=self.sino.shape)
+        sino = self.sino.copy()
+        sino_proc.normalize(sino)
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for sinogram normalization with cuda backend")
+    def test_sino_normalization_cuda(self):
+        sino_proc = SinoNormalization(kind="chebyshev", sinos_shape=self.sino.shape)
+        sino = self.sino.copy()
+        ref = sino_proc.normalize(sino)
+
+        cuda_sino_proc = CudaSinoNormalization(kind="chebyshev", sinos_shape=self.sino.shape)
+        d_sino = garray.to_gpu(self.sino)
+        cuda_sino_proc.normalize(d_sino)
+        res = d_sino.get()
+
+        assert np.max(np.abs(res - ref)) < self.tol
+
+    def get_normalization_reference_result(self, op, normalization_arr):
+        # Perform explicit operations to compare with numpy.divide, numpy.subtract, etc
+        if op == "subtraction":
+            ref = self.sino - normalization_arr
+        elif op == "division":
+            ref = self.sino / normalization_arr
+        return ref
+
+    def test_sino_array_subtraction_and_division(self):
+        with pytest.raises(ValueError):
+            SinoNormalization(kind="subtraction", sinos_shape=self.sino.shape)
+
+        def compare_normalizations(normalization_arr, op):
+            sino_normalization = SinoNormalization(
+                kind=op, sinos_shape=self.sino.shape, normalization_array=normalization_arr
+            )
+            sino = self.sino.copy()
+            sino_normalization.normalize(sino)
+            ref = self.get_normalization_reference_result(op, normalization_arr)
+            assert np.allclose(sino, ref), "operation=%s, normalization_array dims=%d" % (op, normalization_arr.ndim)
+
+        compare_normalizations(self.norm_array_1D, "subtraction")
+        compare_normalizations(self.norm_array_1D, "division")
+        compare_normalizations(self.norm_array_2D, "subtraction")
+        compare_normalizations(self.norm_array_2D, "division")
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for sinogram normalization with cuda backend")
+    def test_sino_array_subtraction_cuda(self):
+        with pytest.raises(ValueError):
+            CudaSinoNormalization(kind="subtraction", sinos_shape=self.sino.shape)
+
+        def compare_normalizations(normalization_arr, op):
+            sino_normalization = CudaSinoNormalization(
+                kind=op, sinos_shape=self.sino.shape, normalization_array=normalization_arr
+            )
+            sino = garray.to_gpu(self.sino)
+            sino_normalization.normalize(sino)
+            ref = self.get_normalization_reference_result(op, normalization_arr)
+            assert np.allclose(sino.get(), ref)
+
+        compare_normalizations(self.norm_array_1D, "subtraction")
+        compare_normalizations(self.norm_array_2D, "subtraction")
+        compare_normalizations(self.norm_array_1D, "division")
+        compare_normalizations(self.norm_array_2D, "division")

build/lib/build/lib/nabu/resources/cor.py

@@ -0,0 +1,5 @@
+from ..pipeline.estimators import CORFinder as ECorFinder
+
+# This class has moved
+# The future location will be nabu.pipeline.estimators.CORFinder
+CORFinder = ECorFinder