nabu 2025.1.0.dev14__py3-none-any.whl → 2025.1.0rc2__py3-none-any.whl

nabu/resources/nxflatfield.py

@@ -6,6 +6,8 @@ from silx.io import get_data
 from tomoscan.framereducer.reducedframesinfos import ReducedFramesInfos
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 from ..utils import check_supported, is_writeable
+from ..preproc.flatfield import PCAFlatsDecomposer
+from ..io.reader import NXDarksFlats
 
 
 def get_frame_possible_urls(dataset_info, user_dir, output_dir):
@@ -22,7 +24,7 @@ def get_frame_possible_urls(dataset_info, user_dir, output_dir):
         Output processing directory
     """
 
-    frame_types = ["flats", "darks"]
+    frame_types = ["flats", "darks", "pcaflats"]
     h5scan = dataset_info.dataset_scanner  # tomoscan object
 
     def make_dataurl(dirname, frame_type):
@@ -32,8 +34,10 @@ def get_frame_possible_urls(dataset_info, user_dir, output_dir):
 
         if frame_type == "flats":
             dataurl_default_template = h5scan.REDUCED_FLATS_DATAURLS[0]
-        else:
+        elif frame_type == "darks":
             dataurl_default_template = h5scan.REDUCED_DARKS_DATAURLS[0]
+        elif frame_type == "pcaflats":
+            dataurl_default_template = h5scan.PCA_FLATS_DATAURLS[0]
 
         rel_file_path = dataurl_default_template.file_path().format(scan_prefix=h5scan.get_dataset_basename())
         return DataUrl(
@@ -149,8 +153,94 @@ def data_url_exists(data_url):
     return group_exists
 
 
+def _compute_and_save_reduced_frames(flatfield_mode, dataset_info, reduced_frames_urls):
+    if flatfield_mode == "pca":
+        dfreader = NXDarksFlats(dataset_info.location)
+        darks = np.concatenate([d for d in dfreader.get_raw_darks()], axis=0)
+        flats = np.concatenate([f for f in dfreader.get_raw_flats()], axis=0)
+        pcaflats_darks = PCAFlatsDecomposer(flats, darks)
+
+        # Get "where to write". tomoscan expects a DataUrl
+        pcaflats_dir_url = reduced_frames_urls.get("user", None)
+        if pcaflats_dir_url is not None:
+            output_url = pcaflats_dir_url
+        elif is_writeable(os.path.dirname(reduced_frames_urls["dataset"]["flats"].file_path())):
+            output_url = reduced_frames_urls["dataset"]
+        else:
+            output_url = reduced_frames_urls["output"]
+        pcaflats_darks.save_decomposition(
+            path=output_url["pcaflats"].file_path(), entry=output_url["pcaflats"].data_path().strip("/").split("/")[0]
+        )
+        dataset_info.logger.info("PCA flats computed and written at %s" % (output_url["pcaflats"].file_path()))
+
+        # Update dataset_info with pca flats and dark
+        dataset_info.darks = {0: pcaflats_darks.dark}
+        flats = {0: pcaflats_darks.mean}
+        for k in range(len(pcaflats_darks.components)):
+            flats.update({k + 1: pcaflats_darks.components[k]})
+        dataset_info.flats = flats
+    else:
+        try:
+            dataset_info.flats = dataset_info.get_reduced_flats()
+            dataset_info.darks = dataset_info.get_reduced_darks()
+        except FileNotFoundError:
+            msg = "Could not find any flats and/or darks"
+            raise FileNotFoundError(msg)
+        _, flats_info, darks_info = save_reduced_frames(
+            dataset_info, {"darks": dataset_info.darks, "flats": dataset_info.flats}, reduced_frames_urls
+        )
+        dataset_info.flats_srcurrent = flats_info.machine_electric_current
+
+
+def _load_existing_flatfields(dataset_info, reduced_frames_urls, frames_types, where_to_load_from):
+    if "pcaflats" not in frames_types:
+        reduced_frames_with_info = {}
+        for frame_type in frames_types:
+            reduced_frames_with_info[frame_type] = tomoscan_load_reduced_frames(
+                dataset_info, frame_type, reduced_frames_urls[where_to_load_from][frame_type]
+            )
+            dataset_info.logger.info(
+                "Loaded %s from %s" % (frame_type, reduced_frames_urls[where_to_load_from][frame_type].file_path())
+            )
+            red_frames_dict, red_frames_info = reduced_frames_with_info[frame_type]
+            setattr(
+                dataset_info,
+                frame_type,
+                {k: get_data(red_frames_dict[k]) for k in red_frames_dict},
+            )
+            if frame_type == "flats":
+                dataset_info.flats_srcurrent = red_frames_info.machine_electric_current
+    else:
+        df_path = reduced_frames_urls[where_to_load_from]["pcaflats"].file_path()
+        entry = reduced_frames_urls[where_to_load_from]["pcaflats"].data_path()
+
+        # Update dark
+        dark_url = DataUrl(f"silx://{df_path}?{entry}/dark")
+        dark = get_data(dark_url)
+        setattr(
+            dataset_info,
+            "dark",
+            {0: dark},
+        )
+        # Update flats with principal compenents
+        # Take mean as first comp., mask as second, flats thereafter
+        flats_url = DataUrl(f"silx://{df_path}?{entry}/p_components")
+        mean_url = DataUrl(f"silx://{df_path}?{entry}/p_mean")
+        flats = get_data(flats_url)
+        mean = get_data(mean_url)
+        flats = np.concatenate([mean[np.newaxis], flats], axis=0)
+        setattr(
+            dataset_info,
+            "flats",
+            {k: flats[k] for k in range(len(flats))},
+        )
+        dataset_info.logger.info("Loaded %s from %s" % ("PCA darks/flats", df_path))
+
+
 # pylint: disable=E1136
-def update_dataset_info_flats_darks(dataset_info, flatfield_mode, output_dir=None, darks_flats_dir=None):
+def update_dataset_info_flats_darks(
+    dataset_info, flatfield_mode, loading_mode="load_if_present", output_dir=None, darks_flats_dir=None
+):
     """
     Update a DatasetAnalyzer object with reduced flats/darks (hereafter "reduced frames").
 
@@ -170,23 +260,14 @@ def update_dataset_info_flats_darks(dataset_info, flatfield_mode, output_dir=Non
     if flatfield_mode is False:
         return
 
-    frames_types = ["darks", "flats"]
+    if flatfield_mode == "pca":
+        frames_types = ["pcaflats"]
+    else:
+        frames_types = ["darks", "flats"]
     reduced_frames_urls = get_frame_possible_urls(dataset_info, darks_flats_dir, output_dir)
 
-    def _compute_and_save_reduced_frames():
-        try:
-            dataset_info.flats = dataset_info.get_reduced_flats()
-            dataset_info.darks = dataset_info.get_reduced_darks()
-        except FileNotFoundError:
-            msg = "Could not find any flats and/or darks"
-            raise FileNotFoundError(msg)
-        _, flats_info, darks_info = save_reduced_frames(
-            dataset_info, {"darks": dataset_info.darks, "flats": dataset_info.flats}, reduced_frames_urls
-        )
-        dataset_info.flats_srcurrent = flats_info.machine_electric_current
-
-    if flatfield_mode == "force-compute":
-        _compute_and_save_reduced_frames()
+    if loading_mode == "force-compute":
+        _compute_and_save_reduced_frames(flatfield_mode, dataset_info, reduced_frames_urls)
         return
 
     def _can_load_from(folder_type):
@@ -206,21 +287,6 @@ def update_dataset_info_flats_darks(dataset_info, flatfield_mode, output_dir=Non
         raise ValueError("Could not load darks/flats (using 'force-load')")
 
     if where_to_load_from is not None:
-        reduced_frames_with_info = {}
-        for frame_type in frames_types:
-            reduced_frames_with_info[frame_type] = tomoscan_load_reduced_frames(
-                dataset_info, frame_type, reduced_frames_urls[where_to_load_from][frame_type]
-            )
-            dataset_info.logger.info(
-                "Loaded %s from %s" % (frame_type, reduced_frames_urls[where_to_load_from][frame_type].file_path())
-            )
-            red_frames_dict, red_frames_info = reduced_frames_with_info[frame_type]
-            setattr(
-                dataset_info,
-                frame_type,
-                {k: get_data(red_frames_dict[k]) for k in red_frames_dict},
-            )
-            if frame_type == "flats":
-                dataset_info.flats_srcurrent = red_frames_info.machine_electric_current
+        _load_existing_flatfields(dataset_info, reduced_frames_urls, frames_types, where_to_load_from)
     else:
-        _compute_and_save_reduced_frames()
+        _compute_and_save_reduced_frames(flatfield_mode, dataset_info, reduced_frames_urls)

nabu/resources/tests/test_nxflatfield.py

@@ -80,7 +80,7 @@ class TestNXFlatField:
         output_dir = self.params.get("output_dir", None)
         if output_dir is not None:
             output_dir = output_dir.format(tempdir=self.tempdir)
-        update_dataset_info_flats_darks(dataset_info, True, output_dir=output_dir)
+        update_dataset_info_flats_darks(dataset_info, True, loading_mode="load_if_present", output_dir=output_dir)
         # After reduction (median/mean), the flats/darks are located in another file.
         # median(series_1) goes to entry/flats/idx1, mean(series_2) goes to entry/flats/idx2, etc.
         assert set(dataset_info.flats.keys()) == set(s.start for s in self.params["flats_pos"])  # noqa: C401

nabu/resources/utils.py

@@ -1,8 +1,9 @@
 from ast import literal_eval
 import numpy as np
+import pint
 from psutil import virtual_memory, cpu_count
-from pyunitsystem.metricsystem import MetricSystem
-from pyunitsystem.energysystem import EnergySI
+
+_ureg = pint.get_application_registry()
 
 
 def get_values_from_file(fname, n_values=None, shape=None, sep=None, any_size=False):
@@ -163,12 +164,17 @@ def get_quantities_and_units(string, sep=";"):
         value, unit = value_and_unit.split()
         val = float(value)
         # Convert to SI
-        try:
-            # handle metrics
-            conversion_factor = MetricSystem.from_str(unit).value
-        except ValueError:
-            # handle energies
-            conversion_factor = EnergySI.from_str(unit).value / EnergySI.KILOELECTRONVOLT.value
-
-        result[quantity_name] = val * conversion_factor
+        if unit.lower() == "kev":
+            current_unit = _ureg.keV
+        elif unit.lower() == "ev":
+            current_unit = _ureg.eV
+        else:
+            current_unit = _ureg(unit)
+        # handle energies (to move to keV)
+        if _ureg.keV.dimensionality == current_unit.dimensionality:
+            result[quantity_name] = (val * current_unit).to(_ureg.keV).magnitude
+        elif _ureg.meter.dimensionality == current_unit.dimensionality:
+            result[quantity_name] = (val * current_unit).to_base_units().magnitude
+        else:
+            raise ValueError(f"Cannot convert: {unit}")
     return result

nabu/stitching/alignment.py

@@ -1,10 +1,10 @@
+from enum import Enum
 import h5py
 import numpy
 from typing import Union
-from silx.utils.enum import Enum as _Enum
 
 
-class AlignmentAxis2(_Enum):
+class AlignmentAxis2(Enum):
     """Specific alignment named to help users orienting themself with specific name"""
 
     CENTER = "center"
@@ -12,7 +12,7 @@ class AlignmentAxis2(_Enum):
     RIGTH = "right"
 
 
-class AlignmentAxis1(_Enum):
+class AlignmentAxis1(Enum):
     """Specific alignment named to help users orienting themself with specific name"""
 
     FRONT = "front"
@@ -20,7 +20,7 @@ class AlignmentAxis1(_Enum):
     BACK = "back"
 
 
-class _Alignment(_Enum):
+class _Alignment(Enum):
     """Internal alignment to be used for 2D alignment"""
 
     LOWER_BOUNDARY = "lower boundary"
@@ -29,7 +29,7 @@ class _Alignment(_Enum):
 
     @classmethod
     def from_value(cls, value):
-        # cast the AlignmentAxis1 and AlignmentAxis2 values to fit the generic definition
+        # cast the AlignmentAxis1 and AlignmentAxis2 values to fit the generic definition.
         if value in ("front", "left", AlignmentAxis1.FRONT, AlignmentAxis2.LEFT):
             return _Alignment.LOWER_BOUNDARY
         elif value in ("back", "right", AlignmentAxis1.BACK, AlignmentAxis2.RIGTH):
@@ -37,7 +37,7 @@ class _Alignment(_Enum):
         elif value in (AlignmentAxis1.CENTER, AlignmentAxis2.CENTER):
             return _Alignment.CENTER
         else:
-            return super().from_value(value)
+            return super().__new__(cls, value)
 
 
 def align_frame(
@@ -103,7 +103,7 @@ def align_horizontally(data: numpy.ndarray, alignment: AlignmentAxis2, new_width
     :param HAlignment alignment: alignment strategy
     :param int new_width: output data width
     """
-    alignment = AlignmentAxis2.from_value(alignment).value
+    alignment = AlignmentAxis2(alignment).value
     return align_frame(
         data=data, alignment=alignment, new_aligned_axis_size=new_width, pad_mode=pad_mode, alignment_axis=1
     )

nabu/stitching/config.py

@@ -1,9 +1,9 @@
+import pint
 from math import ceil
 from typing import Optional, Union
 from collections.abc import Iterable, Sized
 from dataclasses import dataclass
 import numpy
-from pyunitsystem.metricsystem import MetricSystem
 from nxtomo.paths import nxtomo
 from tomoscan.factory import Factory
 from tomoscan.identifier import VolumeIdentifier, ScanIdentifier
@@ -18,6 +18,8 @@ from .utils.utils import ShiftAlgorithm
 from .definitions import StitchingType
 from .alignment import AlignmentAxis1, AlignmentAxis2
 
+_ureg = pint.get_application_registry()
+
 # ruff: noqa: S105
 
 KEY_IMG_REG_METHOD = "img_reg_method"
@@ -220,7 +222,7 @@ def str_to_shifts(my_str: Optional[str]) -> Union[str, tuple]:
         if my_str == "":
             return None
         try:
-            shift = ShiftAlgorithm.from_value(my_str)
+            shift = ShiftAlgorithm(my_str)
         except ValueError:
             shifts_as_str = filter(None, my_str.replace(";", ",").split(","))
             return [float(shift) for shift in shifts_as_str]
@@ -336,7 +338,7 @@ class NormalizationBySample:
 
     @method.setter
     def method(self, method: Union[Method, str]) -> None:
-        self._method = Method.from_value(method)
+        self._method = Method(method)
 
     @property
     def margin(self) -> int:
@@ -353,7 +355,7 @@ class NormalizationBySample:
 
     @side.setter
     def side(self, side: Union[SampleSide, str]):
-        self._side = SampleSide.from_value(side)
+        self._side = SampleSide(side)
 
     @property
     def width(self) -> int:
@@ -548,12 +550,12 @@ class StitchingConfiguration:
             STITCHING_SECTION: {
                 STITCHING_TYPE_FIELD: {
                     "default": StitchingType.Z_PREPROC.value,
-                    "help": f"stitching to be applied. Must be in {StitchingType.values()}",
+                    "help": f"stitching to be applied. Must be in {[st.value for st in StitchingType]}",
                     "type": "required",
                 },
                 STITCHING_STRATEGY_FIELD: {
                     "default": "cosinus weights",
-                    "help": f"Policy to apply to compute the overlap area. Must be in {OverlapStitchingStrategy.values()}.",
+                    "help": f"Policy to apply to compute the overlap area. Must be in {[ov.value for ov in OverlapStitchingStrategy]}.",
                     "type": "required",
                 },
                 CROSS_CORRELATION_SLICE_FIELD: {
@@ -633,7 +635,7 @@ class StitchingConfiguration:
                 },
                 ALIGNMENT_AXIS_2_FIELD: {
                     "default": "center",
-                    "help": f"In case frame have different frame widths how to align them (so along volume axis 2). Valid keys are {AlignmentAxis2.values()}",
+                    "help": f"In case frame have different frame widths how to align them (so along volume axis 2). Valid keys are {[aa.value for aa in AlignmentAxis2]}",
                     "type": "advanced",
                 },
                 PAD_MODE_FIELD: {
@@ -755,7 +757,7 @@ class StitchingConfiguration:
                 AXIS_2_POS_PX: _cast_shift_to_str(self.axis_2_pos_px),
                 AXIS_2_POS_MM: _cast_shift_to_str(self.axis_2_pos_mm),
                 AXIS_2_PARAMS: _dict_to_str(self.axis_2_params or {}),
-                STITCHING_STRATEGY_FIELD: OverlapStitchingStrategy.from_value(self.stitching_strategy).value,
+                STITCHING_STRATEGY_FIELD: OverlapStitchingStrategy(self.stitching_strategy).value,
                 FLIP_UD: self.flip_ud,
                 FLIP_LR: self.flip_lr,
                 RESCALE_FRAMES: self.rescale_frames,
@@ -934,7 +936,7 @@ class PreProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigurat
         if self.pixel_size is None:
             pixel_size_mm = ""
         else:
-            pixel_size_mm = self.pixel_size * MetricSystem.MILLIMETER.value
+            pixel_size_mm = (self.pixel_size * _ureg.meter).to(_ureg.millimeter).magnitude
         return concatenate_dict(
             super().to_dict(),
             {
@@ -998,10 +1000,10 @@ class PreProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigurat
         if pixel_size == "":
             pixel_size = None
         else:
-            pixel_size = float(pixel_size) / MetricSystem.MM
+            pixel_size = (float(pixel_size) * _ureg.millimeter).to_base_units().magnitude
 
         return cls(
-            stitching_strategy=OverlapStitchingStrategy.from_value(
+            stitching_strategy=OverlapStitchingStrategy(
                 config[STITCHING_SECTION].get(
                     STITCHING_STRATEGY_FIELD,
                     OverlapStitchingStrategy.COSINUS_WEIGHTS,
@@ -1042,7 +1044,7 @@ class PreProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigurat
                     config[STITCHING_SECTION].get(STITCHING_KERNELS_EXTRA_PARAMS, {}),
                 )
             ),
-            alignment_axis_2=AlignmentAxis2.from_value(
+            alignment_axis_2=AlignmentAxis2(
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_2_FIELD, AlignmentAxis2.CENTER)
             ),
             pad_mode=config[STITCHING_SECTION].get(PAD_MODE_FIELD, "constant"),
@@ -1163,11 +1165,11 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
         if voxel_size == "":
             voxel_size = None
         else:
-            voxel_size = float(voxel_size) * MetricSystem.MM
+            voxel_size = (float(voxel_size) * _ureg.millimeter).to_base_units().magnitude
 
         # on the next section the one with a default value qre the optional one
         return cls(
-            stitching_strategy=OverlapStitchingStrategy.from_value(
+            stitching_strategy=OverlapStitchingStrategy(
                 config[STITCHING_SECTION].get(
                     STITCHING_STRATEGY_FIELD,
                     OverlapStitchingStrategy.COSINUS_WEIGHTS,
@@ -1198,10 +1200,10 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
                     config[STITCHING_SECTION].get(STITCHING_KERNELS_EXTRA_PARAMS, {}),
                 )
             ),
-            alignment_axis_1=AlignmentAxis1.from_value(
+            alignment_axis_1=AlignmentAxis1(
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_1_FIELD, AlignmentAxis1.CENTER)
             ),
-            alignment_axis_2=AlignmentAxis2.from_value(
+            alignment_axis_2=AlignmentAxis2(
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_2_FIELD, AlignmentAxis2.CENTER)
             ),
             pad_mode=config[STITCHING_SECTION].get(PAD_MODE_FIELD, "constant"),
@@ -1215,7 +1217,7 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
         if self.voxel_size is None:
             voxel_size_mm = ""
         else:
-            voxel_size_mm = numpy.array(self.voxel_size) / MetricSystem.MM
+            voxel_size_mm = numpy.array((self.voxel_size * _ureg.meter).to(_ureg.millimeter).magnitude)
 
         return concatenate_dict(
             super().to_dict(),
@@ -1250,7 +1252,7 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
                 STITCHING_SECTION: {
                     ALIGNMENT_AXIS_1_FIELD: {
                         "default": "center",
-                        "help": f"alignment to apply over axis 1 if needed. Valid values are {AlignmentAxis1.values()}",
+                        "help": f"alignment to apply over axis 1 if needed. Valid values are {[aa for aa in AlignmentAxis1]}",
                         "type": "advanced",
                     }
                 },
@@ -1281,7 +1283,7 @@ def dict_to_config_obj(config: dict):
     if stitching_type is None:
         raise ValueError("Unable to find stitching type from config dict")
     else:
-        stitching_type = StitchingType.from_value(stitching_type)
+        stitching_type = StitchingType(stitching_type)
         if stitching_type is StitchingType.Z_POSTPROC:
             return PostProcessedZStitchingConfiguration.from_dict(config)
         elif stitching_type is StitchingType.Z_PREPROC:
@@ -1304,7 +1306,7 @@ def get_default_stitching_config(stitching_type: Optional[Union[StitchingType, s
     if stitching_type is None:
         return concatenate_dict(z_postproc_stitching_config, z_preproc_stitching_config)
 
-    stitching_type = StitchingType.from_value(stitching_type)
+    stitching_type = StitchingType(stitching_type)
     if stitching_type is StitchingType.Z_POSTPROC:
         return z_postproc_stitching_config
     elif stitching_type is StitchingType.Z_PREPROC:

nabu/stitching/definitions.py

@@ -1,7 +1,7 @@
-from silx.utils.enum import Enum as _Enum
+from enum import Enum
 
 
-class StitchingType(_Enum):
+class StitchingType(Enum):
     Y_PREPROC = "y-preproc"
     Z_PREPROC = "z-preproc"
     Z_POSTPROC = "z-postproc"

nabu/stitching/overlap.py

@@ -1,7 +1,7 @@
 import numpy
 import logging
 from typing import Optional, Union
-from silx.utils.enum import Enum as _Enum
+from enum import Enum
 from nabu.misc import fourier_filters
 from scipy.fft import rfftn as local_fftn
 from scipy.fft import irfftn as local_ifftn
@@ -10,7 +10,7 @@ from tomoscan.utils.geometry import BoundingBox1D
 _logger = logging.getLogger(__name__)
 
 
-class OverlapStitchingStrategy(_Enum):
+class OverlapStitchingStrategy(Enum):
     MEAN = "mean"
     COSINUS_WEIGHTS = "cosinus weights"
     LINEAR_WEIGHTS = "linear weights"
@@ -72,7 +72,7 @@ class ImageStichOverlapKernel(OverlapKernelBase):
         self._stitching_axis = stitching_axis
         self._overlap_size = abs(overlap_size)
         self._frame_unstitched_axis_size = frame_unstitched_axis_size
-        self._stitching_strategy = OverlapStitchingStrategy.from_value(stitching_strategy)
+        self._stitching_strategy = OverlapStitchingStrategy(stitching_strategy)
         self._weights_img_1 = None
         self._weights_img_2 = None
         if extra_params is None:
@@ -391,7 +391,7 @@ def check_overlaps(frames: Union[tuple, numpy.ndarray], positions: tuple, axis:
 
         :return: (tested_bounding_box, bounding_boxes_to_test)
         """
-        my_bounding_boxes = {bb_index: bb for bb_index, bb in enumerate(my_bounding_boxes)}  # noqa: C416
+        my_bounding_boxes = {bb_index: bb for bb_index, bb in enumerate(my_bounding_boxes)}
         bounding_boxes = dict(
             filter(
                 lambda pair: pair[0] not in (index - 1, index, index + 1),

nabu/stitching/sample_normalization.py

@@ -1,13 +1,13 @@
+from enum import Enum
 import numpy
-from silx.utils.enum import Enum as _Enum
 
 
-class SampleSide(_Enum):
+class SampleSide(Enum):
     LEFT = "left"
     RIGHT = "right"
 
 
-class Method(_Enum):
+class Method(Enum):
     MEAN = "mean"
     MEDIAN = "median"
 
@@ -28,8 +28,8 @@ def normalize_frame(
         raise TypeError(f"Frame is expected to be a 2D numpy array.")
     if frame.ndim != 2:
         raise TypeError(f"Frame is expected to be a 2D numpy array. Get {frame.ndim}D")
-    side = SampleSide.from_value(side)
-    method = Method.from_value(method)
+    side = SampleSide(side)
+    method = Method(method)
 
     if frame.shape[1] < sample_width + margin_before_sample:
         raise ValueError(

nabu/stitching/stitcher/post_processing.py

@@ -2,6 +2,7 @@ import logging
 import numpy
 import os
 import h5py
+import pint
 from typing import Union
 from nabu.stitching.config import PostProcessedSingleAxisStitchingConfiguration
 from nabu.stitching.alignment import AlignmentAxis1
@@ -15,7 +16,6 @@ from tomoscan.volumebase import VolumeBase
 from tomoscan.esrf.volume import HDF5Volume
 from collections.abc import Iterable
 from contextlib import AbstractContextManager
-from pyunitsystem.metricsystem import MetricSystem
 from nabu.stitching.config import (
     KEY_IMG_REG_METHOD,
 )
@@ -25,6 +25,8 @@ from .single_axis import SingleAxisStitcher
 
 _logger = logging.getLogger(__name__)
 
+_ureg = pint.get_application_registry()
+
 
 class FlippingValueError(ValueError):
     pass
@@ -266,7 +268,7 @@ class PostProcessingStitching(SingleAxisStitcher):
                 axis_N_pos_px = []
                 for volume, pos_in_mm in zip(self.series, pos_as_mm):
                     voxel_size_m = self.configuration.voxel_size or volume.voxel_size
-                    axis_N_pos_px.append((pos_in_mm / MetricSystem.MILLIMETER.value) / voxel_size_m[0])
+                    axis_N_pos_px.append((pos_in_mm * _ureg.millimeter).to_base_units().magnitude / voxel_size_m[0])
                 return axis_N_pos_px
             else:
                 # deduce from motor position and pixel size
@@ -548,7 +550,7 @@ class _RawDatasetsContext(AbstractContextManager):
             return success
 
     def add_padding(self, data: Union[h5py.Dataset, numpy.ndarray], axis_1_dim, alignment: AlignmentAxis1):
-        alignment = AlignmentAxis1.from_value(alignment)
+        alignment = AlignmentAxis1(alignment)
         if alignment is AlignmentAxis1.BACK:
             axis_1_pad_width = (axis_1_dim - data.shape[1], 0)
         elif alignment is AlignmentAxis1.CENTER: