nabu 2025.1.0.dev12__tar.gz → 2025.1.0.dev14__tar.gz

{nabu-2025.1.0.dev12/nabu.egg-info → nabu-2025.1.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabu
-Version: 2025.1.0.dev12
+Version: 2025.1.0.dev14
 Summary: Nabu - Tomography software
 Author-email: Pierre Paleo <pierre.paleo@esrf.fr>, Henri Payno <henri.payno@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 Maintainer-email: Pierre Paleo <pierre.paleo@esrf.fr>

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2025.1.0-dev12"
+__version__ = "2025.1.0-dev14"
 __nabu_modules__ = [
     "app",
     "cuda",

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/app/cli_configs.py

@@ -162,7 +162,7 @@ MultiCorConfig = ReconstructConfig.copy()
 MultiCorConfig.update(
     {
         "cor": {
-            "help": "Positions of the center of rotation. It must be a list of comma-separated scalars, or in the form start:stop:step, where start, stop and step can all be floating-point values.",
+            "help": "Absolute positions of the center of rotation. It must be a list of comma-separated scalars, or in the form start:stop:step, where start, stop and step can all be floating-point values.",
             "default": "",
             "mandatory": True,
         },

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/app/multicor.py

@@ -59,23 +59,34 @@ def main():
     ######
 
     cors = get_user_cors(args["cor"])
+    options = reconstructor.process_config.processing_options["reconstruction"]
+    reconstruct_from_sinos_stack = (options["method"].lower() == "cone") or (
+        options["method"].lower() == "mlem" and options["implementation"].lower() == "corrct"
+    )
+    do_halftomo = pipeline.process_config.do_halftomo
 
     rec_instance = pipeline.reconstruction
 
+    # Get sinogram
+    if reconstruct_from_sinos_stack:
+        sino = pipeline._d_radios.transpose(axes=(1, 0, 2))
+    else:
+        # Get sinogram into contiguous array
+        # TODO Can't do memcpy2D ?! It used to work in cuda 11.
+        # For now: transfer to host... not optimal
+        sino = pipeline._d_radios[:, pipeline._d_radios.shape[1] // 2, :].get()  # pylint: disable=E1136
+
     for cor in cors:
         # Re-configure with new CoR
         pipeline.processing_options["reconstruction"]["rotation_axis_position"] = cor
         pipeline.processing_options["save"]["file_prefix"] = file_prefix + "_%.03f" % cor
         pipeline._init_writer(create_subfolder=False, single_output_file_initialized=False)
 
-        # Get sinogram into contiguous array
-        # TODO Can't do memcpy2D ?! It used to work in cuda 11.
-        # For now: transfer to host... not optimal
-        sino = pipeline._d_radios[:, pipeline._d_radios.shape[1] // 2, :].get()  # pylint: disable=E1136
-
-        if pipeline.process_config.do_halftomo:
+        # Reconfigure center of rotation
+        if not (do_halftomo):
+            pipeline.reconstruction.reset_rot_center(cor)
+        else:
             # re-initialize FBP object, because in half-tomography the output slice size is a function of CoR
-            options = pipeline.processing_options["reconstruction"]
             rec_instance = pipeline.FBPClass(
                 sino.shape,
                 angles=options["angles"],
@@ -92,11 +103,15 @@ def main():
                     "filter_cutoff": options["fbp_filter_cutoff"],
                 },
             )
-        else:
-            pipeline.reconstruction.reset_rot_center(cor)
 
         # Run reconstruction
-        rec = rec_instance.fbp(sino)
+        if reconstruct_from_sinos_stack:
+            # Need to copy the sino each time, as it is modified by FDK
+            rec = rec_instance.reconstruct(sino.copy())
+            # take the middle slice
+            rec = rec[rec.shape[0] // 2]
+        else:
+            rec = rec_instance.fbp(sino)
         # if return_all_recs:
         # all_recs.append(rec)
         rec_3D = view_as_images_stack(rec)  # writer wants 3D data

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/io/cast_volume.py

@@ -206,6 +206,9 @@ def cast_volume(
         data_min = data_min if data_min is not None else found_data_min
         data_max = data_max if data_max is not None else found_data_max
 
+    if isinstance(output_volume, JP2KVolume):
+        output_volume.rescale_data = False
+
     data = []
     for input_slice, frame_dumper in zip(
         input_volume.browse_slices(),

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/pipeline/fullfield/processconfig.py

@@ -577,6 +577,7 @@ class ProcessConfig(ProcessConfigBase):
                 self.rec_params,
                 [
                     "method",
+                    "iterations",
                     "implementation",
                     "fbp_filter_type",
                     "fbp_filter_cutoff",
@@ -613,8 +614,6 @@ class ProcessConfig(ProcessConfigBase):
                 voxel_size,
             )  # pix size is in microns in dataset_info
 
-            rec_options["iterations"] = nabu_config["reconstruction"]["iterations"]
-
             # x/y/z position information
             def get_mean_pos(position_array):
                 if position_array is None:
@@ -636,6 +635,8 @@ class ProcessConfig(ProcessConfigBase):
                 rec_options["position"] = mean_positions_xyz
             if rec_options["method"] == "cone" and rec_options["sample_detector_dist"] is None:
                 rec_options["sample_detector_dist"] = self.dataset_info.distance  # was checked to be not None earlier
+            if rec_options["method"].lower() == "mlem" and rec_options["implementation"] in [None, ""]:
+                rec_options["implementation"] = "corrct"
 
             # New key
             rec_options["cor_estimated_auto"] = isinstance(nabu_config["reconstruction"]["rotation_axis_position"], str)

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/preproc/tests/test_ctf.py

@@ -223,7 +223,7 @@ class TestCtf:
             # phase_fft = ctf_fft.retrieve_phase(img)
             self.check_result(phase_r2c, self.ref_plain, "Something wrong with CtfFilter-FFT")
 
-    @pytest.mark.skipif(not (__has_pycuda__ and __has_cufft__), reason="pycuda and (scikit-cuda or vkfft)")
+    @pytest.mark.skipif(not (__has_pycuda__ and __has_cufft__), reason="pycuda and (cupy? or vkfft)")
     def test_cuda_ctf(self):
         data = nabu_get_data("brain_phantom.npz")["data"]
         delta_beta = 50.0

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/preproc/tests/test_paganin.py

@@ -77,9 +77,7 @@ class TestPaganin:
         errmax = np.max(np.abs(res - res_tomopy) / np.max(res_tomopy))
         assert errmax < self.rtol_pag, "Max error is too high"
 
-    @pytest.mark.skipif(
-        not (__has_pycuda__ and __has_cufft__), reason="Need pycuda and (scikit-cuda or vkfft) for this test"
-    )
+    @pytest.mark.skipif(not (__has_pycuda__ and __has_cufft__), reason="Need pycuda and (cupy? or vkfft) for this test")
     @pytest.mark.parametrize("config", scenarios)
     def test_gpu_paganin(self, config):
         paganin, data, pag_kwargs = self.get_paganin_instance_and_data(config, self.data)

nabu-2025.1.0.dev14/nabu/processing/fft_cuda.py

@@ -0,0 +1,115 @@
+import os
+import warnings
+from functools import lru_cache
+from multiprocessing import get_context
+from multiprocessing.pool import Pool
+from ..utils import BaseClassError, check_supported, no_decorator
+from .fft_base import _BaseVKFFT
+
+try:
+    from pyvkfft.cuda import VkFFTApp as CudaVkFFTApp
+
+    __has_vkfft__ = True
+except (ImportError, OSError):
+    __has_vkfft__ = False
+    CudaVkFFTApp = BaseClassError
+from ..cuda.processing import CudaProcessing
+
+n_cached_ffts = int(os.getenv("NABU_FFT_CACHE", "0"))
+
+
+maybe_cached = lru_cache(maxsize=n_cached_ffts) if n_cached_ffts > 0 else no_decorator
+
+
+@maybe_cached
+def _get_vkfft_cuda(*args, **kwargs):
+    return CudaVkFFTApp(*args, **kwargs)
+
+
+def get_vkfft_cuda(slf, *args, **kwargs):
+    return _get_vkfft_cuda(*args, **kwargs)
+
+
+class VKCUFFT(_BaseVKFFT):
+    """
+    Cuda FFT, using VKFFT backend
+    """
+
+    implem = "vkfft"
+    backend = "cuda"
+    ProcessingCls = CudaProcessing
+    get_fft_obj = get_vkfft_cuda
+
+    def _init_backend(self, backend_options):
+        super()._init_backend(backend_options)
+        self._vkfft_other_init_kwargs = {"stream": self.processing.stream}
+
+
+def _has_vkfft(x):
+    # should be run from within a Process
+    try:
+        from nabu.processing.fft_cuda import VKCUFFT, __has_vkfft__
+
+        if not __has_vkfft__:
+            return False
+        _ = VKCUFFT((16,), "f")
+        avail = True
+    except (ImportError, RuntimeError, OSError, NameError):
+        avail = False
+    return avail
+
+
+@lru_cache(maxsize=2)
+def has_vkfft(safe=True):
+    """
+    Determine whether pyvkfft is available.
+    For Cuda GPUs, vkfft relies on nvrtc which supports a narrow range of Cuda devices.
+    Unfortunately, it's not possible to determine whether vkfft is available before creating a Cuda context.
+    So we create a process (from scratch, i.e no fork), do the test within, and exit.
+    This function cannot be tested from a notebook/console, a proper entry point has to be created (if __name__ == "__main__").
+    """
+    if not safe:
+        return _has_vkfft(None)
+    try:
+        ctx = get_context("spawn")
+        with Pool(1, context=ctx) as p:
+            v = p.map(_has_vkfft, [1])[0]
+    except AssertionError:
+        # Can get AssertionError: daemonic processes are not allowed to have children
+        # if the calling code is already a subprocess
+        return _has_vkfft(None)
+    return v
+
+
+@lru_cache(maxsize=2)
+def get_fft_class(backend="vkfft"):
+    backends = {
+        "vkfft": VKCUFFT,
+        "pyvkfft": VKCUFFT,
+    }
+
+    def get_fft_cls(asked_fft_backend):
+        asked_fft_backend = asked_fft_backend.lower()
+        check_supported(asked_fft_backend, list(backends.keys()), "Cuda FFT backend name")
+        return backends[asked_fft_backend]
+
+    asked_fft_backend_env = os.environ.get("NABU_FFT_BACKEND", "")
+    if asked_fft_backend_env != "":
+        return get_fft_cls(asked_fft_backend_env)
+
+    avail_fft_implems = get_available_fft_implems()
+    if len(avail_fft_implems) == 0:
+        raise RuntimeError("Could not any Cuda FFT implementation. Please install pyvkfft")
+    if backend not in avail_fft_implems:
+        warnings.warn("Could not get FFT backend '%s'" % backend, RuntimeWarning)
+        backend = avail_fft_implems[0]
+
+    return get_fft_cls(backend)
+
+
+@lru_cache(maxsize=1)
+def get_available_fft_implems():
+    avail_implems = []
+    if has_vkfft(safe=True):
+        avail_implems.append("vkfft")
+    return avail_implems

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/processing/tests/test_fft.py

@@ -4,14 +4,13 @@ import numpy as np
 from scipy.fft import fftn, ifftn, rfftn, irfftn
 from nabu.testutils import generate_tests_scenarios, get_data, get_array_of_given_shape, __do_long_tests__
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
-from nabu.processing.fft_cuda import SKCUFFT, VKCUFFT, get_available_fft_implems
+from nabu.processing.fft_cuda import VKCUFFT, get_available_fft_implems
 from nabu.opencl.utils import __has_pyopencl__, get_opencl_context
 from nabu.processing.fft_opencl import VKCLFFT, has_vkfft as has_cl_vkfft
 from nabu.processing.fft_base import is_fast_axes
 
 available_cuda_fft = get_available_fft_implems()
 __has_vkfft__ = "vkfft" in available_cuda_fft
-__has_skcuda__ = "skcuda" in available_cuda_fft
 
 
 scenarios = {
@@ -113,67 +112,6 @@ class TestFFT:
         ref = ref_ifft_func(data, axes=axes)
         return ref
 
-    @pytest.mark.skipif(
-        not (__has_skcuda__ and __has_pycuda__), reason="Need pycuda and (scikit-cuda or vkfft) for this test"
-    )
-    @pytest.mark.parametrize("config", scenarios)
-    def test_sckcuda(self, config):
-        r2c = config["r2c"]
-        shape = config["shape"]
-        precision = config["precision"]
-        ndim = len(shape)
-        if ndim == 3 and not (__do_long_tests__):
-            pytest.skip("3D FFTs are done only for long tests - use NABU_LONG_TESTS=1")
-
-        data = self._get_data_array(config)
-
-        res, cufft = self._do_fft(data, r2c, return_fft_obj=True, backend_cls=SKCUFFT)
-        ref = self._do_reference_fft(data, r2c)
-
-        tol = self.abs_tol[precision][ndim]
-        self.check_result(res, ref, config, tol, name="skcuda")
-
-        # Complex-to-complex can also be performed on real data (as in numpy.fft.fft(real_data))
-        if not (r2c):
-            res = self._do_fft(data, False, backend_cls=SKCUFFT)
-            ref = self._do_reference_fft(data, False)
-            self.check_result(res, ref, config, tol, name="skcuda")
-
-        # IFFT
-        res = cufft.ifft(cufft.output_fft).get()
-        self.check_result(res, data, config, tol, name="skcuda")
-        # Perhaps we should also check against numpy/scipy ifft,
-        # but it does not yield the good shape for R2C on odd-sized data
-
-    @pytest.mark.skipif(
-        not (__has_skcuda__ and __has_pycuda__), reason="Need pycuda and (scikit-cuda or vkfft) for this test"
-    )
-    @pytest.mark.parametrize("config", scenarios)
-    def test_skcuda_batched(self, config):
-        shape = config["shape"]
-        if len(shape) == 1:
-            return
-        elif len(shape) == 3 and not (__do_long_tests__):
-            pytest.skip("3D FFTs are done only for long tests - use NABU_LONG_TESTS=1")
-        r2c = config["r2c"]
-        tol = self.abs_tol[config["precision"]][len(shape)]
-
-        data = self._get_data_array(config)
-
-        if data.ndim == 2:
-            axes_to_test = [(0,), (1,)]
-        elif data.ndim == 3:
-            # axes_to_test = [(1, 2), (2, 1), (2,)] # See fft.py: works for C2C but not R2C ?
-            axes_to_test = [(2,)]
-
-        for axes in axes_to_test:
-            res, cufft = self._do_fft(data, r2c, axes=axes, return_fft_obj=True, backend_cls=SKCUFFT)
-            ref = self._do_reference_fft(data, r2c, axes=axes)
-            self.check_result(res, ref, config, tol, name="skcuda batched axes=%s" % (str(axes)))
-            # IFFT
-            res = cufft.ifft(cufft.output_fft).get()
-            self.check_result(res, data, config, tol, name="skcuda")
-
     @pytest.mark.parametrize("config", scenarios)
     def test_vkfft(self, config):
         backend = config["backend"]

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/reconstruction/cone.py

@@ -292,6 +292,11 @@ class ConebeamReconstructor:
         # 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 reset_rot_center(self, rot_center):
+        self.rot_center = rot_center
+        self._cor_shift = (self.sinos_shape[-1] - 1) / 2.0 - rot_center
+        self._create_astra_proj_geometry(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

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/reconstruction/mlem.py

@@ -57,7 +57,7 @@ class MLEMReconstructor:
 
     def _set_shifts(self, shifts_uv, cor):
         if shifts_uv is None:
-            self.shifts_uv = np.zeros([self.n_angles, 2])
+            self.shifts_uv = None
         else:
             if shifts_uv.shape[0] != self.n_angles:
                 raise ValueError(
@@ -66,6 +66,9 @@ class MLEMReconstructor:
             self.shifts_uv = shifts_uv.copy()
         self.cor = cor
 
+    def reset_rot_center(self, cor):
+        self.cor = cor - (self.sinos_shape[-1] - 1) // 2
+
     def reconstruct(self, data_vwu):
         """
         data_align_vwu: numpy.ndarray or pycuda.gpuarray
@@ -79,10 +82,13 @@ class MLEMReconstructor:
 
         # MLEM recons
         self.vol_geom_align = cct.models.VolumeGeometry.get_default_from_data(data_vwu)
-        self.prj_geom_align = cct.models.ProjectionGeometry.get_default_parallel()
-        # Vertical shifts were handled in pipeline. Set them to ZERO
-        self.shifts_uv[:, 1] = 0.0
-        self.prj_geom_align.set_detector_shifts_vu(self.shifts_uv.T[::-1])
+        if self.shifts_uv is not None:
+            self.prj_geom_align = cct.models.ProjectionGeometry.get_default_parallel()
+            # Vertical shifts were handled in pipeline. Set them to ZERO
+            self.shifts_uv[:, 1] = 0.0
+            self.prj_geom_align.set_detector_shifts_vu(self.shifts_uv.T[::-1])
+        else:
+            self.prj_geom_align = None
 
         variances_align = cct.processing.compute_variance_poisson(data_vwu)
         self.weights_align = cct.processing.compute_variance_weight(variances_align, normalized=True)  # , use_std=True

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/reconstruction/tests/test_deringer.py

@@ -38,7 +38,7 @@ if __do_long_tests__:
             "sigma": [1.0, 2.0],
             "wname": ["db15", "haar", "rbio4.4"],
             "padding": [None, (100, 100), (50, 71)],
-            "fft_implem": ["skcuda", "vkfft"],
+            "fft_implem": ["vkfft"],
         }
     )
 
@@ -107,7 +107,7 @@ class TestDeringer:
 
     @pytest.mark.skipif(
         not (__has_cuda_deringer__) or munchetal_filter is None,
-        reason="Need pycuda, pycudwt and (scikit-cuda or pyvkfft) for this test",
+        reason="Need pycuda, pycudwt and (cupy? or pyvkfft) for this test",
     )
     @pytest.mark.parametrize("config", fw_scenarios)
     def test_cuda_munch_deringer(self, config):

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/reconstruction/tests/test_fbp.py

@@ -7,10 +7,10 @@ from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import get_opencl_context, __has_pyopencl__
 
-from nabu.processing.fft_cuda import has_skcuda, has_vkfft as has_vkfft_cu
+from nabu.processing.fft_cuda import has_vkfft as has_vkfft_cu
 from nabu.processing.fft_opencl import has_vkfft as has_vkfft_cl
 
-__has_pycuda__ = __has_pycuda__ and (has_skcuda() or has_vkfft_cu())
+__has_pycuda__ = __has_pycuda__ and has_vkfft_cu()
 __has_pyopencl__ = __has_pyopencl__ and has_vkfft_cl()
 
 if __has_pycuda__:
@@ -62,7 +62,7 @@ class TestFBP:
     def _get_backprojector(self, config, *bp_args, **bp_kwargs):
         if config["backend"] == "cuda":
             if not (__has_pycuda__):
-                pytest.skip("Need pycuda + (scikit-cuda or pyvkfft)")
+                pytest.skip("Need pycuda + (cupy? or pyvkfft)")
             Backprojector = CudaBackprojector
             ctx = self.cuda_ctx
         else:

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/reconstruction/tests/test_halftomo.py

@@ -42,7 +42,7 @@ 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 or vkfft")
+                pytest.skip("Need pycuda + cupy? or vkfft")
             Backprojector = CudaBackprojector
             ctx = self.cuda_ctx
         else:

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu/reconstruction/tests/test_reconstructor.py

@@ -48,7 +48,7 @@ def bootstrap(request):
 )
 @pytest.mark.usefixtures("bootstrap")
 class TestReconstructor:
-    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and (scikit-cuda or vkfft)")
+    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and (cupy? or vkfft)")
     @pytest.mark.parametrize("config", scenarios)
     def test_cuda_reconstructor(self, config):
         data = self.projs

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14/nabu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabu
-Version: 2025.1.0.dev12
+Version: 2025.1.0.dev14
 Summary: Nabu - Tomography software
 Author-email: Pierre Paleo <pierre.paleo@esrf.fr>, Henri Payno <henri.payno@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 Maintainer-email: Pierre Paleo <pierre.paleo@esrf.fr>

{nabu-2025.1.0.dev12 → nabu-2025.1.0.dev14}/nabu.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 pyproject.toml
 doc/conf.py
 doc/create_conf_doc.py
-doc/doc_config.py
 doc/get_mathjax.py
 nabu/__init__.py
 nabu/tests.py
@@ -232,7 +231,6 @@ nabu/processing/tests/test_rotation.py
 nabu/processing/tests/test_transpose.py
 nabu/processing/tests/test_unsharp.py
 nabu/reconstruction/__init__.py
-nabu/reconstruction/astra.py
 nabu/reconstruction/cone.py
 nabu/reconstruction/fbp.py
 nabu/reconstruction/fbp_base.py

nabu-2025.1.0.dev12/doc/doc_config.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-from nabu.resources.nabu_config import nabu_config
-
-
-def generate(file_):
-    def write(content):
-        print(content, file=file_)
-    for section, values in nabu_config.items():
-        if section == "about":
-            continue
-        write("## %s\n" % section)
-        for key, val in values.items():
-            if val["type"] == "unsupported":
-                continue
-            write(val["help"] + "\n")
-            write(
-                "```ini\n%s = %s\n```"
-                % (key, val["default"])
-            )
-
-
-
-if __name__ == "__main__":
-
-    import sys, os
-    print(os.path.abspath(__file__))
-    exit(0)
-
-    fname = "/tmp/test.md"
-    with open(fname, "w") as f:
-        generate(f)