nabu 2022.3.0a1__py3-none-any.whl → 2023.1.0a2__py3-none-any.whl

nabu/pipeline/helical/span_strategy.py

@@ -26,7 +26,7 @@ class SpanStrategy:
         ----------
         z_pix_per_proj : array of floats
             an array of floats with one entry per projection, in pixel units. The values are the vertical displacements of the detector.
-            An increasing z means that the rotation axis is following the positive direction of the detector  vertical axis, which is pointing toward the ground.
+            An decreasing z means that the rotation axis is following the positive direction of the detector  vertical axis, which is pointing toward the ground.
             In the experimental setup, the vertical detector axis is pointing toward the ground. Moreover the values are offsetted so that the
             first value is zero. The offset value, in millimiters is z_offset_mm and it is the vertical position of the sample stage relatively
             to the center of the detector. A negative z_offset_mm means that the sample stage is below the detector for the first projection, and this is almost
@@ -186,9 +186,18 @@ class SpanStrategy:
 
     def get_informative_string(self):
         doable_span_v = self.get_doable_span()
+        if self.z_pix_per_proj[-1] > self.z_pix_per_proj[-1]:
+            direction = "ascending"
+        else:
+            direction = "descending"
+
         s = f"""
         Doable vertical span
         --------------------
+             The scan has been performed with an {direction} vertical translation of the rotation axis.
+              
+             The detector vertical axis is up side down.
+
              Detector reference system at iproj=0:
                 from vertical view height  ...   {doable_span_v.view_heights_minmax[0]}
                 up to  (included)     ...   {doable_span_v.view_heights_minmax[1]}
@@ -196,9 +205,7 @@ class SpanStrategy:
                  The slice that projects to the first line of the first projection 
                  corresponds to vertical heigth = 0
 
-             In the sample stage reference system:
-                 from vertical height above stage ( pixel units)  ...   {doable_span_v.z_pix_minmax[0]}
-                 up to  (included)                                ...  {doable_span_v.z_pix_minmax[1]}
+             In voxels, the vertical doable span measures: {doable_span_v.z_pix_minmax[1] - doable_span_v.z_pix_minmax[0]}
 
              And in millimiters above the stage:
                  from vertical height above stage ( mm units)  ...   {doable_span_v.z_mm_minmax[0] - self.z_offset_mm }

nabu/pipeline/helical/tests/test_accumulator.py

@@ -57,7 +57,6 @@ class TestGriddedAccumulator:
     """
 
     def test_regridding(self):
-
         span_info = span_strategy.SpanStrategy(
             z_pix_per_proj=self.z_pix_per_proj,
             x_pix_per_proj=self.x_pix_per_proj,
@@ -109,7 +108,6 @@ class TestGriddedAccumulator:
         pnum_end_list = pnum_start_list[1:] + [proj_num_end]
 
         for pnum_start, pnum_end in zip(pnum_start_list, pnum_end_list):
-
             start_in_chunk = pnum_start - my_first_pnum
             end_in_chunk = pnum_end - my_first_pnum
 
@@ -127,7 +125,6 @@ class TestGriddedAccumulator:
         # h5py.File("processed_sinogram.h5","w")["sinogram"] = res
 
     def _read_data_and_apply_flats(self, sub_total_prange_slice, subchunk_slice, chunk_info, sub_region, span_info):
-
         my_integer_shifts_v = chunk_info.integer_shift_v[subchunk_slice]
         fract_complement_shifts_v = chunk_info.fract_complement_to_integer_shift_v[subchunk_slice]
         x_shifts_list = chunk_info.x_pix_per_proj[subchunk_slice]

nabu/pipeline/helical/tests/test_pipeline_elements_full.py

@@ -98,7 +98,6 @@ class TestGriddedAccumulator:
     """
 
     def test_regridding(self):
-
         span_info = span_strategy.SpanStrategy(
             z_pix_per_proj=self.z_pix_per_proj,
             x_pix_per_proj=self.x_pix_per_proj,
@@ -150,7 +149,6 @@ class TestGriddedAccumulator:
         pnum_end_list = pnum_start_list[1:] + [proj_num_end]
 
         for pnum_start, pnum_end in zip(pnum_start_list, pnum_end_list):
-
             start_in_chunk = pnum_start - my_first_pnum
             end_in_chunk = pnum_end - my_first_pnum
 
@@ -205,7 +203,6 @@ class TestGriddedAccumulator:
         # put the test here
 
     def _reconstruct(self):
-
         axis_corrections = np.zeros_like(self.reconstruction_space.gridded_angles_rad)
         self.reconstruction.set_custom_angles_and_axis_corrections(
             self.reconstruction_space.gridded_angles_rad, axis_corrections
@@ -222,7 +219,6 @@ class TestGriddedAccumulator:
         n_provided_angles = self.d_radios_slim.shape[0]
 
         for first_angle_index in range(0, n_provided_angles, self.num_weight_radios_per_app):
-
             end_angle_index = min(n_provided_angles, first_angle_index + self.num_weight_radios_per_app)
             self._d_radios_weights[: end_angle_index - first_angle_index].set(
                 weights[first_angle_index:end_angle_index, i_slice]
@@ -242,7 +238,6 @@ class TestGriddedAccumulator:
         )
 
     def _init_reconstructor(self, processed_radios_shape):
-
         one_slice_data_shape = processed_radios_shape[:1] + processed_radios_shape[2:]
 
         self.d_radios_slim = garray.zeros(one_slice_data_shape, np.float32)
@@ -297,7 +292,6 @@ class TestGriddedAccumulator:
         return processed_radios
 
     def _read_data_and_apply_flats(self, sub_total_prange_slice, subchunk_slice, chunk_info, sub_region, span_info):
-
         my_integer_shifts_v = chunk_info.integer_shift_v[subchunk_slice]
 
         subr_start_z, subr_end_z = sub_region

nabu/pipeline/helical/tests/test_strategy.py

@@ -34,7 +34,6 @@ def bootstrap_TestStrategy(request):
 @pytest.mark.usefixtures("bootstrap_TestStrategy")
 class TestStrategy:
     def test_strategy(self):
-
         # the python implementation is slow. so we take only a p[art of the scan
         limit = 4000
         span_info = SpanStrategy(

nabu/pipeline/helical/weight_balancer.py

@@ -43,7 +43,6 @@ class WeightBalancer:
             angle = self.my_angles_rad[i]
 
             for i_half_turn in range(-n_span - 1, n_span + 2):
-
                 if i_half_turn == 0:
                     w_res[:] += radios_weights[i]
                     continue

nabu/pipeline/params.py

@@ -78,6 +78,7 @@ files_formats = {
     "j2k": "jp2",
     "jpeg2000": "jp2",
     "edf": "edf",
+    "vol": "vol",
 }
 
 distribution_methods = {
@@ -129,6 +130,9 @@ rings_methods = {
     "munch": "munch",
 }
 
+detector_distortion_correction_methods = {"none": None, "": None, "identity": "identity", "map_xz": "map_xz"}
+
+
 radios_rotation_mode = {
     "none": None,
     "": None,

nabu/pipeline/processconfig.py

@@ -1,6 +1,6 @@
 import os
 from .config import parse_nabu_config_file
-from ..utils import deprecation_warning
+from ..utils import deprecation_warning, is_writeable
 from ..resources.logger import Logger, PrinterLogger
 from .config import validate_config
 from ..resources.dataset_analyzer import analyze_dataset, _tomoscan_has_nxversion
@@ -92,7 +92,11 @@ class ProcessConfigBase:
             logger_filename = create_logger
         else:
             raise ValueError("Expected bool or str for create_logger")
-        self.logger = Logger("nabu", level=self.nabu_config["pipeline"]["verbosity"], logfile=logger_filename)
+        if not is_writeable(os.path.dirname(logger_filename)):
+            self.logger = PrinterLogger()
+            self.logger.error("Cannot create logger file %s: no permission to write therein" % logger_filename)
+        else:
+            self.logger = Logger("nabu", level=self.nabu_config["pipeline"]["verbosity"], logfile=logger_filename)
 
     def _parse_configuration(self, conf_fname, conf_dict):
         """

nabu/pipeline/writer.py

@@ -4,7 +4,7 @@ from posixpath import join as posixjoin
 from silx.io.dictdump import dicttonx
 from tomoscan.esrf import HDF5Volume, TIFFVolume, MultiTIFFVolume, EDFVolume, JP2KVolume
 from ..resources.logger import LoggerOrPrint
-from ..io.writer import get_datetime, NXProcessWriter
+from ..io.writer import get_datetime, NXProcessWriter, HSTVolVolume
 from ..io.utils import convert_dict_values
 from .. import version as nabu_version
 from ..resources.utils import is_hdf5_extension
@@ -94,6 +94,7 @@ class WriterManager:
         self.is_bigtiff = file_format in ["tiff", "tif"] and any(
             [self.extra_options.get(opt, False) for opt in ["tiff_single_file", "use_bigtiff"]]
         )
+        self.is_vol = file_format == "vol"
 
         self.file_prefix = file_prefix
         self._set_output_dir(output_dir)
@@ -127,7 +128,7 @@ class WriterManager:
             if self.is_bigtiff:
                 writer = MultiTIFFVolume
                 writer_kwargs = _get_writer_kwargs_multi_frames()
-                writer_kwargs.update({"append": self.extra_options.get("single_tiff_initialized", False)})
+                writer_kwargs.update({"append": self.extra_options.get("single_output_file_initialized", False)})
             else:
                 writer = TIFFVolume
                 writer_kwargs = _get_writer_kwargs_single_frame()
@@ -138,10 +139,14 @@ class WriterManager:
                         "overwrite": True,
                     }
                 )
+        elif file_format == "vol":
+            writer = HSTVolVolume
+            writer_kwargs = _get_writer_kwargs_multi_frames()
+            writer_kwargs.update({"append": self.extra_options.get("single_output_file_initialized", False)})
         elif file_format == "edf":
             writer = EDFVolume
             writer_kwargs = _get_writer_kwargs_single_frame()
-        elif file_format in ["jp2k", "j2k", "jp2000", "jpeg2000"]:
+        elif file_format in ["jp2k", "j2k", "jp2", "jp2000", "jpeg2000"]:
             writer = JP2KVolume
             writer_kwargs = _get_writer_kwargs_single_frame()
         else:
@@ -153,7 +158,7 @@ class WriterManager:
         # This class is generally used to create partial files, i.e files containing a subset of the processed volume.
         # In this case, the files containing partial results are stored in a sub-directory with the same file prefix.
         # Otherwise, everything is put in a single file (for now it's only the case for "big tiff").
-        self.is_partial_file = not (self.is_bigtiff)
+        self.is_partial_file = not (self.is_bigtiff or self.is_vol)
         if self.is_partial_file:
             output_dir = path.join(output_dir, self.file_prefix)
 

nabu/preproc/distortion.py

@@ -1,5 +1,5 @@
 import numpy as np
-from scipy.interpolate import interpn
+from scipy.interpolate import RegularGridInterpolator
 from ..utils import check_supported
 from ..estimation.distortion import estimate_flat_distortion
 
@@ -15,13 +15,14 @@ def correct_distortion_interpn(image, coords, bounds_error=False, fill_value=Non
     coords: array
         Coordinates of the distortion correction to apply, with the shape (Ny, Nx, 2)
     """
-    return interpn(
+    foo = RegularGridInterpolator(
         (np.arange(image.shape[0]), np.arange(image.shape[1])),
         image,
-        coords,
         bounds_error=bounds_error,
+        method="linear",
         fill_value=fill_value,
     )
+    return foo(coords)
 
 
 class DistortionCorrection:

nabu/preproc/double_flatfield.py

@@ -8,7 +8,6 @@ from ..io.writer import Writers
 
 
 class DoubleFlatField:
-
     _default_h5_path = "/entry/double_flatfield/results"
     _small = 1e-7
 
@@ -17,6 +16,7 @@ class DoubleFlatField:
         shape,
         result_url=None,
         sub_region=None,
+        detector_corrector=None,
         input_is_mlog=True,
         output_is_mlog=False,
         average_is_on_log=False,
@@ -55,7 +55,7 @@ class DoubleFlatField:
         self.radios_shape = get_2D_3D_shape(shape)
         self.n_angles = self.radios_shape[0]
         self.shape = self.radios_shape[1:]
-        self._init_filedump(result_url, sub_region)
+        self._init_filedump(result_url, sub_region, detector_corrector)
         self._init_processing(input_is_mlog, output_is_mlog, average_is_on_log, sigma_filter, filter_mode)
         self._computed = False
 
@@ -67,6 +67,13 @@ class DoubleFlatField:
 
     def _load_dff_dump(self):
         res = self.reader.get_data(self.result_url)
+        if self.detector_corrector is not None:
+            if res.ndim == 2:
+                res = self.detector_corrector.transform(res)
+            else:
+                for i in range(res.shape[0]):
+                    res[i] = self.detector_corrector.transform(res[i])
+
         if res.ndim == 3 and res.shape[0] == 1:
             res = res.reshape(res.shape[1], res.shape[2])
         if res.shape != self.shape:
@@ -76,10 +83,11 @@ class DoubleFlatField:
             )
         return res
 
-    def _init_filedump(self, result_url, sub_region):
+    def _init_filedump(self, result_url, sub_region, detector_corrector=None):
         if isinstance(result_url, str):
             result_url = DataUrl(file_path=result_url, data_path=self._default_h5_path)
         self.sub_region = sub_region
+        self.detector_corrector = detector_corrector
         self.result_url = result_url
         self.writer = None
         self.reader = None
@@ -87,7 +95,11 @@ class DoubleFlatField:
             return
         self._get_reader_writer_class()
         if path.exists(result_url.file_path()):
-            self.reader = self._reader_cls(sub_region=self.sub_region)
+            if detector_corrector is None:
+                adapted_subregion = sub_region
+            else:
+                adapted_subregion = self.detector_corrector.get_adapted_subregion(sub_region)
+            self.reader = self._reader_cls(sub_region=adapted_subregion)
         else:
             self.writer = self._writer_cls(self.result_url.file_path())
 

nabu/preproc/double_flatfield_cuda.py

@@ -1,7 +1,6 @@
-import numpy as np
 from .double_flatfield import DoubleFlatField
 from ..utils import check_shape
-from ..cuda.utils import get_cuda_context, __has_pycuda__
+from ..cuda.utils import __has_pycuda__
 from ..cuda.processing import CudaProcessing
 from ..misc.unsharp_cuda import CudaUnsharpMask
 
@@ -16,6 +15,7 @@ class CudaDoubleFlatField(DoubleFlatField):
         shape,
         result_url=None,
         sub_region=None,
+        detector_corrector=None,
         input_is_mlog=True,
         output_is_mlog=False,
         average_is_on_log=False,
@@ -31,6 +31,7 @@ class CudaDoubleFlatField(DoubleFlatField):
             shape,
             result_url=result_url,
             sub_region=sub_region,
+            detector_corrector=detector_corrector,
             input_is_mlog=input_is_mlog,
             output_is_mlog=output_is_mlog,
             average_is_on_log=average_is_on_log,

nabu/preproc/double_flatfield_variable_region.py

@@ -8,7 +8,14 @@ from ..misc.binning import get_binning_function
 
 
 class DoubleFlatFieldVariableRegion(DoubleFlatField):
-    def __init__(self, shape, result_url=None, binning_x=None, binning_z=None):
+    def __init__(
+        self,
+        shape,
+        result_url=None,
+        binning_x=None,
+        binning_z=None,
+        detector_corrector=None,
+    ):
         """This class provides the division by the double flat field.
         At variance with the standard class, it store as member the
         whole field, and performs the division by the proper region
@@ -20,12 +27,11 @@ class DoubleFlatFieldVariableRegion(DoubleFlatField):
         self.radios_shape = get_2D_3D_shape(shape)
         self.n_angles = self.radios_shape[0]
         self.shape = self.radios_shape[1:]
-        self._init_filedump(result_url, None)
+        self._init_filedump(result_url, None, detector_corrector)
 
         data = self._load_dff_full_dump()
 
         if (binning_z, binning_x) != (1, 1):
-
             print(" (binning_z, binning_x) ", (binning_z, binning_x))
             binning_function = get_binning_function((binning_z, binning_x))
             if binning_function is None:
@@ -38,6 +44,10 @@ class DoubleFlatFieldVariableRegion(DoubleFlatField):
 
     def _load_dff_full_dump(self):
         res = self.reader.get_data(self.result_url)
+        if self.detector_corrector is not None:
+            self.detector_corrector.set_full_transformation()
+            res = self.detector_corrector.transform(res, do_full=True)
+
         return res
 
     def apply_double_flatfield_for_sub_regions(self, radios, sub_regions_per_radio):
@@ -48,7 +58,6 @@ class DoubleFlatFieldVariableRegion(DoubleFlatField):
         my_double_ff = self.data
 
         for i in range(radios.shape[0]):
-
             s_x, e_x, s_y, e_y = sub_regions_per_radio[i]
 
             dff = my_double_ff[s_y:e_y, s_x:e_x]

nabu/preproc/flatfield.py

@@ -1,7 +1,8 @@
+from multiprocessing.pool import ThreadPool
 from bisect import bisect_left
 import numpy as np
 from ..io.reader import load_images_from_dataurl_dict
-from ..utils import check_supported
+from ..utils import check_supported, get_num_threads
 
 
 class FlatFieldArrays:
@@ -26,6 +27,7 @@ class FlatFieldArrays:
         nan_value=1.0,
         radios_srcurrent=None,
         flats_srcurrent=None,
+        n_threads=None,
     ):
         """
         Initialize a flat-field normalization process.
@@ -59,6 +61,8 @@ class FlatFieldArrays:
             for the corresponding flat. The items must be ordered in the same order as the flats indices (`flats.keys()`).
             This parameter must be used along with 'radios_srcurrent'.
             Please refer to "Notes" for more information on this normalization.
+        n_threads: int or None, optional
+            Number of threads to use for flat-field correction. Default is to use half the threads.
 
         Important
         ----------
@@ -98,6 +102,7 @@ class FlatFieldArrays:
         self._precompute_flats_indices_weights()
         self._configure_srcurrent_normalization(radios_srcurrent, flats_srcurrent)
         self.distortion_correction = distortion_correction
+        self.n_threads = min(1, get_num_threads(n_threads) // 2)
 
     def _set_parameters(self, radios_shape, radios_indices, interpolation, nan_value):
         self._set_radios_shape(radios_shape)
@@ -147,8 +152,7 @@ class FlatFieldArrays:
         self._sorted_dark_indices = sorted(self.darks.keys())
         self._dark = None
 
-    @staticmethod
-    def _check_frames(frames, frames_type, min_frames_required, max_frames_supported):
+    def _check_frames(self, frames, frames_type, min_frames_required, max_frames_supported):
         n_frames = len(frames)
         if n_frames < min_frames_required:
             raise ValueError("Need at least %d %s" % (min_frames_required, frames_type))
@@ -156,6 +160,15 @@ class FlatFieldArrays:
             raise ValueError(
                 "Flat-fielding with more than %d %s is not supported" % (max_frames_supported, frames_type)
             )
+        self._check_frame_shape(frames, frames_type)
+
+    def _check_frame_shape(self, frames, frames_type):
+        for frame_idx, frame in frames.items():
+            if frame.shape != self.shape:
+                raise ValueError(
+                    "Invalid shape for %s %s: expected %s, but got %s"
+                    % (frames_type, frame_idx, str(self.shape), str(frame.shape))
+                )
 
     def _check_radios_and_indices_congruence(self, radios_indices):
         if radios_indices.size != self.n_radios:
@@ -318,15 +331,24 @@ class FlatFieldArrays:
         """
         do_flats_distortion_correction = self.distortion_correction is not None
         dark = self.get_dark()
-        for i in range(self.n_radios):
+
+        def apply_flatfield(i):
             radio_data = radios[i]
             radio_data -= dark
             flat = self.get_flat(i)
             flat = flat - dark
             if do_flats_distortion_correction:
                 flat = self.distortion_correction.estimate_and_correct(flat, radio_data)
-            radios[i] = radio_data / flat
-            self.remove_invalid_values(radios[i])
+            np.divide(radio_data, flat, out=radio_data)
+            self.remove_invalid_values(radio_data)
+
+        if self.n_threads > 2:
+            with ThreadPool(self.n_threads) as tp:
+                tp.map(apply_flatfield, range(self.n_radios))
+        else:
+            for i in range(self.n_radios):
+                apply_flatfield(i)
+
         if self.normalize_srcurrent:
             radios *= self.srcurrent_ratios[:, np.newaxis, np.newaxis]
         return radios
@@ -388,7 +410,7 @@ class FlatFieldDataUrls(FlatField):
         interpolation: str, optional
             Interpolation method for flat-field. See below for more details.
         distortion_correction: DistortionCorrection, optional
-            A DistortionCorrection object. If provided, it is used to
+            A DistortionCorrection object. If provided, it is used to correct flat distortions based on each radio.
         nan_value: float, optional
             Which float value is used to replace nan/inf after flat-field.
 

nabu/preproc/flatfield_cuda.py

@@ -133,7 +133,6 @@ class CudaFlatFieldDataUrls(CudaFlatField):
         cuda_options: Union[dict, None] = None,
         **chunk_reader_kwargs,
     ):
-
         flats_arrays_dict = load_images_from_dataurl_dict(flats, **chunk_reader_kwargs)
         darks_arrays_dict = load_images_from_dataurl_dict(darks, **chunk_reader_kwargs)
         super().__init__(

nabu/preproc/flatfield_variable_region.py

@@ -3,9 +3,13 @@ from .flatfield import FlatFieldArrays, load_images_from_dataurl_dict, check_sup
 
 
 class FlatFieldArraysVariableRegion(FlatFieldArrays):
-
     _full_shape = True
 
+    def _check_frame_shape(self, frames, frames_type):
+        # in helical the flat is the whole one and its shape does not necesseraly match the smaller frames.
+        # Therefore no check is done to allow this.
+        pass
+
     def _check_radios_and_indices_congruence(self, radios_indices):
         """At variance with parent class, preprocesing is done with on a fraction of the radios,
         whose length may vary. So we dont enforce here that the lenght is always the same
@@ -50,7 +54,6 @@ class FlatFieldDataVariableRegionUrls(FlatFieldArraysVariableRegion):
         flats_srcurrent=None,
         **chunk_reader_kwargs,
     ):
-
         flats_arrays_dict = load_images_from_dataurl_dict(flats, **chunk_reader_kwargs)
         darks_arrays_dict = load_images_from_dataurl_dict(darks, **chunk_reader_kwargs)
 

nabu/preproc/phase.py

@@ -38,7 +38,6 @@ def lmicron_to_db(Lmicron, energy, distance):
 
 
 class PaganinPhaseRetrieval:
-
     available_padding_modes = ["zeros", "mean", "edge", "symmetric", "reflect"]
     powers = generate_powers()
 

nabu/preproc/phase_cuda.py

@@ -9,7 +9,6 @@ from ..cuda.kernel import CudaKernel
 
 
 class CudaPaganinPhaseRetrieval(PaganinPhaseRetrieval):
-
     supported_paddings = ["zeros", "constant", "edge"]
 
     def __init__(

nabu/preproc/tests/test_ctf.py

@@ -54,7 +54,6 @@ class TestCtf:
         diff[diff > np.percentile(diff, 99)] = 0
         assert diff.max() < self.abs_tol * (np.abs(ref).mean()), error_message
 
-    @pytest.mark.skipif(True, reason="wait for scipy.interpolate calls to be fixed")
     def test_ctf_id16_way(self):
         """test the ctf phase retrieval.
         The cft filter, of the CtfFilter class is iniitalised with the geomety informations contained in geo_pars object
@@ -95,13 +94,15 @@ class TestCtf:
             correction_spike_threshold=3,
         )
 
-        my_flat = scipy.interpolate.interpn(
+        interpolator = scipy.interpolate.RegularGridInterpolator(
             (np.arange(my_flat.shape[0]), np.arange(my_flat.shape[1])),
             my_flat,
-            new_coordinates,
             bounds_error=False,
+            method="linear",
             fill_value=None,
         )
+        my_flat = interpolator(new_coordinates)
+
         my_img = my_img / my_flat
         my_img = correct_spikes(my_img, self.remove_spikes_threshold)
 

nabu/preproc/tests/test_flatfield.py

@@ -131,18 +131,18 @@ def generate_test_flatfield_generalized(
     flats = {}
     flats_urls = {}
     for i, flat_idx in enumerate(flats_indices):
-        flats["flats_%04d" % flat_idx] = np.zeros(img_shape, dtype=dtype) + flats_values[i]
+        flats["flats_%06d" % flat_idx] = np.zeros(img_shape, dtype=dtype) + flats_values[i]
         flats_urls[flat_idx] = DataUrl(
-            file_path=testffname, data_path=str("/flats/flats_%04d" % flat_idx), scheme="silx"
+            file_path=testffname, data_path=str("/flats/flats_%06d" % flat_idx), scheme="silx"
         )
 
     # Darks
     darks = {}
     darks_urls = {}
     for i, dark_idx in enumerate(darks_indices):
-        darks["darks_%04d" % dark_idx] = np.zeros(img_shape, dtype=dtype) + darks_values[i]
+        darks["darks_%06d" % dark_idx] = np.zeros(img_shape, dtype=dtype) + darks_values[i]
         darks_urls[dark_idx] = DataUrl(
-            file_path=testffname, data_path=str("/darks/darks_%04d" % dark_idx), scheme="silx"
+            file_path=testffname, data_path=str("/darks/darks_%06d" % dark_idx), scheme="silx"
         )
 
     dicttoh5(flats, testffname, h5path="/flats", mode="w")
@@ -455,7 +455,6 @@ class FlatFieldTestDataset:
         self.projs_data = np.zeros((len(self.projs_idx),) + self.shp, "f")
         self.projs = {}
         for i, proj_idx in enumerate(self.projs_idx):
-
             flat = self.get_flat(proj_idx)
 
             proj_val = self.dark_val + proj_idx * (flat[0, 0] - self.dark_val)
@@ -562,8 +561,8 @@ def generate_test_flatfield(n_radios, radio_shape, flat_interval, h5_fname):
     for i in range(n_radios):
         f_i = i + 2
         if (i % flat_interval) == 0:
-            flats["flats_%04d" % i] = np.zeros(radio_shape, "f") + f_i
-            flats_urls[i] = DataUrl(file_path=testffname, data_path=str("/flats/flats_%04d" % i), scheme="silx")
+            flats["flats_%06d" % i] = np.zeros(radio_shape, "f") + f_i
+            flats_urls[i] = DataUrl(file_path=testffname, data_path=str("/flats/flats_%06d" % i), scheme="silx")
         radios[i] = i * (f_i - 1) + 1
     dark = {"dark_0000": dark_data}
     dicttoh5(flats, testffname, h5path="/flats", mode="w")

nabu/reconstruction/fbp_opencl.py

@@ -2,6 +2,7 @@ import numpy as np
 from silx.opencl.backprojection import Backprojection
 from ..utils import deprecation_warning
 
+
 # Compatibility layer Nabu/silx
 class Backprojector:
     def __init__(
@@ -21,7 +22,6 @@ class Backprojector:
         profile=False,
         extra_options=None,
     ):
-
         if slice_roi and (
             slice_roi[0] > 0 or slice_roi[2] > 0 or slice_roi[1] < sino_shape[1] or slice_roi[3] < sino_shape[1]
         ):

nabu/reconstruction/filtering.py

@@ -8,7 +8,6 @@ from ..utils import get_cuda_srcfile, check_supported, updiv
 
 
 class SinoFilter:
-
     available_padding_modes = ["zeros", "edges"]
 
     def __init__(

nabu/reconstruction/tests/test_fbp.py

@@ -85,6 +85,7 @@ class TestFBP:
         Test the "axis correction" feature
         """
         sino = self.sino_512
+
         # Create a sinogram with a drift in the rotation axis
         def create_drifted_sino(sino, drifts):
             out = np.zeros_like(sino)

nabu/resources/dataset_analyzer.py

@@ -19,7 +19,6 @@ _tomoscan_has_nxversion = parse_version(tomoscan_version) > parse_version("0.6.0
 
 
 class DatasetAnalyzer:
-
     _scanner = None
     kind = "none"