nabu 2024.2.4__py3-none-any.whl → 2024.2.6__py3-none-any.whl

doc/doc_config.py

@@ -0,0 +1,32 @@
+#!/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)

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.2.4"
+__version__ = "2024.2.6"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/cuda/src/cone.cu

@@ -26,23 +26,33 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
-static const unsigned int g_anglesPerWeightBlock = 16;
-static const unsigned int g_detBlockU = 32;
-static const unsigned int g_detBlockV = 32;
+// static const unsigned int g_anglesPerWeightBlock = 16;
+// static const unsigned int g_detBlockU = 32;
+// static const unsigned int g_detBlockV = 32;
 
 
 __global__ void devFDK_preweight(void* D_projData, unsigned int projPitch, unsigned int startAngle, unsigned int endAngle, float fSrcOrigin, float fDetOrigin, float fZShift, float fDetUSize, float fDetVSize, unsigned int iProjAngles, unsigned int iProjU, unsigned int iProjV)
 {
     float* projData = (float*)D_projData;
-    int angle = startAngle + blockIdx.y * g_anglesPerWeightBlock + threadIdx.y;
+
+    const uint angle = blockDim.y * blockIdx.y + threadIdx.y + startAngle;
+
     if (angle >= endAngle)
         return;
 
-    const int detectorU = (blockIdx.x%((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockU + threadIdx.x;
-    const int startDetectorV = (blockIdx.x/((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockV;
-    int endDetectorV = startDetectorV + g_detBlockV;
-    if (endDetectorV > iProjV)
-        endDetectorV = iProjV;
+    // Astra FDK kernel used this indexing (with the appropriate grid)
+    // const int detectorU = (blockIdx.x%((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockU + threadIdx.x;
+    // const int startDetectorV = (blockIdx.x/((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockV;
+    // Instead we choose a simpler scheme which does not assume pitch memory allocation
+
+    const uint detectorU = blockDim.x * blockIdx.x + threadIdx.x;
+    const int startDetectorV = 0;
+
+    int endDetectorV = iProjV; // startDetectorV + g_detBlockV;
+    // if (endDetectorV > iProjV)
+        // endDetectorV = iProjV;
+    if (detectorU >= iProjU) return;
+
 
     // We need the length of the central ray and the length of the ray(s) to
     // our detector pixel(s).

nabu/pipeline/fullfield/reconstruction.py

@@ -131,8 +131,12 @@ class FullFieldReconstructor:
         self.resources["gpus"] = avail_gpus
         if len(avail_gpus) == 0:
             return
-        # pick first GPU by default. TODO: handle user's nabu_config["resources"]["gpu_id"]
-        self.resources["gpu_id"] = self._gpu_id = list(avail_gpus.keys())[0]
+        user_gpus = self.process_config.nabu_config.get("resources", {}).get("gpu_id", [])
+        if len(user_gpus) == 0:
+            user_gpus = [0]
+        # For now nabu does not support multi-GPU reconstruction. Take the first one.
+        user_gpu_idx = user_gpus[0]
+        self.resources["gpu_id"] = self._gpu_id = list(avail_gpus.keys())[user_gpu_idx]
 
     def _get_backend(self, backend, cuda_options):
         self._pipeline_cls = ChunkedPipeline
@@ -145,6 +149,7 @@ class FullFieldReconstructor:
                 backend = "numpy"
             else:
                 self.gpu_mem = self.resources["gpus"][self._gpu_id]["memory_GB"] * self.gpu_mem_fraction
+                self.cuda_options = {"device_id": self._gpu_id}
         if backend == "cuda":
             if not (__has_pycuda__):
                 raise RuntimeError("pycuda not avilable")

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/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,
@@ -406,7 +479,7 @@ def generate_hollow_cube_cone_sinograms(
     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

nabu/resources/dataset_analyzer.py

@@ -2,8 +2,10 @@ import os
 import numpy as np
 from silx.io.url import DataUrl
 from silx.io import get_data
+from tomoscan import __version__ as __tomoscan_version__
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
+from packaging.version import parse as parse_version
 
 from ..utils import check_supported, indices_to_slices
 from ..io.reader import EDFStackReader, NXDarksFlats, NXTomoReader
@@ -143,7 +145,10 @@ class DatasetAnalyzer:
         Return the sample-detector distance in meters.
         """
         if self._distance is None:
-            self._distance = abs(self.dataset_scanner.distance)
+            if parse_version(__tomoscan_version__) < parse_version("2.0"):
+                self._distance = abs(self.dataset_scanner.distance)
+            else:
+                self._distance = abs(self.dataset_scanner.sample_detector_distance)
         return self._distance
 
     @distance.setter

nabu/stitching/utils/utils.py

@@ -1,4 +1,4 @@
-from distutils.version import StrictVersion
+from packaging.version import parse as parse_version
 from typing import Optional, Union
 import logging
 import functools
@@ -523,7 +523,7 @@ def find_shift_with_itk(img1: numpy.ndarray, img2: numpy.ndarray) -> tuple:
         _logger.warning("itk is not installed. Please install it to find shift with it")
         return (0, 0)
 
-    if StrictVersion(itk.Version.GetITKVersion()) < StrictVersion("4.9.0"):
+    if parse_version(itk.Version.GetITKVersion()) < parse_version("4.9.0"):
         _logger.error("ITK 4.9.0 is required to find shift with it.")
         return (0, 0)
 

{nabu-2024.2.4.dist-info → nabu-2024.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: nabu
-Version: 2024.2.4
+Version: 2024.2.6
 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>
@@ -49,35 +49,35 @@ Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy <2,>1.9.0
+Requires-Dist: numpy<2,>1.9.0
 Requires-Dist: scipy
-Requires-Dist: h5py >=3.0
-Requires-Dist: silx >=0.15.0
-Requires-Dist: tomoscan >=2.1.0
+Requires-Dist: h5py>=3.0
+Requires-Dist: silx>=0.15.0
+Requires-Dist: tomoscan>=2.1.0
 Requires-Dist: psutil
 Requires-Dist: pytest
 Requires-Dist: tifffile
 Requires-Dist: tqdm
-Provides-Extra: doc
-Requires-Dist: sphinx ; extra == 'doc'
-Requires-Dist: cloud-sptheme ; extra == 'doc'
-Requires-Dist: myst-parser ; extra == 'doc'
-Requires-Dist: nbsphinx ; extra == 'doc'
 Provides-Extra: full
-Requires-Dist: scikit-image ; extra == 'full'
-Requires-Dist: PyWavelets ; extra == 'full'
-Requires-Dist: glymur ; extra == 'full'
-Requires-Dist: pycuda !=2024.1.1 ; extra == 'full'
-Requires-Dist: scikit-cuda ; extra == 'full'
-Requires-Dist: pycudwt ; extra == 'full'
-Requires-Dist: sluurp >=0.3 ; extra == 'full'
-Requires-Dist: pyvkfft ; extra == 'full'
-Provides-Extra: full_nocuda
-Requires-Dist: scikit-image ; extra == 'full_nocuda'
-Requires-Dist: PyWavelets ; extra == 'full_nocuda'
-Requires-Dist: glymur ; extra == 'full_nocuda'
-Requires-Dist: sluurp >=0.3 ; extra == 'full_nocuda'
-Requires-Dist: pyvkfft ; extra == 'full_nocuda'
+Requires-Dist: scikit-image; extra == "full"
+Requires-Dist: PyWavelets; extra == "full"
+Requires-Dist: glymur; extra == "full"
+Requires-Dist: pycuda!=2024.1.1; extra == "full"
+Requires-Dist: scikit-cuda; extra == "full"
+Requires-Dist: pycudwt; extra == "full"
+Requires-Dist: sluurp>=0.3; extra == "full"
+Requires-Dist: pyvkfft; extra == "full"
+Provides-Extra: full-nocuda
+Requires-Dist: scikit-image; extra == "full-nocuda"
+Requires-Dist: PyWavelets; extra == "full-nocuda"
+Requires-Dist: glymur; extra == "full-nocuda"
+Requires-Dist: sluurp>=0.3; extra == "full-nocuda"
+Requires-Dist: pyvkfft; extra == "full-nocuda"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: cloud_sptheme; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
 
 # Nabu
 

{nabu-2024.2.4.dist-info → nabu-2024.2.6.dist-info}/RECORD

@@ -1,7 +1,8 @@
 doc/conf.py,sha256=3xtCarCHrXPr50GbeRDuH-o3Jzojw7mpr7vpGfZPLAE,3787
 doc/create_conf_doc.py,sha256=IVOdP70KvbW9WS_UQu3Iyd0YfS60E2fJ5IDtQ_s4cDw,1143
+doc/doc_config.py,sha256=anqeOVjqE2e7eVzg7yuh9dvIneTkrA5doGl1cVBqT7Q,730
 doc/get_mathjax.py,sha256=VIvKRCdDuF2VoY8JD3mSey9XX13AZMmwTJBHdt1tUs4,1012
-nabu/__init__.py,sha256=c6RQ-mRwrAgEkoyeON7u8FYClLvqty1oogHOSMgxIRw,270
+nabu/__init__.py,sha256=EVuU--KTOdCVd-SsAeXYWg4ZcflIHGPc1zOOSai-Qw4,270
 nabu/tests.py,sha256=cew9OY2uTyncHI_HM32W8CP6B1GTGKaOW65XtMEqs7o,1417
 nabu/testutils.py,sha256=VkSL9tbY0XEH49Z5OjDFFhzkSxrCv4UIuvSVFgegSUY,7632
 nabu/utils.py,sha256=V1B_sD54XGNKn5pORa2yNCATyswOzybey3sv8BuIYWY,26355
@@ -44,7 +45,7 @@ nabu/cuda/src/ElementOp.cu,sha256=PhebQQgeF0V7MDNzeYiRXIeNq3tE2PsBx00XhanBmvg,71
 nabu/cuda/src/backproj.cu,sha256=Zq9w8TP9zSYCHH_91dfrTVLOSEmY0y4hzm7J2qdCdJ8,6257
 nabu/cuda/src/backproj_polar.cu,sha256=sZbtw3KMfN69XyubJQSSLC87d5IPOyzbPBoRSNC1Cek,1851
 nabu/cuda/src/boundary.h,sha256=eQhfKZm-o0kj88BvkUwzqfqxYfRde4Tuj8AhQvRK16Y,2898
-nabu/cuda/src/cone.cu,sha256=Q-mKNBnx0pXzpOUGKi0Kq4POp7VqaQrLCDgqTf1pdkk,3071
+nabu/cuda/src/cone.cu,sha256=IuuVpHPnGekQmLq7_FyJ3pN4Ntjs7k5yeUiPKty7H9w,3399
 nabu/cuda/src/convolution.cu,sha256=O6r8qPpQjpaqnNivMRX0LK3dEACKk9xyNYO9u_JysU0,7353
 nabu/cuda/src/dfi_fftshift.cu,sha256=ElgNXy8H14mff2hmyjxCq7CnFK_DSY2Z564QGytRO1o,2220
 nabu/cuda/src/flatfield.cu,sha256=ZVVmEd-jcsK03VWv42uugYw6LeUnDEVY8qo_G07doHs,2058
@@ -143,7 +144,7 @@ nabu/pipeline/fullfield/computations.py,sha256=AEp3qvwyY-l8-GzjH1E6kmcmU6OgDp6sB
 nabu/pipeline/fullfield/dataset_validator.py,sha256=Iy6oOnXnBldDcg0ifm_zzrzMQ6YdkR_hkHFySZgxbno,2943
 nabu/pipeline/fullfield/nabu_config.py,sha256=rvHmCNHx2y-GKBidRWCAjJd0IynvolPTTmBqNoOSvEA,31877
 nabu/pipeline/fullfield/processconfig.py,sha256=2eE9W0KjsHq8aSCXlczsISpWM9SMjWL03fN1RqZWyxg,36815
-nabu/pipeline/fullfield/reconstruction.py,sha256=fMHKR8LnpQ2_asIO5bJB3pRixABrKLi53KzJuB83NZ4,37422
+nabu/pipeline/fullfield/reconstruction.py,sha256=LpIMyl8LLJoJLhayHXT3VyOwRpEL9tdjPhIegFUS388,37678
 nabu/pipeline/helical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/pipeline/helical/dataset_validator.py,sha256=0YQc0hdYdpaXznFaKmlj9SIu7mNs0xXMejcRkhOZHaI,640
 nabu/pipeline/helical/fbp.py,sha256=0fAz-Fb0Rn_FzellvcS2cy-Wvm-5dxEf494YFt4pLws,5845
@@ -220,7 +221,8 @@ nabu/processing/tests/test_rotation.py,sha256=vedRXV9RePJywBKoyBkGANP1dhZCjphbYO
 nabu/processing/tests/test_transpose.py,sha256=hTG17wTaB5Wv6twbW3ZFhBv6BYfqJY7DTQPoO0-KdkM,2760
 nabu/processing/tests/test_unsharp.py,sha256=R3ovbwDDp3ccy2A8t6CcUVELXRWkED5EnQdN2FQOfQM,4391
 nabu/reconstruction/__init__.py,sha256=EmKVvx_-FJvzJngG4ielIC7FhMCpI1Waaflg_lF44tk,163
-nabu/reconstruction/cone.py,sha256=WObFcHvv7NkaZhUoC_xTlvl95f38AjsAJkePSOzngVk,18870
+nabu/reconstruction/astra.py,sha256=qnFYabU-Bzgys8hXjIBcwO2NazrvhNXUYFIkMHc6BmM,10444
+nabu/reconstruction/cone.py,sha256=RZj1JoxqskShvglgxUnsbYw7qbm6Rralt7hJ96eU-8c,19015
 nabu/reconstruction/fbp.py,sha256=uwEniGdEOn1atc9mTAHEDeF1y-ZqneifCKVr-ieHZss,5015
 nabu/reconstruction/fbp_base.py,sha256=DwZCilPXgGMRPV8_XfkWiaXUzWFM8rNBa8IyMdy5nno,17092
 nabu/reconstruction/fbp_opencl.py,sha256=coEGLq65PCuvWnhAbIyLPHACkWjMB0XOceMp9ZIDWtc,3274
@@ -238,7 +240,7 @@ nabu/reconstruction/sinogram.py,sha256=KTSGP_JJABf4Yr9l628HPbyWsBnpbnyGKyPEq3ZrP
 nabu/reconstruction/sinogram_cuda.py,sha256=DmTWdI9JhINjBpBuPiEt5mSqFmqu2FitIV94g3hSTAI,10659
 nabu/reconstruction/sinogram_opencl.py,sha256=vxJa5BeOd2NVdUayXYfQGAfO1AEbJfTGotuijT8qgCs,1486
 nabu/reconstruction/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-nabu/reconstruction/tests/test_cone.py,sha256=2BsR1kHlnlronghckifGmcrtROWF43lilYo8TMDUTjo,17846
+nabu/reconstruction/tests/test_cone.py,sha256=Vb31LX_KXYU8FPlco9heFRHIftk0-RI5_LSbhX9OMIA,21453
 nabu/reconstruction/tests/test_deringer.py,sha256=XE97waf6TKFm-Kxe9PGQ-Vs_Pldn-OzvOolhuy7a5k4,8340
 nabu/reconstruction/tests/test_fbp.py,sha256=jj2eSRB56-xs4SM_pK3Q9EupKQWFTzbtraXPD165rcU,15291
 nabu/reconstruction/tests/test_filtering.py,sha256=I5H1KSfd4iXTJWSqeMPR5Q7v5rFTXO6Vp2jYU4ugl58,5247
@@ -249,7 +251,7 @@ nabu/reconstruction/tests/test_reconstructor.py,sha256=3p2Wk_OqgZqkNOkhK_NJWlHkO
 nabu/reconstruction/tests/test_sino_normalization.py,sha256=fGv5Dlidxgm8ZC70Nk6oqVgpY2jzOW9NJaGlo44IJOo,3692
 nabu/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/resources/cor.py,sha256=-mcrTbj3G7o4PP5E_gIRo2j6_-ADmMkkOc_0CyQv84c,170
-nabu/resources/dataset_analyzer.py,sha256=e3AqYR9ORW9Q03mGYCiC66nXld-X0LPnx9E8X3zFIGU,18568
+nabu/resources/dataset_analyzer.py,sha256=nye5a2QgbeZZeRSMl2UEdR1gx9_IQf6rYMvfDJWm1QE,18859
 nabu/resources/gpu.py,sha256=GgpMb5umRQAUsEDEAefb4wSA5qm4JSMhkWmCEpW3X9g,5702
 nabu/resources/logger.py,sha256=-lOzhN_sU4R3BIfC69aMj2O8S_ocsvXsmwkhWlcxVEc,3758
 nabu/resources/nxflatfield.py,sha256=FhPqiXe6ZKu5eGI6aVfyTgcHhZF9kQUNX0cOxDPD73k,9324
@@ -262,7 +264,6 @@ nabu/resources/templates/id16_holo.conf,sha256=sDd_rEJGZjOGVAsGub5sT2arfXDnc_sxy
 nabu/resources/templates/id16a_fluo.conf,sha256=Nz1etzO2fSwksi7CThWJ5T1kZEdyBe8rMO7puNJ93Hc,542
 nabu/resources/templates/id19_pag.conf,sha256=u4fFPEBprzOW9_5_ChkIgowQcYpLhjmA8Gwm5XgC4Jc,384
 nabu/resources/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nabu/resources/tests/test_extract.py,sha256=msYWFP96LjpEntq1ucTWgKZMhUvZcLpJ-AQB3oGOh2E,206
 nabu/resources/tests/test_nxflatfield.py,sha256=XRGbYwqJv0NYAVQnAB224TwTZP_W2Bs3-yu0zQnDzEM,4179
 nabu/resources/tests/test_units.py,sha256=F2jFTck-1UwYET1MwTtX6ntzYUosfwOJkugSencGgz8,2155
 nabu/stitching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -302,7 +303,7 @@ nabu/stitching/tests/test_z_postprocessing_stitching.py,sha256=kKRb3PvMOnCW84S58
 nabu/stitching/tests/test_z_preprocessing_stitching.py,sha256=3EhX161S2JVz6z3vXnYgBlUUQVb1weXBqIR0KAXLeUg,16157
 nabu/stitching/utils/__init__.py,sha256=alIDGBnxWH4JvP-UW-7N99seBBi0r1GV1h8f1ERFBec,21
 nabu/stitching/utils/post_processing.py,sha256=aow36shbYhFgAnbCoq6mtXVpjBNCKm7VSLIvv3EYVdA,11303
-nabu/stitching/utils/utils.py,sha256=EssaIs7eUL1vrImJIi_Y5OzHHdEaoVedHAGWcOT8M6k,24650
+nabu/stitching/utils/utils.py,sha256=Z_JcVrUdykYFzeHJD8J-3y7kQb4Ef3_FM7M0zjQTPXg,24659
 nabu/stitching/utils/tests/test_post-processing.py,sha256=Xy0UW8sL7ERtrxN7lEZhm8gJukDeL8vxkliMT8Agvas,753
 nabu/thirdparty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/thirdparty/algotom_convert_sino.py,sha256=iZVRilvyqMyLTu8RKgbqDFUjObWW5X69rCARrnNizuI,13872
@@ -310,9 +311,9 @@ nabu/thirdparty/pore3d_deringer_munch.py,sha256=o4bisnFc-wMjuohWBT8wgWmfNehPQGtC
 nabu/thirdparty/tomocupy_remove_stripe.py,sha256=Khe4zFf0kRzu65Yxnvq58gt1ljOztqJGdMDhVAiM7lM,24363
 nabu/thirdparty/tomopy_phase.py,sha256=hK4oPpkogLOhv23XzzEXQY2u3r8fJvASY_bINVs6ERE,8634
 nabu/thirdparty/tomwer_load_flats_darks.py,sha256=ZNoVAinUb_wGYbfvs_4BVnWsjsQmNxSvCh1bWhR2WWg,5611
-nabu-2024.2.4.dist-info/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
-nabu-2024.2.4.dist-info/METADATA,sha256=8aKl-Zw_YMikzn33XIqdUzSbSqI4x3bUwhxL_wZi8Dc,5538
-nabu-2024.2.4.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
-nabu-2024.2.4.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
-nabu-2024.2.4.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
-nabu-2024.2.4.dist-info/RECORD,,
+nabu-2024.2.6.dist-info/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
+nabu-2024.2.6.dist-info/METADATA,sha256=5dkZbelyWSeWdpeFuTiuLAfLGkkWVmzeDIbie1bjmk4,5514
+nabu-2024.2.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nabu-2024.2.6.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
+nabu-2024.2.6.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
+nabu-2024.2.6.dist-info/RECORD,,

{nabu-2024.2.4.dist-info → nabu-2024.2.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.1)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nabu/resources/tests/test_extract.py

@@ -1,9 +0,0 @@
-from nabu.utils import list_match_queries
-
-
-def test_list_match_queries():
-
-    # entry0000 .... entry0099
-    avail = ["entry%04d" % i for i in range(100)]
-    query = "entry0000"
-    list_match_queries()