nabu 2025.1.0rc5__py3-none-any.whl → 2025.1.1__py3-none-any.whl

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2025.1.0-rc5"
+__version__ = "2025.1.1"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/estimation/motion.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from multiprocessing.pool import ThreadPool
+from warnings import warn
 import numpy as np
 from ..utils import get_num_threads
 
@@ -218,12 +219,18 @@ class MotionEstimation:
             return _normalize_with_reference(a_all[-n_outward_projs:])
 
     def _configure_shifts_estimator(self, shifts_estimator, shifts_estimator_kwargs):
-        self.shifts_estimator = shifts_estimator
         if shifts_estimator not in self._shifts_estimators_default_kwargs:
             raise NotImplementedError(
                 f"Unknown estimator shifts '{shifts_estimator}', available are {list(self._shifts_estimators_default_kwargs.keys())}"
             )
-        self._shifts_estimator_kwargs = self._shifts_estimators_default_kwargs[shifts_estimator].copy()
+        self.shifts_estimator = shifts_estimator
+        if self.shifts_estimator == "phase_cross_correlation" and phase_cross_correlation is None:
+            warn(
+                "shift estimator was set to 'phase_cross_correlation' but it requires scikit-image which is not available. Falling back to 'DetectorTranslationAlongBeam'",
+                Warning,
+            )
+            self.shifts_estimator = "DetectorTranslationAlongBeam"
+        self._shifts_estimator_kwargs = self._shifts_estimators_default_kwargs[self.shifts_estimator].copy()
         self._shifts_estimator_kwargs.update(shifts_estimator_kwargs or {})
 
     def _find_shifts(self, img1, img2):

nabu/io/cast_volume.py

@@ -142,7 +142,7 @@ def cast_volume(
     remove_input_volume: bool = False,
 ) -> VolumeBase:
     """
-    cast givent volume to output_volume of 'output_data_type' type
+    cast given volume to output_volume of 'output_data_type' type
 
     :param VolumeBase input_volume:
     :param VolumeBase output_volume:
@@ -231,6 +231,7 @@ def cast_volume(
                 data_max=data_max,
                 rescale_min_percentile=rescale_min_percentile,
                 rescale_max_percentile=rescale_max_percentile,
+                default_value_for_nan=new_min,
             ).astype(output_data_type)
         else:
             output_slice = input_slice.astype(output_data_type)
@@ -268,25 +269,46 @@ def clamp_and_rescale_data(
     data_max=None,
     rescale_min_percentile=RESCALE_MIN_PERCENTILE,
     rescale_max_percentile=RESCALE_MAX_PERCENTILE,
+    default_value_for_nan=None,
+    do_float64=True,
 ):
     """
     rescale data to 'new_min', 'new_max'
 
-    :param numpy.ndarray data: data to be rescaled
-    :param dtype output_dtype: output dtype
-    :param new_min: rescaled data new min (clamp min value)
-    :param new_max: rescaled data new max (clamp max value)
-    :param data_min: `data` min value to clamp to new_min. Any lower value will also be clamp to new_min.
-    :param data_max: `data` max value to clamp to new_max. Any hight value will also be clamp to new_max.
-    :param rescale_min_percentile: if `data_min` is None will set data_min to 'rescale_min_percentile'
-    :param rescale_max_percentile: if `data_max` is None will set data_min to 'rescale_max_percentile'
+    Parameters
+    ----------
+    data: numpy.ndarray
+        Data to be rescaled (image or volume)
+    new_min: scalar
+        Rescaled data new min (clamp min value)
+    new_max: scalar
+        Rescaled data new min (clamp max value)
+    data_min: scalar, optional
+        Data minimum value. If not provided, will re-compute the min() over data.
+    data_max: scalar, optional
+        Data maximum value. If not provided, will re-compute the min() over data.
+    rescale_min_percentile: scalar, optional
+        if `data_min` is None will set data_min to 'rescale_min_percentile'
+    rescale_max_percentile
+        if `data_max` is None will set data_min to 'rescale_max_percentile'
+    default_value_for_nan: scalar, optional
+        Value that will replace NaNs, if any. Default is None (keep NaNs, will likely raise an error)
+    do_float64
+        Whether to do internal computations in float64. Recommended when casting from float32 to int32 for example.
     """
+    if do_float64 and data.dtype.itemsize < 8:
+        data = numpy.float64(data)
     if data_min is None:
-        data_min = numpy.percentile(data, rescale_min_percentile)
+        data_min = numpy.nanpercentile(data, rescale_min_percentile)
     if data_max is None:
-        data_max = numpy.percentile(data, rescale_max_percentile)
+        data_max = numpy.nanpercentile(data, rescale_max_percentile)
     # rescale data
     rescaled_data = rescale_data(data, new_min=new_min, new_max=new_max, data_min=data_min, data_max=data_max)
+    # Handle NaNs
+    if default_value_for_nan is not None:
+        isnan_mask = numpy.isnan(rescaled_data)
+        if numpy.any(isnan_mask):
+            rescaled_data[isnan_mask] = default_value_for_nan
     # clamp data
     rescaled_data[rescaled_data < new_min] = new_min
     rescaled_data[rescaled_data > new_max] = new_max

nabu/io/reader.py

@@ -556,7 +556,11 @@ class VolReaderBase:
             slice_x = None
         if isinstance(sub_region, (tuple, list)):
             slice_angle, slice_z, slice_x = sub_region
-        self.sub_region = (slice_angle or slice(None, None), slice_z or slice(None, None), slice_x or slice(None, None))
+        self.sub_region = (
+            slice_angle if slice_angle is not None else slice(None, None),
+            slice_z if slice_z is not None else slice(None, None),
+            slice_x if slice_x is not None else slice(None, None),
+        )
 
     def _set_processing_function(self, processing_func, processing_func_args, processing_func_kwargs):
         self.processing_func = processing_func
@@ -682,9 +686,13 @@ class NXTomoReader(VolReaderBase):
             # In this case, we can use h5py read_direct() to avoid extraneous memory consumption
             image_key_slice = self._image_key_slices[0]
             # merge image key selection and user selection (if any)
-            self._source_selection = (
-                merge_slices(image_key_slice, self.sub_region[0] or slice(None, None)),
-            ) + self.sub_region[1:]
+            angles_slice = self.sub_region[0]
+            if isinstance(angles_slice, slice) or angles_slice is None:
+                angles_slice = merge_slices(image_key_slice, self.sub_region[0] or slice(None, None))
+            else:  # assuming numpy array
+                # TODO more elegant
+                angles_slice = np.arange(self.data_shape_total[0], dtype=np.uint64)[image_key_slice][angles_slice]
+            self._source_selection = (angles_slice,) + self.sub_region[1:]
         else:
             user_selection_dim0 = self.sub_region[0]
             indices = np.arange(self.data_shape_total[0])

nabu/io/tests/test_readers.py

@@ -1,41 +1,23 @@
 from math import ceil
 from tempfile import TemporaryDirectory
-from dataclasses import dataclass
 from tomoscan.io import HDF5File
 import pytest
 import numpy as np
 from nxtomo.application.nxtomo import ImageKey
 from tomoscan.esrf import EDFVolume
 from nabu.pipeline.reader import NXTomoReaderBinning
-from nabu.testutils import utilstest, __do_long_tests__, get_file
+from nabu.testutils import utilstest, __do_long_tests__, get_file, get_dummy_nxtomo_info
 from nabu.utils import indices_to_slices, merge_slices
 from nabu.io.reader import EDFStackReader, NXTomoReader, NXDarksFlats
-
-
-@dataclass
-class SimpleNXTomoDescription:
-    n_darks: int = 0
-    n_flats1: int = 0
-    n_projs: int = 0
-    n_flats2: int = 0
-    n_align: int = 0
-    frame_shape: tuple = None
-    dtype: np.dtype = np.uint16
+from nabu.resources.dataset_analyzer import analyze_dataset
 
 
 @pytest.fixture(scope="class")
 def bootstrap_nx_reader(request):
     cls = request.cls
-
-    cls.nx_fname = utilstest.getfile("dummy_nxtomo.nx")
-    cls.nx_data_path = "entry/instrument/detector/data"
-    cls.data_desc = SimpleNXTomoDescription(
-        n_darks=10, n_flats1=11, n_projs=100, n_flats2=11, n_align=12, frame_shape=(11, 10), dtype=np.uint16
+    cls.nx_fname, cls.data_desc, cls.image_key, cls.projs_vals, cls.darks_vals, cls.flats1_vals, cls.flats2_vals = (
+        get_dummy_nxtomo_info()
     )
-    cls.projs_vals = np.arange(cls.data_desc.n_projs) + cls.data_desc.n_flats1 + cls.data_desc.n_darks
-    cls.darks_vals = np.arange(cls.data_desc.n_darks)
-    cls.flats1_vals = np.arange(cls.data_desc.n_darks, cls.data_desc.n_darks + cls.data_desc.n_flats1)
-    cls.flats2_vals = np.arange(cls.data_desc.n_darks, cls.data_desc.n_darks + cls.data_desc.n_flats2)
 
     yield
     # teardown
@@ -45,7 +27,7 @@ def bootstrap_nx_reader(request):
 class TestNXReader:
     def test_incorrect_path(self):
         with pytest.raises(FileNotFoundError):
-            reader = NXTomoReader("/invalid/path", self.nx_data_path)
+            reader = NXTomoReader("/invalid/path")
         with pytest.raises(KeyError):
             reader = NXTomoReader(self.nx_fname, "/bad/data/path")  # noqa: F841
 
@@ -53,7 +35,7 @@ class TestNXReader:
         """
         Test NXTomoReader with simplest settings
         """
-        reader1 = NXTomoReader(self.nx_fname, self.nx_data_path)
+        reader1 = NXTomoReader(self.nx_fname)
         data1 = reader1.load_data()
         assert data1.shape == (self.data_desc.n_projs,) + self.data_desc.frame_shape
         assert np.allclose(data1[:, 0, 0], self.projs_vals)
@@ -62,15 +44,15 @@ class TestNXReader:
         """
         Test the data selection using "image_key".
         """
-        reader_projs = NXTomoReader(self.nx_fname, self.nx_data_path, image_key=ImageKey.PROJECTION.value)
+        reader_projs = NXTomoReader(self.nx_fname, image_key=ImageKey.PROJECTION.value)
         data = reader_projs.load_data()
         assert np.allclose(data[:, 0, 0], self.projs_vals)
 
-        reader_darks = NXTomoReader(self.nx_fname, self.nx_data_path, image_key=ImageKey.DARK_FIELD.value)
+        reader_darks = NXTomoReader(self.nx_fname, image_key=ImageKey.DARK_FIELD.value)
         data_darks = reader_darks.load_data()
         assert np.allclose(data_darks[:, 0, 0], self.darks_vals)
 
-        reader_flats = NXTomoReader(self.nx_fname, self.nx_data_path, image_key=ImageKey.FLAT_FIELD.value)
+        reader_flats = NXTomoReader(self.nx_fname, image_key=ImageKey.FLAT_FIELD.value)
         data_flats = reader_flats.load_data()
         assert np.allclose(data_flats[:, 0, 0], np.concatenate([self.flats1_vals, self.flats2_vals]))
 
@@ -83,10 +65,10 @@ class TestNXReader:
         def _check_correct_shape_succeeds(shape, sub_region, test_description=""):
             err_msg = "Something wrong with the following test:" + test_description
             data_buffer = np.zeros(shape, dtype="f")
-            reader1 = NXTomoReader(self.nx_fname, self.nx_data_path, sub_region=sub_region)
+            reader1 = NXTomoReader(self.nx_fname, sub_region=sub_region)
             data1 = reader1.load_data(output=data_buffer)
             assert id(data1) == id(data_buffer), err_msg
-            reader2 = NXTomoReader(self.nx_fname, self.nx_data_path, sub_region=sub_region)
+            reader2 = NXTomoReader(self.nx_fname, sub_region=sub_region)
             data2 = reader2.load_data()
             assert np.allclose(data1, data2), err_msg
 
@@ -124,7 +106,6 @@ class TestNXReader:
                     data_buffer_wrong_shape = np.zeros(wrong_shape, dtype="f")
                     reader = NXTomoReader(
                         self.nx_fname,
-                        self.nx_data_path,
                         sub_region=test_case["sub_region"],
                     )
                     reader.load_data(output=data_buffer_wrong_shape)
@@ -148,7 +129,7 @@ class TestNXReader:
         ]
 
         for test_case in test_cases:
-            reader = NXTomoReader(self.nx_fname, self.nx_data_path, sub_region=test_case["sub_region"])
+            reader = NXTomoReader(self.nx_fname, sub_region=test_case["sub_region"])
             data = reader.load_data()
             assert data.shape == test_case["expected_shape"]
             assert np.allclose(data[:, 0, 0], test_case["expected_values"])
@@ -156,7 +137,7 @@ class TestNXReader:
     def test_reading_with_binning_(self):
         from nabu.pipeline.reader import NXTomoReaderBinning
 
-        reader_with_binning = NXTomoReaderBinning((2, 2), self.nx_fname, self.nx_data_path)
+        reader_with_binning = NXTomoReaderBinning((2, 2), self.nx_fname)
         data = reader_with_binning.load_data()
         assert data.shape == (self.data_desc.n_projs,) + tuple(n // 2 for n in self.data_desc.frame_shape)
 
@@ -177,7 +158,6 @@ class TestNXReader:
         reader_distortion_corr = NXTomoReaderDistortionCorrection(
             distortion_corrector,
             self.nx_fname,
-            self.nx_data_path,
             sub_region=sub_region,
         )
 
@@ -220,7 +200,7 @@ class TestNXReader:
         for test_case in test_cases:
             binning = test_case.get("binning", None)
             reader_cls = NXTomoReader
-            init_args = [self.nx_fname, self.nx_data_path]
+            init_args = [self.nx_fname]
             init_kwargs = {"sub_region": test_case["sub_region"]}
             if binning is not None:
                 reader_cls = NXTomoReaderBinning
@@ -231,6 +211,29 @@ class TestNXReader:
             assert data.shape == test_case["expected_shape"], err_msg
             assert np.allclose(data[:, 0, 0], test_case["expected_values"]), err_msg
 
+    def test_load_exclude_projections(self):
+        n_z, n_x = self.data_desc.frame_shape
+        # projs_idx = np.where(self.image_key == 0)[0]
+        projs_idx = np.arange(self.data_desc.n_projs, dtype=np.int64)
+        excluded_projs_idx_1 = projs_idx[10:20]
+        excluded_projs_idx_2 = np.concatenate([projs_idx[10:14], projs_idx[50:57]])
+
+        set_to_nparray = lambda x: np.array(sorted(list(x)))
+
+        projs_idx1 = set_to_nparray(set(projs_idx) - set(excluded_projs_idx_1))
+        projs_idx2 = set_to_nparray(set(projs_idx) - set(excluded_projs_idx_2))
+
+        sub_regions_to_test = (
+            (projs_idx1, None, None),
+            (projs_idx1, slice(0, n_z // 2), None),
+            (projs_idx2, None, None),
+            (projs_idx2, slice(3, n_z // 2), None),
+        )
+        for sub_region in sub_regions_to_test:
+            reader = NXTomoReader(self.nx_fname, sub_region=sub_region)
+            data = reader.load_data()
+            assert np.allclose(data[:, 0, 0], self.projs_vals[sub_region[0]])
+
 
 @pytest.fixture(scope="class")
 def bootstrap_edf_reader(request):

nabu/misc/utils.py

@@ -3,9 +3,9 @@ import numpy as np
 
 def rescale_data(data, new_min, new_max, data_min=None, data_max=None):
     if data_min is None:
-        data_min = np.min(data)
+        data_min = np.nanmin(data)
     if data_max is None:
-        data_max = np.max(data)
+        data_max = np.nanmax(data)
     return (new_max - new_min) / (data_max - data_min) * (data - data_min) + new_min
 
 

nabu/pipeline/estimators.py

@@ -690,7 +690,7 @@ class CompositeCORFinder(CORFinderBase):
         tmp_sy, ovsd_sx = radio1.shape
         assert orig_sy == tmp_sy and orig_ovsd_sx == ovsd_sx, "this should not happen"
 
-        cor_side = self.cor_options["side"]
+        cor_side = self._lookup_side if self._lookup_side is not None else self.cor_options["side"]
         if cor_side == "center":
             overlap_min = max(round(ovsd_sx - ovsd_sx / 3), 4)
             overlap_max = min(round(ovsd_sx + ovsd_sx / 3), 2 * ovsd_sx - 4)

nabu/pipeline/fullfield/chunked.py

@@ -1,6 +1,5 @@
 from os import path
 from time import time
-from math import ceil
 import numpy as np
 from silx.io.url import DataUrl
 
@@ -127,10 +126,10 @@ class ChunkedPipeline:
         if len(chunk_shape) != 3:
             raise ValueError("Expected chunk_shape to be a tuple of length 3 in the form (n_z, n_y, n_x)")
         self.chunk_shape = tuple(int(c) for c in chunk_shape)  # cast to int, as numpy.int64 can make pycuda crash
-        # TODO: sanity check (eg. compare to size of radios in dataset_info) ?
+        ss_start = getattr(self.process_config, "subsampling_start", 0)
         # (n_a, n_z, n_x)
         self.radios_shape = (
-            ceil(self.chunk_shape[0] / self.process_config.subsampling_factor),
+            np.arange(self.chunk_shape[0])[ss_start :: self.process_config.subsampling_factor].size,
             self.chunk_shape[1] // self.process_config.binning[1],
             self.chunk_shape[2] // self.process_config.binning[0],
         )
@@ -340,13 +339,28 @@ class ChunkedPipeline:
             subs_z = None
             subs_x = None
             angular_sub_region = slice(*(self.sub_region[0]))
+
+            # exclude(subsample(.)) != subsample(exclude(.))
+            # Here we want the latter: first exclude the user-defined angular range, and then subsample the remaining indices
+            if len(self.dataset_info.get_excluded_projections_indices()) > 0:
+                angular_sub_region = np.array(
+                    [
+                        self.dataset_info.index_to_proj_number(i)
+                        for i in sorted(list(self.dataset_info.projections.keys()))
+                    ]
+                )
             if self.process_config.subsampling_factor:
                 subs_angles = self.process_config.subsampling_factor
-                angular_sub_region = slice(
-                    getattr(self.process_config, "subsampling_start", 0) + self.sub_region[0][0],
-                    self.sub_region[0][1],
-                    subs_angles,
-                )
+                start = getattr(self.process_config, "subsampling_start", 0) + self.sub_region[0][0]
+                if isinstance(angular_sub_region, slice):
+                    angular_sub_region = slice(
+                        start,
+                        self.sub_region[0][1],
+                        subs_angles,
+                    )
+                else:
+                    angular_sub_region = angular_sub_region[start::subs_angles]
+
             reader_sub_region = (
                 angular_sub_region,
                 slice(*(self.sub_region[1]) + ((subs_z,) if subs_z else ())),
@@ -363,7 +377,7 @@ class ChunkedPipeline:
             if self.dataset_info.kind == "nx":
                 self.chunk_reader = NXTomoReader(
                     self.dataset_info.dataset_hdf5_url.file_path(),
-                    self.dataset_info.dataset_hdf5_url.data_path(),
+                    data_path=self.dataset_info.dataset_hdf5_url.data_path(),
                     sub_region=reader_sub_region,
                     image_key=0,
                     **other_reader_kwargs,
@@ -865,9 +879,10 @@ class ChunkedPipeline:
             data_vwu[i] = self.radios[:, i, :]
         # ---
 
-        return self.reconstruction.reconstruct(  # pylint: disable=E1101
+        rec = self.reconstruction.reconstruct(  # pylint: disable=E1101
             data_vwu,
         )
+        return rec.astype("f")  # corrct uses float64 data
 
     @pipeline_step("histogram", "Computing histogram")
     def _compute_histogram(self, data=None):

nabu/pipeline/fullfield/nabu_config.py

@@ -103,7 +103,7 @@ nabu_config = {
         },
         "detector_distortion_correction": {
             "default": "",
-            "help": "Apply coordinate transformation on the raw data, at the reading stage. Default (empty) is None. Available are: None, identity(for testing the pipeline), map_xz. This latter method requires two URLs being passed by detector_distortion_correction_options: map_x and map_z pointing to two 2D arrays containing the position where each pixel can be interpolated at in the raw data",
+            "help": "Apply coordinate transformation on the raw data, at the reading stage. Default (empty) is None.\n Available are: None, identity(for testing the pipeline), map_xz.\n This latter method requires two URLs being passed by detector_distortion_correction_options: map_x and map_z pointing to two 2D arrays containing the position where each pixel can be interpolated at in the raw data",
             "validator": detector_distortion_correction_validator,
             "type": "advanced",
         },

nabu/pipeline/fullfield/processconfig.py

@@ -12,6 +12,7 @@ from ...resources.nxflatfield import update_dataset_info_flats_darks
 from ...resources.utils import get_quantities_and_units
 from ..estimators import estimate_cor
 from ..processconfig import ProcessConfigBase
+from ..config_validators import convert_to_bool
 from .nabu_config import nabu_config, renamed_keys
 from .dataset_validator import FullFieldDatasetValidator
 from nxtomo.nxobject.nxdetector import ImageKey
@@ -475,7 +476,7 @@ class ProcessConfig(ProcessConfigBase):
         # Double flat field
         #
         # ---- COMPAT  ----
-        if nabu_config["preproc"].get("double_flatfield_enabled", False):
+        if convert_to_bool(nabu_config["preproc"].get("double_flatfield_enabled", False))[0]:
             deprecation_warning(
                 "'double_flatfield_enabled' has been renamed to 'double_flatfield'. Please update your configuration file"
             )

nabu/pipeline/fullfield/reconstruction.py

@@ -367,6 +367,7 @@ class FullFieldReconstructor:
         # overlap = ceil(delta_z * d2 / (d1 + d2))  # sqrt(2) missing ?
 
         max_overlap = ceil(n_z * d2 / (d1 + d2))  # sqrt(2) missing ?
+        max_overlap = max(max_overlap, 10)  # use at least 10 pixels
 
         return (max_overlap, 0)
 

nabu/preproc/flatfield.py

@@ -456,10 +456,10 @@ class FlatFieldDataUrls(FlatField):
 
 
 class PCAFlatsNormalizer:
-    """This class implement a flatfield normalization based on a PCA of a series of acauired flatfields.
+    """This class implement a flatfield normalization based on a PCA of a series of acquired flatfields.
     The PCA decomposition is handled by a PCAFlatsDecomposer object.
 
-    This implementation was proposed by Jailin C. et al in https://doi.org/10.1107/S1600577516015812.
+    This implementation was proposed by Jailin C. et al in https://journals.iucr.org/s/issues/2017/01/00/fv5055/
 
     Code initially written by ID11 @ ESRF staff.
     Jonathan Wright - Implementation based on research paper
@@ -619,7 +619,7 @@ class PCAFlatsDecomposer:
     """This class implements a PCA decomposition of a serie of acquired flatfields.
     The PCA decomposition is used to normalize the projections through a PCAFLatNormalizer object.
 
-    This implementation was proposed by Jailin C. et al in https://doi.org/10.1107/S1600577516015812.
+    This implementation was proposed by Jailin C. et al in https://journals.iucr.org/s/issues/2017/01/00/fv5055/
 
     Code initially written by ID11 @ ESRF staff.
     Jonathan Wright - Implementation based on research paper

nabu/reconstruction/iterative.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+
+class IterativeBase:
+
+    backend = None  # placeholder
+    implementation = None  # placeholder
+
+    default_extra_options = {
+        "axis_correction": None,
+        "centered_axis": False,
+        "clip_outer_circle": False,
+        "scale_factor": None,
+        "outer_circle_value": 0.0,
+    }
+
+    backend_processing_class = ProcessingBase
+
+    def __init__(
+        self,
+        sino_shape,
+        angles=None,
+        rot_center=None,
+        halftomo=False,
+        filter_name=None,
+        slice_roi=None,
+        scale_factor=None,
+        extra_options=None,
+        backend_options=None,
+    ): ...

nabu/resources/dataset_analyzer.py

@@ -396,6 +396,11 @@ class EDFDatasetAnalyzer(DatasetAnalyzer):
     def scan_dirname(self):
         return self.dataset_scanner.path
 
+    def get_excluded_projections_indices(self, including_other_frames_types=True):
+        if not (including_other_frames_types):
+            raise NotImplementedError
+        return self.dataset_scanner.get_ignored_projection_indices()
+
 
 class HDF5DatasetAnalyzer(DatasetAnalyzer):
     """
@@ -606,6 +611,36 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
     def get_frame(self, idx):
         return get_data(self.dataset_scanner.frames[idx].url)
 
+    def get_frames_indices(self, frame_type):
+        return self._select_according_to_frame_type(np.arange(self.dataset_scanner.image_key_control.size), frame_type)
+
+    def index_to_proj_number(self, proj_index):
+        """
+        Return the projection *number*, from its frame *index*.
+
+        For example if there are 11 flats before projections,
+        then projections will have indices [11, 12, .....] (possibly not contiguous)
+        while their number is [0, 1, ..., ] (contiguous, starts from 0)
+        """
+        all_projs_indices = self.get_frames_indices("projection")
+        return search_sorted(all_projs_indices, proj_index)
+
+    def get_excluded_projections_indices(self, including_other_frames_types=True):
+        # Get indices of ALL projections (even excluded ones)
+        # the index accounts for flats/darks !
+        # Get indices of excluded projs (again, accounting for flats/darks)
+        ignored_projs_indices = self.dataset_scanner.get_ignored_projection_indices()
+        ignored_projs_indices = [
+            idx for idx in ignored_projs_indices if self.dataset_scanner.frames[idx].is_control is False
+        ]
+        if including_other_frames_types:
+            return ignored_projs_indices
+        # Get indices of excluded projs, now relative to the pure projections stack
+        ignored_projs_indices_rel = [
+            self.index_to_proj_number(ignored_proj_idx_abs) for ignored_proj_idx_abs in ignored_projs_indices
+        ]
+        return ignored_projs_indices_rel
+
 
 def get_angle_at_index(all_angles, index):
     """

nabu/resources/tests/test_dataset_analyzer.py

@@ -0,0 +1,37 @@
+import pytest
+import numpy as np
+from nabu.testutils import get_dummy_nxtomo_info
+from nabu.resources.dataset_analyzer import analyze_dataset
+
+
+@pytest.fixture(scope="class")
+def bootstrap_nx(request):
+    cls = request.cls
+    cls.nx_fname, cls.data_desc, cls.image_key, cls.projs_vals, cls.darks_vals, cls.flats1_vals, cls.flats2_vals = (
+        get_dummy_nxtomo_info()
+    )
+
+
+@pytest.mark.usefixtures("bootstrap_nx")
+class TestNXDataset:
+
+    def test_exclude_projs_angular_range(self):
+        dataset_info_with_all_projs = analyze_dataset(self.nx_fname)
+
+        # Test exclude angular range - angles min and max in degrees
+        angular_ranges_to_test = [(0, 15), (5, 6), (50, 58.5)]
+        for angular_range in angular_ranges_to_test:
+            angle_min, angle_max = angular_range
+            dataset_info = analyze_dataset(
+                self.nx_fname,
+                extra_options={"exclude_projections": {"type": "angular_range", "range": [angle_min, angle_max]}},
+            )
+            excluded_projs_indices = dataset_info.get_excluded_projections_indices()
+            # Check that get_excluded_projections_indices() angles are correct
+            for excluded_proj_index in excluded_projs_indices:
+                frame_angle_deg = dataset_info.dataset_scanner.frames[excluded_proj_index].rotation_angle
+                assert angle_min <= frame_angle_deg and frame_angle_deg <= angle_max
+
+            assert set(dataset_info_with_all_projs.projections.keys()) - set(dataset_info.projections.keys()) == set(
+                excluded_projs_indices
+            )

nabu/testutils.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from itertools import product
 import tarfile
 import os
@@ -5,6 +6,7 @@ import numpy as np
 from scipy.signal.windows import gaussian
 from silx.resources import ExternalResources
 from silx.io.dictdump import nxtodict, dicttonx
+from nxtomo.application.nxtomo import ImageKey
 
 utilstest = ExternalResources(
     project="nabu", url_base="http://www.silx.org/pub/nabu/data/", env_key="NABU_DATA", timeout=60
@@ -56,6 +58,38 @@ def get_data(*dataset_path):
     return np.load(dataset_downloaded_path)
 
 
+@dataclass
+class SimpleNXTomoDescription:
+    n_darks: int = 0
+    n_flats1: int = 0
+    n_projs: int = 0
+    n_flats2: int = 0
+    n_align: int = 0
+    frame_shape: tuple = None
+    dtype: np.dtype = np.uint16
+
+
+def get_dummy_nxtomo_info():
+    nx_fname = utilstest.getfile("dummy_nxtomo.nx")
+    data_desc = SimpleNXTomoDescription(
+        n_darks=10, n_flats1=11, n_projs=100, n_flats2=11, n_align=12, frame_shape=(11, 10), dtype=np.uint16
+    )
+    image_key = np.concatenate(
+        [
+            np.zeros(data_desc.n_darks, dtype=np.int32) + ImageKey.DARK_FIELD.value,
+            np.zeros(data_desc.n_flats1, dtype=np.int32) + ImageKey.FLAT_FIELD.value,
+            np.zeros(data_desc.n_projs, dtype=np.int32) + ImageKey.PROJECTION.value,
+            np.zeros(data_desc.n_flats2, dtype=np.int32) + ImageKey.FLAT_FIELD.value,
+            np.zeros(data_desc.n_align, dtype=np.int32) + ImageKey.ALIGNMENT.value,
+        ]
+    )
+    projs_vals = np.arange(data_desc.n_projs) + data_desc.n_flats1 + data_desc.n_darks
+    darks_vals = np.arange(data_desc.n_darks)
+    flats1_vals = np.arange(data_desc.n_darks, data_desc.n_darks + data_desc.n_flats1)
+    flats2_vals = np.arange(data_desc.n_darks, data_desc.n_darks + data_desc.n_flats2)
+    return nx_fname, data_desc, image_key, projs_vals, darks_vals, flats1_vals, flats2_vals
+
+
 def get_array_of_given_shape(img, shape, dtype):
     """
     From a given image, returns an array of the wanted shape and dtype.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabu
-Version: 2025.1.0rc5
+Version: 2025.1.1
 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.0rc5.dist-info → nabu-2025.1.1.dist-info}/RECORD

@@ -1,10 +1,9 @@
 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=MqQy5o-iAgwXYvJPxuObZvQDv0dpmXSmWkMXaLkGkog,274
+nabu/__init__.py,sha256=cquIT6AKfmVtn7EkXyjYjG8hLJ0tMLDKmD2vmBh_vnY,270
 nabu/tests.py,sha256=hOJD1GGxn_KE1bWMoxfjnjzI7d9JBUpoc9B2_tVFiEk,1370
-nabu/testutils.py,sha256=eL81DWgYwu2CCFmDMsFs4QjfI7w9RPXFuPU5gvYF6No,8631
+nabu/testutils.py,sha256=4I62IP3VLOJx8JvGBgY1t4i4CiJMWfT_aUopxg39JIM,10047
 nabu/utils.py,sha256=tJI64BNXMhD6W293fwwcgf9bvTalYG_5AwVGYkgi6tU,27179
 nabu/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/app/bootstrap.py,sha256=3yLZJmrmQBmPJMBtE2ih2cspfqOy5T_UN2U8B3i_hkI,3266
@@ -70,7 +69,7 @@ nabu/estimation/cor.py,sha256=8RsyZ_MYT04EWvP2tLThftn_bD3cz9-uWo8D5FpXLKQ,50353
 nabu/estimation/cor_sino.py,sha256=qN6y16UVqoDX696JYyn3iWXDxQo0FMcFTuGbT92BW_s,18959
 nabu/estimation/distortion.py,sha256=DEXizQpgHBXmrhbQ0kuEchicxmiDgmU2qrh8bCgSezg,4701
 nabu/estimation/focus.py,sha256=CdtMFk6Xt4qq1JwwKDmDcVCeVocz-mpV0saikO0B1mc,17995
-nabu/estimation/motion.py,sha256=8fgwGsJMZleUugCCMRyZ2Zfi6-fWp-_dJpUnvetxGvk,26501
+nabu/estimation/motion.py,sha256=5p6Tsea-77Kc9QaYKkD33aQ_ZA5mSO1arHQ4tjclEJ0,26927
 nabu/estimation/tilt.py,sha256=6R8l8gnf00m-xdgLhvQmkvZ3lIO_8hDglNsFjzlzZ4E,8834
 nabu/estimation/translation.py,sha256=qoxT8VT38TZqrqLRwOef7-wBE5OeEObp_Qy9T2De2Do,10184
 nabu/estimation/utils.py,sha256=31d17Ng__NxcLOtGXPmbPPW1veh1m0poCvRgDCJssUA,347
@@ -82,15 +81,15 @@ nabu/estimation/tests/test_motion_estimation.py,sha256=WKUpkVand8VszoBIvsaEnhKqv
 nabu/estimation/tests/test_tilt.py,sha256=KIgTJqQvNfWndm8f3aRSdznWFl3AdQhYXiZPKLseYOs,1672
 nabu/estimation/tests/test_translation.py,sha256=RkOnCYgk9DZGKlIka1snqTv4wbIz_nG7-EHAxnBHsJU,2999
 nabu/io/__init__.py,sha256=AbQgj4-fCCHOKynO_PyAR9ejnFSuWKgroxxhxWVpjyQ,120
-nabu/io/cast_volume.py,sha256=eJuiKuZILD3xClUtYOjCqmwnbW12gwg-gJTzj606u_Y,21499
+nabu/io/cast_volume.py,sha256=y7MRsrC5WBbY0BtlnqQJWxByEP43Gq1qrq969bADGBI,22220
 nabu/io/detector_distortion.py,sha256=qO1Z6gejkBrixThvU_sLwH3UfLAe8aAO63YQ8z7PH78,11750
-nabu/io/reader.py,sha256=M6kLLzDe-OLh4veNr_F1Nn4TT6E6RfBpWPxMxrsnL94,41324
+nabu/io/reader.py,sha256=CRQfzLqG10QNzKpPY1j3z2toEAti2bNgImMwWnHQfVE,41775
 nabu/io/reader_helical.py,sha256=q3LOmu6F_4Uxi3rZZWJ-rsix2Lgu_saXXdiJF8TLi24,4533
 nabu/io/utils.py,sha256=iSeBhOIcLlKgiHXdDLfAdyvSrgdv6I5iQUcjT2gv_WQ,9303
 nabu/io/writer.py,sha256=0bZ2X0hvT-r_2Uu2u3fIfXZH7clxKIDhBwHmBS0ZcxM,15811
 nabu/io/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/io/tests/test_cast_volume.py,sha256=UGrIYVp1fxm372YFJinLWAL-xCtcR731axYchhonZHY,10774
-nabu/io/tests/test_readers.py,sha256=E26UE_nwqKcA6fBvzSdANNwqJ4Py07Dho61ShcMLb50,18131
+nabu/io/tests/test_readers.py,sha256=70vD7qPuhVjZnebDAR9zrXjk1cD65bCH_F_5xb0JfbA,18252
 nabu/io/tests/test_remove_volume.py,sha256=q632Rq0qLneDcJLHGWCR8HYlvdnTvaEEyTQAsNv1ggM,5967
 nabu/io/tests/test_writers.py,sha256=EJp3DKeaRko7FVTgGdjrl2tt6jES228_XT5Jb767I0w,3137
 nabu/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -110,7 +109,7 @@ nabu/misc/transpose.py,sha256=ogJ1PPYO0sOPUfCgjk-Ho5cTjlBbP-KXGqhCgTj75DY,223
 nabu/misc/unsharp.py,sha256=3xYsdiLTqTDlE8G-tIY7EeTf3nKxPrvMHOnXgkcKWvU,209
 nabu/misc/unsharp_cuda.py,sha256=-csDxfQt_naYn5O8fOxksYNqyFKxbF8lV7yXlPd2XoM,235
 nabu/misc/unsharp_opencl.py,sha256=HCPoobPwi2LEAfqGQ2qekjQi6G2VDKmqJQZTDXySv1Y,252
-nabu/misc/utils.py,sha256=s8ACtKdw9rTmlD0APdrpeo_ZIneKsTv2Xq3X2TRxCRk,3898
+nabu/misc/utils.py,sha256=b0JlnRmhEyx-9SBycRGQxPqNa25uTZqOFtGOF3Fyxdg,3904
 nabu/misc/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 nabu/misc/tests/test_binning.py,sha256=vcZZINi_v_KOw4DMqLIgPlF-CwLTG102Yf7dMQ5_SEo,1890
 nabu/misc/tests/test_interpolation.py,sha256=H8ZJ7dppCcpxVa9wOBkJ9U0mymH5lGyCJ0LZCYIK8PE,2389
@@ -135,21 +134,21 @@ 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=ALzlcBxaVMt7OprEgndfBE_csuv9aKZax3erD3nBWU0,51786
+nabu/pipeline/estimators.py,sha256=GhBs5bW4J2ZgDK30Pgg-hcb-B6SYQUPIP5sZmQhBpYA,51842
 nabu/pipeline/params.py,sha256=UKMQWFQnrlNMW5aIGty-JoGmBdkS6tpoAXCjW8n6FX8,4229
 nabu/pipeline/processconfig.py,sha256=3xx2Lc8uEzPAqSMwUncr4RCiCtKn2c7wnXXbPSn8GNo,7719
 nabu/pipeline/reader.py,sha256=wkxPHYOi_C8dHNc7kddB8AMtFuW7GjsP_tm6SJeHlEY,4792
 nabu/pipeline/utils.py,sha256=5GGhT9Wu7tHDlF3w7YNjTTYkNBl5xHa9EcRZSGFUWtM,3538
 nabu/pipeline/writer.py,sha256=NVeAtkWDtXg5UJ4C3wsbkfM23ZnK64atCWl8tjmjsuY,8166
 nabu/pipeline/fullfield/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nabu/pipeline/fullfield/chunked.py,sha256=MVqIceFGZKQZSiNa1PfetXrNAVlto-a4K4b_AyWtZnA,42534
+nabu/pipeline/fullfield/chunked.py,sha256=5dGoP_vCajI7kl2b9AysufG6DV1gdX9uvF0THrhNDaA,43330
 nabu/pipeline/fullfield/chunked_cuda.py,sha256=US5prrhNjsx3QVHkY5duQp8uFcGdgYEPzVS7nfWkJRw,6047
 nabu/pipeline/fullfield/computations.py,sha256=uqf7LvuDPm7n51BpP8eb8vTewDgRFyzSDP249g3FWBE,10098
 nabu/pipeline/fullfield/dataset_validator.py,sha256=HK_bmlII9pc59PXCgKJOyLv7Xu3DYv_jbH3RmQSgzvI,2933
 nabu/pipeline/fullfield/get_double_flatfield.py,sha256=uYFDAii6Nw4RCUQO_6Id6tXLdmtVbj_pxAHQWennSeE,5411
-nabu/pipeline/fullfield/nabu_config.py,sha256=F1E4KwHTfw6tynBnBjvr1F6tflIFsvDp8Pyop7xNmGg,33146
-nabu/pipeline/fullfield/processconfig.py,sha256=skNF8z7bV0-dw8xJUUNsrR2hSnmBYG1fnwIpyIS2Jfs,38393
-nabu/pipeline/fullfield/reconstruction.py,sha256=cljRyxD8rvZ5qDws_5AwChi7P-5T_0SSXsGkYUGOVb8,38006
+nabu/pipeline/fullfield/nabu_config.py,sha256=XcvPpJjyTmp8QSWK1lcNWRa1ybL0AQ0poj3O_CgDYtM,33150
+nabu/pipeline/fullfield/processconfig.py,sha256=72hjxgClKcxmzypVpvcWzkzoXP7Ypu5VpRxMjYQVnJQ,38461
+nabu/pipeline/fullfield/reconstruction.py,sha256=Fi3GCsVjO3CpYIWZM-4i6S2UOzG7iqVeukQ375j09Pg,38075
 nabu/pipeline/helical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/pipeline/helical/dataset_validator.py,sha256=HdKjUSj3PIpJb1dKSzJg8s4zXbAnMPWaPn8kvp_xQEs,657
 nabu/pipeline/helical/fbp.py,sha256=MKn587bO5Lj7yFu-Sll2RkOIY5r3rC-fmC10SzFU5i0,5841
@@ -177,7 +176,7 @@ nabu/preproc/distortion.py,sha256=XksQNrrSBfZS7mlvIdVEMZjw839ppQWP6AitTLcgfb0,33
 nabu/preproc/double_flatfield.py,sha256=WcYsNuotgQgm_KaioNa3OVI8rGfk3Wrn_YCW5v4mo4w,7895
 nabu/preproc/double_flatfield_cuda.py,sha256=lqgvZyeujdWJ5nF_GNRMQx7punjqA3SZ8K3IIyL3HDY,6197
 nabu/preproc/double_flatfield_variable_region.py,sha256=yiyvfGLFv3b93aKzHw84EQszPwQHfBv0PqtlQ8khvm4,2258
-nabu/preproc/flatfield.py,sha256=Lgh_2MsszLshUotH-Y1RJj0qtplnASy81tuanuxPrdc,30552
+nabu/preproc/flatfield.py,sha256=t0NaV0NYaUAKtfWAop2srhL7wrfw6sGPMUAjs--LE3k,30574
 nabu/preproc/flatfield_cuda.py,sha256=Iiqv7bHa870DZOH68L19xiN1kG9I9JXuckFfA3khGtY,5482
 nabu/preproc/flatfield_variable_region.py,sha256=RVmSW515vgkHagjqotPNPUe97oQooHgdqkBn6hPH_2Q,3142
 nabu/preproc/phase.py,sha256=nRFhnHN_Bmmu5AHDcoO-Kt59sXYFSQaTljHZ5dlZiA0,13857
@@ -228,7 +227,6 @@ 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
@@ -237,6 +235,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/iterative.py,sha256=urZg_Aj3P2wGfsbjlyvmOvf2yd-kXNt_f4Sjlj6oxhE,637
 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
@@ -258,7 +257,7 @@ 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=WnY3GpNc5EfmYaCSgoCM2kguBkd3LC2BRa6U1vO6wfI,23982
+nabu/resources/dataset_analyzer.py,sha256=X52X2YAOGBSMRfWko4Z2-oL_VePpc27A1GZbbTAk5yI,25739
 nabu/resources/gpu.py,sha256=oQA8PpPdyuIzpxq1PwVd9gJdyCiLIry2godUV1AbPW0,5769
 nabu/resources/logger.py,sha256=xV9UoLZBw3wXAWYfOgqrnOtzJc9aC1VNO4LM2cHxWJg,3738
 nabu/resources/nxflatfield.py,sha256=kgHPf_jGQiuJ_EFe8fladRkx_PM6PfdRtcf5Tf2cYgU,12385
@@ -271,6 +270,7 @@ 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_dataset_analyzer.py,sha256=qp0cCwZfZMITWNDvxa-q84xpfUyFnQygDwCLN7QMSOs,1590
 nabu/resources/tests/test_extract.py,sha256=6ufLTc4Wgf9-FLsscpG2TbUDEn767iLVdyOrwRQyI9A,443
 nabu/resources/tests/test_nxflatfield.py,sha256=XCiFULzNyApdhr89a3a3BseJMPUN4JnzxQ8VdBaA8ac,4225
 nabu/resources/tests/test_units.py,sha256=F2jFTck-1UwYET1MwTtX6ntzYUosfwOJkugSencGgz8,2155
@@ -319,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.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,,
+nabu-2025.1.1.dist-info/licenses/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
+nabu-2025.1.1.dist-info/METADATA,sha256=3wyX7ZF2Sqn5Z_w80g6_dvSEeT6Uct06l8DvCoYRxpA,4271
+nabu-2025.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nabu-2025.1.1.dist-info/entry_points.txt,sha256=YxzCY5CNQ1XHrIGbRKg-BgC1Jy7QaCITdITpyhhxpZU,1338
+nabu-2025.1.1.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
+nabu-2025.1.1.dist-info/RECORD,,

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)

nabu/reconstruction/astra.py

@@ -1,245 +0,0 @@
-# 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)