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

nabu/pipeline/fullfield/chunked.py

@@ -10,7 +10,7 @@ from ...resources.utils import extract_parameters
 from ...misc.binning import binning as image_binning
 from ...io.reader import EDFStackReader, HDF5Loader, NXTomoReader
 from ...preproc.ccd import Log, CCDFilter
-from ...preproc.flatfield import FlatField
+from ...preproc.flatfield import FlatField, PCAFlatsNormalizer
 from ...preproc.distortion import DistortionCorrection
 from ...preproc.shift import VerticalShift
 from ...preproc.double_flatfield import DoubleFlatField
@@ -45,6 +45,7 @@ class ChunkedPipeline:
 
     backend = "numpy"
     FlatFieldClass = FlatField
+    PCAFlatFieldClass = PCAFlatsNormalizer
     DoubleFlatFieldClass = DoubleFlatField
     CCDCorrectionClass = CCDFilter
     PaganinPhaseRetrievalClass = PaganinPhaseRetrieval
@@ -393,50 +394,68 @@ class ChunkedPipeline:
 
     @use_options("flatfield", "flatfield")
     def _init_flatfield(self):
-        self._ff_options = self.processing_options["flatfield"].copy()
-
-        # This won't work when resuming from a step (i.e before FF), because we rely on H5Loader()
-        # which re-compacts the data. When data is re-compacted, we have to know the original radios positions.
-        # These positions can be saved in the "file_dump" metadata, but it is not loaded for now
-        # (the process_config object is re-built from scratch every time)
-        self._ff_options["projs_indices"] = self.chunk_reader.get_frames_indices()
-
-        if self._ff_options.get("normalize_srcurrent", False):
-            a_start_idx, a_end_idx = self.sub_region[0]
-            subs = self.process_config.subsampling_factor
-            self._ff_options["radios_srcurrent"] = self._ff_options["radios_srcurrent"][a_start_idx:a_end_idx:subs]
-
-        distortion_correction = None
-        if self._ff_options["do_flat_distortion"]:
-            self.logger.info("Flats distortion correction will be applied")
-            self.FlatFieldClass = FlatField  # no GPU implementation available, force this backend
-            estimation_kwargs = {}
-            estimation_kwargs.update(self._ff_options["flat_distortion_params"])
-            estimation_kwargs["logger"] = self.logger
-            distortion_correction = DistortionCorrection(
-                estimation_method="fft-correlation", estimation_kwargs=estimation_kwargs, correction_method="interpn"
-            )
+        if self.processing_options["flatfield"]:
+            self._ff_options = self.processing_options["flatfield"].copy()
+
+            # This won't work when resuming from a step (i.e before FF), because we rely on H5Loader()
+            # which re-compacts the data. When data is re-compacted, we have to know the original radios positions.
+            # These positions can be saved in the "file_dump" metadata, but it is not loaded for now
+            # (the process_config object is re-built from scratch every time)
+            self._ff_options["projs_indices"] = self.chunk_reader.get_frames_indices()
+
+            if self._ff_options.get("normalize_srcurrent", False):
+                a_start_idx, a_end_idx = self.sub_region[0]
+                subs = self.process_config.subsampling_factor
+                self._ff_options["radios_srcurrent"] = self._ff_options["radios_srcurrent"][a_start_idx:a_end_idx:subs]
+
+            distortion_correction = None
+            if self._ff_options["do_flat_distortion"]:
+                self.logger.info("Flats distortion correction will be applied")
+                self.FlatFieldClass = FlatField  # no GPU implementation available, force this backend
+                estimation_kwargs = {}
+                estimation_kwargs.update(self._ff_options["flat_distortion_params"])
+                estimation_kwargs["logger"] = self.logger
+                distortion_correction = DistortionCorrection(
+                    estimation_method="fft-correlation",
+                    estimation_kwargs=estimation_kwargs,
+                    correction_method="interpn",
+                )
 
-        # Reduced darks/flats are loaded, but we have to crop them on the current sub-region
-        # and possibly do apply some pre-processing (binning, distortion correction, ...)
-        darks_flats = load_darks_flats(
-            self.dataset_info,
-            self.sub_region[1:],
-            processing_func=self._ff_processing_function,
-            processing_func_args=self._ff_processing_function_args,
-        )
+            if self.processing_options["flatfield"]["method"].lower() != "pca":
+                # Reduced darks/flats are loaded, but we have to crop them on the current sub-region
+                # and possibly do apply some pre-processing (binning, distortion correction, ...)
+                darks_flats = load_darks_flats(
+                    self.dataset_info,
+                    self.sub_region[1:],
+                    processing_func=self._ff_processing_function,
+                    processing_func_args=self._ff_processing_function_args,
+                )
 
-        # FlatField parameter "radios_indices" must account for subsampling
-        self.flatfield = self.FlatFieldClass(
-            self.radios_shape,
-            flats=darks_flats["flats"],
-            darks=darks_flats["darks"],
-            radios_indices=self._ff_options["projs_indices"],
-            interpolation="linear",
-            distortion_correction=distortion_correction,
-            radios_srcurrent=self._ff_options["radios_srcurrent"],
-            flats_srcurrent=self._ff_options["flats_srcurrent"],
-        )
+                # FlatField parameter "radios_indices" must account for subsampling
+                self.flatfield = self.FlatFieldClass(
+                    self.radios_shape,
+                    flats=darks_flats["flats"],
+                    darks=darks_flats["darks"],
+                    radios_indices=self._ff_options["projs_indices"],
+                    interpolation="linear",
+                    distortion_correction=distortion_correction,
+                    radios_srcurrent=self._ff_options["radios_srcurrent"],
+                    flats_srcurrent=self._ff_options["flats_srcurrent"],
+                )
+            else:
+                flats = self.process_config.dataset_info.flats
+                darks = self.process_config.dataset_info.darks
+                if len(darks) != 1:
+                    raise ValueError(f"There should be only one reduced dark. Found {len(darks)}.")
+                else:
+                    dark_key = list(darks.keys())[0]
+                nb_pca_components = len(flats) - 1
+                img_subregion = tuple(slice(*sr) for sr in self.sub_region[1:])
+                self.flatfield = self.PCAFlatFieldClass(
+                    np.array([flats[k][img_subregion] for k in range(1, nb_pca_components)]),
+                    darks[dark_key][img_subregion],
+                    flats[0][img_subregion],  # Mean
+                )
 
     @use_options("double_flatfield", "double_flatfield")
     def _init_double_flatfield(self):
@@ -647,6 +666,11 @@ class ChunkedPipeline:
                     "v_max_for_v_shifts": None,
                     "v_min_for_u_shifts": 0,
                     "v_max_for_u_shifts": None,
+                    "scale_factor": 1.0 / options["voxel_size_cm"][0],
+                    "clip_outer_circle": options["clip_outer_circle"],
+                    "outer_circle_value": options["outer_circle_value"],
+                    "filter_cutoff": options["fbp_filter_cutoff"],
+                    "crop_filtered_data": options["crop_filtered_data"],
                 },
             )
 

nabu/pipeline/fullfield/chunked_cuda.py

@@ -75,8 +75,11 @@ class CudaChunkedPipeline(ChunkedPipeline):
         # Decide when to transfer data to GPU. Normally it's right after reading the data,
         # But sometimes a part of the processing is done on CPU.
         self._when_to_transfer_radios_on_gpu = "read_data"
-        if self.flatfield is not None and self.flatfield.distortion_correction is not None:
-            self._when_to_transfer_radios_on_gpu = "flatfield"
+        if self.flatfield is not None:
+            use_flats_distortion = getattr(self.flatfield, "distortion_correction", None) is not None
+            use_pca_flats = self.processing_options["flatfield"]["method"].lower() == "pca"
+            if use_flats_distortion or use_pca_flats:
+                self._when_to_transfer_radios_on_gpu = "flatfield"
 
     def _init_cuda(self, cuda_options):
         if not (__has_pycuda__):

nabu/pipeline/fullfield/nabu_config.py

@@ -23,7 +23,7 @@ nabu_config = {
         },
         "darks_flats_dir": {
             "default": "",
-            "help": "Path to a directory where XXX_flats.h5 and XXX_darks.h5 are to be found, where 'XXX' denotes the dataset basename. If these files are found, then reduced flats/darks will be loaded from them. Otherwise, reduced flats/darks will be saved to there once computed, either in the .nx directory, or in the output directory. Mind that the HDF5 entry corresponds to the one of the dataset.",
+            "help": "Path to a directory where XXX_flats.h5 and XXX_darks.h5 are to be found, where 'XXX' denotes the dataset basename. If these files are found, then reduced flats/darks will be loaded from them. Otherwise, reduced flats/darks will be saved there once computed, either in the .nx directory, or in the output directory. Mind that the HDF5 entry corresponds to the one of the dataset.",
             "validator": optional_directory_location_validator,
             "type": "optional",
         },
@@ -41,7 +41,7 @@ nabu_config = {
         },
         "projections_subsampling": {
             "default": "1",
-            "help": "Projections subsampling factor: take one projection out of 'projection_subsampling'. The format can be an integer (take 1 projection out of N), or N:M (take 1 projection out of N, start with the projection number M)\nFor example: 2 (or 2:0) to reconstruct from even projections, 2:1 to reconstruct from odd projections.",
+            "help": "Projections subsampling factor: take one projection out of 'projections_subsampling'. The format can be an integer (take 1 projection out of N), or N:M (take 1 projection out of N, start with the projection number M)\nFor example: 2 (or 2:0) to reconstruct from even projections, 2:1 to reconstruct from odd projections.",
             "validator": projections_subsampling_validator,
             "type": "advanced",
         },
@@ -61,13 +61,19 @@ nabu_config = {
     "preproc": {
         "flatfield": {
             "default": "1",
-            "help": "How to perform flat-field normalization. The parameter value can be:\n - 1 or True: enabled.\n - 0 or False: disabled\n - forced or force-load: perform flatfield regardless of the dataset by attempting to load darks/flats\n - force-compute: perform flatfield, ignore all .h5 files containing already computed darks/flats.",
-            "validator": flatfield_enabled_validator,
+            "help": "How to perform flat-field normalization. The parameter value can be:\n - 1 or True: enabled.\n - 0 or False: disabled\n - pca: perform a normalization via Principal Component Analysis decomposition PCA-flat-field normalization",
+            "validator": flatfield_validator,
             "type": "required",
         },
+        "flatfield_loading_mode": {
+            "default": "load_if_present",
+            "help": "How to load/compute flat-field. This parameter can be:\n - load_if_present (default) or empty string: Use the existing flatfield files, if existing.\n - force-load: perform flatfield regardless of the dataset by attempting to load darks/flats\n - force-compute: perform flatfield, ignore all .h5 files containing already computed darks/flats.",
+            "validator": flatfield_loading_mode_validator,
+            "type": "optional",
+        },
         "flat_distortion_correction_enabled": {
             "default": "0",
-            "help": "Whether to correct for flat distortion. If activated, each radio is correlated with its corresponding flat, in order to determine and correct the flat distortion.",
+            "help": "Whether to correct for flat distortion. If activated, each radiograph is correlated with its corresponding flat, in order to determine and correct the flat distortion.",
             "validator": boolean_validator,
             "type": "advanced",
         },
@@ -113,7 +119,7 @@ nabu_config = {
         "double_flatfield": {
             "default": "0",
             "help": "Whether to perform 'double flat-field' filtering (this can help to remove rings artefacts). Possible values:\n - 1 or True: enabled.\n - 0 or False: disabled\n - force-load: use an existing DFF file regardless of the dataset\n - force-compute: re-compute the DFF, ignore all existing .h5 files containing already computed DFF",
-            "validator": flatfield_enabled_validator,
+            "validator": flatfield_validator,
             "type": "optional",
         },
         "dff_sigma": {
@@ -172,7 +178,7 @@ nabu_config = {
         },
         "rotate_projections_center": {
             "default": "",
-            "help": "Center of rotation when 'tilt_correction' is non-empty. By default the center of rotation is the middle of each radio, i.e ((Nx-1)/2.0, (Ny-1)/2.0).",
+            "help": "Center of rotation when 'tilt_correction' is non-empty. By default the center of rotation is the middle of each radiograph, i.e ((Nx-1)/2.0, (Ny-1)/2.0).",
             "validator": optional_tuple_of_floats_validator,
             "type": "advanced",
         },
@@ -272,7 +278,7 @@ nabu_config = {
         },
         "cor_slice": {
             "default": "",
-            "help": "Which slice to use for estimating the Center of Rotation (CoR). This parameter can be an integer or 'top', 'middle', 'bottom'.\nIf provided, the CoR will be estimated from the correspondig sinogram, and 'cor_options' can contain the parameter 'subsampling'.",
+            "help": "Which slice to use for estimating the Center of Rotation (CoR). This parameter can be an integer or 'top', 'middle', 'bottom'.\nIf provided, the CoR will be estimated from the corresponding sinogram, and 'cor_options' can contain the parameter 'subsampling'.",
             "validator": cor_slice_validator,
             "type": "advanced",
         },
@@ -479,7 +485,7 @@ nabu_config = {
     },
     "postproc": {
         "output_histogram": {
-            "default": "0",
+            "default": "1",
             "help": "Whether to compute a histogram of the volume.",
             "validator": boolean_validator,
             "type": "optional",
@@ -544,7 +550,7 @@ nabu_config = {
     "pipeline": {
         "save_steps": {
             "default": "",
-            "help": "Save intermediate results. This is a list of comma-separated processing steps, for ex: flatfield, phase, sinogram.\nEach step generates a HDF5 file in the form name_file_prefix.hdf5 (ex. 'sinogram_file_prefix.hdf5')",
+            "help": "Save intermediate results. This is a list of comma-separated processing steps, for ex: flatfield, phase, sinogram.\nEach step generates a HDF5 file in the form name_file_prefix.hdf5 (e.g. 'sinogram_file_prefix.hdf5')",
             "validator": optional_string_validator,
             "type": "optional",
         },
@@ -556,7 +562,7 @@ nabu_config = {
         },
         "steps_file": {
             "default": "",
-            "help": "File where the intermediate processing steps are written. By default it is empty, and intermediate processing steps are written in the same directory as the reconstructions, with a file prefix, ex. sinogram_mydataset.hdf5.",
+            "help": "File where the intermediate processing steps are written. By default it is empty, and intermediate processing steps are written in the same directory as the reconstructions, with a file prefix, e.g. sinogram_mydataset.hdf5.",
             "validator": optional_output_file_path_validator,
             "type": "advanced",
         },

nabu/pipeline/fullfield/processconfig.py

@@ -75,16 +75,19 @@ class ProcessConfig(ProcessConfigBase):
         Update the 'dataset_info' (DatasetAnalyzer class instance) data structure with options from user configuration.
         """
         self.logger.debug("Updating dataset information with user configuration")
-        if self.dataset_info.kind == "nx":
+        if self.dataset_info.kind == "nx" and self.nabu_config["preproc"]["flatfield"]:
             update_dataset_info_flats_darks(
                 self.dataset_info,
                 self.nabu_config["preproc"]["flatfield"],
+                loading_mode=self.nabu_config["preproc"]["flatfield_loading_mode"],
                 output_dir=self.nabu_config["output"]["location"],
                 darks_flats_dir=self.nabu_config["dataset"]["darks_flats_dir"],
             )
         elif self.dataset_info.kind == "edf":
             self.dataset_info.flats = self.dataset_info.get_reduced_flats()
             self.dataset_info.darks = self.dataset_info.get_reduced_darks()
+        else:
+            raise TypeError("Unknown dataset format")
         self.rec_params = self.nabu_config["reconstruction"]
 
         subsampling_factor, subsampling_start = self.nabu_config["dataset"]["projections_subsampling"]
@@ -425,8 +428,10 @@ class ProcessConfig(ProcessConfigBase):
         # Flat-field
         #
         if nabu_config["preproc"]["flatfield"]:
+            ff_method = "pca" if nabu_config["preproc"]["flatfield"] == "pca" else "default"
             tasks.append("flatfield")
             options["flatfield"] = {
+                "method": ff_method,
                 #  Data reader handles binning/subsampling by itself,
                 # but FlatField needs "real" indices (after binning/subsampling)
                 "projs_indices": self.projs_indices(subsampling=False),
@@ -434,7 +439,7 @@ class ProcessConfig(ProcessConfigBase):
                 "do_flat_distortion": nabu_config["preproc"]["flat_distortion_correction_enabled"],
                 "flat_distortion_params": extract_parameters(nabu_config["preproc"]["flat_distortion_params"]),
             }
-            normalize_srcurrent = nabu_config["preproc"]["normalize_srcurrent"]
+            normalize_srcurrent = nabu_config["preproc"]["normalize_srcurrent"] and ff_method == "default"
             radios_srcurrent = None
             flats_srcurrent = None
             if normalize_srcurrent:
@@ -458,6 +463,7 @@ class ProcessConfig(ProcessConfigBase):
             if len(dataset_info.darks) > 1:
                 self.logger.warning("Cannot do flat-field with more than one reduced dark. Taking the first one.")
                 dataset_info.darks = dataset_info.darks[sorted(dataset_info.darks.keys())[0]]
+
         #
         # Spikes filter
         #

nabu/pipeline/fullfield/reconstruction.py

@@ -261,6 +261,9 @@ class FullFieldReconstructor:
         if (self.process_config.dataset_info.detector_tilt or 0) > 15:
             force_grouped_mode = True
             msg = "Radios rotation with a large angle needs to process full radios"
+        if self.process_config.processing_options.get("flatfield", {}).get("method", "default") == "pca":
+            force_grouped_mode = True
+            msg = "PCA-Flatfield normalization needs to process full radios"
         if self.process_config.resume_from_step == "sinogram" and force_grouped_mode:
             self.logger.warning("Cannot use grouped-radios processing when resuming from sinogram")
             force_grouped_mode = False

nabu/pipeline/params.py

@@ -3,6 +3,17 @@ flatfield_modes = {
     "1": True,
     "false": False,
     "0": False,
+    # These three should be removed after a while (moved to 'flatfield_loading_mode')
+    "forced": "force-load",
+    "force-load": "force-load",
+    "force-compute": "force-compute",
+    #
+    "pca": "pca",
+}
+
+flatfield_loading_mode = {
+    "": "load_if_present",
+    "load_if_present": "load_if_present",
     "forced": "force-load",
     "force-load": "force-load",
     "force-compute": "force-compute",
@@ -77,6 +88,7 @@ iterative_methods = {
 optim_algorithms = {
     "chambolle": "chambolle-pock",
     "chambollepock": "chambolle-pock",
+    "chambolle-pock": "chambolle-pock",
     "fista": "fista",
 }
 

nabu/pipeline/tests/test_estimators.py

@@ -1,14 +1,23 @@
 import os
+from tempfile import TemporaryDirectory
 import pytest
 import numpy as np
-from nabu.testutils import utilstest, __do_long_tests__
-from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer, analyze_dataset
+from pint import get_application_registry
+from nxtomo import NXtomo
+from nabu.testutils import utilstest, __do_long_tests__, get_data
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer, analyze_dataset, ImageKey
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from nabu.resources.utils import extract_parameters
-from nabu.pipeline.estimators import CompositeCOREstimator
+from nabu.pipeline.estimators import CompositeCOREstimator, TranslationsEstimator
 from nabu.pipeline.config import parse_nabu_config_file
 from nabu.pipeline.estimators import SinoCORFinder, CORFinder
 
+from nabu.estimation.tests.test_motion_estimation import (
+    check_motion_estimation,
+    project_volume,
+    _create_translations_vector,
+)
+
 
 #
 # Test CoR estimation with "composite-coarse-to-fine" (aka "near" in the legacy system vocable)
@@ -119,3 +128,231 @@ class TestCorNearPos:
             cor = finder.find_cor()
             message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
             assert np.isclose(self.true_cor + 0.5, cor, atol=self.abs_tol), message
+
+
+def _add_fake_flats_and_dark_to_data(data, n_darks=10, n_flats=21, dark_val=1, flat_val=3):
+    img_shape = data.shape[1:]
+    # Use constant darks/flats, to avoid "reduction" (mean/median) issues
+    fake_darks = np.ones((n_darks,) + img_shape, dtype=np.uint16) * dark_val
+    fake_flats = np.ones((n_flats,) + img_shape, dtype=np.uint16) * flat_val
+    return data * (fake_flats[0, 0, 0] - fake_darks[0, 0, 0]) + fake_darks[0, 0, 0], fake_darks, fake_flats
+
+
+def _generate_nx_for_180_dataset(volume, output_file_path, n_darks=10, n_flats=21):
+
+    n_angles = 250
+    cor = -10
+
+    alpha_x = 4
+    beta_x = 3
+    alpha_y = -5
+    beta_y = 10
+    beta_z = 0
+    orig_det_dist = 0
+
+    angles0 = np.linspace(0, np.pi, n_angles, False)
+    return_angles = np.deg2rad([180.0, 135.0, 90.0, 45.0, 0.0])
+    angles = np.hstack([angles0, return_angles]).ravel()
+    a = np.arange(angles0.size + return_angles.size) / angles0.size
+
+    tx = _create_translations_vector(a, alpha_x, beta_x)
+    ty = _create_translations_vector(a, alpha_y, beta_y)
+    tz = _create_translations_vector(a, 0, beta_z)
+
+    sinos = project_volume(volume, angles, -tx, -ty, -tz, cor=-cor, orig_det_dist=orig_det_dist)
+    data = np.moveaxis(sinos, 1, 0)
+
+    sample_motion_xy = np.stack([-tx, ty], axis=1)
+    sample_motion_z = -tz
+    angles_deg = np.degrees(angles0)
+    return_angles_deg = np.degrees(return_angles)
+    n_return_radios = len(return_angles_deg)
+    n_radios = data.shape[0] - n_return_radios
+
+    ureg = get_application_registry()
+    fake_raw_data, darks, flats = _add_fake_flats_and_dark_to_data(data, n_darks=n_darks, n_flats=n_flats)
+
+    nxtomo = NXtomo()
+    nxtomo.instrument.detector.data = np.concatenate(
+        [
+            darks,
+            flats,
+            fake_raw_data,  # radios + return radios (in float32 !)
+        ]
+    )
+    image_key_control = np.concatenate(
+        [
+            [ImageKey.DARK_FIELD.value] * n_darks,
+            [ImageKey.FLAT_FIELD.value] * n_flats,
+            [ImageKey.PROJECTION.value] * n_radios,
+            [ImageKey.ALIGNMENT.value] * n_return_radios,
+        ]
+    )
+    nxtomo.instrument.detector.image_key_control = image_key_control
+
+    rotation_angle = np.concatenate(
+        [np.zeros(n_darks, dtype="f"), np.zeros(n_flats, dtype="f"), angles_deg, return_angles_deg]
+    )
+    nxtomo.sample.rotation_angle = rotation_angle * ureg.degree
+    nxtomo.instrument.detector.field_of_view = "Full"
+    nxtomo.instrument.detector.x_pixel_size = nxtomo.instrument.detector.y_pixel_size = 1 * ureg.micrometer
+    nxtomo.save(file_path=output_file_path, data_path="entry", overwrite=True)
+
+    return sample_motion_xy, sample_motion_z, cor
+
+
+def _generate_nx_for_360_dataset(volume, output_file_path, n_darks=10, n_flats=21):
+
+    n_angles = 250
+    cor = -5.5
+
+    alpha_x = -2
+    beta_x = 7.0
+    alpha_y = -2
+    beta_y = 3
+    beta_z = 100
+    orig_det_dist = 0
+
+    angles = np.linspace(0, 2 * np.pi, n_angles, False)
+    a = np.linspace(0, 1, angles.size, endpoint=False)  # theta/theta_max
+
+    tx = _create_translations_vector(a, alpha_x, beta_x)
+    ty = _create_translations_vector(a, alpha_y, beta_y)
+    tz = _create_translations_vector(a, 0, beta_z)
+
+    sinos = project_volume(volume, angles, -tx, -ty, -tz, cor=-cor, orig_det_dist=orig_det_dist)
+    data = np.moveaxis(sinos, 1, 0)
+
+    sample_motion_xy = np.stack([-tx, ty], axis=1)
+    sample_motion_z = -tz
+    angles_deg = np.degrees(angles)
+
+    ureg = get_application_registry()
+
+    fake_raw_data, darks, flats = _add_fake_flats_and_dark_to_data(data, n_darks=n_darks, n_flats=n_flats)
+
+    nxtomo = NXtomo()
+    nxtomo.instrument.detector.data = np.concatenate([darks, flats, fake_raw_data])  # in float32 !
+
+    image_key_control = np.concatenate(
+        [
+            [ImageKey.DARK_FIELD.value] * n_darks,
+            [ImageKey.FLAT_FIELD.value] * n_flats,
+            [ImageKey.PROJECTION.value] * data.shape[0],
+        ]
+    )
+    nxtomo.instrument.detector.image_key_control = image_key_control
+
+    rotation_angle = np.concatenate(
+        [
+            np.zeros(n_darks, dtype="f"),
+            np.zeros(n_flats, dtype="f"),
+            angles_deg,
+        ]
+    )
+    nxtomo.sample.rotation_angle = rotation_angle * ureg.degree
+    nxtomo.instrument.detector.field_of_view = "Full"
+    nxtomo.instrument.detector.x_pixel_size = nxtomo.instrument.detector.y_pixel_size = 1 * ureg.micrometer
+    nxtomo.save(file_path=output_file_path, data_path="entry", overwrite=True)
+
+    return sample_motion_xy, sample_motion_z, cor
+
+
+@pytest.fixture(scope="class")
+def setup_test_motion_estimator(request):
+    cls = request.cls
+    cls.volume = get_data("motion/mri_volume_subsampled.npy")
+
+
+@pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
+@pytest.mark.usefixtures("setup_test_motion_estimator")
+class TestMotionEstimator:
+
+    def _setup(self, tmpdir):
+        # pytest uses some weird data structure for "tmpdir"
+        if not (isinstance(tmpdir, str)):
+            tmpdir = str(tmpdir)
+        #
+        if getattr(self, "volume", None) is None:
+            self.volume = get_data("motion/mri_volume_subsampled.npy")
+
+    def test_estimate_motion_360_dataset(self, tmpdir, verbose=False):
+        self._setup(tmpdir)
+        nx_file_path = os.path.join(tmpdir, "mri_projected_360_motion.nx")
+        sample_motion_xy, sample_motion_z, cor = _generate_nx_for_360_dataset(self.volume, nx_file_path)
+
+        dataset_info = analyze_dataset(nx_file_path)
+
+        translations_estimator = TranslationsEstimator(
+            dataset_info, do_flatfield=True, rot_center=cor, angular_subsampling=5, deg_xy=2, deg_z=2
+        )
+        estimated_shifts_h, estimated_shifts_v, estimated_cor = translations_estimator.estimate_motion()
+
+        s = translations_estimator.angular_subsampling
+        if verbose:
+            translations_estimator.motion_estimator.plot_detector_shifts(cor=cor)
+            translations_estimator.motion_estimator.plot_movements(
+                cor=cor,
+                angles_rad=dataset_info.rotation_angles[::s],
+                gt_xy=sample_motion_xy[::s, :],
+                gt_z=sample_motion_z[::s],
+            )
+        check_motion_estimation(
+            translations_estimator.motion_estimator,
+            dataset_info.rotation_angles[::s],
+            cor,
+            sample_motion_xy[::s, :],
+            sample_motion_z[::s],
+            fit_error_shifts_tol_vu=(0.2, 0.2),
+            fit_error_det_tol_vu=(1e-5, 5e-2),
+            fit_error_tol_xyz=(0.05, 0.05, 0.05),
+            fit_error_det_all_angles_tol_vu=(1e-5, 0.05),
+        )
+
+    def test_estimate_motion_180_dataset(self, tmpdir, verbose=False):
+        self._setup(tmpdir)
+        nx_file_path = os.path.join(tmpdir, "mri_projected_180_motion.nx")
+
+        sample_motion_xy, sample_motion_z, cor = _generate_nx_for_180_dataset(self.volume, nx_file_path)
+
+        dataset_info = analyze_dataset(nx_file_path)
+
+        translations_estimator = TranslationsEstimator(
+            dataset_info,
+            do_flatfield=True,
+            rot_center=cor,
+            angular_subsampling=2,
+            deg_xy=2,
+            deg_z=2,
+            shifts_estimator="DetectorTranslationAlongBeam",
+        )
+        estimated_shifts_h, estimated_shifts_v, estimated_cor = translations_estimator.estimate_motion()
+
+        if verbose:
+            translations_estimator.motion_estimator.plot_detector_shifts(cor=cor)
+            translations_estimator.motion_estimator.plot_movements(
+                cor=cor,
+                angles_rad=dataset_info.rotation_angles,
+                gt_xy=sample_motion_xy[: dataset_info.n_angles],
+                gt_z=sample_motion_z[: dataset_info.n_angles],
+            )
+
+        check_motion_estimation(
+            translations_estimator.motion_estimator,
+            dataset_info.rotation_angles,
+            cor,
+            sample_motion_xy,
+            sample_motion_z,
+            fit_error_shifts_tol_vu=(0.02, 0.1),
+            fit_error_det_tol_vu=(1e-2, 0.5),
+            fit_error_tol_xyz=(0.5, 2, 1e-2),
+            fit_error_det_all_angles_tol_vu=(1e-2, 2),
+        )
+
+
+if __name__ == "__main__":
+
+    T = TestMotionEstimator()
+    with TemporaryDirectory(suffix="_motion", prefix="nabu_testdata") as tmpdir:
+        T.test_estimate_motion_360_dataset(tmpdir, verbose=True)
+        T.test_estimate_motion_180_dataset(tmpdir, verbose=True)