nabu 2025.1.0rc3__py3-none-any.whl → 2025.1.0rc5__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__ = "2025.1.0-rc3"
+__version__ = "2025.1.0-rc5"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/app/cli_configs.py

@@ -353,6 +353,11 @@ EstimateMotionConfig = {
         "default": 2,
         "type": int,
     },
+    "win_size": {
+        "help": "Size of the look-up window for half-tomography",
+        "default": 300,
+        "type": int,
+    },
     "verbose": {
         "help": "Whether to plot the movement estimation fit",
         "default": 1,
@@ -365,6 +370,16 @@ EstimateMotionConfig = {
         "help": "Whether to only generate motion file for horizontal or vertical movement: --only horizontal  or --only vertical",
         "default": "",
     },
+    "ccd_filter_size": {
+        "help": "Size of conditional median filter to apply on radios. Default is zero (disabled)",
+        "default": 0,
+        "type": int,
+    },
+    "ccd_filter_threshold": {
+        "help": "Threshold for median filter, 'ccd_filter_size' is not zero. Default is 0.04",
+        "default": 0.04,
+        "type": float,
+    },
 }
 
 # Default configuration for "stitching" command

nabu/app/estimate_motion.py

@@ -1,8 +1,11 @@
 from os import path
+from multiprocessing.pool import ThreadPool
 
+from ..utils import get_num_threads
 from ..resources.nxflatfield import update_dataset_info_flats_darks
 from ..resources.logger import LoggerOrPrint
 from ..resources.dataset_analyzer import analyze_dataset
+from ..preproc.ccd import CCDFilter
 from ..pipeline.config_validators import convert_to_bool
 from ..pipeline.estimators import TranslationsEstimator
 from .utils import parse_params_values
@@ -26,6 +29,22 @@ def estimate_motion():
     if do_ff:
         update_dataset_info_flats_darks(dataset_info, True, loading_mode="load_if_present")
 
+    radios_filter = None
+    do_ccd_filter = args["ccd_filter_size"] > 0
+    if do_ccd_filter:
+        radios_filter_obj = CCDFilter(
+            dataset_info.radio_dims[::-1],
+            kernel_size=args["ccd_filter_size"],
+            median_clip_thresh=args["ccd_filter_threshold"],
+        )
+
+        def radios_filter(images):
+            def _apply_median_clip(img):
+                radios_filter_obj.median_clip_correction(img, output=img)
+
+            with ThreadPool(get_num_threads()) as tp:
+                tp.map(_apply_median_clip, images)
+
     est = TranslationsEstimator(
         dataset_info,
         do_flatfield=do_ff,
@@ -34,6 +53,8 @@ def estimate_motion():
         deg_xy=args["deg_xy"],
         deg_z=args["deg_z"],
         shifts_estimator="phase_cross_correlation",
+        radios_filter=radios_filter,
+        extra_options={"window_size": args["win_size"]},
     )
 
     estimated_shifts_h, estimated_shifts_v, cor = est.estimate_motion()

nabu/pipeline/estimators.py

@@ -1000,7 +1000,7 @@ def estimate_translations(dataset_info, do_flatfield=True): ...
 class TranslationsEstimator:
 
     _default_extra_options = {
-        "window_size": 200,
+        "window_size": 300,
     }
 
     def __init__(
@@ -1013,6 +1013,7 @@ class TranslationsEstimator:
         deg_xy=2,
         deg_z=2,
         shifts_estimator="phase_cross_correlation",
+        radios_filter=None,
         extra_options=None,
     ):
         self._configure_extra_options(extra_options)
@@ -1021,6 +1022,7 @@ class TranslationsEstimator:
         self.angular_subsampling = angular_subsampling
         self.do_360 = self.dataset_info.is_360
         self.do_flatfield = do_flatfield
+        self.radios_filter = radios_filter
         self.radios = None
         self._deg_xy = deg_xy
         self._deg_z = deg_z
@@ -1163,6 +1165,9 @@ class TranslationsEstimator:
     def estimate_motion(self):
         self._load_data()
         self._apply_flatfield()
+        if self.radios_filter is not None:
+            self.logger.debug("[MotionEstimation] applying radios filter")
+            self.radios_filter(self.radios)
 
         n_projs_tot = self.dataset_info.n_angles
         if self.do_360:
@@ -1210,7 +1215,7 @@ class TranslationsEstimator:
         self.sample_shifts_z = estimated_shifts_v
         if self._cor is None:
             self.logger.info(
-                "[MotionEstimation] Estimated center of rotation (relative to middle of detector): %.2f" % cor
+                "[MotionEstimation] Estimated center of rotation (relative to left-most pixel): %.2f" % cor
             )
         return estimated_shifts_h, estimated_shifts_v, cor
 

nabu/processing/azim.py

@@ -96,8 +96,11 @@ def do_radial_distribution(ip, X0, Y0, mR, nBins=None, use_calibration=False, ca
     Accumulator = np.zeros((2, nBins))
 
     # Define the bounding box
-    xmin, xmax = X0 - mR, X0 + mR
-    ymin, ymax = Y0 - mR, Y0 + mR
+    height, width = ip.shape
+    xmin = max(int(X0 - mR), 0)
+    xmax = min(int(X0 + mR), width)
+    ymin = max(int(Y0 - mR), 0)
+    ymax = min(int(Y0 + mR), height)
 
     # Create grid of coordinates
     x = np.arange(xmin, xmax)
@@ -112,10 +115,11 @@ def do_radial_distribution(ip, X0, Y0, mR, nBins=None, use_calibration=False, ca
     bins = np.clip(bins - 1, 0, nBins - 1)  # Adjust bins to be in range [0, nBins-1]
 
     # Accumulate values
+    sub_image = ip[xmin:xmax, ymin:ymax]  # prevent issue on non-square images
     for b in range(nBins):
         mask = bins == b
         Accumulator[0, b] = np.sum(mask)
-        Accumulator[1, b] = np.sum(ip[mask])
+        Accumulator[1, b] = np.sum(sub_image[mask])
 
     # Normalize integrated intensity
     Accumulator[1] /= Accumulator[0]

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

@@ -104,7 +104,7 @@ class MLEMReconstructor:
     def reset_rot_center(self, cor):
         self.cor = -cor + (self.sinos_shape[-1] - 1) / 2.0
 
-    def reconstruct(self, data_vwu):
+    def reconstruct(self, data_vwu, x0=None):
         """
         data_align_vwu: numpy.ndarray or pycuda.gpuarray
             Raw data, with shape (n_sinograms, n_angles, width)
@@ -134,5 +134,5 @@ class MLEMReconstructor:
         with cct.projectors.ProjectorUncorrected(
             self.vol_geom_align, self.angles_rad, rot_axis_shift_pix=self.cor, prj_geom=self.prj_geom_align
         ) as A:
-            rec, _ = solver(A, data_vwu, iterations=self.n_iterations, **self.solver_opts)
+            rec, _ = solver(A, data_vwu, iterations=self.n_iterations, x0=x0, **self.solver_opts)
         return rec * self.scale_factor

nabu/resources/dataset_analyzer.py

@@ -328,8 +328,8 @@ class DatasetAnalyzer:
         Return True iff the scan is 360 degrees (regardless of half-tomo mode)
         """
         angles = self.rotation_angles
-        d_theta = angles[1] - angles[0]
-        return np.isclose(angles.max() - angles.min(), 2 * np.pi, atol=2 * d_theta)
+        delta_theta = abs(angles.max() - angles.min())
+        return abs(delta_theta - 2 * np.pi) < abs(delta_theta - np.pi)
 
 
 class EDFDatasetAnalyzer(DatasetAnalyzer):

nabu/resources/nxflatfield.py

@@ -71,7 +71,7 @@ def save_reduced_frames(dataset_info, reduced_frames_arrays, reduced_frames_urls
     darks_flats_dir_url = reduced_frames_urls.get("user", None)
     if darks_flats_dir_url is not None:
         output_url = darks_flats_dir_url
-    elif is_writeable(os.path.dirname(reduced_frames_urls["dataset"]["flats"].file_path())):
+    elif is_writeable(os.path.abspath(os.path.dirname(reduced_frames_urls["dataset"]["flats"].file_path()))):
         output_url = reduced_frames_urls["dataset"]
     else:
         output_url = reduced_frames_urls["output"]

{nabu-2025.1.0rc3.dist-info → nabu-2025.1.0rc5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabu
-Version: 2025.1.0rc3
+Version: 2025.1.0rc5
 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.0rc3.dist-info → nabu-2025.1.0rc5.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=weQJf5hGEi-BzNCLAkn3BNQ71AJRC7nINDlNmkELmCc,274
+nabu/__init__.py,sha256=MqQy5o-iAgwXYvJPxuObZvQDv0dpmXSmWkMXaLkGkog,274
 nabu/tests.py,sha256=hOJD1GGxn_KE1bWMoxfjnjzI7d9JBUpoc9B2_tVFiEk,1370
 nabu/testutils.py,sha256=eL81DWgYwu2CCFmDMsFs4QjfI7w9RPXFuPU5gvYF6No,8631
 nabu/utils.py,sha256=tJI64BNXMhD6W293fwwcgf9bvTalYG_5AwVGYkgi6tU,27179
@@ -9,14 +10,14 @@ nabu/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/app/bootstrap.py,sha256=3yLZJmrmQBmPJMBtE2ih2cspfqOy5T_UN2U8B3i_hkI,3266
 nabu/app/bootstrap_stitching.py,sha256=wCKgugOQr6-lPMWEn4AYQeric0tCuRc9O-RnpBuTWAA,2230
 nabu/app/cast_volume.py,sha256=OufJDx_ZJ-ZbhbvIPHxRox4jtL6PfWcL148g77BWCDU,11454
-nabu/app/cli_configs.py,sha256=paHLX7ZDmTKhiXF9ZDzo18ld7H1HoOpaO8YnHPAqwhc,24991
+nabu/app/cli_configs.py,sha256=SakK1GhLDR4msZIJa0werjK6KxggrIED2yg6kxcDkJk,25482
 nabu/app/compare_volumes.py,sha256=3qm3QsxV-D_myLAkhM_LlX0DTrDmhzfhrnNak-1538Q,3337
 nabu/app/composite_cor.py,sha256=-qAbMJCFa0NmSb1hO2G1QvdW4fwEXSMBBbSFCnQXmCc,5068
 nabu/app/create_distortion_map_from_poly.py,sha256=aa-vE-ndB9PsuHwdHUW7-8jGz4BxvjC-bQDWHlPV0Kg,6193
 nabu/app/diag_to_pix.py,sha256=KKIj4YrcvEc8Ey-_T3yvxeSKTfrY5o13ekteMQN_cr4,14987
 nabu/app/diag_to_rot.py,sha256=tBaF1Oy0-bjCqkLFK-Bu_n74easzLlRkI_FTC1cAH2Q,16933
 nabu/app/double_flatfield.py,sha256=1yquRUIHYXmrIg7NGHMDIXpkUCS_muEioUeqLyWf8PI,5641
-nabu/app/estimate_motion.py,sha256=VyUv3scqbzj8mlccdMO3XgI-HIekFjxFtlVEGd2swo4,2079
+nabu/app/estimate_motion.py,sha256=-E21ttzzHYSYnDnFo4ggVgIP3AARLUgU2IA4L95vz7k,2844
 nabu/app/generate_header.py,sha256=Voo-FAvwS_mU5gtDxyqpZnSpP_mlMSfd_6bEtgdi_tg,8919
 nabu/app/histogram.py,sha256=gyLXKwFrU5WPQMkM1k8OdpIXSwGEEKC-f8RcTHKOho4,7930
 nabu/app/multicor.py,sha256=FjmJurruRmrwXF7v56KlTszQGIGsqft1_P7AKR9feY0,4726
@@ -134,7 +135,7 @@ nabu/pipeline/config_validators.py,sha256=Wx9nnUpfxTJ8H2ODkUyjImTtJS9V68TafLH1Te
 nabu/pipeline/datadump.py,sha256=tKW-Dl28FU2vf1OuIie_YI1-GT1DMreis57sOR-DuGU,7026
 nabu/pipeline/dataset_validator.py,sha256=etQw9NC_YGsdWCgjsn8aJ3WfvcRuJlLVZlWoqhvvo-8,9263
 nabu/pipeline/detector_distortion_provider.py,sha256=ru1AxbcuO-FA8FYooPBWgp1lzdSDUtzFUC1A_sS8jME,920
-nabu/pipeline/estimators.py,sha256=8OKGEMn6VKwyy1FK1eADokP32AOolsXM8pmwc4FOs8E,51556
+nabu/pipeline/estimators.py,sha256=ALzlcBxaVMt7OprEgndfBE_csuv9aKZax3erD3nBWU0,51786
 nabu/pipeline/params.py,sha256=UKMQWFQnrlNMW5aIGty-JoGmBdkS6tpoAXCjW8n6FX8,4229
 nabu/pipeline/processconfig.py,sha256=3xx2Lc8uEzPAqSMwUncr4RCiCtKn2c7wnXXbPSn8GNo,7719
 nabu/pipeline/reader.py,sha256=wkxPHYOi_C8dHNc7kddB8AMtFuW7GjsP_tm6SJeHlEY,4792
@@ -192,7 +193,7 @@ nabu/preproc/tests/test_paganin.py,sha256=Ixlp624o0xtFs12akN6sDn-gHWXm1wVlcdumm2
 nabu/preproc/tests/test_pcaflats.py,sha256=tZpMNzEtcqhLgnfl02VYyn9Ez8_YmZgtHAZublYNTHo,6356
 nabu/preproc/tests/test_vshift.py,sha256=Gq9sDtbbAAdLTJALH2qcbeYXE5dINQ8QpBnCgZM0tFQ,2972
 nabu/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nabu/processing/azim.py,sha256=GIv_C1NYjUP3IYd51qvfECTDu-rfs3Dl2Hb5-ZhdhHY,7080
+nabu/processing/azim.py,sha256=edTySuOWaZlc2dxU-PSY7Odd_mrVl0_MtjOvh8fzKxw,7264
 nabu/processing/convolution_cuda.py,sha256=jOLKdEwzBwNZPTEjXIBWStZp22ieeukc6KGnuSNVnaA,15421
 nabu/processing/fft_base.py,sha256=wSLiyJEwX51chfZG3CWPl0DvKp182qAmTnRY8N1mWW0,5741
 nabu/processing/fft_cuda.py,sha256=0JNzdSPPQ1xS38mjsgriN3-Cj9MXCtADLVHzIQjQjWc,3467
@@ -227,6 +228,7 @@ nabu/processing/tests/test_rotation.py,sha256=5O1yHthJfdoP-2loXob96j_V2IwI2eb8ro
 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/astra.py,sha256=qnFYabU-Bzgys8hXjIBcwO2NazrvhNXUYFIkMHc6BmM,10444
 nabu/reconstruction/cone.py,sha256=tSjaMDHeFV-h_IFbxUqSbhqlWmvlBcJQ8u89Y9Q9gg8,20559
 nabu/reconstruction/fbp.py,sha256=ptHcQsZTxgMFa9PhFJeTzDekibWR-P1BUj2SvRrk770,5684
 nabu/reconstruction/fbp_base.py,sha256=usd49ctQMI5w6uU5xn8qBsN7gI95iU9a3jRZgSPmOJk,18653
@@ -235,7 +237,7 @@ nabu/reconstruction/filtering.py,sha256=monJnA_kk9k_Gy7bMAos9I-XgU8czWhf9vBth6ik
 nabu/reconstruction/filtering_cuda.py,sha256=_S-BZMhtnNt8ugePSmf-LF7JvMPCOyGPUMSseymgwZw,4019
 nabu/reconstruction/filtering_opencl.py,sha256=v-sUzbnRp6M1B221F-iSh-crBCGknjHYYsjFs05VhDY,3788
 nabu/reconstruction/hbp.py,sha256=Qll7i20LWxUo1-SHRxemkYAolBTP8HScwt1OvWmD2r0,18642
-nabu/reconstruction/mlem.py,sha256=ToQjy81vFvRwNKc8YA8jWAa4Ms6bQSQmRBx8QcBZ_oc,5778
+nabu/reconstruction/mlem.py,sha256=wgC2pKl6RKB-f2318worB9VE-qCGoQcz24aKbtkrJos,5794
 nabu/reconstruction/projection.py,sha256=SNocaOY9HuNiHs-VxkW9IS707JPJnd3sDjAbf7aIw2E,9081
 nabu/reconstruction/reconstructor.py,sha256=16xxHcK4iie-uh-trf6x_IuvgxJKBvQRTE5B8tnc4F8,7358
 nabu/reconstruction/reconstructor_cuda.py,sha256=m_3GzG44PRyiSEfTvYjgr5atLwl26hMfZOMyqTWxp0g,1644
@@ -256,10 +258,10 @@ nabu/reconstruction/tests/test_reconstructor.py,sha256=xzfEM0j48ScQoGqWVcAK74HG9
 nabu/reconstruction/tests/test_sino_normalization.py,sha256=qNnpVUp3UcFGyLlSP0rCzE5hxdV6YENL9AF6mo72WcQ,3669
 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=PfYov5UrEkfE3oMLZaVJEpEWQuR5gtxctkA1hPhcpK4,23980
+nabu/resources/dataset_analyzer.py,sha256=WnY3GpNc5EfmYaCSgoCM2kguBkd3LC2BRa6U1vO6wfI,23982
 nabu/resources/gpu.py,sha256=oQA8PpPdyuIzpxq1PwVd9gJdyCiLIry2godUV1AbPW0,5769
 nabu/resources/logger.py,sha256=xV9UoLZBw3wXAWYfOgqrnOtzJc9aC1VNO4LM2cHxWJg,3738
-nabu/resources/nxflatfield.py,sha256=uPivKr4T5AYDGeyxoLns7UL6KYZt_2niNYuSsXrUMm8,12368
+nabu/resources/nxflatfield.py,sha256=kgHPf_jGQiuJ_EFe8fladRkx_PM6PfdRtcf5Tf2cYgU,12385
 nabu/resources/utils.py,sha256=79iO6I0sXx8VGXZOC9eXquNvasF37A9Zr6r2BYSwJWU,5974
 nabu/resources/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/resources/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -317,9 +319,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-2025.1.0rc3.dist-info/licenses/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
-nabu-2025.1.0rc3.dist-info/METADATA,sha256=YmXboCie2GZY8Om4wco2-8--nuhCJnhMq99FXIYKSfE,4274
-nabu-2025.1.0rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nabu-2025.1.0rc3.dist-info/entry_points.txt,sha256=YxzCY5CNQ1XHrIGbRKg-BgC1Jy7QaCITdITpyhhxpZU,1338
-nabu-2025.1.0rc3.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
-nabu-2025.1.0rc3.dist-info/RECORD,,
+nabu-2025.1.0rc5.dist-info/licenses/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
+nabu-2025.1.0rc5.dist-info/METADATA,sha256=AL9rbvVgIzYBY5oxByuzL3yj8iZBJ0ozErVn3Y8n8FU,4274
+nabu-2025.1.0rc5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nabu-2025.1.0rc5.dist-info/entry_points.txt,sha256=YxzCY5CNQ1XHrIGbRKg-BgC1Jy7QaCITdITpyhhxpZU,1338
+nabu-2025.1.0rc5.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
+nabu-2025.1.0rc5.dist-info/RECORD,,