nabu 2024.2.14__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/stitching/stitcher/pre_processing.py

@@ -2,7 +2,8 @@ import numpy
 import logging
 import h5py
 import os
-from typing import Iterable
+import pint
+from collections.abc import Iterable
 from silx.io.url import DataUrl
 from silx.io.utils import get_data
 from datetime import datetime
@@ -26,8 +27,8 @@ from nabu.stitching.config import (
 from nabu.stitching.utils import find_projections_relative_shifts
 from functools import lru_cache as cache
 from .single_axis import SingleAxisStitcher
-from pyunitsystem.metricsystem import MetricSystem
 
+_ureg = pint.get_application_registry()
 
 _logger = logging.getLogger(__name__)
 
@@ -40,7 +41,6 @@ class PreProcessingStitching(SingleAxisStitcher):
     """
 
     def __init__(self, configuration, progress=None) -> None:
-        """ """
         if not isinstance(configuration, PreProcessedSingleAxisStitchingConfiguration):
             raise TypeError(
                 f"configuration is expected to be an instance of {PreProcessedSingleAxisStitchingConfiguration}. Get {type(configuration)} instead"
@@ -239,18 +239,18 @@ class PreProcessingStitching(SingleAxisStitcher):
             if not scan_0.field_of_view == scan_1.field_of_view:
                 raise ValueError(f"{scan_0} and {scan_1} have different field of view")
             # check distance
-            if scan_0.distance is None:
+            if scan_0.sample_detector_distance is None:
                 _logger.warning(f"no distance found for {scan_0}")
-            elif not numpy.isclose(scan_0.distance, scan_1.distance, rtol=10e-3):
+            elif not numpy.isclose(scan_0.sample_detector_distance, scan_1.sample_detector_distance, rtol=10e-3):
                 raise ValueError(f"{scan_0} and {scan_1} have different sample / detector distance")
             # check pixel size
-            if not numpy.isclose(scan_0.x_pixel_size, scan_1.x_pixel_size):
+            if not numpy.isclose(scan_0.sample_x_pixel_size, scan_1.sample_x_pixel_size):
                 raise ValueError(
-                    f"{scan_0} and {scan_1} have different x pixel size. {scan_0.x_pixel_size} vs {scan_1.x_pixel_size}"
+                    f"{scan_0} and {scan_1} have different x pixel size. {scan_0.sample_x_pixel_size} vs {scan_1.sample_x_pixel_size}"
                 )
-            if not numpy.isclose(scan_0.y_pixel_size, scan_1.y_pixel_size):
+            if not numpy.isclose(scan_0.sample_y_pixel_size, scan_1.sample_y_pixel_size):
                 raise ValueError(
-                    f"{scan_0} and {scan_1} have different y pixel size. {scan_0.y_pixel_size} vs {scan_1.y_pixel_size}"
+                    f"{scan_0} and {scan_1} have different y pixel size. {scan_0.sample_y_pixel_size} vs {scan_1.sample_y_pixel_size}"
                 )
 
         for scan in self.series:
@@ -292,7 +292,7 @@ class PreProcessingStitching(SingleAxisStitcher):
                 axis_N_pos_px = []
                 for scan, pos_in_mm in zip(self.series, pos_as_mm):
                     pixel_size_m = self.configuration.pixel_size or scan.pixel_size
-                    axis_N_pos_px.append((pos_in_mm / MetricSystem.MILLIMETER.value) / pixel_size_m)
+                    axis_N_pos_px.append((pos_in_mm * _ureg.millimeter).to_base_units().magnitude / pixel_size_m)
                 return axis_N_pos_px
             else:
                 # deduce from motor position and pixel size
@@ -472,7 +472,7 @@ class PreProcessingStitching(SingleAxisStitcher):
         """
         nx_tomo = NXtomo()
 
-        nx_tomo.energy = self.series[0].energy
+        nx_tomo.energy = self.series[0].energy * _ureg.keV
         start_times = list(filter(None, [scan.start_time for scan in self.series]))
         end_times = list(filter(None, [scan.end_time for scan in self.series]))
 
@@ -496,9 +496,9 @@ class PreProcessingStitching(SingleAxisStitcher):
 
         # handle detector (without frames)
         nx_tomo.instrument.detector.field_of_view = self.series[0].field_of_view
-        nx_tomo.instrument.detector.distance = self.series[0].distance
-        nx_tomo.instrument.detector.x_pixel_size = self.series[0].x_pixel_size
-        nx_tomo.instrument.detector.y_pixel_size = self.series[0].y_pixel_size
+        nx_tomo.instrument.detector.distance = self.series[0].sample_detector_distance * _ureg.meter
+        nx_tomo.instrument.detector.x_pixel_size = self.series[0].x_pixel_size * _ureg.meter
+        nx_tomo.instrument.detector.y_pixel_size = self.series[0].y_pixel_size * _ureg.meter
         nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_proj
         nx_tomo.instrument.detector.tomo_n = n_proj
         # note: stitching process insure un-flipping of frames. So make sure transformations is defined as an empty set
@@ -506,13 +506,13 @@ class PreProcessingStitching(SingleAxisStitcher):
 
         if isinstance(self.series[0], NXtomoScan):
             # note: first scan is always the reference as order to read data (so no rotation_angle inversion here)
-            rotation_angle = numpy.asarray(self.series[0].rotation_angle)
+            rotation_angle = numpy.asarray(self.series[0].rotation_angle) * _ureg.degree
             nx_tomo.sample.rotation_angle = rotation_angle[
                 numpy.asarray(self.series[0].image_key_control) == ImageKey.PROJECTION.value
             ]
         elif isinstance(self.series[0], EDFTomoScan):
-            nx_tomo.sample.rotation_angle = numpy.linspace(
-                start=0, stop=self.series[0].scan_range, num=self.series[0].tomo_n
+            nx_tomo.sample.rotation_angle = (
+                numpy.linspace(start=0, stop=self.series[0].scan_range, num=self.series[0].tomo_n) * _ureg.degree
             )
         else:
             raise NotImplementedError(
@@ -526,12 +526,15 @@ class PreProcessingStitching(SingleAxisStitcher):
             if isinstance(slices, slice):
                 return array[slices.start : slices.stop : 1]
             elif isinstance(slices, Iterable):
-                return list([array[index] for index in slices])
+                return [array[index] for index in slices]
             else:
-                raise RuntimeError("slices must be instance of a slice or of an iterable")
+                raise RuntimeError("slices must be instance of a slice or of an iterable")  # noqa: TRY004
 
-        nx_tomo.sample.rotation_angle = apply_slices_selection(
-            array=nx_tomo.sample.rotation_angle, slices=self._slices_to_stitch
+        nx_tomo.sample.rotation_angle = (
+            apply_slices_selection(
+                array=nx_tomo.sample.rotation_angle.to_base_units().magnitude, slices=self._slices_to_stitch
+            )
+            * _ureg.degree
         )
 
         # handle sample
@@ -560,7 +563,7 @@ class PreProcessingStitching(SingleAxisStitcher):
                 # note: if at least one has missing values the numpy.Array(x_translation) with create an error as well
                 x_translation = [0.0] * n_proj
                 _logger.warning("Unable to fin input nxtomo x_translation values. Set it to 0.0")
-            nx_tomo.sample.x_translation = x_translation
+            nx_tomo.sample.x_translation = x_translation * _ureg.meter
 
             y_translation = [
                 get_sample_translation_for_projs(scan, "y_translation")
@@ -575,7 +578,7 @@ class PreProcessingStitching(SingleAxisStitcher):
             else:
                 y_translation = [0.0] * n_proj
                 _logger.warning("Unable to fin input nxtomo y_translation values. Set it to 0.0")
-            nx_tomo.sample.y_translation = y_translation
+            nx_tomo.sample.y_translation = y_translation * _ureg.meter
             z_translation = [
                 get_sample_translation_for_projs(scan, "z_translation")
                 for scan in self.series
@@ -589,7 +592,7 @@ class PreProcessingStitching(SingleAxisStitcher):
             else:
                 z_translation = [0.0] * n_proj
                 _logger.warning("Unable to fin input nxtomo z_translation values. Set it to 0.0")
-            nx_tomo.sample.z_translation = z_translation
+            nx_tomo.sample.z_translation = z_translation * _ureg.meter
 
             nx_tomo.sample.name = self.series[0].sample_name
 
@@ -794,7 +797,7 @@ class PreProcessingStitching(SingleAxisStitcher):
         ):
             i_frame = 0
             _, set_of_compacted_slices = get_compacted_dataslices(scan_urls, return_url_set=True)
-            for _, url in set_of_compacted_slices.items():
+            for url in set_of_compacted_slices.values():
                 scan = scans[i_scan]
                 url = DataUrl(
                     file_path=url.file_path(),
@@ -886,6 +889,9 @@ class PreProcessingStitching(SingleAxisStitcher):
         """
         make sure reduced dark and flats are existing otherwise compute them
         """
+        # TODO
+        # ruff: noqa: SIM105, S110
+        # --
         for scan in self.series:
             try:
                 reduced_darks, darks_infos = scan.load_reduced_darks(return_info=True)
@@ -896,7 +902,7 @@ class PreProcessingStitching(SingleAxisStitcher):
                 try:
                     # if we don't have write in the folder containing the .nx for example
                     scan.save_reduced_darks(reduced_darks, darks_infos=darks_infos)
-                except Exception as e:
+                except Exception:
                     pass
             scan.set_reduced_darks(reduced_darks, darks_infos=darks_infos)
 
@@ -909,7 +915,7 @@ class PreProcessingStitching(SingleAxisStitcher):
                 try:
                     # if we don't have write in the folder containing the .nx for example
                     scan.save_reduced_flats(reduced_flats, flats_infos=flats_infos)
-                except Exception as e:
+                except Exception:
                     pass
             scan.set_reduced_flats(reduced_flats, flats_infos=flats_infos)
 
@@ -979,7 +985,7 @@ class PreProcessingStitching(SingleAxisStitcher):
         ):
             i_frame = 0
             _, set_of_compacted_slices = get_compacted_dataslices(scan_urls, return_url_set=True)
-            for _, url in set_of_compacted_slices.items():
+            for url in set_of_compacted_slices.values():
                 scan = scans[i_scan]
                 url = DataUrl(
                     file_path=url.file_path(),
@@ -1000,12 +1006,12 @@ class PreProcessingStitching(SingleAxisStitcher):
 
                 missing = []
                 if len(scan.reduced_flats) == 0:
-                    missing = "flats"
+                    missing.append("flats")
                 if len(scan.reduced_darks) == 0:
-                    missing = "darks"
+                    missing.append("darks")
 
                 if len(missing) > 0:
-                    _logger.warning(f"missing {'and'.join(missing)}. Unable to do flat field correction")
+                    _logger.warning(f"missing {' and '.join(missing)}. Unable to do flat field correction")
                     ff_arrays = None
                     data = raw_radios
                 else:

nabu/stitching/stitcher/single_axis.py

@@ -1,8 +1,7 @@
-import h5py
 import numpy
 import logging
-from math import ceil
-from typing import Optional, Iterable, Union
+from typing import Optional, Union
+from collections.abc import Iterable
 from tomoscan.series import Series
 from tomoscan.identifier import BaseIdentifier
 from nabu.stitching.stitcher.base import _StitcherBase, get_obj_constant_side_length

nabu/stitching/stitcher_2D.py

@@ -1,3 +1,4 @@
+# ruff: noqa: N999
 import numpy
 from math import ceil
 from typing import Union, Optional
@@ -19,7 +20,7 @@ def stitch_raw_frames(
     pad_mode="constant",
     new_unstitched_axis_size: Optional[int] = None,
 ) -> numpy.ndarray:
-    """
+    r"""
     stitches raw frames (already shifted and flat fielded !!!) together using
     raw stitching (no pixel interpolation, y_overlap_in_px is expected to be a int).
     Sttiching depends on the kernel used.

nabu/stitching/tests/test_config.py

@@ -10,7 +10,7 @@ from nabu.stitching.overlap import OverlapStitchingStrategy
 from nabu.stitching import config as stiching_config
 
 
-_stitching_types = list(stiching_config.StitchingType.values())
+_stitching_types = [st.value for st in list(stiching_config.StitchingType)]
 _stitching_types.append(None)
 
 
@@ -37,18 +37,16 @@ def test_stitching_config(stitching_type, option_level):
 
         assert "stitching" in config
         assert "type" in config["stitching"]
-        stitching_type = stiching_config.StitchingType.from_value(config["stitching"]["type"])
+        stitching_type = stiching_config.StitchingType(config["stitching"]["type"])
         if stitching_type is stiching_config.StitchingType.Z_POSTPROC:
             assert isinstance(
                 stiching_config.dict_to_config_obj(config),
                 stiching_config.PostProcessedSingleAxisStitchingConfiguration,
             )
-        elif stitching_type is stiching_config.StitchingType.Z_PREPROC:
-            assert isinstance(
-                stiching_config.dict_to_config_obj(config),
-                stiching_config.PreProcessedSingleAxisStitchingConfiguration,
-            )
-        elif stitching_type is stiching_config.StitchingType.Y_PREPROC:
+        elif (
+            stitching_type is stiching_config.StitchingType.Z_PREPROC
+            or stitching_type is stiching_config.StitchingType.Y_PREPROC
+        ):
             assert isinstance(
                 stiching_config.dict_to_config_obj(config),
                 stiching_config.PreProcessedSingleAxisStitchingConfiguration,
@@ -84,7 +82,7 @@ def test_stitching_config(stitching_type, option_level):
         assert isinstance(config_class_instance.to_dict(), dict)
 
 
-@pytest.mark.parametrize("stitching_strategy", OverlapStitchingStrategy.values())
+@pytest.mark.parametrize("stitching_strategy", [oss for oss in OverlapStitchingStrategy])
 @pytest.mark.parametrize("overwrite_results", (True, "False", 0, "1"))
 @pytest.mark.parametrize(
     "axis_shifts",
@@ -92,7 +90,7 @@ def test_stitching_config(stitching_type, option_level):
         "",
         None,
         "None",
-        "",
+        "",  # noqa: PT014
         "skimage",
         "nabu-fft",
     ),
@@ -176,7 +174,8 @@ def test_PreProcessedZStitchingConfiguration(
 
     from_dict = stiching_config.PreProcessedZStitchingConfiguration.from_dict(pre_process_config.to_dict())
     # workaround for scans because a new object is created each time
-    pre_process_config.settle_inputs
+    # ???
+    pre_process_config.settle_inputs  # noqa: B018
     assert len(from_dict.input_scans) == len(pre_process_config.input_scans)
     from_dict.input_scans = None
     pre_process_config.input_scans = None

nabu/stitching/tests/test_sample_normalization.py

@@ -1,6 +1,6 @@
 import numpy
 import pytest
-from nabu.stitching.sample_normalization import normalize_frame, SampleSide, Method
+from nabu.stitching.sample_normalization import normalize_frame
 
 
 def test_normalize_frame():

nabu/stitching/tests/test_slurm_utils.py

@@ -1,5 +1,4 @@
 import os
-import numpy
 import pytest
 from tomoscan.esrf import NXtomoScan
 from tomoscan.esrf.volume import HDF5Volume
@@ -14,7 +13,7 @@ from nabu.stitching.slurm_utils import (
 from tomoscan.esrf.mock import MockNXtomo
 
 try:
-    import sluurp
+    import sluurp  # noqa: F401
 except ImportError:
     has_sluurp = False
 else:

nabu/stitching/tests/test_y_preprocessing_stitching.py

@@ -1,6 +1,7 @@
 import os
 import pytest
 import numpy
+import pint
 from tqdm import tqdm
 
 from nabu.stitching.y_stitching import y_stitching
@@ -9,6 +10,8 @@ from nxtomo.application.nxtomo import NXtomo
 from nxtomo.nxobject.nxdetector import ImageKey
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 
+_ureg = pint.UnitRegistry()
+
 
 def build_nxtomos(output_dir, flip_lr, flip_ud) -> tuple:
     r"""
@@ -52,10 +55,10 @@ def build_nxtomos(output_dir, flip_lr, flip_ud) -> tuple:
 
         n_projs = 3
         nx_tomo = NXtomo()
-        nx_tomo.sample.x_translation = [0] * (n_projs + 2)
-        nx_tomo.sample.y_translation = [frame_y_position] * (n_projs + 2)
-        nx_tomo.sample.z_translation = [0] * (n_projs + 2)
-        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=(n_projs + 2), endpoint=False)
+        nx_tomo.sample.x_translation = ([0] * (n_projs + 2)) * _ureg.meter
+        nx_tomo.sample.y_translation = ([frame_y_position] * (n_projs + 2)) * _ureg.meter
+        nx_tomo.sample.z_translation = ([0] * (n_projs + 2)) * _ureg.meter
+        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=(n_projs + 2), endpoint=False) * _ureg.degree
         nx_tomo.instrument.detector.image_key_control = (
             ImageKey.DARK_FIELD,
             ImageKey.FLAT_FIELD,
@@ -63,10 +66,10 @@ def build_nxtomos(output_dir, flip_lr, flip_ud) -> tuple:
             ImageKey.PROJECTION,
             ImageKey.PROJECTION,
         )
-        nx_tomo.instrument.detector.x_pixel_size = 1.0
-        nx_tomo.instrument.detector.y_pixel_size = 1.0
-        nx_tomo.instrument.detector.distance = 2.3
-        nx_tomo.energy = 19.2
+        nx_tomo.instrument.detector.x_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.y_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.distance = 2.3 * _ureg.meter
+        nx_tomo.energy = 19.2 * _ureg.keV
         nx_tomo.instrument.detector.data = numpy.stack(
             (
                 my_dark_data,

nabu/stitching/tests/test_z_postprocessing_stitching.py

@@ -395,7 +395,7 @@ def test_vol_z_stitching_with_alignment_axis_2(tmp_path, alignment_axis_2):
         axis_2_params={"img_reg_method": ShiftAlgorithm.NONE},
         slice_for_cross_correlation="middle",
         voxel_size=None,
-        alignment_axis_2=AlignmentAxis2.from_value(alignment_axis_2),
+        alignment_axis_2=AlignmentAxis2(alignment_axis_2),
     )
 
     stitcher = PostProcessZStitcher(z_stich_config, progress=None)
@@ -512,7 +512,7 @@ def test_vol_z_stitching_with_alignment_axis_1(tmp_path, alignment_axis_1):
         axis_2_params={"img_reg_method": ShiftAlgorithm.NONE},
         slice_for_cross_correlation="middle",
         voxel_size=None,
-        alignment_axis_1=AlignmentAxis1.from_value(alignment_axis_1),
+        alignment_axis_1=AlignmentAxis1(alignment_axis_1),
     )
 
     stitcher = PostProcessZStitcher(z_stich_config, progress=None)
@@ -770,6 +770,6 @@ def test_data_duplication(tmp_path, data_duplication):
     if not data_duplication:
         # make sure an error is raised if we try to ask for no data duplication and if we get some flips
         z_stich_config.flip_ud = (False, True, False)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError):  # noqa: PT012
             stitcher = PostProcessZStitcherNoDD(z_stich_config, progress=None)
             stitcher.stitch()

nabu/stitching/tests/test_z_preprocessing_stitching.py

@@ -1,15 +1,16 @@
 import os
+import pint
 from silx.image.phantomgenerator import PhantomGenerator
 from scipy.ndimage import shift as scipy_shift
 import numpy
 import pytest
 from nabu.stitching.config import PreProcessedZStitchingConfiguration
 from nabu.stitching.config import KEY_IMG_REG_METHOD
-from nabu.stitching.overlap import ImageStichOverlapKernel, OverlapStitchingStrategy
+from nabu.stitching.overlap import OverlapStitchingStrategy
 from nabu.stitching.z_stitching import (
     PreProcessZStitcher,
 )
-from nabu.stitching.stitcher_2D import stitch_raw_frames, get_overlap_areas
+from nabu.stitching.stitcher_2D import get_overlap_areas
 from nxtomo.nxobject.nxdetector import ImageKey
 from nxtomo.utils.transformation import DetYFlipTransformation, DetZFlipTransformation
 from nxtomo.application.nxtomo import NXtomo
@@ -17,6 +18,8 @@ from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 from nabu.stitching.utils import ShiftAlgorithm
 import h5py
 
+_ureg = pint.get_application_registry()
+
 
 _stitching_configurations = (
     # simple case where shifts are provided
@@ -82,13 +85,13 @@ def test_PreProcessZStitcher(tmp_path, dtype, configuration):
     scans = []
     for (i_frame, frame), z_pos in zip(enumerate(frames), z_position):
         nx_tomo = NXtomo()
-        nx_tomo.sample.z_translation = [z_pos] * n_proj
-        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=n_proj, endpoint=False)
+        nx_tomo.sample.z_translation = ([z_pos] * n_proj) * _ureg.meter
+        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=n_proj, endpoint=False) * _ureg.degree
         nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_proj
-        nx_tomo.instrument.detector.x_pixel_size = 1.0
-        nx_tomo.instrument.detector.y_pixel_size = 1.0
-        nx_tomo.instrument.detector.distance = 2.3
-        nx_tomo.energy = 19.2
+        nx_tomo.instrument.detector.x_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.y_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.distance = 2.3 * _ureg.meter
+        nx_tomo.energy = 19.2 * _ureg.keV
         nx_tomo.instrument.detector.data = numpy.asarray([frame] * n_proj)
 
         file_path = os.path.join(raw_data_dir, f"nxtomo_{i_frame}.nx")
@@ -160,8 +163,8 @@ def test_PreProcessZStitcher(tmp_path, dtype, configuration):
         )
 
     # check also other metadata are here
-    assert created_nx_tomo.instrument.detector.distance.value == 2.3
-    assert created_nx_tomo.energy.value == 19.2
+    assert created_nx_tomo.instrument.detector.distance == 2.3 * _ureg.meter
+    assert created_nx_tomo.energy == 19.2 * _ureg.keV
     numpy.testing.assert_array_equal(
         created_nx_tomo.instrument.detector.image_key_control,
         numpy.asarray([ImageKey.PROJECTION.PROJECTION] * n_proj),
@@ -228,13 +231,13 @@ def build_nxtomos(output_dir) -> tuple:
     scans = []
     for (i_frame, frame), z_pos in zip(enumerate(frames), z_positions):
         nx_tomo = NXtomo()
-        nx_tomo.sample.z_translation = [z_pos] * n_projs
-        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=n_projs, endpoint=False)
+        nx_tomo.sample.z_translation = [z_pos] * n_projs * _ureg.meter
+        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=n_projs, endpoint=False) * _ureg.degree
         nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_projs
-        nx_tomo.instrument.detector.x_pixel_size = 1.0
-        nx_tomo.instrument.detector.y_pixel_size = 1.0
-        nx_tomo.instrument.detector.distance = 2.3
-        nx_tomo.energy = 19.2
+        nx_tomo.instrument.detector.x_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.y_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.distance = 2.3 * _ureg.meter
+        nx_tomo.energy = 19.2 * _ureg.keV
         nx_tomo.instrument.detector.data = frame
 
         file_path = os.path.join(output_dir, f"nxtomo_{i_frame}.nx")
@@ -301,11 +304,11 @@ def test_DistributePreProcessZStitcher(tmp_path, configuration_dist):
     )
 
     if complete:
-        len(final_nx_tomo.instrument.detector.data) == 128
+        assert len(final_nx_tomo.instrument.detector.data) == 100
         # test middle
         numpy.testing.assert_array_almost_equal(raw_data[1], final_nx_tomo.instrument.detector.data[1, :, :])
     else:
-        len(final_nx_tomo.instrument.detector.data) == 3
+        assert len(final_nx_tomo.instrument.detector.data) == 3
         # test middle
         numpy.testing.assert_array_almost_equal(raw_data[49], final_nx_tomo.instrument.detector.data[1, :, :])
     # in the case of first, middle and last frames
@@ -373,15 +376,15 @@ def test_frame_flip(tmp_path):
     scans = []
     for (i_frame, frame), z_pos, x_flip, y_flip in zip(enumerate(frames), z_position, x_flips, y_flips):
         nx_tomo = NXtomo()
-        nx_tomo.sample.z_translation = [z_pos] * n_proj
-        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=n_proj, endpoint=False)
+        nx_tomo.sample.z_translation = [z_pos] * n_proj * _ureg.meter
+        nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=n_proj, endpoint=False) * _ureg.degree
         nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_proj
-        nx_tomo.instrument.detector.x_pixel_size = 1.0
-        nx_tomo.instrument.detector.y_pixel_size = 1.0
-        nx_tomo.instrument.detector.distance = 2.3
+        nx_tomo.instrument.detector.x_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.y_pixel_size = 1.0 * _ureg.meter
+        nx_tomo.instrument.detector.distance = 2.3 * _ureg.meter
         nx_tomo.instrument.detector.transformations.add_transformation(DetZFlipTransformation(flip=x_flip))
         nx_tomo.instrument.detector.transformations.add_transformation(DetYFlipTransformation(flip=y_flip))
-        nx_tomo.energy = 19.2
+        nx_tomo.energy = 19.2 * _ureg.keV
         nx_tomo.instrument.detector.data = numpy.asarray([frame] * n_proj)
 
         file_path = os.path.join(raw_data_dir, f"nxtomo_{i_frame}.nx")

nabu/stitching/utils/tests/test_post-processing.py

@@ -1,3 +1,4 @@
+# noqa: N999
 import pytest
 
 from nabu.stitching.stitcher.single_axis import PROGRESS_BAR_STITCH_VOL_DESC

nabu/stitching/utils/utils.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from packaging.version import parse as parse_version
 from typing import Optional, Union
 import logging
@@ -6,10 +7,8 @@ import numpy
 from tomoscan.scanbase import TomoScanBase
 from tomoscan.volumebase import VolumeBase
 from nxtomo.utils.transformation import build_matrix, DetYFlipTransformation
-from silx.utils.enum import Enum as _Enum
 from scipy.fft import rfftn as local_fftn
 from scipy.fft import irfftn as local_ifftn
-from ..overlap import OverlapStitchingStrategy, ImageStichOverlapKernel
 from ..alignment import AlignmentAxis1, AlignmentAxis2, PaddedRawData
 from ...misc import fourier_filters
 from ...estimation.alignment import AlignmentBase
@@ -37,7 +36,7 @@ else:
     __has_sk_phase_correlation__ = True
 
 
-class ShiftAlgorithm(_Enum):
+class ShiftAlgorithm(Enum):
     """All generic shift search algorithm"""
 
     NABU_FFT = "nabu-fft"
@@ -59,7 +58,7 @@ class ShiftAlgorithm(_Enum):
         if value in ("", None):
             return ShiftAlgorithm.NONE
         else:
-            return super().from_value(value=value)
+            return super().__new__(cls, value)
 
 
 def find_frame_relative_shifts(
@@ -73,9 +72,9 @@ def find_frame_relative_shifts(
     y_shifts_params: Optional[dict] = None,
 ):
     """
-    :param overlap_axis: axis in [0, 1] on which the overlap exists. In image space. So 0 is aka y and 1 as x
+    :param overlap_axis: axis in [0, 1] on which the overlap exists. In image space. So 0 is aka y and 1 as x.
     """
-    if not overlap_axis in (0, 1):
+    if overlap_axis not in (0, 1):
         raise ValueError(f"overlap_axis should be in (0, 1). Get {overlap_axis}")
     from nabu.stitching.config import (
         KEY_LOW_PASS_FILTER,
@@ -146,7 +145,7 @@ def find_frame_relative_shifts(
     }
 
     res_algo = {}
-    for shift_alg in set((x_cross_correlation_function, y_cross_correlation_function)):
+    for shift_alg in set((x_cross_correlation_function, y_cross_correlation_function)):  # noqa: C405
         if shift_alg not in shift_methods:
             raise ValueError(f"requested image alignment function not handled ({shift_alg})")
         try:
@@ -200,8 +199,8 @@ def find_volumes_relative_shifts(
     else:
         raise ValueError(f"Stitching is done in 3D space. Expect axis to be in [0,2]. Get {overlap_axis}")
 
-    alignment_axis_2 = AlignmentAxis2.from_value(alignment_axis_2)
-    alignment_axis_1 = AlignmentAxis1.from_value(alignment_axis_1)
+    alignment_axis_2 = AlignmentAxis2(alignment_axis_2)
+    alignment_axis_1 = AlignmentAxis1(alignment_axis_1)
     assert dim_axis_1 > 0, "dim_axis_1 <= 0"
 
     if isinstance(slice_for_shift, str):
@@ -249,7 +248,7 @@ def find_volumes_relative_shifts(
 
     w_window_size = int(y_shifts_params.get(KEY_WINDOW_SIZE, 400))
     start_overlap = max(estimated_shifts[0] // 2 - w_window_size // 2, 0)
-    end_overlap = min(estimated_shifts[0] // 2 + w_window_size // 2, min(upper_frame.shape[0], lower_frame.shape[0]))
+    end_overlap = min(estimated_shifts[0] // 2 + w_window_size // 2, upper_frame.shape[0], lower_frame.shape[0])
 
     if start_overlap == 0:
         overlap_upper_frame = upper_frame[-end_overlap:]
@@ -385,12 +384,10 @@ def find_projections_relative_shifts(
             cor_options=cor_options,
         )
 
-        estimated_shifts = tuple(
-            [
-                estimated_shifts[0],
-                (lower_scan_pos - upper_scan_pos),
-            ]
-        )
+        estimated_shifts = [
+            estimated_shifts[0],
+            (lower_scan_pos - upper_scan_pos),
+        ]
         x_cross_correlation_function = ShiftAlgorithm.NONE
 
     # } else we will compute shift from the flat projections
@@ -464,7 +461,8 @@ def find_projections_relative_shifts(
     start_overlap = max(estimated_shifts[axis_proj_space] // 2 - w_window_size // 2, 0)
     end_overlap = min(
         estimated_shifts[axis_proj_space] // 2 + w_window_size // 2,
-        min(upper_proj.shape[axis_proj_space], lower_proj.shape[axis_proj_space]),
+        upper_proj.shape[axis_proj_space],
+        lower_proj.shape[axis_proj_space],
     )
     o_upper_sel = numpy.array(range(-end_overlap, -start_overlap))
     overlap_upper_frame = numpy.take_along_axis(
@@ -502,7 +500,7 @@ def find_shift_correlate(img1, img2, padding_mode="reflect"):
         padding_mode,
     )
 
-    img_shape = img1.shape[-2:]
+    img_shape = cc.shape  # Because cc.shape can differ from img_2.shape (e.g. in case of odd nb of cols)
     cc_vs = numpy.fft.fftfreq(img_shape[-2], 1 / img_shape[-2])
     cc_hs = numpy.fft.fftfreq(img_shape[-1], 1 / img_shape[-1])
 

nabu/tests.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
 import sys
 import os
 import pytest