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

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

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

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

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

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

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