nabu 2025.1.0rc4__tar.gz → 2025.1.0rc6__tar.gz

{nabu-2025.1.0rc4/nabu.egg-info → nabu-2025.1.0rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabu
-Version: 2025.1.0rc4
+Version: 2025.1.0rc6
 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.0rc4 → nabu-2025.1.0rc6}/nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2025.1.0-rc4"
+__version__ = "2025.1.0-rc6"
 __nabu_modules__ = [
     "app",
     "cuda",

{nabu-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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,

{nabu-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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.0rc6/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-2025.1.0rc4 → nabu-2025.1.0rc6}/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.0rc4 → nabu-2025.1.0rc6/nabu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabu
-Version: 2025.1.0rc4
+Version: 2025.1.0rc6
 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.0rc4 → nabu-2025.1.0rc6}/nabu.egg-info/SOURCES.txt

@@ -278,6 +278,7 @@ nabu/resources/templates/id16_holo.conf
 nabu/resources/templates/id16a_fluo.conf
 nabu/resources/templates/id19_pag.conf
 nabu/resources/tests/__init__.py
+nabu/resources/tests/test_dataset_analyzer.py
 nabu/resources/tests/test_extract.py
 nabu/resources/tests/test_nxflatfield.py
 nabu/resources/tests/test_units.py