nabu 2023.2.1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

nabu/stitching/z_stitching.py

@@ -37,30 +37,33 @@ from math import ceil
 from contextlib import AbstractContextManager
 import h5py
 import logging
-
 from scipy.ndimage import shift as shift_scipy
+from functools import lru_cache as cache
 
 from silx.io.utils import get_data
 from silx.io.url import DataUrl
 from silx.io.dictdump import dicttonx
 
+from nxtomo.nxobject.nxdetector import ImageKey
+from nxtomo.nxobject.nxtransformations import NXtransformations
+from nxtomo.paths.nxtomo import get_paths as _get_nexus_paths
+from nxtomo.utils.transformation import build_matrix, LRDetTransformation, UDDetTransformation
+
 from tomoscan.io import HDF5File
 from tomoscan.esrf.scan.utils import cwd_context
 from tomoscan.identifier import BaseIdentifier
-from tomoscan.esrf import HDF5TomoScan, EDFTomoScan
+from tomoscan.esrf import NXtomoScan, EDFTomoScan
 from tomoscan.volumebase import VolumeBase
 from tomoscan.esrf.volume import HDF5Volume
 from tomoscan.serie import Serie
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from tomoscan.nexus.paths.nxtomo import get_paths as _get_nexus_paths
 from tomoscan.factory import Factory as TomoscanFactory
 from tomoscan.utils.volume import concatenate as concatenate_volumes
 from tomoscan.esrf.scan.utils import (
     get_compacted_dataslices,
 )  # this version has a 'return_url_set' needed here. At one point they should be merged together
-from tomoscan.unitsystem.metricsystem import MetricSystem
+from pyunitsystem.metricsystem import MetricSystem
 
-from nxtomomill.nexus import NXtomo
+from nxtomo.application.nxtomo import NXtomo
 from silx.io.dictdump import dicttonx
 
 from nabu.io.utils import DatasetReader
@@ -76,16 +79,19 @@ from nabu.stitching.config import (
     KEY_RESCALE_MAX_PERCENTILES,
     KEY_THRESHOLD_FREQUENCY,
 )
+from nabu.stitching.alignment import align_horizontally, AlignmentAxis1
 from nabu.utils import Progress
 from nabu import version as nabu_version
 from nabu.io.writer import get_datetime
 from .overlap import (
     ZStichOverlapKernel,
+    check_overlaps,
 )
 from .. import version as nabu_version
 from nabu.io.writer import get_datetime
 from nabu.misc.utils import rescale_data
-
+from nabu.stitching.alignment import PaddedRawData
+from nabu.stitching.sample_normalization import normalize_frame as normalize_frame_by_sample
 
 _logger = logging.getLogger(__name__)
 
@@ -127,6 +133,9 @@ class ZStitcher:
         self._axis_2_rel_shifts = []
         # shift between upper and lower frames
 
+        self._stitching_width = None
+        # stitching width: larger volume width. Other volume will be pad
+
         # z serie must be defined from daughter class
         assert hasattr(self, "_z_serie")
 
@@ -184,6 +193,7 @@ class ZStitcher:
         estimated_shifts_axis_0.insert(0, 0)
 
         final_pos = {}
+        previous_shift = 0
         for tomo_obj, pos_axis_0, pos_axis_2, final_shift_axis_0, estimated_shift_axis_0, final_shift_axis_2 in zip(
             self.z_serie,
             self.configuration.axis_0_pos_px,
@@ -194,10 +204,11 @@ class ZStitcher:
         ):
             # warning estimated_shift is the estimatation from the overlap. So playes no role here
             final_pos[tomo_obj.get_identifier().to_str()] = (
-                pos_axis_0 + (final_shift_axis_0 - estimated_shift_axis_0),
+                pos_axis_0 - (final_shift_axis_0 - estimated_shift_axis_0) + previous_shift,
                 None,  # axis 1 is not handled for now
                 pos_axis_2 + final_shift_axis_2,
             )
+            previous_shift += final_shift_axis_0 - estimated_shift_axis_0
         return final_pos
 
     def from_abs_pos_to_rel_pos(self, abs_position: tuple):
@@ -278,21 +289,17 @@ class ZStitcher:
         else:
             overlap_size = int(overlap_size)
 
-        for axis_0_shift, obj in zip(self._axis_0_rel_shifts, self.z_serie):
+        self._stitching_width = max([get_obj_width(obj) for obj in self.z_serie])
+
+        for axis_0_shift in self._axis_0_rel_shifts:
             if overlap_size == -1:
                 height = abs(axis_0_shift)
             else:
                 height = overlap_size
-            if isinstance(obj, HDF5TomoScan):
-                frame_width = obj.dim_1
-            elif isinstance(obj, VolumeBase):
-                frame_width = obj.get_volume_shape()[2]
-            else:
-                raise TypeError(f"obj type ({type(obj)}) is not handled")
 
             self._overlap_kernels.append(
                 ZStichOverlapKernel(
-                    frame_width=frame_width,
+                    frame_width=self._stitching_width,
                     stitching_strategy=self.configuration.stitching_strategy,
                     overlap_size=height,
                     extra_params=self.configuration.stitching_kernels_extra_params,
@@ -385,6 +392,7 @@ class ZStitcher:
         """
         rescale_frames if requested by the configuration
         """
+        _logger.info("apply rescale frames")
 
         def cast_percentile(percentile) -> int:
             if isinstance(percentile, str):
@@ -407,9 +415,27 @@ class ZStitcher:
 
         return tuple([rescale(data) for data in frames])
 
+    def normalize_frame_by_sample(self, frames: tuple):
+        """
+        normalize frame from a sample picked on the left or the right
+        """
+        _logger.info("apply normalization by a sample")
+        return tuple(
+            [
+                normalize_frame_by_sample(
+                    frame=frame,
+                    side=self.configuration.normalization_by_sample.side,
+                    method=self.configuration.normalization_by_sample.method,
+                    margin_before_sample=self.configuration.normalization_by_sample.margin,
+                    sample_width=self.configuration.normalization_by_sample.width,
+                )
+                for frame in frames
+            ]
+        )
+
     @staticmethod
     def stitch_frames(
-        frames: tuple,
+        frames: Union[tuple, numpy.ndarray],
         x_relative_shifts: tuple,
         y_relative_shifts: tuple,
         output_dtype: numpy.ndarray,
@@ -421,6 +447,9 @@ class ZStitcher:
         shift_mode="nearest",
         i_frame=None,
         return_composition_cls=False,
+        alignment="center",
+        pad_mode="constant",
+        new_width: Optional[int] = None,
     ) -> numpy.ndarray:
         """
         shift frames according to provided `shifts` (as y, x tuples) then stitch all the shifted frames together and
@@ -444,6 +473,21 @@ class ZStitcher:
                     f"expect to have the same number of y_relative_shifts ({len(y_relative_shifts)}) and y_overlap ({len(overlap_kernels)})"
                 )
 
+            relative_positions = [(0, 0)]
+            for y_rel_pos, x_rel_pos in zip(y_relative_shifts, x_relative_shifts):
+                relative_positions.append(
+                    (
+                        y_rel_pos + relative_positions[-1][0],
+                        x_rel_pos + relative_positions[-1][1],
+                    )
+                )
+            check_overlaps(
+                frames=tuple(frames),
+                positions=tuple(relative_positions),
+                axis=0,
+                raise_error=False,
+            )
+
         def check_frame_is_2d(frame):
             if frame.ndim != 2:
                 raise ValueError(f"2D frame expected when {frame.ndim}D provided")
@@ -462,6 +506,7 @@ class ZStitcher:
                 data.append(frame)
             else:
                 raise TypeError(f"frames are expected to be DataUrl or 2D numpy array. Not {type(frame)}")
+
         # step 1: shift each frames (except the first one)
         x_shifted_data = [data[0]]
         for frame, x_relative_shift in zip(data[1:], x_relative_shifts):
@@ -492,6 +537,9 @@ class ZStitcher:
             check_inputs=check_inputs,
             output_dtype=output_dtype,
             return_composition_cls=return_composition_cls,
+            alignment=alignment,
+            pad_mode=pad_mode,
+            new_width=new_width,
         )
         if return_composition_cls:
             stitched_frame, _ = res
@@ -507,6 +555,24 @@ class ZStitcher:
             )
         return res
 
+    @staticmethod
+    @cache(maxsize=None)
+    def _get_UD_flip_matrix():
+        return UDDetTransformation().as_matrix()
+
+    @staticmethod
+    @cache(maxsize=None)
+    def _get_LR_flip_matrix():
+        return LRDetTransformation().as_matrix()
+
+    @staticmethod
+    @cache(maxsize=None)
+    def _get_UD_AND_LR_flip_matrix():
+        return numpy.matmul(
+            ZStitcher._get_UD_flip_matrix(),
+            ZStitcher._get_LR_flip_matrix(),
+        )
+
 
 class PreProcessZStitcher(ZStitcher):
     def __init__(self, configuration, progress=None) -> None:
@@ -681,13 +747,6 @@ class PreProcessZStitcher(ZStitcher):
             if isinstance(axis_pos_px, Iterable) and len(axis_pos_px) != (n_scans):
                 raise ValueError(f"{axis_name} expect {n_scans} shift defined. Get {len(axis_pos_px)}")
 
-        for scan in self.z_serie:
-            if scan.x_flipped is None or scan.y_flipped is None:
-                _logger.warning(
-                    f"Found at least one scan with no frame flips information ({scan}). Will consider those are unflipped. Might end up with some inverted frame errors."
-                )
-                break
-
         self._reading_orders = []
         # the first scan will define the expected reading orderd, and expected flip.
         # if all scan are flipped then we will keep it this way
@@ -697,8 +756,8 @@ class PreProcessZStitcher(ZStitcher):
         for scan_0, scan_1 in zip(self.z_serie[0:-1], self.z_serie[1:]):
             if len(scan_0.projections) != len(scan_1.projections):
                 raise ValueError(f"{scan_0} and {scan_1} have a different number of projections")
-            if isinstance(scan_0, HDF5TomoScan) and isinstance(scan_1, HDF5TomoScan):
-                # check rotation (only of is an HDF5TomoScan)
+            if isinstance(scan_0, NXtomoScan) and isinstance(scan_1, NXtomoScan):
+                # check rotation (only of is an NXtomoScan)
                 scan_0_angles = numpy.asarray(scan_0.rotation_angle)
                 scan_0_projections_angles = scan_0_angles[
                     numpy.asarray(scan_0.image_key_control) == ImageKey.PROJECTION.value
@@ -749,8 +808,8 @@ class PreProcessZStitcher(ZStitcher):
                 )
 
         for scan in self.z_serie:
-            # check x, y and z translation are constant (only if is an HDF5TomoScan)
-            if isinstance(scan, HDF5TomoScan):
+            # check x, y and z translation are constant (only if is an NXtomoScan)
+            if isinstance(scan, NXtomoScan):
                 if scan.x_translation is not None and not numpy.isclose(
                     min(scan.x_translation), max(scan.x_translation)
                 ):
@@ -1002,23 +1061,43 @@ class PreProcessZStitcher(ZStitcher):
                         darks=scan.reduced_darks,
                         radios_indices=radio_indices,
                         radios_srcurrent=scan.electric_current[radio_indices] if has_reduced_metadata else None,
-                        flats_srcurrent=scan.reduced_flats_infos.machine_electric_current
-                        if has_reduced_metadata
-                        else None,
+                        flats_srcurrent=(
+                            scan.reduced_flats_infos.machine_electric_current if has_reduced_metadata else None
+                        ),
                     )
                     # note: we need to cast radios to float 32. Darks and flats are cast to anyway
                     data = ff_arrays.normalize_radios(raw_radios.astype(numpy.float32))
 
-                flip_lr = scans[i_scan].get_x_flipped(default=False) ^ scan_flip_lr
-                flip_ud = scans[i_scan].get_y_flipped(default=False) ^ scan_flip_ud
+                transformations = list(scans[i_scan].get_detector_transformations(tuple()))
+                if scan_flip_lr:
+                    transformations.append(LRDetTransformation())
+                if scan_flip_ud:
+                    transformations.append(UDDetTransformation())
+
+                transformation_matrix_det_space = build_matrix(transformations)
+                if transformation_matrix_det_space is None or numpy.allclose(
+                    transformation_matrix_det_space, numpy.identity(3)
+                ):
+                    flip_ud = False
+                    flip_lr = False
+                elif numpy.array_equal(transformation_matrix_det_space, ZStitcher._get_UD_flip_matrix()):
+                    flip_ud = True
+                    flip_lr = False
+                elif numpy.allclose(transformation_matrix_det_space, ZStitcher._get_LR_flip_matrix()):
+                    flip_ud = False
+                    flip_lr = True
+                elif numpy.allclose(transformation_matrix_det_space, ZStitcher._get_UD_AND_LR_flip_matrix()):
+                    flip_ud = True
+                    flip_lr = True
+                else:
+                    raise ValueError("case not handled... For now only handle up-down flip as left-right flip")
+
                 for frame in data:
-                    f_frame = frame
-                    if flip_lr:
-                        f_frame = numpy.fliplr(f_frame)
                     if flip_ud:
-                        f_frame = numpy.flipud(f_frame)
-
-                    all_scan_final_data[i_frame, i_scan] = f_frame
+                        frame = numpy.flipud(frame)
+                    if flip_lr:
+                        frame = numpy.fliplr(frame)
+                    all_scan_final_data[i_frame, i_scan] = frame
                     i_frame += 1
 
         return all_scan_final_data
@@ -1032,7 +1111,9 @@ class PreProcessZStitcher(ZStitcher):
         ):
             upper_scan_pos = upper_scan_axis_0_pos - upper_scan.dim_2 / 2
             lower_scan_high_pos = lower_scan_axis_0_pos + lower_scan.dim_2 / 2
-            assert lower_scan_high_pos > upper_scan_pos, f"no overlap found between {upper_scan} and {lower_scan}"
+            # simple test of overlap. More complete test are runned by check_overlaps later
+            if lower_scan_high_pos <= upper_scan_pos:
+                raise ValueError(f"no overlap found between {upper_scan} and {lower_scan}")
             self._axis_0_estimated_shifts.append(
                 int(lower_scan_high_pos - upper_scan_pos)  # overlap are expected to be int for now
             )
@@ -1074,11 +1155,10 @@ class PreProcessZStitcher(ZStitcher):
         nx_tomo.instrument.detector.y_pixel_size = self.z_serie[0].y_pixel_size
         nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_proj
         nx_tomo.instrument.detector.tomo_n = n_proj
-        # note: stitching process insure unflipping of frames
-        nx_tomo.instrument.detector.x_flipped = False
-        nx_tomo.instrument.detector.y_flipped = False
+        # note: stitching process insure unflipping of frames. So make sure transformations is defined as an empty set
+        nx_tomo.instrument.detector.transformations = NXtransformations()
 
-        if isinstance(self.z_serie[0], HDF5TomoScan):
+        if isinstance(self.z_serie[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.z_serie[0].rotation_angle)
             nx_tomo.sample.rotation_angle = rotation_angle[
@@ -1091,8 +1171,8 @@ class PreProcessZStitcher(ZStitcher):
         else:
             raise NotImplementedError(
                 f"scan type ({type(self.z_serie[0])} is not handled)",
-                HDF5TomoScan,
-                isinstance(self.z_serie[0], HDF5TomoScan),
+                NXtomoScan,
+                isinstance(self.z_serie[0], NXtomoScan),
             )
 
         # do a sub selection of the rotation angle if a we are only computing a part of the slices
@@ -1110,7 +1190,7 @@ class PreProcessZStitcher(ZStitcher):
 
         # handle sample
         n_frames = n_proj
-        if False not in [isinstance(scan, HDF5TomoScan) for scan in self.z_serie]:
+        if False not in [isinstance(scan, NXtomoScan) for scan in self.z_serie]:
             # we consider the new x, y and z position to be at the center of the one created
             x_translation = [scan.x_translation for scan in self.z_serie if scan.x_translation is not None]
             nx_tomo.sample.x_translation = [numpy.asarray(x_translation).mean()] * n_frames
@@ -1128,7 +1208,7 @@ class PreProcessZStitcher(ZStitcher):
                 numpy.asarray([scan.dim_2 for scan in self.z_serie]).sum()
                 - numpy.asarray([abs(overlap) for overlap in self._axis_0_rel_shifts]).sum()
             ),
-            self.z_serie[0].dim_1,
+            self._stitching_width,
         )
 
         # get expected output dataset first (just in case output and input files are the same)
@@ -1151,11 +1231,15 @@ class PreProcessZStitcher(ZStitcher):
             overwrite=self.configuration.overwrite_results,
         )
 
+        transformation_matrices = {
+            scan.get_identifier()
+            .to_str()
+            .center(80, "-"): numpy.array2string(build_matrix(scan.get_detector_transformations(tuple())))
+            for scan in self.z_serie
+        }
         _logger.info(
-            f"scan x flipped are {','.join([str(scan.get_x_flipped(default=False)) for scan in self.z_serie])}"
-        )
-        _logger.info(
-            f"scan y flipped are {','.join([str(scan.get_y_flipped(default=False)) for scan in self.z_serie])}"
+            "scan detector transformation matrices are:\n"
+            "\n".join(["/n".join(item) for item in transformation_matrices.items()])
         )
 
         _logger.info(
@@ -1214,6 +1298,9 @@ class PreProcessZStitcher(ZStitcher):
                 ):
                     if self.configuration.rescale_frames:
                         data_frames = self.rescale_frames(data_frames)
+                    if self.configuration.normalization_by_sample.is_active():
+                        data_frames = self.normalize_frame_by_sample(data_frames)
+
                     sf = ZStitcher.stitch_frames(
                         frames=data_frames,
                         x_relative_shifts=self._axis_2_rel_shifts,
@@ -1225,6 +1312,10 @@ class PreProcessZStitcher(ZStitcher):
                         dump_frame_fct=self._dump_frame,
                         return_composition_cls=store_composition if i_proj == 0 else False,
                         stitching_axis=0,
+                        pad_mode=self.configuration.pad_mode,
+                        alignment=self.configuration.alignment_axis_2,
+                        new_width=self._stitching_width,
+                        check_inputs=i_proj == 0,  # on process check on the first iteration
                     )
                     if i_proj == 0 and store_composition:
                         _, self._frame_composition = sf
@@ -1277,6 +1368,7 @@ class PreProcessZStitcher(ZStitcher):
 class PostProcessZStitcher(ZStitcher):
     def __init__(self, configuration, progress: Progress = None) -> None:
         self._input_volumes = configuration.input_volumes
+        self.__output_data_type = None
 
         self._z_serie = Serie("z-serie", iterable=self._input_volumes, use_identifiers=False)
         super().__init__(configuration, progress)
@@ -1333,7 +1425,7 @@ class PostProcessZStitcher(ZStitcher):
                 if scan_location is not None:
                     # this work around (until most volume have position metadata) works only for Hdf5volume
                     with cwd_context(os.path.dirname(volume.file_path)):
-                        o_scan = HDF5TomoScan(scan_location, scan_entry)
+                        o_scan = NXtomoScan(scan_location, scan_entry)
                         bb_acqui = o_scan.get_bounding_box(axis=None)
                         # for next step volume position will be required.
                         # if you can find it set it directly
@@ -1414,7 +1506,7 @@ class PostProcessZStitcher(ZStitcher):
                 # deduce from position given in configuration and pixel size
                 axis_N_pos_px = []
                 for volume, pos_in_mm in zip(self.z_serie, pos_as_mm):
-                    voxel_size_m = self.configuration.voxel_size or volume.pixel_size
+                    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])
                 return axis_N_pos_px
             else:
@@ -1422,7 +1514,7 @@ class PostProcessZStitcher(ZStitcher):
                 axis_N_pos_px = []
                 base_position_m = self.z_serie[0].get_bounding_box(axis=axis).min
                 for volume in self.z_serie:
-                    voxel_size_m = self.configuration.voxel_size or volume.pixel_size
+                    voxel_size_m = self.configuration.voxel_size or volume.voxel_size
                     volume_axis_bb = volume.get_bounding_box(axis=axis)
                     axis_N_mean_pos_m = (volume_axis_bb.max - volume_axis_bb.min) / 2 + volume_axis_bb.min
                     axis_N_mean_rel_pos_m = axis_N_mean_pos_m - base_position_m
@@ -1464,6 +1556,7 @@ class PostProcessZStitcher(ZStitcher):
         slice_for_shift = self.configuration.slice_for_cross_correlation or "middle"
         y_rel_shifts = self._axis_0_estimated_shifts
         x_rel_shifts = self.from_abs_pos_to_rel_pos(self.configuration.axis_2_pos_px)
+        dim_axis_1 = max([volume.get_volume_shape()[1] for volume in self.z_serie])
 
         final_rel_shifts = []
         for (
@@ -1488,6 +1581,8 @@ class PostProcessZStitcher(ZStitcher):
             found_shift_y, found_shift_x = find_volumes_relative_shifts(
                 upper_volume=upper_volume,
                 lower_volume=lower_volume,
+                dtype=self.get_output_data_type(),
+                dim_axis_1=dim_axis_1,
                 slice_for_shift=slice_for_shift,
                 x_cross_correlation_function=x_cross_algo,
                 y_cross_correlation_function=y_cross_algo,
@@ -1496,6 +1591,8 @@ class PostProcessZStitcher(ZStitcher):
                 estimated_shifts=(y_rel_shift, x_rel_shift),
                 flip_ud_lower_frame=flip_ud_lower,
                 flip_ud_upper_frame=flip_ud_upper,
+                alignment_axis_1=self.configuration.alignment_axis_1,
+                alignment_axis_2=self.configuration.alignment_axis_2,
             )
             final_rel_shifts.append(
                 (found_shift_y, found_shift_x),
@@ -1504,10 +1601,10 @@ class PostProcessZStitcher(ZStitcher):
         # set back values. Now position should start at 0
         self._axis_0_rel_shifts = [final_shift[0] for final_shift in final_rel_shifts]
         self._axis_2_rel_shifts = [final_shift[1] for final_shift in final_rel_shifts]
-        _logger.info(f"axis 2 relative shifts (x in radio ref) to be used will be {self._axis_0_rel_shifts}")
-        print(f"axis 2 relative shifts (x in radio ref) to be used will be {self._axis_0_rel_shifts}")
-        _logger.info(f"axis 0 relative shifts (y in radio ref) y to be used will be {self._axis_2_rel_shifts}")
-        print(f"axis 0 relative shifts (y in radio ref) y to be used will be {self._axis_2_rel_shifts}")
+        _logger.info(f"axis 2 relative shifts (x in radio ref) to be used will be {self._axis_2_rel_shifts}")
+        print(f"axis 2 relative shifts (x in radio ref) to be used will be {self._axis_2_rel_shifts}")
+        _logger.info(f"axis 0 relative shifts (y in radio ref) y to be used will be {self._axis_0_rel_shifts}")
+        print(f"axis 0 relative shifts (y in radio ref) y to be used will be {self._axis_0_rel_shifts}")
 
     def _dump_stitching_configuration(self):
         voxel_size = self._input_volumes[0].voxel_size
@@ -1583,22 +1680,27 @@ class PostProcessZStitcher(ZStitcher):
         ):
             raise ValueError(f"expect {n_volumes} overlap defined. Get {len(self.configuration.axis_2_pos_mm)}")
 
-        yz_shape = None
-        for volume in self.configuration.input_volumes:
-            assert isinstance(volume, VolumeBase)
-            volume_shape = volume.get_volume_shape()
-            if volume_shape is None:
-                raise ValueError("Unable to load volume shape (probably no data found from {volume.get_identifier()}")
-            if yz_shape is None:
-                yz_shape = volume_shape[1:]
-            elif yz_shape != volume_shape[1:]:
-                raise ValueError("Input volumes have incoherent (yz) shapes. Unable to stitch it together")
-
         self._reading_orders = []
         # the first scan will define the expected reading orderd, and expected flip.
         # if all scan are flipped then we will keep it this way
         self._reading_orders.append(1)
 
+    def get_output_data_type(self):
+        if self.__output_data_type is None:
+
+            def find_output_data_type():
+                first_vol = self._input_volumes[0]
+                if first_vol.data is not None:
+                    return first_vol.data.dtype
+                elif isinstance(first_vol, HDF5Volume):
+                    with DatasetReader(first_vol.data_url) as vol_dataset:
+                        return vol_dataset.dtype
+                else:
+                    return first_vol.load_data(store=False).dtype
+
+            self.__output_data_type = find_output_data_type()
+        return self.__output_data_type
+
     def _create_stitched_volume(self, store_composition: bool):
         overlap_kernels = self._overlap_kernels
         self._slices_to_stitch, n_slices = self.configuration.settle_slices()
@@ -1614,20 +1716,10 @@ class PostProcessZStitcher(ZStitcher):
                 - numpy.asarray([abs(overlap) for overlap in self._axis_0_rel_shifts]).sum(),
             ),
             n_slices,
-            self._input_volumes[0].get_volume_shape()[2],
+            self._stitching_width,
         )
 
-        def get_output_data_type():
-            first_vol = self._input_volumes[0]
-            if first_vol.data is not None:
-                return first_vol.data.dtype
-            elif isinstance(first_vol, HDF5Volume):
-                with DatasetReader(first_vol.data_url) as vol_dataset:
-                    return vol_dataset.dtype
-            else:
-                return first_vol.load_data(store=False).dtype
-
-        data_type = get_output_data_type()
+        data_type = self.get_output_data_type()
 
         if self.progress:
             self.progress.set_max_advancement(final_volume_shape[1])
@@ -1641,7 +1733,10 @@ class PostProcessZStitcher(ZStitcher):
             volume=final_volume, volume_shape=final_volume_shape, dtype=data_type
         ) as output_dataset:
             # note: output_dataset is a HDF5 dataset if final volume is an HDF5 volume else is a numpy array
-            with PostProcessZStitcher._RawDatasetsContext(self._input_volumes) as raw_datasets:
+            with PostProcessZStitcher._RawDatasetsContext(
+                self._input_volumes,
+                alignment_axis_1=self.configuration.alignment_axis_1,
+            ) as raw_datasets:
                 # note: raw_datasets can be numpy arrays or HDF5 dataset (in the case of HDF5Volume)
                 # to speed up we read by bunch of dataset. For numpy array this doesn't change anything
                 # but for HDF5 dataset this can speed up a lot the processing (depending on HDF5 dataset chuncks)
@@ -1659,6 +1754,9 @@ class PostProcessZStitcher(ZStitcher):
                     ):
                         if self.configuration.rescale_frames:
                             data_frames = self.rescale_frames(data_frames)
+                        if self.configuration.normalization_by_sample.is_active():
+                            data_frames = self.normalize_frame_by_sample(data_frames)
+
                         sf = ZStitcher.stitch_frames(
                             frames=data_frames,
                             x_relative_shifts=self._axis_2_rel_shifts,
@@ -1670,6 +1768,7 @@ class PostProcessZStitcher(ZStitcher):
                             output_dtype=data_type,
                             return_composition_cls=store_composition if y_index == 0 else False,
                             stitching_axis=0,
+                            check_inputs=y_index == 0,  # on process check on the first iteration
                         )
                         if y_index == 0 and store_composition:
                             _, self._frame_composition = sf
@@ -1680,7 +1779,12 @@ class PostProcessZStitcher(ZStitcher):
 
     @staticmethod
     def _get_bunch_of_data(
-        bunch_start: int, bunch_end: int, step: int, volumes: tuple, flip_lr_arr: bool, flip_ud_arr: bool
+        bunch_start: int,
+        bunch_end: int,
+        step: int,
+        volumes: tuple,
+        flip_lr_arr: bool,
+        flip_ud_arr: bool,
     ):
         """
         goal is to load contiguous frames as much as possible...
@@ -1768,7 +1872,7 @@ class PostProcessZStitcher(ZStitcher):
         If the volume is of another type then it will be loaded in memory then used (more memory consuming)
         """
 
-        def __init__(self, volumes: tuple) -> None:
+        def __init__(self, volumes: tuple, alignment_axis_1) -> None:
             super().__init__()
             for volume in volumes:
                 if not isinstance(volume, VolumeBase):
@@ -1778,25 +1882,36 @@ class PostProcessZStitcher(ZStitcher):
 
             self._volumes = volumes
             self.__file_handlers = []
+            self._alignment_axis_1 = alignment_axis_1
+
+        @property
+        def alignment_axis_1(self):
+            return self._alignment_axis_1
 
         def __enter__(self):
             # handle the specific case of HDF5. Goal: avoid getting the full stitched volume in memory
             datasets = []
+            shapes = {volume.get_volume_shape()[1] for volume in self._volumes}
+            axis_1_dim = max(shapes)
+            axis_1_need_padding = len(shapes) > 1
+
             try:
                 for volume in self._volumes:
                     if volume.data is not None:
-                        datasets.append(volume.data)
+                        data = volume.data
                     elif isinstance(volume, HDF5Volume):
                         file_handler = HDF5File(filename=volume.data_url.file_path(), mode="r")
                         dataset = file_handler[volume.data_url.data_path()]
-                        datasets.append(dataset)
+                        data = dataset
                         self.__file_handlers.append(file_handler)
                     # for other file format: load the full dataset in memory
                     else:
                         data = volume.load_data(store=False)
                         if data is None:
                             raise ValueError(f"No data found for volume {volume.get_identifier()}")
-                        datasets.append(data)
+                    if axis_1_need_padding:
+                        data = self.add_padding(data=data, axis_1_dim=axis_1_dim, alignment=self.alignment_axis_1)
+                    datasets.append(data)
             except Exception as e:
                 # if some errors happen during loading HDF5
                 for file_handled in self.__file_handlers:
@@ -1811,16 +1926,36 @@ class PostProcessZStitcher(ZStitcher):
                 success = success and file_handler.close()
             return success
 
+        def add_padding(self, data: Union[h5py.Dataset, numpy.ndarray], axis_1_dim, alignment: AlignmentAxis1):
+            alignment = AlignmentAxis1.from_value(alignment)
+            if alignment is AlignmentAxis1.BACK:
+                axis_1_pad_width = (axis_1_dim - data.shape[1], 0)
+            elif alignment is AlignmentAxis1.CENTER:
+                half_width = int((axis_1_dim - data.shape[1]) / 2)
+                axis_1_pad_width = (half_width, axis_1_dim - data.shape[1] - half_width)
+            elif alignment is AlignmentAxis1.FRONT:
+                axis_1_pad_width = (0, axis_1_dim - data.shape[1])
+            else:
+                raise ValueError(f"alignment {alignment} is not handled")
+
+            return PaddedRawData(
+                data=data,
+                axis_1_pad_width=axis_1_pad_width,
+            )
+
 
 def stitch_vertically_raw_frames(
     frames: tuple,
     key_lines: tuple,
-    overlap_kernels: Optional[Union[ZStichOverlapKernel, tuple]],
+    overlap_kernels: Union[ZStichOverlapKernel, tuple],
     output_dtype: numpy.dtype = numpy.float32,
     check_inputs=True,
     raw_frames_compositions: Optional[ZFrameComposition] = None,
     overlap_frames_compositions: Optional[ZFrameComposition] = None,
     return_composition_cls=False,
+    alignment="center",
+    pad_mode="constant",
+    new_width: Optional[int] = None,
 ) -> numpy.ndarray:
     """
     stitches raw frames (already shifted and flat fielded !!!) together using
@@ -1865,8 +2000,7 @@ def stitch_vertically_raw_frames(
         for frame_0, frame_1 in zip(frames[:-1], frames[1:]):
             if not (frame_0.ndim == frame_1.ndim == 2):
                 raise ValueError("Frames are expected to be 2D")
-            if frame_0.shape[1] != frame_1.shape[1]:
-                raise ValueError("Both projections are expected to have the same width")
+
         for frame_0, frame_1, kernel in zip(frames[:-1], frames[1:], overlap_kernels):
             if frame_0.shape[0] < kernel.overlap_size:
                 raise ValueError(
@@ -1886,6 +2020,20 @@ def stitch_vertically_raw_frames(
                     elif value < 0:
                         raise ValueError(f"key lines are expected to be positive values. Get {value} as key line value")
 
+    if new_width is None:
+        new_width = max([frame.shape[-1] for frame in frames])
+    frames = tuple(
+        [
+            align_horizontally(
+                data=frame,
+                alignment=alignment,
+                new_width=new_width,
+                pad_mode=pad_mode,
+            )
+            for frame in frames
+        ]
+    )
+
     # step 1: create numpy array that will contain stitching
     # if raw composition doesn't exists create it
     if raw_frames_compositions is None:
@@ -1899,7 +2047,7 @@ def stitch_vertically_raw_frames(
     stitched_projection_shape = (
         # here we only handle frames because shift are already done
         int(new_frame_height),
-        frames[0].shape[1],
+        new_width,
     )
     stitch_array = numpy.empty(stitched_projection_shape, dtype=output_dtype)
 
@@ -1966,18 +2114,67 @@ class StitchingPostProcAggregation:
 
     This is the goal of this class.
     Please be careful with API. This is already inheriting from a tomwer class
+
+    :param ZStitchingConfiguration stitching_config: configuration of the stitching configuration
+    :param Optional[tuple] futures: futures that just runned
+    :param Optional[tuple] existing_objs: futures that just runned
+    :param
     """
 
-    def __init__(self, futures, stitching_config) -> None:
-        if isinstance(stitching_config, (PreProcessedZStitchingConfiguration, PostProcessedZStitchingConfiguration)):
-            raise TypeError
+    def __init__(
+        self,
+        stitching_config: ZStitchingConfiguration,
+        futures: Optional[tuple] = None,
+        existing_objs_ids: Optional[tuple] = None,
+    ) -> None:
+        if not isinstance(stitching_config, (ZStitchingConfiguration)):
+            raise TypeError(f"stitching_config should be an instance of {ZStitchingConfiguration}")
+        if not ((existing_objs_ids is None) ^ (futures is None)):
+            raise ValueError("Either existing_objs or futures should be provided (can't provide both)")
         self._futures = futures
         self._stitching_config = stitching_config
+        self._existing_objs_ids = existing_objs_ids
 
     @property
     def futures(self):
+        # TODO: deprecate it ?
         return self._futures
 
+    def retrieve_tomo_objects(self) -> tuple():
+        """
+        Return tomo objects to be stitched together. Either from future or from existing_objs
+        """
+        if self._existing_objs_ids is not None:
+            scan_ids = self._existing_objs_ids
+        else:
+            results = {}
+            _logger.info(f"wait for slurm job to be completed")
+            for obj_id, future in self.futures.items():
+                results[obj_id] = future.result()
+
+            failed = tuple(
+                filter(
+                    lambda x: x.exception() is not None,
+                    self.futures.values(),
+                )
+            )
+            if len(failed) > 0:
+                # if some job failed: unseless to do the concatenation
+                exceptions = " ; ".join([f"{job} : {job.exception()}" for job in failed])
+                raise RuntimeError(f"some job failed. Won't do the concatenation. Exceptiosn are {exceptions}")
+
+            canceled = tuple(
+                filter(
+                    lambda x: x.cancelled(),
+                    self.futures.values(),
+                )
+            )
+            if len(canceled) > 0:
+                # if some job canceled: unseless to do the concatenation
+                raise RuntimeError(f"some job failed. Won't do the concatenation. Jobs are {' ; '.join(canceled)}")
+            scan_ids = results.keys()
+        return [TomoscanFactory.create_tomo_object_from_identifier(scan_id) for scan_id in scan_ids]
+
     def dump_stiching_config_as_nx_process(self, file_path: str, data_path: str, overwrite: bool, process_name: str):
         dict_to_dump = {
             process_name: {
@@ -2005,40 +2202,14 @@ class StitchingPostProcAggregation:
         """
         main function
         """
-        # retrive results (and wait if some processing are not finished)
-        results = {}
-        _logger.info(f"wait for slurm job to be completed")
-        for obj_id, future in self.futures.items():
-            results[obj_id] = future.result()
-
-        failed = tuple(
-            filter(
-                lambda x: x.exception() is not None,
-                self.futures.values(),
-            )
-        )
-        if len(failed) > 0:
-            # if some job failed: unseless to do the concatenation
-            exceptions = " ; ".join([f"{job} : {job.exception()}" for job in failed])
-            raise RuntimeError(f"some job failed. Won't do the concatenation. Exceptiosn are {exceptions}")
-
-        canceled = tuple(
-            filter(
-                lambda x: x.cancelled(),
-                self.futures.values(),
-            )
-        )
-        if len(canceled) > 0:
-            # if some job canceled: unseless to do the concatenation
-            raise RuntimeError(f"some job failed. Won't do the concatenation. Jobs are {' ; '.join(canceled)}")
 
         # concatenate result
         _logger.info("all job succeeded. Concatenate results")
         if isinstance(self._stitching_config, PreProcessedZStitchingConfiguration):
             # 1: case of a pre-processing stitching
+            scans = self.retrieve_tomo_objects()
             nx_tomos = []
-            for result in results.keys():
-                scan = TomoscanFactory.create_tomo_object_from_identifier(result)
+            for scan in scans:
                 nx_tomos.append(
                     NXtomo().load(
                         file_path=scan.master_file,
@@ -2069,9 +2240,7 @@ class StitchingPostProcAggregation:
 
         elif isinstance(self.stitching_config, PostProcessedZStitchingConfiguration):
             # 2: case of a post-processing stitching
-            outputs_sub_volumes = [
-                TomoscanFactory.create_tomo_object_from_identifier(result) for result in results.keys()
-            ]
+            outputs_sub_volumes = self.retrieve_tomo_objects()
             concatenate_volumes(
                 output_volume=self.stitching_config.output_volume,
                 volumes=tuple(outputs_sub_volumes),
@@ -2092,3 +2261,17 @@ class StitchingPostProcAggregation:
                     process_name=process_name,
                     overwrite=self.stitching_config.overwrite_results,
                 )
+        else:
+            raise TypeError(f"stitching_config type ({type(self.stitching_config)}) not handled")
+
+
+def get_obj_width(obj: Union[NXtomoScan, VolumeBase]) -> int:
+    """
+    return tomo object width
+    """
+    if isinstance(obj, NXtomoScan):
+        return obj.dim_1
+    elif isinstance(obj, VolumeBase):
+        return obj.get_volume_shape()[-1]
+    else:
+        raise TypeError(f"obj type ({type(obj)}) is not handled")