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

nabu/stitching/frame_composition.py

@@ -1,36 +1,33 @@
-from copy import copy
 from dataclasses import dataclass
 import numpy
 from math import ceil
 
-from nabu.stitching.overlap import ZStichOverlapKernel
-
 
 @dataclass
-class _FrameCompositionBase:
-    def compose(self, output_frame: numpy.ndarray, input_frames: tuple):
-        raise NotImplementedError("Base class")
-
-
-@dataclass
-class ZFrameComposition(_FrameCompositionBase):
+class FrameComposition:
     """
     class used to define intervals to know where to dump raw data or stitched data according to requested policy.
     The idea is to create this once for all for one stitching operation and reuse it for each frame.
     """
 
-    local_start_y: tuple
-    local_end_y: tuple
-    global_start_y: tuple
-    global_end_y: tuple
+    composed_axis: int
+    """axis along which the composition is done"""
+    local_start: tuple
+    """tuple of indices on the input frames ref to know where each region start (along the composed axis)"""
+    local_end: tuple
+    """tuple of indices on the input frames ref to know where each region end (along the composed axis)"""
+    global_start: tuple
+    """tuple of indices on the output frame ref to know where each region start (along the composed axis)"""
+    global_end: tuple
+    """tuple of indices on the output frame ref to know where each region end (along the composed axis)"""
 
     def browse(self):
-        for i in range(len(self.local_start_y)):
+        for i in range(len(self.local_start)):
             yield (
-                self.local_start_y[i],
-                self.local_end_y[i],
-                self.global_start_y[i],
-                self.global_end_y[i],
+                self.local_start[i],
+                self.local_end[i],
+                self.global_start[i],
+                self.global_end[i],
             )
 
     def compose(self, output_frame: numpy.ndarray, input_frames: tuple):
@@ -39,20 +36,25 @@ class ZFrameComposition(_FrameCompositionBase):
                 f"output_frame is expected to be 2D (gray scale) or 3D (RGB(A)) and not {output_frame.ndim}"
             )
         for (
-            global_start_y,
-            global_end_y,
-            local_start_y,
-            local_end_y,
+            global_start,
+            global_end,
+            local_start,
+            local_end,
             input_frame,
         ) in zip(
-            self.global_start_y,
-            self.global_end_y,
-            self.local_start_y,
-            self.local_end_y,
+            self.global_start,
+            self.global_end,
+            self.local_start,
+            self.local_end,
             input_frames,
         ):
             if input_frame is not None:
-                output_frame[global_start_y:global_end_y] = input_frame[local_start_y:local_end_y]
+                if self.composed_axis == 0:
+                    output_frame[global_start:global_end] = input_frame[local_start:local_end]
+                elif self.composed_axis == 1:
+                    output_frame[:, global_start:global_end] = input_frame[:, local_start:local_end]
+                else:
+                    raise ValueError(f"composed axis must be in (0, 1). Get {self.composed_axis}")
 
     @staticmethod
     def compute_raw_frame_compositions(frames: tuple, key_lines: tuple, overlap_kernels: tuple, stitching_axis):
@@ -63,37 +65,42 @@ class ZFrameComposition(_FrameCompositionBase):
         """
         assert len(frames) == len(overlap_kernels) + 1 == len(key_lines) + 1
 
-        global_start_ys = [0]
+        global_start_indices = [0]
 
         # extend shifts and kernels to have a first shift of 0 and two overlaps values at 0 to
         # generalize processing
-        local_start_ys = [0]
+        local_start_indices = [0]
 
-        local_start_ys.extend(
+        local_start_indices.extend(
             [ceil(key_line[1] + kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)]
         )
-        local_end_ys = list(
+        local_end_indices = list(
             [ceil(key_line[0] - kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)]
         )
-        local_end_ys.append(frames[-1].shape[stitching_axis])
+        local_end_indices.append(frames[-1].shape[stitching_axis])
 
         for (
-            new_local_start_y,
-            new_local_end_y,
+            new_local_start_index,
+            new_local_end_index,
             kernel,
-        ) in zip(local_start_ys, local_end_ys, overlap_kernels):
-            global_start_ys.append(global_start_ys[-1] + (new_local_end_y - new_local_start_y) + kernel.overlap_size)
+        ) in zip(local_start_indices, local_end_indices, overlap_kernels):
+            global_start_indices.append(
+                global_start_indices[-1] + (new_local_end_index - new_local_start_index) + kernel.overlap_size
+            )
 
         # global end can be easily found from global start + local start and end
-        global_end_ys = []
-        for global_start_y, new_local_start_y, new_local_end_y in zip(global_start_ys, local_start_ys, local_end_ys):
-            global_end_ys.append(global_start_y + new_local_end_y - new_local_start_y)
-
-        return ZFrameComposition(
-            local_start_y=tuple(local_start_ys),
-            local_end_y=tuple(local_end_ys),
-            global_start_y=tuple(global_start_ys),
-            global_end_y=tuple(global_end_ys),
+        global_end_indices = []
+        for global_start_index, new_local_start_index, new_local_end_index in zip(
+            global_start_indices, local_start_indices, local_end_indices
+        ):
+            global_end_indices.append(global_start_index + new_local_end_index - new_local_start_index)
+
+        return FrameComposition(
+            composed_axis=stitching_axis,
+            local_start=tuple(local_start_indices),
+            local_end=tuple(local_end_indices),
+            global_start=tuple(global_start_indices),
+            global_end=tuple(global_end_indices),
         )
 
     @staticmethod
@@ -102,33 +109,34 @@ class ZFrameComposition(_FrameCompositionBase):
         compute frame composition for stiching.
         """
         assert len(frames) == len(overlap_kernels) + 1 == len(key_lines) + 1
-        assert stitching_axis in (0, 1, 2)
+        assert stitching_axis in (0, 1)
 
         # position in the stitched frame;
-        local_start_ys = [0] * len(overlap_kernels)
-        local_end_ys = [kernel.overlap_size for kernel in overlap_kernels]
+        local_start_indices = [0] * len(overlap_kernels)
+        local_end_indices = [kernel.overlap_size for kernel in overlap_kernels]
 
         # position in the global frame. For this one it is simpler to rely on the raw frame composition
-        composition_raw = ZFrameComposition.compute_raw_frame_compositions(
+        composition_raw = FrameComposition.compute_raw_frame_compositions(
             frames=frames,
             key_lines=key_lines,
             overlap_kernels=overlap_kernels,
             stitching_axis=stitching_axis,
         )
-        global_start_ys = composition_raw.global_end_y[:-1]
-        global_end_ys = composition_raw.global_start_y[1:]
-
-        return ZFrameComposition(
-            local_start_y=tuple(local_start_ys),
-            local_end_y=tuple(local_end_ys),
-            global_start_y=tuple(global_start_ys),
-            global_end_y=tuple(global_end_ys),
+        global_start_indices = composition_raw.global_end[:-1]
+        global_end_indices = composition_raw.global_start[1:]
+
+        return FrameComposition(
+            composed_axis=stitching_axis,
+            local_start=tuple(local_start_indices),
+            local_end=tuple(local_end_indices),
+            global_start=tuple(global_start_indices),
+            global_end=tuple(global_end_indices),
         )
 
     @staticmethod
-    def pprint_z_stitching(raw_composition, stitch_composition):
+    def pprint_composition(raw_composition, stitch_composition):
         """
-        util to display what the output of the z stitch will looks like from composition
+        util to display what the output of the composition will looks like from composition
         """
         for i_frame, (raw_comp, stitch_comp) in enumerate(zip(raw_composition.browse(), stitch_composition.browse())):
             raw_local_start, raw_local_end, raw_global_start, raw_global_end = raw_comp

nabu/stitching/overlap.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"
-
-
 import numpy
 import logging
 from typing import Optional, Union
@@ -59,34 +29,49 @@ class OverlapKernelBase:
     pass
 
 
-class ZStichOverlapKernel(OverlapKernelBase):
+class ImageStichOverlapKernel(OverlapKernelBase):
     """
-    class used to define overlap between two scans and create stitch between frames (`stitch` function)
+    Stitch two images along Y (axis 0 in image space)
     """
 
     DEFAULT_HIGH_FREQUENCY_THRESHOLD = 2
 
     def __init__(
         self,
-        frame_width: int,
+        stitching_axis: int,
+        frame_unstitched_axis_size: tuple,
         stitching_strategy: OverlapStitchingStrategy = DEFAULT_OVERLAP_STRATEGY,
         overlap_size: int = DEFAULT_OVERLAP_SIZE,
         extra_params: Optional[dict] = None,
     ) -> None:
-        """ """
+        """
+        :param stitching_axis: axis along which stitching is operate. Must be in '0', '1'
+        :param frame_unstitched_axis_size: according to the stitching axis the stitched framed will always have a constant size:
+            * If stitching_axis == 0 then it will be the frame width
+            * If stitching_axis == 1 then it will be the frame height
+        :param stitching_strategy: stategy / algorithm to use in order to generate the stitching
+        :param overlap_size: size (int) of the overlap (stitching) between the two images
+        :param extra_params: possibly extra parameters to operate the stitching
+        """
         from nabu.stitching.config import KEY_THRESHOLD_FREQUENCY  # avoid acylic import
 
         if not isinstance(overlap_size, int) and overlap_size > 0:
             raise TypeError(
                 f"overlap_size is expected to be a positive int, {overlap_size} - not {overlap_size} ({type(overlap_size)})"
             )
-        if not isinstance(frame_width, int) or not frame_width > 0:
+        if not isinstance(frame_unstitched_axis_size, int) or not frame_unstitched_axis_size > 0:
             raise TypeError(
-                f"frame_width is expected to be a positive int, {frame_width} - not {frame_width} ({type(frame_width)})"
+                f"frame_width is expected to be a positive int, {frame_unstitched_axis_size} - not {frame_unstitched_axis_size} ({type(frame_unstitched_axis_size)})"
+            )
+
+        if not stitching_axis in (0, 1):
+            raise ValueError(
+                "stitching_axis is expected to be the axis along which stitching must be done. It should be '0' or '1'"
             )
 
+        self._stitching_axis = stitching_axis
         self._overlap_size = abs(overlap_size)
-        self._frame_width = frame_width
+        self._frame_unstitched_axis_size = frame_unstitched_axis_size
         self._stitching_strategy = OverlapStitchingStrategy.from_value(stitching_strategy)
         self._weights_img_1 = None
         self._weights_img_2 = None
@@ -97,13 +82,28 @@ class ZStichOverlapKernel(OverlapKernelBase):
         )
 
     def __str__(self) -> str:
-        return f"z-stitching kernel (policy={self.stitching_strategy.value}, overlap_size={self.overlap_size}, frame={self._frame_width})"
+        return f"z-stitching kernel (policy={self.stitching_strategy.value}, overlap_size={self.overlap_size}, frame={self._frame_unstitched_axis_size})"
 
     @staticmethod
     def __check_img(img, name):
         if not isinstance(img, numpy.ndarray) and img.ndim == 2:
             raise ValueError(f"{name} is expected to be 2D numpy array")
 
+    @property
+    def stitched_axis(self) -> int:
+        return self._stitching_axis
+
+    @property
+    def unstitched_axis(self) -> int:
+        """
+        util function. The kernel is operating stitching on images along a single axis (`stitching_axis`).
+        This property is returning the other axis.
+        """
+        if self.stitched_axis == 0:
+            return 1
+        else:
+            return 0
+
     @property
     def overlap_size(self) -> int:
         return self._overlap_size
@@ -169,8 +169,22 @@ class ZStichOverlapKernel(OverlapKernelBase):
         else:
             raise NotImplementedError(f"{self.stitching_strategy} not implemented")
 
-        self._weights_img_1 = weights_img_1.reshape(-1, 1) * numpy.ones(self._frame_width).reshape(1, -1)
-        self._weights_img_2 = weights_img_2.reshape(-1, 1) * numpy.ones(self._frame_width).reshape(1, -1)
+        if self._stitching_axis == 0:
+            self._weights_img_1 = weights_img_1.reshape(-1, 1) * numpy.ones(self._frame_unstitched_axis_size).reshape(
+                1, -1
+            )
+            self._weights_img_2 = weights_img_2.reshape(-1, 1) * numpy.ones(self._frame_unstitched_axis_size).reshape(
+                1, -1
+            )
+        elif self._stitching_axis == 1:
+            self._weights_img_1 = weights_img_1.reshape(1, -1) * numpy.ones(self._frame_unstitched_axis_size).reshape(
+                -1, 1
+            )
+            self._weights_img_2 = weights_img_2.reshape(1, -1) * numpy.ones(self._frame_unstitched_axis_size).reshape(
+                -1, 1
+            )
+        else:
+            raise ValueError(f"stitching_axis should be in (0, 1). {self._stitching_axis} provided")
 
     def stitch(self, img_1, img_2, check_input=True) -> tuple:
         """Compute overlap region from the defined strategy"""
@@ -186,14 +200,20 @@ class ZStichOverlapKernel(OverlapKernelBase):
         if self._stitching_strategy is OverlapStitchingStrategy.IMAGE_MINIMUM_DIVERGENCE:
             return (
                 compute_image_minimum_divergence(
-                    img_1=img_1, img_2=img_2, high_frequency_threshold=self._high_frequency_threshold
+                    img_1=img_1,
+                    img_2=img_2,
+                    high_frequency_threshold=self._high_frequency_threshold,
+                    stitching_axis=self.stitched_axis,
                 ),
                 None,
                 None,
             )
         elif self._stitching_strategy is OverlapStitchingStrategy.HIGHER_SIGNAL:
             return (
-                compute_image_higher_signal(img_1=img_1, img_2=img_2),
+                compute_image_higher_signal(
+                    img_1=img_1,
+                    img_2=img_2,
+                ),
                 None,
                 None,
             )
@@ -208,7 +228,9 @@ class ZStichOverlapKernel(OverlapKernelBase):
             )
 
 
-def compute_image_minimum_divergence(img_1: numpy.ndarray, img_2: numpy.ndarray, high_frequency_threshold):
+def compute_image_minimum_divergence(
+    img_1: numpy.ndarray, img_2: numpy.ndarray, high_frequency_threshold, stitching_axis: int
+):
     """
     Algorithm to improve treatment of high frequency.
 
@@ -242,10 +264,20 @@ def compute_image_minimum_divergence(img_1: numpy.ndarray, img_2: numpy.ndarray,
     low_freq_img_2, high_freq_img_2 = split_image(img_2, threshold=high_frequency_threshold)
 
     # handle low frequency
-    low_freq_stitching_kernel = ZStichOverlapKernel(
-        frame_width=img_1.shape[1],
+    if stitching_axis == 0:
+        frame_cst_size = img_1.shape[1]
+        overlap_size = img_1.shape[0]
+    elif stitching_axis == 1:
+        frame_cst_size = img_1.shape[0]
+        overlap_size = img_1.shape[1]
+    else:
+        raise ValueError("")
+
+    low_freq_stitching_kernel = ImageStichOverlapKernel(
+        frame_unstitched_axis_size=frame_cst_size,
         stitching_strategy=OverlapStitchingStrategy.COSINUS_WEIGHTS,
-        overlap_size=img_1.shape[0],
+        overlap_size=overlap_size,
+        stitching_axis=stitching_axis,
     )
     low_freq_stitched = low_freq_stitching_kernel.stitch(
         img_1=low_freq_img_1,
@@ -292,8 +324,8 @@ def check_overlaps(frames: Union[tuple, numpy.ndarray], positions: tuple, axis:
     """
     if not isinstance(frames, (tuple, numpy.ndarray)):
         raise TypeError(f"frames is expected to be a tuple or a numpy array. Get {type(frames)} instead")
-    if not isinstance(positions, tuple):
-        raise TypeError(f"positions is expected to be a tuple. Get {type(positions)} instead")
+    if not isinstance(positions, tuple) and len(positions) == 3:
+        raise TypeError(f"positions is expected to be a tuple of 3 elements. Get {type(positions)} instead")
     assert isinstance(axis, int), "axis is expected to be an int"
     assert isinstance(raise_error, bool), "raise_error is expected to be a bool"
 
@@ -301,14 +333,22 @@ def check_overlaps(frames: Union[tuple, numpy.ndarray], positions: tuple, axis:
         if raise_error:
             raise ValueError(error_msg)
         else:
-            _logger.error(error_msg)
+            _logger.error(raise_error)
+
+    if axis == 0:
+        axis_frame_space = 0
+    elif axis == 2:
+        raise NotImplementedError(f"overlap check along axis {axis_frame_space}")
+    elif axis == 1:
+        axis_frame_space = 1
 
     # convert each frame to appropriate bounding box according to the axis
     def convert_to_bb(frame: numpy.ndarray, position: tuple, axis: int):
         assert isinstance(axis, int)
         assert isinstance(position, tuple), f"position expected a tuple. Get {type(position)} instead"
-        start_frame = position[axis] - frame.shape[axis] // 2
-        end_frame = start_frame + frame.shape[axis]
+        assert len(position) == 3, f"Expect to have three items for the position. Get {len(position)}"
+        start_frame = position[axis] - frame.shape[axis_frame_space] // 2
+        end_frame = start_frame + frame.shape[axis_frame_space]
         return BoundingBox1D(start_frame, end_frame)
 
     bounding_boxes = {

nabu/stitching/single_axis_stitching.py

@@ -0,0 +1,32 @@
+from .y_stitching import y_stitching
+from .z_stitching import z_stitching
+from tomoscan.identifier import BaseIdentifier
+from nabu.stitching.config import (
+    SingleAxisStitchingConfiguration,
+    PreProcessedYStitchingConfiguration,
+    PreProcessedZStitchingConfiguration,
+    PostProcessedZStitchingConfiguration,
+)
+
+
+def stitching(configuration: SingleAxisStitchingConfiguration, progress=None) -> BaseIdentifier:
+    """
+    Apply stitching from provided configuration.
+    Stitching will be applied along a single axis at the moment.
+
+    like:
+                    axis 0
+                      ^
+                      |
+    x-ray             |
+    -------->          ------> axis 2
+                     /
+                    /
+                     axis 1
+    """
+    if isinstance(configuration, (PreProcessedYStitchingConfiguration,)):
+        return y_stitching(configuration=configuration, progress=progress)
+    elif isinstance(configuration, (PreProcessedZStitchingConfiguration, PostProcessedZStitchingConfiguration)):
+        return z_stitching(configuration=configuration, progress=progress)
+    else:
+        raise NotImplementedError(f"configuration type ({type(configuration)}) is not handled")

nabu/stitching/slurm_utils.py

@@ -13,8 +13,8 @@ from ..pipeline.config import generate_nabu_configfile
 from .config import (
     StitchingConfiguration,
     get_default_stitching_config,
-    PreProcessedZStitchingConfiguration,
-    PostProcessedZStitchingConfiguration,
+    PreProcessedSingleAxisStitchingConfiguration,
+    PostProcessedSingleAxisStitchingConfiguration,
     SLURM_SECTION,
 )
 
@@ -64,11 +64,11 @@ def split_stitching_configuration_to_slurm_job(
     configuration.settle_inputs()
 
     slice_sub_parts = split_slices(slices=configuration.slices, n_parts=n_jobs)
-    if isinstance(configuration, PreProcessedZStitchingConfiguration):
+    if isinstance(configuration, PreProcessedSingleAxisStitchingConfiguration):
         stitch_prefix = os.path.basename(os.path.splitext(configuration.output_file_path)[0])
         configuration.output_file_path = os.path.abspath(configuration.output_file_path)
 
-    elif isinstance(configuration, PostProcessedZStitchingConfiguration):
+    elif isinstance(configuration, PostProcessedSingleAxisStitchingConfiguration):
         stitch_prefix = os.path.basename(os.path.splitext(configuration.output_volume.file_path)[0])
         configuration.output_volume.file_path = os.path.abspath(configuration.output_volume.file_path)
     else:
@@ -81,7 +81,7 @@ def split_stitching_configuration_to_slurm_job(
         # remove slurm configuration because once on the partition we run it manually
         sub_configuration.slurm_config = None
 
-        if isinstance(sub_configuration, PreProcessedZStitchingConfiguration):
+        if isinstance(sub_configuration, PreProcessedSingleAxisStitchingConfiguration):
             original_output_file_path, file_extension = os.path.splitext(sub_configuration.output_file_path)
             sub_configuration.output_file_path = os.path.join(
                 original_output_file_path,
@@ -91,7 +91,7 @@ def split_stitching_configuration_to_slurm_job(
                 scan=sub_configuration.output_file_path,
                 entry=sub_configuration.output_data_path,
             )
-        elif isinstance(sub_configuration, PostProcessedZStitchingConfiguration):
+        elif isinstance(sub_configuration, PostProcessedSingleAxisStitchingConfiguration):
             if isinstance(sub_configuration.output_volume, (HDF5Volume, MultiTIFFVolume)):
                 original_output_file_path, file_extension = os.path.splitext(sub_configuration.output_volume.file_path)
                 sub_configuration.output_volume.file_path = os.path.join(

nabu/stitching/stitcher/base.py

@@ -0,0 +1,124 @@
+from copy import copy
+from typing import Union
+from nabu.stitching.config import SingleAxisStitchingConfiguration
+from tomoscan.esrf import NXtomoScan
+from tomoscan.volumebase import VolumeBase
+from tomoscan.identifier import BaseIdentifier
+
+
+def get_obj_constant_side_length(obj: Union[NXtomoScan, VolumeBase], axis: int) -> int:
+    """
+    return tomo object lenght that will be constant over 1D stitching.
+    In the case of a stitching along axis 0 this will be:
+        * the projection width for pre-processing
+        * volume.shape[2] for post-processing
+
+    In the case of a stitching along axis 1 this will be:
+        * the projection height for pre-processing
+    """
+    if isinstance(obj, NXtomoScan):
+        if axis == 0:
+            return obj.dim_1
+        elif axis in (1, 2):
+            return obj.dim_2
+    elif isinstance(obj, VolumeBase) and axis == 0:
+        return obj.get_volume_shape()[-1]
+    else:
+        raise TypeError(f"obj type ({type(obj)}) and axis == {axis} is not handled")
+
+
+class _StitcherBase:
+    """
+    Any stitcher base class
+    """
+
+    def __init__(self, configuration, progress=None) -> None:
+        if not isinstance(configuration, SingleAxisStitchingConfiguration):
+            raise TypeError
+
+        # flag to check if the serie has been ordered yet or not
+        self._configuration = copy(configuration)
+        # copy configuration because we will edit it
+        self._frame_composition = None
+        self._progress = progress
+        self._overlap_kernels = []
+        # kernels to create the stitching on overlaps.
+
+    @property
+    def serie_label(self) -> str:
+        """return serie name for logs"""
+        raise NotImplementedError("Base class")
+
+    @property
+    def reading_orders(self):
+        """
+        as scan can be take on one direction or the order (rotation goes from X to Y then from Y to X)
+        we might need to read data from one direction or another
+        """
+        return self._reading_orders
+
+    def order_input_tomo_objects(self):
+        """
+        order inputs tomo objects
+        """
+        raise NotImplementedError("Base class")
+
+    def check_inputs(self):
+        """
+        order inputs tomo objects
+        """
+        raise NotImplementedError("Base class")
+
+    def pre_processing_computation(self):
+        """
+        some specific pre-processing that can be call before retrieving the data
+        """
+        pass
+
+    @staticmethod
+    def param_is_auto(param):
+        return param in ("auto", ("auto",))
+
+    def stitch(self, store_composition: bool = True) -> BaseIdentifier:
+        """
+        Apply expected stitch from configuration and return the DataUrl of the object created
+
+        :param bool store_composition: if True then store the composition used for stitching in frame_composition.
+                                       So it can be reused by third part (like tomwer) to display composition made
+        """
+        raise NotImplementedError("base class")
+
+    @property
+    def frame_composition(self):
+        return self._frame_composition
+
+    @staticmethod
+    def from_abs_pos_to_rel_pos(abs_position: tuple):
+        """
+        return relative position from on object to the other but in relative this time
+        :param tuple abs_position: tuple containing the absolute positions
+        :return: len(abs_position) - 1 relative position
+        :rtype: tuple
+        """
+        return tuple([pos_obj_b - pos_obj_a for (pos_obj_a, pos_obj_b) in zip(abs_position[:-1], abs_position[1:])])
+
+    @staticmethod
+    def from_rel_pos_to_abs_pos(rel_positions: tuple, init_pos: int):
+        """
+        return absolute positions from a tuple of relative position and an initial position
+        :param tuple rel_positions: tuple containing the absolute positions
+        :return: len(rel_positions) + 1 relative position
+        :rtype: tuple
+        """
+        abs_pos = [
+            init_pos,
+        ]
+        for rel_pos in rel_positions:
+            abs_pos.append(abs_pos[-1] + rel_pos)
+        return abs_pos
+
+    def _compute_shifts(self):
+        """
+        after this stage the final shifts must be determine
+        """
+        raise NotImplementedError("base class")

nabu/stitching/stitcher/dumper/__init__.py

@@ -0,0 +1,3 @@
+from .postprocessing import PostProcessingStitchingDumper
+from .postprocessing import PostProcessingStitchingDumperNoDD
+from .preprocessing import PreProcessingStitchingDumper