nabu 2025.1.0.dev13__py3-none-any.whl → 2025.1.0rc1__py3-none-any.whl

nabu/io/reader.py

@@ -4,6 +4,7 @@ from math import ceil
 from multiprocessing.pool import ThreadPool
 from posixpath import sep as posix_sep, join as posix_join
 import numpy as np
+from h5py import Dataset
 from silx.io import get_data
 from silx.io.dictdump import h5todict
 from tomoscan.io import HDF5File
@@ -770,7 +771,7 @@ class NXDarksFlats:
         reduced_frames = [self._reduce_func[method](frames, axis=0) for frames in raw_frames]
         reader = getattr(self, "%s_reader" % what)
         if as_dict:
-            return {k: v for k, v in zip([s.start for s in reader._image_key_slices], reduced_frames)}  # noqa: C416
+            return {k: v for k, v in zip([s.start for s in reader._image_key_slices], reduced_frames)}
         return reduced_frames
 
     def get_raw_darks(self, force_reload=False, as_multiple_array=True):
@@ -987,6 +988,12 @@ def get_entry_from_h5_path(h5_path):
     return v[0] or v[1]
 
 
+def list_hdf5_entries(fname):
+    with HDF5File(fname, "r") as f:
+        entries = list(f.keys())
+    return entries
+
+
 def check_virtual_sources_exist(fname, data_path):
     with HDF5File(fname, "r") as f:
         if data_path not in f:
@@ -1006,6 +1013,30 @@ def check_virtual_sources_exist(fname, data_path):
     return True
 
 
+def get_hdf5_file_all_virtual_sources(file_path_or_obj, return_only_filenames=False):
+    result = []
+
+    def collect_vsources(name, obj):
+        if isinstance(obj, Dataset) and obj.is_virtual:
+            vs = obj.virtual_sources()
+            if return_only_filenames:
+                vs = [vs_.file_name for vs_ in vs]
+            result.append({name: vs})
+
+    _self_opened_file = False
+    if isinstance(file_path_or_obj, str):
+        fdesc = HDF5File(file_path_or_obj, "r")
+        _self_opened_file = True
+    else:
+        fdesc = file_path_or_obj
+
+    fdesc.visititems(collect_vsources)
+
+    if _self_opened_file:
+        fdesc.close()
+    return result
+
+
 def import_h5_to_dict(h5file, h5path, asarray=False):
     """
     Wrapper on top of silx.io.dictdump.dicttoh5 replacing "None" with None

nabu/io/tests/test_remove_volume.py

@@ -0,0 +1,152 @@
+from pathlib import Path
+from os import path, mkdir, rename
+import numpy as np
+import pytest
+from tomoscan.esrf.volume import (
+    EDFVolume,
+    HDF5Volume,
+    JP2KVolume,
+    MultiTIFFVolume,
+    TIFFVolume,
+)
+from tomoscan.esrf.volume.jp2kvolume import has_glymur
+from nabu.io.writer import merge_hdf5_files
+from nabu.io.cast_volume import remove_volume
+
+
+def test_remove_single_frame_volume(tmpdir):
+    """
+    Test volume removal for tiff, jp2 and EDF
+    """
+    # Have to use a not-too-small size because of jp2k
+    data = np.arange(10 * 40 * 50, dtype="f").reshape((10, 40, 50))
+
+    volume_classes = [EDFVolume, TIFFVolume, JP2KVolume]
+    if not (has_glymur):
+        volume_classes.pop()
+    for volume_cls in volume_classes:
+        ext = volume_cls.DEFAULT_DATA_EXTENSION
+        folder = path.join(tmpdir, f"{ext}_vol")
+        volume_basename = f"{ext}_basename"
+
+        vol_writer = volume_cls(folder=folder, volume_basename=volume_basename, overwrite=True, start_index=0)
+        vol_writer.data = data
+        vol_writer.save()
+
+        vol_reader = volume_cls(folder=folder, volume_basename=volume_basename)
+        assert path.isdir(folder), f"Expected to find a folder f{folder}"
+        remove_volume(vol_reader)
+        assert not (path.isdir(folder)), f"Expected to have removed the folder f{folder}"
+
+        vol_writer.save()
+        vol_reader = volume_cls(folder=folder, volume_basename=volume_basename)
+        Path(path.join(folder, f"unexpected.{ext}")).touch()
+        with pytest.raises(RuntimeError) as exc:
+            remove_volume(vol_reader, check=True)
+        assert "Unexpected files present" in str(exc.value), "Expected check to find extraneous files"
+
+
+def test_remove_multiframe_volume(tmpdir):
+    """
+    Test volume removal for "multiframe" formats (HDF5, tiff3D)
+    The HDF5 files considered in this test do not have virtual sources
+    """
+    data = np.arange(3 * 4 * 5, dtype="f").reshape((3, 4, 5))
+
+    for ext, volume_cls in {"h5": HDF5Volume, "tiff": MultiTIFFVolume}.items():
+        file_path = path.join(tmpdir, f"{ext}_vol.{ext}")
+
+        init_kwargs = {"file_path": file_path}
+        if ext == "h5":
+            init_kwargs["data_path"] = "entry"
+        vol_writer = volume_cls(**init_kwargs)
+        vol_writer.data = data
+        vol_writer.save()
+
+        vol_reader = volume_cls(**init_kwargs)
+        assert path.isfile(file_path), f"Expected to find a {ext} volume at {file_path}"
+        remove_volume(vol_reader)
+        assert not (path.isfile(file_path)), f"Expected to have removed f{file_path}"
+
+
+def test_remove_hdf5_multiple_entries(tmpdir):
+    data = np.arange(3 * 4 * 5, dtype="f").reshape((3, 4, 5))
+    file_path = path.join(tmpdir, "h5_vol.h5")
+    vol_writer_1 = HDF5Volume(file_path=file_path, data_path="entry0000")
+    vol_writer_1.data = data
+    vol_writer_1.save()
+    vol_writer_2 = HDF5Volume(file_path=file_path, data_path="entry0001")
+    vol_writer_2.data = data + 10
+    vol_writer_2.save()
+    vol_reader = HDF5Volume(file_path=file_path, data_path="entry0000")
+    with pytest.raises(NotImplementedError) as exc:
+        remove_volume(vol_reader, check=True)
+    assert "Removing a HDF5 volume with more than one entry is not supported" in str(
+        exc.value
+    ), "Expected an error message"
+
+
+def test_remove_nabu_hdf5_reconstruction(tmpdir):
+    """
+    Test removal of HDF5 reconstruction generated by nabu (i.e with virtual sources)
+    """
+
+    entry = "entry"
+    process_name = "reconstruction"
+
+    master_file_path = path.join(tmpdir, "sample_naburec.hdf5")
+    associated_dir = path.join(tmpdir, "sample_naburec")
+    if not (path.isdir(associated_dir)):
+        mkdir(associated_dir)
+
+    n_chunks = 5
+    local_files = []
+    for i in range(n_chunks):
+        fname = "sample_naburec_%06d.h5" % i
+        partial_rec_abspath = path.join(associated_dir, fname)
+        local_files.append(f"sample_naburec/{fname}")
+        # local_files.append(fname)
+        vol = HDF5Volume(partial_rec_abspath, data_path=f"{entry}/{process_name}")
+        vol.data = np.arange(3 * 4 * 5, dtype="f").reshape((3, 4, 5))
+        vol.save()
+
+    h5_path = f"{entry}/{process_name}/results/data"
+
+    merge_hdf5_files(
+        local_files,
+        h5_path,
+        master_file_path,
+        process_name,
+        output_entry=entry,
+        output_filemode="a",
+        processing_index=0,
+        config=None,
+        base_dir=path.dirname(associated_dir),
+        axis=0,
+        overwrite=True,
+    )
+
+    assert path.isfile(master_file_path), f"Expected to find the master file at {master_file_path}"
+    assert path.isdir(associated_dir)
+    for local_file in local_files:
+        partial_rec_file = path.join(tmpdir, local_file)
+        assert path.isfile(partial_rec_file), f"Expected to find partial file number {i} at {partial_rec_file}"
+
+    # Check that the virtual links are handled properly
+    #  sample_rec.hdf5   should reference sample_rec/sample_rec_{i}.h5
+    renamed_master_file_path = (
+        path.join(path.dirname(master_file_path), path.basename(master_file_path).split(".")[0]) + "_renamed" + ".h5"
+    )
+    rename(master_file_path, renamed_master_file_path)
+    h5_vol = HDF5Volume(file_path=renamed_master_file_path, data_path=f"{entry}/{process_name}")
+    with pytest.raises(ValueError) as exc:
+        remove_volume(h5_vol)
+    expected_error_message = f"The virtual sources in {renamed_master_file_path}:{process_name}/results/data reference the directory sample_naburec, but expected was sample_naburec_renamed"
+    assert str(exc.value) == expected_error_message
+
+    # Check removal in normal circumstances
+    rename(renamed_master_file_path, master_file_path)
+    h5_vol = HDF5Volume(file_path=master_file_path, data_path=f"{entry}/{process_name}")
+    remove_volume(h5_vol)
+    assert not (path.isfile(master_file_path)), f"Expected to find the master file at {master_file_path}"
+    assert not (path.isdir(associated_dir))

nabu/pipeline/config_validators.py

@@ -2,7 +2,7 @@
 import os
 
 path = os.path
-from ..utils import check_supported, is_writeable
+from ..utils import check_supported, deprecation_warning, is_writeable
 from .params import *  # noqa: F403
 
 """
@@ -97,12 +97,21 @@ def convert_to_bool_noerr(val):
     return res
 
 
-def name_range_checker(name, valid_names, descr, replacements=None):
+def name_range_checker(name, available_names, descr):
+    """
+    Check whether a parameter name is valid, against a list or dictionary of names.
+    """
     name = name.strip().lower()
-    if replacements is not None and name in replacements:
-        name = replacements[name]
-    valid = name in valid_names
-    assert valid, "Invalid %s '%s'. Available are %s" % (descr, name, str(valid_names))
+    valid = name in available_names
+    if isinstance(available_names, dict):
+        # handle replacements, eg. {"edge": "edges"}
+        name = available_names[name]
+        # we could use .keys() instead to be more permissive to the user
+        available_names_str = str(set(available_names.values()))
+    else:
+        # assuming list
+        available_names_str = str(available_names)
+    assert valid, "Invalid %s '%s'. Available are %s" % (descr, name, available_names_str)
     return name
 
 
@@ -338,9 +347,7 @@ def cor_validator(val):
         return val_float
     if len(val.strip()) == 0:
         return None
-    val = name_range_checker(
-        val.lower(), set(cor_methods.values()), "center of rotation estimation method", replacements=cor_methods
-    )
+    val = name_range_checker(val, cor_methods, "center of rotation estimation method")
     return val
 
 
@@ -351,9 +358,7 @@ def tilt_validator(val):
         return val_float
     if len(val.strip()) == 0:
         return None
-    val = name_range_checker(
-        val.lower(), set(tilt_methods.values()), "automatic detector tilt estimation method", replacements=tilt_methods
-    )
+    val = name_range_checker(val, tilt_methods, "automatic detector tilt estimation method")
     return val
 
 
@@ -395,53 +400,55 @@ def cor_slice_validator(val):
 
 
 @validator
-def flatfield_enabled_validator(val):
-    return name_range_checker(val, set(flatfield_modes.values()), "flatfield mode", replacements=flatfield_modes)
+def flatfield_validator(val):
+    ret = name_range_checker(val, flatfield_modes, "flatfield mode")
+    if ret in ["force-load", "force-compute"]:
+        deprecation_warning(
+            f"Using 'flatfield = {ret}' is deprecated since version 2025.1.0. Please use the parameter 'flatfield_loading_mode'",
+        )
+    return ret
+
+
+@validator
+def flatfield_loading_mode_validator(val):
+    return name_range_checker(val, flatfield_loading_mode, "flatfield mode")
 
 
 @validator
 def phase_method_validator(val):
-    return name_range_checker(
-        val, set(phase_retrieval_methods.values()), "phase retrieval method", replacements=phase_retrieval_methods
-    )
+    return name_range_checker(val, phase_retrieval_methods, "phase retrieval method")
 
 
 @validator
 def detector_distortion_correction_validator(val):
     return name_range_checker(
         val,
-        set(detector_distortion_correction_methods.values()),
+        detector_distortion_correction_methods,
         "detector_distortion_correction_methods",
-        replacements=detector_distortion_correction_methods,
     )
 
 
 @validator
 def unsharp_method_validator(val):
-    return name_range_checker(
-        val, set(unsharp_methods.values()), "unsharp mask method", replacements=phase_retrieval_methods
-    )
+    return name_range_checker(val, unsharp_methods, "unsharp mask method")
 
 
 @validator
 def padding_mode_validator(val):
-    return name_range_checker(val, set(padding_modes.values()), "padding mode", replacements=padding_modes)
+    return name_range_checker(val, padding_modes, "padding mode")
 
 
 @validator
 def reconstruction_method_validator(val):
-    return name_range_checker(
-        val, set(reconstruction_methods.values()), "reconstruction method", replacements=reconstruction_methods
-    )
+    return name_range_checker(val, reconstruction_methods, "reconstruction method")
 
 
 @validator
 def fbp_filter_name_validator(val):
     return name_range_checker(
         val,
-        set(fbp_filters.values()),
+        fbp_filters,
         "FBP filter",
-        replacements=fbp_filters,
     )
 
 
@@ -449,29 +456,24 @@ def fbp_filter_name_validator(val):
 def reconstruction_implementation_validator(val):
     return name_range_checker(
         val,
-        set(reco_implementations.values()),
+        reco_implementations,
         "Reconstruction method implementation",
-        replacements=reco_implementations,
     )
 
 
 @validator
 def optimization_algorithm_name_validator(val):
-    return name_range_checker(
-        val, set(optim_algorithms.values()), "optimization algorithm name", replacements=iterative_methods
-    )
+    return name_range_checker(val, optim_algorithms, "optimization algorithm name")
 
 
 @validator
 def output_file_format_validator(val):
-    return name_range_checker(val, set(files_formats.values()), "output file format", replacements=files_formats)
+    return name_range_checker(val, files_formats, "output file format")
 
 
 @validator
 def distribution_method_validator(val):
-    val = name_range_checker(
-        val, set(distribution_methods.values()), "workload distribution method", replacements=distribution_methods
-    )
+    val = name_range_checker(val, distribution_methods, "workload distribution method")
     # TEMP.
     if val != "local":
         raise NotImplementedError("Computation method '%s' is not implemented yet" % val)
@@ -481,9 +483,7 @@ def distribution_method_validator(val):
 
 @validator
 def sino_normalization_validator(val):
-    val = name_range_checker(
-        val, set(sino_normalizations.values()), "sinogram normalization method", replacements=sino_normalizations
-    )
+    val = name_range_checker(val, sino_normalizations, "sinogram normalization method")
     return val
 
 
@@ -491,9 +491,8 @@ def sino_normalization_validator(val):
 def sino_deringer_methods(val):
     val = name_range_checker(
         val,
-        set(rings_methods.values()),
+        rings_methods,
         "sinogram rings artefacts correction method",
-        replacements=rings_methods,
     )
     return val
 
@@ -556,7 +555,7 @@ def nonempty_string_validator(val):
 
 @validator
 def logging_validator(val):
-    return name_range_checker(val, set(log_levels.values()), "logging level", replacements=log_levels)
+    return name_range_checker(val, log_levels, "logging level")
 
 
 @validator

nabu/pipeline/estimators.py

@@ -9,6 +9,7 @@ import scipy.fft  #  pylint: disable=E0611
 from silx.io import get_data
 import math
 from scipy import ndimage as nd
+
 from ..preproc.flatfield import FlatField
 from ..estimation.cor import (
     CenterOfRotation,
@@ -17,8 +18,10 @@ from ..estimation.cor import (
     CenterOfRotationGrowingWindow,
     CenterOfRotationOctaveAccurate,
 )
+from .. import version as nabu_version
 from ..estimation.cor_sino import SinoCorInterface, CenterOfRotationFourierAngles, CenterOfRotationVo
 from ..estimation.tilt import CameraTilt
+from ..estimation.motion import MotionEstimation
 from ..estimation.utils import is_fullturn_scan
 from ..resources.logger import LoggerOrPrint
 from ..resources.utils import extract_parameters
@@ -989,3 +992,255 @@ class DetectorTiltEstimator:
 
 # alias
 TiltFinder = DetectorTiltEstimator
+
+
+def estimate_translations(dataset_info, do_flatfield=True): ...
+
+
+class TranslationsEstimator:
+
+    _default_extra_options = {
+        "window_size": 200,
+    }
+
+    def __init__(
+        self,
+        dataset_info,
+        do_flatfield=True,
+        rot_center=None,
+        halftomo_side=None,
+        angular_subsampling=10,
+        deg_xy=2,
+        deg_z=2,
+        shifts_estimator="phase_cross_correlation",
+        extra_options=None,
+    ):
+        self._configure_extra_options(extra_options)
+        self.logger = LoggerOrPrint(dataset_info.logger)
+        self.dataset_info = dataset_info
+        self.angular_subsampling = angular_subsampling
+        self.do_360 = self.dataset_info.is_360
+        self.do_flatfield = do_flatfield
+        self.radios = None
+        self._deg_xy = deg_xy
+        self._deg_z = deg_z
+        self._shifts_estimator = shifts_estimator
+        self._shifts_estimator_kwargs = {}
+        self._cor = rot_center
+        self._configure_halftomo(halftomo_side)
+        self._estimate_cor = self._cor is None
+        self.sample_shifts_xy = None
+        self.sample_shifts_z = None
+
+    def _configure_extra_options(self, extra_options):
+        self.extra_options = self._default_extra_options.copy()
+        self.extra_options.update(extra_options or {})
+
+    def _configure_halftomo(self, halftomo_side):
+        if halftomo_side is False:
+            # Force disable halftomo
+            self.halftomo_side = False
+            return
+        self._start_x = None
+        self._end_x = None
+        if (halftomo_side is not None) and not (self.do_360):
+            raise ValueError(
+                "Expected 360° dataset for half-tomography, but this dataset does not look like a 360° dataset"
+            )
+        if halftomo_side is None:
+            if self.dataset_info.is_halftomo:
+                halftomo_side = "right"
+            else:
+                self.halftomo_side = False
+                return
+        self.halftomo_side = halftomo_side
+        window_size = self.extra_options["window_size"]
+        if self._cor is not None:
+            # In this case we look for shifts around the CoR
+            self._start_x = int(self._cor - window_size / 2)
+            self._end_x = int(self._cor + window_size / 2)
+        elif halftomo_side == "right":
+            self._start_x = -window_size
+            self._end_x = None
+        elif halftomo_side == "left":
+            self._start_x = 0
+            self._end_x = window_size
+        elif is_scalar(halftomo_side):
+            # Expect approximate location of CoR, relative to left-most column
+            self._start_x = int(halftomo_side - window_size / 2)
+            self._end_x = int(halftomo_side + window_size / 2)
+        else:
+            raise ValueError(
+                f"Expected 'halftomo_side' to be either 'left', 'right', or an integer (got {halftomo_side})"
+            )
+        self.logger.debug(f"[MotionEstimation] Half-tomo looking at [{self._start_x}:{self._end_x}]")
+        # For half-tomo, skimage.registration.phase_cross_correlation might look a bit too far away
+        if (
+            self._shifts_estimator == "phase_cross_correlation"
+            and self._shifts_estimator_kwargs.get("overlap_ratio", 0.3) >= 0.3
+        ):
+            self._shifts_estimator_kwargs.update({"overlap_ratio": 0.2})
+        #
+
+    def _load_data(self):
+        self.logger.debug("[MotionEstimation] reading data")
+        if self.do_360:
+            """
+            In this case we compare pair of opposite projections.
+            If rotation angles are arbitrary, we should do something like
+              for angle in dataset_info.rotation_angles:
+                  img, angle_deg, idx = dataset_info.get_image_at_angle(
+                      np.degrees(angle)+180, return_angle_and_index=True
+                  )
+            Most of the time (always ?), the dataset was acquired with a circular trajectory,
+            so we can use angles:
+                dataset_info.rotation_angles[::self.angular_subsampling]
+            which amounts to reading one radio out of "angular_subsampling"
+            """
+
+            # TODO account for more general rotation angles. The following will only work for circular trajectory and ordered angles
+            self._reader = self.dataset_info.get_reader(
+                sub_region=(slice(None, None, self.angular_subsampling), slice(None), slice(None))
+            )
+            self.radios = self._reader.load_data()
+            self.angles = self.dataset_info.rotation_angles[:: self.angular_subsampling]
+            self._radios_idx = self._reader.get_frames_indices()
+            self.logger.debug("[MotionEstimation] This is a 360° scan, will use pairs of opposite projections")
+        else:
+            """
+            In this case we use the "return projections", i.e special projections acquired at several angles
+            (eg. [180, 90, 0]) before ending the scan
+            """
+            return_projs, return_angles_deg, return_idx = self.dataset_info.get_alignment_projections()
+            self._angles_return = np.radians(return_angles_deg)
+            self._radios_return = return_projs
+            self._radios_idx_return = return_idx
+
+            projs = []
+            angles_rad = []
+            projs_idx = []
+            for angle_deg in return_angles_deg:
+                proj, rot_angle_deg, proj_idx = self.dataset_info.get_image_at_angle(
+                    angle_deg, image_type="projection", return_angle_and_index=True
+                )
+                projs.append(proj)
+                angles_rad.append(np.radians(rot_angle_deg))
+                projs_idx.append(proj_idx)
+            self._radios_outwards = np.array(projs)
+            self._angles_outward = np.array(angles_rad)
+            self._radios_idx_outwards = np.array(projs_idx)
+            self.logger.debug("[MotionEstimation] This is a 180° scan, will use 'return projections'")
+
+    def _apply_flatfield(self):
+        if not (self.do_flatfield):
+            return
+        self.logger.debug("[MotionEstimation] flatfield")
+        if self.do_360:
+            self._flatfield = FlatField(
+                self.radios.shape,
+                flats=self.dataset_info.flats,
+                darks=self.dataset_info.darks,
+                radios_indices=self._radios_idx,
+            )
+            self._flatfield.normalize_radios(self.radios)
+        else:
+            # 180 + return projs
+            self._flatfield_outwards = FlatField(
+                self._radios_outwards.shape,
+                flats=self.dataset_info.flats,
+                darks=self.dataset_info.darks,
+                radios_indices=self._radios_idx_outwards,
+            )
+            self._flatfield_outwards.normalize_radios(self._radios_outwards)
+            self._flatfield_return = FlatField(
+                self._radios_return.shape,
+                flats=self.dataset_info.flats,
+                darks=self.dataset_info.darks,
+                radios_indices=self._radios_idx_return,
+            )
+            self._flatfield_outwards.normalize_radios(self._radios_return)
+
+    def estimate_motion(self):
+        self._load_data()
+        self._apply_flatfield()
+
+        n_projs_tot = self.dataset_info.n_angles
+        if self.do_360:
+            n_a = self.radios.shape[0]
+            # See notes above - this works only for circular trajectory / ordered angles
+            projs_stack1 = self.radios[: n_a // 2]
+            projs_stack2 = self.radios[n_a // 2 :]
+            angles1 = self.angles[: n_a // 2]
+            angles2 = self.angles[n_a // 2 :]
+            indices1 = (self._radios_idx - self._radios_idx[0])[: n_a // 2]
+            indices2 = (self._radios_idx - self._radios_idx[0])[n_a // 2 :]
+        else:
+            projs_stack1 = self._radios_outwards
+            projs_stack2 = self._radios_return
+            angles1 = self._angles_outward
+            angles2 = self._angles_return
+            indices1 = self._radios_idx_outwards - self._radios_idx_outwards.min()
+            indices2 = self._radios_idx_return - self._radios_idx_outwards.min()
+
+        if self._start_x is not None:
+            # Compute Motion Estimation on subset of images (eg. for half-tomo)
+            projs_stack1 = projs_stack1[..., self._start_x : self._end_x]
+            projs_stack2 = projs_stack2[..., self._start_x : self._end_x]
+
+        self.motion_estimator = MotionEstimation(
+            projs_stack1,
+            projs_stack2,
+            angles1,
+            angles2,
+            indices1,
+            indices2,
+            n_projs_tot,
+            shifts_estimator=self._shifts_estimator,
+            shifts_estimator_kwargs=self._shifts_estimator_kwargs,
+        )
+
+        self.logger.debug("[MotionEstimation] estimating shifts")
+
+        estimated_shifts_v = self.motion_estimator.estimate_vertical_motion(degree=self._deg_z)
+        estimated_shifts_h, cor = self.motion_estimator.estimate_horizontal_motion(degree=self._deg_xy, cor=self._cor)
+        if self._start_x is not None:
+            cor += (self._start_x % self.radios.shape[-1]) + (projs_stack1.shape[-1] - 1) / 2.0
+
+        self.sample_shifts_xy = estimated_shifts_h
+        self.sample_shifts_z = estimated_shifts_v
+        if self._cor is None:
+            self.logger.info(
+                "[MotionEstimation] Estimated center of rotation (relative to middle of detector): %.2f" % cor
+            )
+        return estimated_shifts_h, estimated_shifts_v, cor
+
+    def generate_translations_movements_file(self, filename, fmt="%.3f", only=None):
+        if self.sample_shifts_xy is None:
+            raise RuntimeError("Need to run estimate_motion() first")
+
+        angles = self.dataset_info.rotation_angles
+        cor = self._cor or 0
+        txy_est_all_angles = self.motion_estimator.apply_fit_horiz(angles=angles)
+        tz_est_all_angles = self.motion_estimator.apply_fit_vertic(angles=angles)
+        estimated_shifts_vu_all_angles = self.motion_estimator.convert_sample_motion_to_detector_shifts(
+            txy_est_all_angles, tz_est_all_angles, angles, cor=cor
+        )
+        estimated_shifts_vu_all_angles[:, 1] -= cor
+        correct_shifts_uv = -estimated_shifts_vu_all_angles[:, ::-1]
+
+        if only is not None:
+            if only == "horizontal":
+                correct_shifts_uv[:, 1] = 0
+            elif only == "vertical":
+                correct_shifts_uv[:, 0] = 0
+            else:
+                raise ValueError("Expected 'only' to be either None, 'horizontal' or 'vertical'")
+
+        header = f"Generated by nabu {nabu_version} : {str(self)}"
+        np.savetxt(filename, correct_shifts_uv, fmt=fmt, header=header)
+
+    def __str__(self):
+        ret = f"{self.__class__.__name__}(do_flatfield={self.do_flatfield}, rot_center={self._cor}, angular_subsampling={self.angular_subsampling})"
+        if self.sample_shifts_xy is not None:
+            ret += f", shifts_estimator={self.motion_estimator.shifts_estimator}"
+        return ret