nabu 2025.1.0.dev14__py3-none-any.whl → 2025.1.0rc2__py3-none-any.whl

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

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

@@ -16,14 +16,14 @@ nabu_config = {
             "type": "advanced",
         },
         "nexus_version": {
-            "default": "1.4",
-            "help": "Nexus version to use when browsing the HDF5 dataset. Default is 1.0.",
-            "validator": float_validator,
+            "default": "",
+            "help": "Specify a Nexus version to use when browsing the HDF5 dataset.",
+            "validator": optional_float_validator,
             "type": "advanced",
         },
         "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

@@ -4,7 +4,7 @@ import numpy as np
 from .get_double_flatfield import get_double_flatfield
 from silx.io import get_data
 from silx.io.url import DataUrl
-from ...utils import copy_dict_items, compare_dicts
+from ...utils import copy_dict_items, compare_dicts, deprecation_warning
 from ...io.utils import hdf5_entry_exists, get_h5_value
 from ...io.reader import import_h5_to_dict
 from ...resources.utils import extract_parameters, get_values_from_file
@@ -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
         #
@@ -470,6 +476,14 @@ class ProcessConfig(ProcessConfigBase):
         #
         # Double flat field
         #
+        # ---- COMPAT  ----
+        if nabu_config["preproc"].get("double_flatfield_enabled", False):
+            deprecation_warning(
+                "'double_flatfield_enabled' has been renamed to 'double_flatfield'. Please update your configuration file"
+            )
+            nabu_config["preproc"]["double_flatfield"] = True
+
+        # -------------
         if nabu_config["preproc"]["double_flatfield"]:
             tasks.append("double_flatfield")
             options["double_flatfield"] = {

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
@@ -483,7 +486,7 @@ class FullFieldReconstructor:
                 {
                     "sub_region": (
                         (0, self.n_angles),
-                        (curr_z_min - margin_up, curr_z_max + margin_down),
+                        (int(curr_z_min - margin_up), int(curr_z_max + margin_down)),
                         (0, self.chunk_shape[-1]),
                     ),
                     "margin": ((margin_up, margin_down), (0, 0)),

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",
 }