nabu 2024.1.9__py3-none-any.whl → 2024.2.0__py3-none-any.whl

nabu/resources/templates/id16a_fluo.conf

@@ -0,0 +1,42 @@
+#
+# ESRF ID16a fluo-tomography
+#
+
+#
+# Write here your custom configuration as a python dictionary.
+# Any parameter not present will take the default value.
+#
+
+[dataset]
+hdf5_entry = all
+
+[preproc]
+
+flatfield = 0
+flat_distortion_correction_enabled = 0
+take_logarithm = 0
+
+
+
+[phase]
+
+method = none
+
+
+[reconstruction]
+
+method = mlem
+rotation_axis_position = 0.
+cor_options =
+translation_movements_file = 
+enable_halftomo = 0
+clip_outer_circle = 1
+centered_axis = 1
+iterations = 200
+
+
+[output]
+
+location =
+file_format = tiff
+tiff_single_file = 1

nabu/resources/tests/test_extract.py

@@ -0,0 +1,10 @@
+import pytest
+from nabu.utils import list_match_queries
+
+
+def test_list_match_queries():
+
+    # entry0000 .... entry0099
+    avail = ["entry%04d" % i for i in range(100)]
+    query = "entry0000"
+    list_match_queries()

nabu/resources/tests/test_nxflatfield.py

@@ -96,9 +96,9 @@ class TestNXFlatField:
         for s in self.params["darks_pos"]:
             expected_darks[s.start] = self._reduction_func["darks"](data_volume[s.start : s.stop], axis=0)
 
-        flats = {idx: get_data(dataset_info.flats[idx]) for idx in dataset_info.flats.keys()}
+        flats = dataset_info.flats
         for idx in flats.keys():
             assert np.allclose(flats[idx], expected_flats[idx])
-        darks = {idx: get_data(dataset_info.darks[idx]) for idx in dataset_info.darks.keys()}
+        darks = dataset_info.darks
         for idx in darks.keys():
             assert np.allclose(darks[idx], expected_darks[idx])

nabu/stitching/alignment.py

@@ -8,52 +8,108 @@ from nabu.io.utils import DatasetReader
 
 
 class AlignmentAxis2(_Enum):
+    """Specific alignment named to help users orienting themself with specific name"""
+
     CENTER = "center"
     LEFT = "left"
     RIGTH = "right"
 
 
 class AlignmentAxis1(_Enum):
+    """Specific alignment named to help users orienting themself with specific name"""
+
     FRONT = "front"
     CENTER = "center"
     BACK = "back"
 
 
-def align_horizontally(data: numpy.ndarray, alignment: AlignmentAxis2, new_width: int, pad_mode="constant"):
+class _Alignment(_Enum):
+    """Internal alignment to be used for 2D alignment"""
+
+    LOWER_BOUNDARY = "lower boundary"
+    HIGHER_BOUNDARY = "higher boundary"
+    CENTER = "center"
+
+    @classmethod
+    def from_value(cls, value):
+        # 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):
+            return _Alignment.HIGHER_BOUNDARY
+        elif value in (AlignmentAxis1.CENTER, AlignmentAxis2.CENTER):
+            return _Alignment.CENTER
+        else:
+            return super().from_value(value)
+
+
+def align_frame(
+    data: numpy.ndarray, alignment: _Alignment, alignment_axis: int, new_aligned_axis_size: int, pad_mode="constant"
+):
     """
-    Align data horizontally to make sure new data width will ne `new_width`.
+    Align 2D array to extend if size along `alignment_axis` to `new_aligned_axis_size`.
 
-    :param numpy.ndarray data: data to align
+    :param numpy.ndarray data: data (frame) to align (2D numpy array)
+    :param alignment_axis: axis along which we want to align the frame. Must be in (0, 1)
     :param HAlignment alignment: alignment strategy
     :param int new_width: output data width
     """
-    current_width = data.shape[-1]
-    alignment = AlignmentAxis2.from_value(alignment)
+    if alignment_axis not in (0, 1):
+        raise ValueError(f"alignment_axis should be in (0, 1). Get {alignment_axis}")
+    alignment = _Alignment.from_value(alignment)
 
-    if current_width > new_width:
-        raise ValueError(f"data.shape[-1] ({data.shape[-1]}) > new_width ({new_width}). Unable to crop data")
-    elif current_width == new_width:
+    aligned_axis_size = data.shape[alignment_axis]
+
+    if aligned_axis_size > new_aligned_axis_size:
+        raise ValueError(
+            f"data.shape[alignment_axis] ({data.shape[alignment_axis]}) > new_aligned_axis_size ({new_aligned_axis_size}). Unable to crop data"
+        )
+    elif aligned_axis_size == new_aligned_axis_size:
         return data
     else:
-        if alignment is AlignmentAxis2.CENTER:
-            left_width = (new_width - current_width) // 2
-            right_width = (new_width - current_width) - left_width
-        elif alignment is AlignmentAxis2.LEFT:
-            left_width = 0
-            right_width = new_width - current_width
-        elif alignment is AlignmentAxis2.RIGTH:
-            left_width = new_width - current_width
-            right_width = 0
+        if alignment is _Alignment.CENTER:
+            lower_boundary = (new_aligned_axis_size - aligned_axis_size) // 2
+            higher_boundary = (new_aligned_axis_size - aligned_axis_size) - lower_boundary
+        elif alignment is _Alignment.LOWER_BOUNDARY:
+            lower_boundary = 0
+            higher_boundary = new_aligned_axis_size - aligned_axis_size
+        elif alignment is _Alignment.HIGHER_BOUNDARY:
+            lower_boundary = new_aligned_axis_size - aligned_axis_size
+            higher_boundary = 0
         else:
             raise ValueError(f"alignment {alignment.value} is not handled")
 
-        assert left_width >= 0, f"pad width must be positive - left width isn't ({left_width})"
-        assert right_width >= 0, f"pad width must be positive - right width isn't ({right_width})"
-        return numpy.pad(
-            data,
-            pad_width=((0, 0), (left_width, right_width)),
-            mode=pad_mode,
-        )
+        assert lower_boundary >= 0, f"pad size must be positive - lower boundary isn't ({lower_boundary})"
+        assert higher_boundary >= 0, f"pad size must be positive - higher boundary isn't ({higher_boundary})"
+
+        if alignment_axis == 1:
+            return numpy.pad(
+                data,
+                pad_width=((0, 0), (lower_boundary, higher_boundary)),
+                mode=pad_mode,
+            )
+        elif alignment_axis == 0:
+            return numpy.pad(
+                data,
+                pad_width=((lower_boundary, higher_boundary), (0, 0)),
+                mode=pad_mode,
+            )
+        else:
+            raise ValueError("alignment_axis should be in (0, 1)")
+
+
+def align_horizontally(data: numpy.ndarray, alignment: AlignmentAxis2, new_width: int, pad_mode="constant"):
+    """
+    Align data horizontally to make sure new data width will ne `new_width`.
+
+    :param numpy.ndarray data: data to align
+    :param HAlignment alignment: alignment strategy
+    :param int new_width: output data width
+    """
+    alignment = AlignmentAxis2.from_value(alignment).value
+    return align_frame(
+        data=data, alignment=alignment, new_aligned_axis_size=new_width, pad_mode=pad_mode, alignment_axis=1
+    )
 
 
 class PaddedRawData:

nabu/stitching/config.py

@@ -1,33 +1,3 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "10/05/2022"
-
-
 from math import ceil
 from typing import Any, Iterable, Optional, Union, Sized
 from dataclasses import dataclass
@@ -44,7 +14,7 @@ from ..pipeline.config_validators import (
 from ..utils import concatenate_dict, convert_str_to_tuple
 from ..io.utils import get_output_volume
 from .overlap import OverlapStitchingStrategy
-from .utils import ShiftAlgorithm
+from .utils.utils import ShiftAlgorithm
 from .definitions import StitchingType
 from .alignment import AlignmentAxis1, AlignmentAxis2
 from pyunitsystem.metricsystem import MetricSystem
@@ -66,9 +36,9 @@ OUTPUT_SECTION = "output"
 
 INPUTS_SECTION = "inputs"
 
-Z_PRE_PROC_SECTION = "z-preproc"
+PRE_PROC_SECTION = "preproc"
 
-Z_POST_PROC_SECTION = "z-postproc"
+POST_PROC_SECTION = "postproc"
 
 INPUT_DATASETS_FIELD = "input_datasets"
 
@@ -134,6 +104,8 @@ ALIGNMENT_AXIS_1_FIELD = "alignment_axis_1"
 
 PAD_MODE_FIELD = "pad_mode"
 
+AVOID_DATA_DUPLICATION_FIELD = "avoid_data_duplication"
+
 # SLURM
 
 SLURM_SECTION = "slurm"
@@ -539,6 +511,10 @@ class StitchingConfiguration:
 
     normalization_by_sample: NormalizationBySample = None
 
+    duplicate_data: bool = True
+    """when possible (for HDF5) avoid duplicating data as-much-much-as-possible. Overlaping region between two frames will be duplicated. Remaining will be 'raw_data' for volume.
+    For projection flat field will be applied"""
+
     @property
     def stitching_type(self):
         raise NotImplementedError("Base class")
@@ -657,6 +633,12 @@ class StitchingConfiguration:
                     "help": f"pad mode to use for frame alignment. Valid values are 'constant', 'edge', 'linear_ramp', maximum', 'mean', 'median', 'minimum', 'reflect', 'symmetric', 'wrap', and 'empty'. See nupy.pad documentation for details",
                     "type": "advanced",
                 },
+                AVOID_DATA_DUPLICATION_FIELD: {
+                    "default": "1",
+                    "help": "When possible (stitching on reconstructed volume and HDF5 volume as input and output) create link to original data instead of duplicating it all. Warning: this will create relative link between the stiched volume and the original reconstructed volume.",
+                    "validator": boolean_validator,
+                    "type": "advanced",
+                },
             },
             OUTPUT_SECTION: {
                 OVERWRITE_RESULTS_FIELD: {
@@ -771,6 +753,7 @@ class StitchingConfiguration:
                 RESCALE_FRAMES: self.rescale_frames,
                 RESCALE_PARAMS: _dict_to_str(self.rescale_params or {}),
                 STITCHING_KERNELS_EXTRA_PARAMS: _dict_to_str(self.stitching_kernels_extra_params or {}),
+                AVOID_DATA_DUPLICATION_FIELD: not self.duplicate_data,
             },
             OUTPUT_SECTION: {
                 OVERWRITE_RESULTS_FIELD: int(
@@ -781,20 +764,39 @@ class StitchingConfiguration:
         }
 
 
+class SingleAxisConfigMetaClass(type):
+    """
+    Metaclass for single axis stitcher in order to aggregate dumper class and axis
+
+    warning: this class is used by tomwer as well
+    """
+
+    def __new__(mcls, name, bases, attrs, axis=None):
+        # assert axis is not None
+        mcls = super().__new__(mcls, name, bases, attrs)
+        mcls._axis = axis
+        return mcls
+
+
 @dataclass
-class ZStitchingConfiguration(StitchingConfiguration):
+class SingleAxisStitchingConfiguration(StitchingConfiguration, metaclass=SingleAxisConfigMetaClass):
     """
     base class to define z-stitching parameters
     """
 
-    slices: Union[
-        slice, tuple, None
-    ] = None  # slices to reconstruct. Over axis 0 for pre-processing, over axis 1 for post-processing. If None will reconstruct all
+    slices: Union[slice, tuple, None] = (
+        None  # slices to reconstruct. Over axis 0 for pre-processing, over axis 1 for post-processing. If None will reconstruct all
+    )
 
     alignment_axis_2: AlignmentAxis2 = AlignmentAxis2.CENTER
 
     pad_mode: str = "constant"  # pad mode to be used for alignment
 
+    @property
+    def axis(self) -> int:
+        # self._axis is defined by the metaclass
+        return self._axis
+
     def settle_inputs(self) -> None:
         self.settle_slices()
 
@@ -826,7 +828,7 @@ class ZStitchingConfiguration(StitchingConfiguration):
 
 
 @dataclass
-class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
+class PreProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfiguration):
     """
     base class to define z-stitching parameters
     """
@@ -839,7 +841,15 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
 
     @property
     def stitching_type(self) -> StitchingType:
-        return StitchingType.Z_PREPROC
+        if self.axis == 0:
+            return StitchingType.Z_PREPROC
+        elif self.axis == 1:
+            return StitchingType.Y_PREPROC
+        else:
+            raise ValueError(
+                "unexpected axis value. Only stitching over axis 0 (aka z) and 1 (aka y) are handled. Current axis value is %s",
+                self.axis,
+            )
 
     def get_output_object(self):
         return NXtomoScan(
@@ -853,9 +863,11 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
 
     def settle_input_scans(self):
         self.input_scans = [
-            Factory.create_tomo_object_from_identifier(identifier)
-            if isinstance(identifier, (str, ScanIdentifier))
-            else identifier
+            (
+                Factory.create_tomo_object_from_identifier(identifier)
+                if isinstance(identifier, (str, ScanIdentifier))
+                else identifier
+            )
             for identifier in self.input_scans
         ]
 
@@ -918,7 +930,7 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
         return concatenate_dict(
             super().to_dict(),
             {
-                Z_PRE_PROC_SECTION: {
+                PRE_PROC_SECTION: {
                     DATA_FILE_FIELD: self.output_file_path,
                     DATA_PATH_FIELD: self.output_data_path,
                     NEXUS_VERSION_FIELD: self.output_nexus_version,
@@ -935,9 +947,9 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
     @staticmethod
     def get_description_dict() -> dict:
         return concatenate_dict(
-            ZStitchingConfiguration.get_description_dict(),
+            SingleAxisStitchingConfiguration.get_description_dict(),
             {
-                Z_PRE_PROC_SECTION: {
+                PRE_PROC_SECTION: {
                     DATA_FILE_FIELD: {
                         "default": "",
                         "help": "output nxtomo file path",
@@ -957,8 +969,8 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
             },
         )
 
-    @staticmethod
-    def from_dict(config: dict):
+    @classmethod
+    def from_dict(cls, config: dict):
         if not isinstance(config, dict):
             raise TypeError(f"config is expected to be a dict and not {type(config)}")
         inputs_scans_str = config.get(INPUTS_SECTION, {}).get(INPUT_DATASETS_FIELD, None)
@@ -967,9 +979,9 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
         else:
             input_scans = identifiers_as_str_to_instances(inputs_scans_str)
 
-        output_file_path = config.get(Z_PRE_PROC_SECTION, {}).get(DATA_FILE_FIELD, None)
+        output_file_path = config.get(PRE_PROC_SECTION, {}).get(DATA_FILE_FIELD, None)
 
-        nexus_version = config.get(Z_PRE_PROC_SECTION, {}).get(NEXUS_VERSION_FIELD, None)
+        nexus_version = config.get(PRE_PROC_SECTION, {}).get(NEXUS_VERSION_FIELD, None)
         if nexus_version in (None, ""):
             nexus_version = nxtomo.LATEST_VERSION
         else:
@@ -980,7 +992,7 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
         else:
             pixel_size = float(pixel_size) / MetricSystem.MM
 
-        return PreProcessedZStitchingConfiguration(
+        return cls(
             stitching_strategy=OverlapStitchingStrategy.from_value(
                 config[STITCHING_SECTION].get(
                     STITCHING_STRATEGY_FIELD,
@@ -1006,7 +1018,7 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
             ),
             input_scans=input_scans,
             output_file_path=output_file_path,
-            output_data_path=config.get(Z_PRE_PROC_SECTION, {}).get(DATA_PATH_FIELD, "entry_from_stitchig"),
+            output_data_path=config.get(PRE_PROC_SECTION, {}).get(DATA_PATH_FIELD, "entry_from_stitchig"),
             overwrite_results=config[STITCHING_SECTION].get(OVERWRITE_RESULTS_FIELD, True),
             output_nexus_version=nexus_version,
             slices=_slices_to_list_or_slice(config[INPUTS_SECTION].get(STITCHING_SLICES, None)),
@@ -1026,12 +1038,13 @@ class PreProcessedZStitchingConfiguration(ZStitchingConfiguration):
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_2_FIELD, AlignmentAxis2.CENTER)
             ),
             pad_mode=config[STITCHING_SECTION].get(PAD_MODE_FIELD, "constant"),
+            duplicate_data=not config[STITCHING_SECTION].get(AVOID_DATA_DUPLICATION_FIELD, False),
             normalization_by_sample=NormalizationBySample.from_dict(config.get(NORMALIZATION_BY_SAMPLE_SECTION, {})),
         )
 
 
 @dataclass
-class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
+class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfiguration):
     """
     base class to define z-stitching parameters
     """
@@ -1043,7 +1056,10 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
 
     @property
     def stitching_type(self) -> StitchingType:
-        return StitchingType.Z_POSTPROC
+        if self.axis == 0:
+            return StitchingType.Z_POSTPROC
+        else:
+            raise ValueError(f"unexpected axis value. Only stitching over axis 0 (aka z) is handled. Not {self.axis}")
 
     def get_output_object(self):
         return self.output_volume
@@ -1054,9 +1070,11 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
 
     def settle_input_volumes(self):
         self.input_volumes = [
-            Factory.create_tomo_object_from_identifier(identifier)
-            if isinstance(identifier, (str, VolumeIdentifier))
-            else identifier
+            (
+                Factory.create_tomo_object_from_identifier(identifier)
+                if isinstance(identifier, (str, VolumeIdentifier))
+                else identifier
+            )
             for identifier in self.input_volumes
         ]
 
@@ -1117,8 +1135,8 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
         self.slices = slices
         return slices, n_slices
 
-    @staticmethod
-    def from_dict(config: dict):
+    @classmethod
+    def from_dict(cls, config: dict):
         if not isinstance(config, dict):
             raise TypeError(f"config is expected to be a dict and not {type(config)}")
         inputs_volumes_str = config.get(INPUTS_SECTION, {}).get(INPUT_DATASETS_FIELD, None)
@@ -1127,7 +1145,7 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
         else:
             input_volumes = identifiers_as_str_to_instances(inputs_volumes_str)
         overwrite_results = config[STITCHING_SECTION].get(OVERWRITE_RESULTS_FIELD, True) in ("1", True, "True", 1)
-        output_volume = config.get(Z_POST_PROC_SECTION, {}).get(OUTPUT_VOLUME, None)
+        output_volume = config.get(POST_PROC_SECTION, {}).get(OUTPUT_VOLUME, None)
         if output_volume is not None:
             output_volume = Factory.create_tomo_object_from_identifier(output_volume)
             output_volume.overwrite = overwrite_results
@@ -1138,8 +1156,8 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
         else:
             voxel_size = float(voxel_size) * MetricSystem.MM
 
-        # on the next section the one with a default value qre the optionnal one
-        return PostProcessedZStitchingConfiguration(
+        # on the next section the one with a default value qre the optional one
+        return cls(
             stitching_strategy=OverlapStitchingStrategy.from_value(
                 config[STITCHING_SECTION].get(
                     STITCHING_STRATEGY_FIELD,
@@ -1178,6 +1196,7 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_2_FIELD, AlignmentAxis2.CENTER)
             ),
             pad_mode=config[STITCHING_SECTION].get(PAD_MODE_FIELD, "constant"),
+            duplicate_data=not config[STITCHING_SECTION].get(AVOID_DATA_DUPLICATION_FIELD, False),
             normalization_by_sample=NormalizationBySample.from_dict(config.get(NORMALIZATION_BY_SAMPLE_SECTION, {})),
         )
 
@@ -1194,10 +1213,10 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
                     INPUT_DATASETS_FIELD: [volume.get_identifier().to_str() for volume in self.input_volumes],
                     INPUT_VOXEL_SIZE_MM: voxel_size_mm,
                 },
-                Z_POST_PROC_SECTION: {
-                    OUTPUT_VOLUME: self.output_volume.get_identifier().to_str()
-                    if self.output_volume is not None
-                    else "",
+                POST_PROC_SECTION: {
+                    OUTPUT_VOLUME: (
+                        self.output_volume.get_identifier().to_str() if self.output_volume is not None else ""
+                    ),
                 },
                 STITCHING_SECTION: {
                     ALIGNMENT_AXIS_1_FIELD: self.alignment_axis_1.value,
@@ -1208,9 +1227,9 @@ class PostProcessedZStitchingConfiguration(ZStitchingConfiguration):
     @staticmethod
     def get_description_dict() -> dict:
         return concatenate_dict(
-            ZStitchingConfiguration.get_description_dict(),
+            SingleAxisStitchingConfiguration.get_description_dict(),
             {
-                Z_POST_PROC_SECTION: {
+                POST_PROC_SECTION: {
                     OUTPUT_VOLUME: {
                         "default": "",
                         "help": "identifier of the output volume. Like hdf5:volume:[file_path]?path=[data_path] for an HDF5 volume",
@@ -1249,13 +1268,15 @@ def dict_to_config_obj(config: dict):
         raise TypeError
     stitching_type = config.get(STITCHING_SECTION, {}).get(STITCHING_TYPE_FIELD, None)
     if stitching_type is None:
-        raise ValueError("Unagle to find stitching type from config dict")
+        raise ValueError("Unable to find stitching type from config dict")
     else:
         stitching_type = StitchingType.from_value(stitching_type)
         if stitching_type is StitchingType.Z_POSTPROC:
             return PostProcessedZStitchingConfiguration.from_dict(config)
         elif stitching_type is StitchingType.Z_PREPROC:
             return PreProcessedZStitchingConfiguration.from_dict(config)
+        elif stitching_type is StitchingType.Y_PREPROC:
+            return PreProcessedYStitchingConfiguration.from_dict(config)
         else:
             raise NotImplementedError(f"stitching type {stitching_type.value} not handled yet")
 
@@ -1277,10 +1298,26 @@ def get_default_stitching_config(stitching_type: Optional[Union[StitchingType, s
         return z_postproc_stitching_config
     elif stitching_type is StitchingType.Z_PREPROC:
         return z_preproc_stitching_config
+    elif stitching_type is StitchingType.Y_PREPROC:
+        return y_preproc_stitching_config
     else:
         raise NotImplementedError
 
 
+class PreProcessedYStitchingConfiguration(PreProcessedSingleAxisStitchingConfiguration, axis=1):
+    pass
+
+
+class PreProcessedZStitchingConfiguration(PreProcessedSingleAxisStitchingConfiguration, axis=0):
+    pass
+
+
+class PostProcessedZStitchingConfiguration(PostProcessedSingleAxisStitchingConfiguration, axis=0):
+    pass
+
+
+y_preproc_stitching_config = PreProcessedYStitchingConfiguration.get_description_dict()
+
 z_preproc_stitching_config = PreProcessedZStitchingConfiguration.get_description_dict()
 
 z_postproc_stitching_config = PostProcessedZStitchingConfiguration.get_description_dict()

nabu/stitching/definitions.py

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