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

nabu/pipeline/fullfield/chunked.py

@@ -3,12 +3,14 @@ from time import time
 from math import ceil
 import numpy as np
 from silx.io.url import DataUrl
-from ...utils import remove_items_from_list
+
+from ...utils import get_num_threads, remove_items_from_list
 from ...resources.logger import LoggerOrPrint
 from ...resources.utils import extract_parameters
-from ...io.reader import ChunkReader, HDF5Loader
+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 FlatFieldDataUrls
+from ...preproc.flatfield import FlatField
 from ...preproc.distortion import DistortionCorrection
 from ...preproc.shift import VerticalShift
 from ...preproc.double_flatfield import DoubleFlatField
@@ -16,14 +18,15 @@ from ...preproc.phase import PaganinPhaseRetrieval
 from ...preproc.ctf import CTFPhaseRetrieval, GeoPars
 from ...reconstruction.sinogram import SinoNormalization
 from ...reconstruction.filtering import SinoFilter
+from ...reconstruction.mlem import __have_corrct__, MLEMReconstructor
 from ...processing.rotation import Rotation
 from ...reconstruction.rings import MunchDeringer, SinoMeanDeringer, VoDeringer
 from ...processing.unsharp import UnsharpMask
 from ...processing.histogram import PartialHistogram, hist_as_2Darray
 from ..utils import use_options, pipeline_step, get_subregion
+from ..reader import bin_image_stack, load_darks_flats
 from ..datadump import DataDumpManager
 from ..writer import WriterManager
-from ..detector_distortion_provider import DetectorDistortionProvider
 
 # For now we don't have a plain python/numpy backend for reconstruction
 try:
@@ -41,7 +44,7 @@ class ChunkedPipeline:
     """
 
     backend = "numpy"
-    FlatFieldClass = FlatFieldDataUrls
+    FlatFieldClass = FlatField
     DoubleFlatFieldClass = DoubleFlatField
     CCDCorrectionClass = CCDFilter
     PaganinPhaseRetrievalClass = PaganinPhaseRetrieval
@@ -57,6 +60,8 @@ class ChunkedPipeline:
     SinoFilterClass = SinoFilter
     FBPClass = Backprojector
     ConebeamClass = None  # unsupported on CPU
+    MLEMClass = MLEMReconstructor
+    HBPClass = None  # unsupported on CPU
     HistogramClass = PartialHistogram
 
     _default_extra_options = {}
@@ -195,6 +200,7 @@ class ChunkedPipeline:
         self.logger.debug("Set sub-region to %s" % (str(sub_region)))
         self.sub_region = sub_region
         self._sub_region_xz = sub_region[2] + sub_region[1]
+        self._radios_were_cropped = False
 
     def _set_extra_options(self, extra_options):
         self.extra_options = self._default_extra_options.copy()
@@ -300,33 +306,72 @@ class ChunkedPipeline:
             self.datadump_manager._configure_dump("sinogram", force_dump_to_fname=sino_dump_fname)
             self.logger.debug("Will dump sinogram to %s" % self.datadump_manager.data_dump["sinogram"].fname)
 
+    def _init_reading_processing_function(self):
+        # Some processing may be applied directly when reading data (eg. distortion correction, binning, ...)
+        # Configure it here
+        self._reader_processing_function = None
+        self._reader_processing_function_args = None
+        self._reader_processing_function_kwargs = None
+        self._ff_processing_function = None
+        self._ff_processing_function_args = None
+        if self.process_config.binning is None or self.process_config.binning == (1, 1):
+            return
+        if self.dataset_info.kind == "nx":
+            self._reader_processing_function = bin_image_stack
+            self._reader_processing_function_kwargs = {
+                "binning_factor": self.process_config.binning[::-1],
+                "num_threads": get_num_threads(),
+            }
+        else:
+            self._reader_processing_function = image_binning
+            self._reader_processing_function_args = [self.process_config.binning[::-1]]
+        # flat-field is read image-wise
+        self._ff_processing_function = image_binning
+        self._ff_processing_function_args = [self.process_config.binning[::-1]]
+
     @use_options("read_chunk", "chunk_reader")
     def _init_reader(self):
         options = self.processing_options["read_chunk"]
-        self._update_reader_configuration()
-
         process_file = options.get("process_file", None)
-        if process_file is None:
-            # Standard case - start pipeline from raw data
-            if self.process_config.nabu_config["preproc"]["detector_distortion_correction"] is None:
-                self.detector_corrector = None
-            else:
-                self.detector_corrector = DetectorDistortionProvider(
-                    detector_full_shape_vh=self.process_config.dataset_info.radio_dims[::-1],
-                    correction_type=self.process_config.nabu_config["preproc"]["detector_distortion_correction"],
-                    options=self.process_config.nabu_config["preproc"]["detector_distortion_correction_options"],
-                )
-            # ChunkReader always take a non-subsampled dictionary "files".
-            self.chunk_reader = ChunkReader(
-                self._read_options["files"],
-                sub_region=self.sub_region_xz,
-                data_buffer=self.radios,
-                pre_allocate=False,
-                detector_corrector=self.detector_corrector,
-                convert_float=True,
-                binning=options["binning"],
-                dataset_subsampling=options["dataset_subsampling"],
+        if process_file is None:  # Standard case - start pipeline from raw data
+            self._init_reading_processing_function()
+
+            subs_angles = None
+            subs_z = None
+            subs_x = None
+            if self.process_config.subsampling_factor:
+                subs_angles = self.process_config.subsampling_factor
+            reader_sub_region = (
+                slice(*(self.sub_region[0]) + ((subs_angles,) if subs_angles else ())),
+                slice(*(self.sub_region[1]) + ((subs_z,) if subs_z else ())),
+                slice(*(self.sub_region[2]) + ((subs_x,) if subs_x else ())),
             )
+
+            other_reader_kwargs = {
+                "output_dtype": np.float32,
+                "processing_func": self._reader_processing_function,
+                "processing_func_args": self._reader_processing_function_args,
+                "processing_func_kwargs": self._reader_processing_function_kwargs,
+            }
+
+            if self.dataset_info.kind == "nx":
+                self.chunk_reader = NXTomoReader(
+                    self.dataset_info.dataset_hdf5_url.file_path(),
+                    self.dataset_info.dataset_hdf5_url.data_path(),
+                    sub_region=reader_sub_region,
+                    image_key=0,
+                    **other_reader_kwargs,
+                )
+            elif self.dataset_info.kind == "edf":
+                files = [
+                    self.dataset_info.projections[k].file_path() for k in sorted(self.dataset_info.projections.keys())
+                ]
+                self.chunk_reader = EDFStackReader(
+                    files,
+                    sub_region=reader_sub_region,
+                    n_reading_threads=max(1, get_num_threads() // 2),
+                    **other_reader_kwargs,
+                )
         else:
             # Resume pipeline from dumped intermediate step
             self.chunk_reader = HDF5Loader(
@@ -341,36 +386,16 @@ class ChunkedPipeline:
                 "Load subregion %s from file %s" % (str(self.chunk_reader.sub_region), self.chunk_reader.fname)
             )
 
-    def _update_reader_configuration(self):
-        """
-        Modify self.processing_options["read_chunk"] to select a subset of the files, if needed
-        (i.e when processing only a subset of the images stack)
-        """
-        self._read_options = self.processing_options["read_chunk"].copy()
-        if self.n_angles == self.process_config.n_angles(subsampling=True):
-            # Nothing to do if the full angular range is processed in one shot
-            return
-        if self._resume_from_step is not None:
-            if self._resume_from_step == "sinogram":
-                msg = "It makes no sense to use 'grouped processing' when resuming from sinogram"
-                self.logger.fatal(msg)
-                raise ValueError(msg)
-            # Nothing to do if we resume the processing from a given step
-            return
-        input_data_files = {}
-        files_indices = sorted(self._read_options["files"].keys())
-        angle_idx_start, angle_idx_end = self.sub_region[0]
-        for i in range(angle_idx_start, angle_idx_end):
-            idx = files_indices[i]
-            input_data_files[idx] = self._read_options["files"][idx]
-        self._read_options["files"] = input_data_files
-
     @use_options("flatfield", "flatfield")
     def _init_flatfield(self):
         self._ff_options = self.processing_options["flatfield"].copy()
-        # Use chunk_reader.files instead of process_config.projs_indices(subsampling=True), because
-        # chunk_reader might read only a subset of the files (in "grouped mode")
-        self._ff_options["projs_indices"] = list(self.chunk_reader.files_subsampled.keys())
+
+        # 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
@@ -379,7 +404,7 @@ class ChunkedPipeline:
         distortion_correction = None
         if self._ff_options["do_flat_distortion"]:
             self.logger.info("Flats distortion correction will be applied")
-            self.FlatFieldClass = FlatFieldDataUrls  # no GPU implementation available, force this backend
+            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
@@ -387,20 +412,25 @@ class ChunkedPipeline:
                 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,
+        )
+
         # FlatField parameter "radios_indices" must account for subsampling
         self.flatfield = self.FlatFieldClass(
             self.radios_shape,
-            flats=self.dataset_info.flats,
-            darks=self.dataset_info.darks,
+            flats=darks_flats["flats"],
+            darks=darks_flats["darks"],
             radios_indices=self._ff_options["projs_indices"],
             interpolation="linear",
             distortion_correction=distortion_correction,
-            sub_region=self.sub_region_xz,
-            detector_corrector=self.detector_corrector,
-            binning=self._ff_options["binning"],
             radios_srcurrent=self._ff_options["radios_srcurrent"],
             flats_srcurrent=self._ff_options["flats_srcurrent"],
-            convert_float=True,
         )
 
     @use_options("double_flatfield", "double_flatfield")
@@ -421,8 +451,7 @@ class ChunkedPipeline:
         self.double_flatfield = self.DoubleFlatFieldClass(
             self.radios_shape,
             result_url=result_url,
-            sub_region=self.sub_region_xz,
-            detector_corrector=self.detector_corrector,
+            sub_region=self.sub_region[1:],
             input_is_mlog=False,
             output_is_mlog=False,
             average_is_on_log=avg_is_on_log,
@@ -438,13 +467,15 @@ class ChunkedPipeline:
             self.radios_shape[1:], median_clip_thresh=options["median_clip_thresh"]
         )
 
-    @use_options("rotate_projections", "projs_rot")
+    @use_options("tilt_correction", "projs_rot")
     def _init_radios_rotation(self):
-        options = self.processing_options["rotate_projections"]
+        options = self.processing_options["tilt_correction"]
         center = options["center"]
         if center is None:
-            nx, ny = self.radios_shape[1:][::-1]  # after binning
-            center = (nx / 2 - 0.5, ny / 2 - 0.5)
+            nz, nx = self.radios_shape[1:]  # after binning
+            center_x = self.process_config.rotation_axis_position(binning=True)
+            center_z = nz / 2 - 0.5
+            center = (center_x, center_z)
         center = (center[0], center[1] - self.z_min)
         self.projs_rot = self.ImageRotationClass(
             self.radios_shape[1:], options["angle"], center=center, mode="edge", reshape=False
@@ -545,10 +576,13 @@ class ChunkedPipeline:
             raise ValueError("No usable FBP module was found")
         if options["method"] == "cone" and self.ConebeamClass is None:
             raise ValueError("No usable cone-beam module was found")
+        if options["method"] == "mlem" and self.MLEMClass is None:
+            raise ValueError("No usable MLEM module was found.")
 
-        if options["method"] == "FBP":
-            n_slices = self.n_slices
-            self.reconstruction = self.FBPClass(
+        n_slices = self.n_slices
+        if options["method"] in ["FBP", "HBP"]:  # both have the same API
+            rec_cls = self.HBPClass if options["method"] == "HBP" else self.FBPClass
+            self.reconstruction = rec_cls(
                 self.sinos_shape[1:],
                 angles=options["angles"],
                 rot_center=options["rotation_axis_position"],
@@ -561,7 +595,10 @@ class ChunkedPipeline:
                     "axis_correction": options["axis_correction"],
                     "centered_axis": options["centered_axis"],
                     "clip_outer_circle": options["clip_outer_circle"],
+                    "outer_circle_value": options["outer_circle_value"],
                     "filter_cutoff": options["fbp_filter_cutoff"],
+                    "hbp_legs": options["hbp_legs"],
+                    "hbp_reduction_steps": options["hbp_reduction_steps"],
                 },
             )
 
@@ -577,11 +614,33 @@ class ChunkedPipeline:
                 sample_detector_dist,
                 angles=-options["angles"],
                 rot_center=options["rotation_axis_position"],
-                axis_correction=(-options["axis_correction"] if options["axis_correction"] is not None else None),
                 pixel_size=1,
-                scale_factor=1.0 / options["voxel_size_cm"][0],
                 padding_mode=options["padding_type"],
                 slice_roi=self.process_config.rec_roi,
+                extra_options={
+                    "scale_factor": 1.0 / options["voxel_size_cm"][0],
+                    "axis_correction": -options["axis_correction"] if options["axis_correction"] is not None else None,
+                    "clip_outer_circle": options["clip_outer_circle"],
+                    "outer_circle_value": options["outer_circle_value"],
+                    "filter_cutoff": options["fbp_filter_cutoff"],
+                },
+            )
+
+        if options["method"] == "mlem" and options["implementation"] in (None, "corrct"):
+            self.reconstruction = self.MLEMClass(  # pylint: disable=E1102
+                (self.radios_shape[1],) + self.sino_shape,
+                angles_rad=-options["angles"],  # WARNING: mind the sign...
+                shifts_uv=self.dataset_info.translations,  # In config file, one line per proj, each line is (tu,tv). Corrct expects one col per proj and (tv,tu).
+                cor=options["rotation_axis_position"],
+                n_iterations=options["iterations"],
+                extra_options={
+                    "compute_shifts": False,
+                    "tomo_consistency": False,
+                    "v_min_for_v_shifts": 0,
+                    "v_max_for_v_shifts": None,
+                    "v_min_for_u_shifts": 0,
+                    "v_max_for_u_shifts": None,
+                },
             )
 
         self._allocate_recs(*self.process_config.rec_shape, n_slices=n_slices)
@@ -609,7 +668,10 @@ class ChunkedPipeline:
             "jpeg2000_compression_ratio": options["jpeg2000_compression_ratio"],
             "float_clip_values": options["float_clip_values"],
             "tiff_single_file": options.get("tiff_single_file", False),
-            "single_output_file_initialized": getattr(self.process_config, "single_output_file_initialized", False),
+            "single_output_file_initialized": getattr(
+                self.process_config, "single_output_file_initialized", False
+            ),  # COMPAT.
+            "writer_initialized": getattr(self.process_config, "_writer_initialized", False),
             "raw_vol_metadata": {"voxelSize": self.dataset_info.pixel_size},  # legacy...
         }
         writer_extra_options.update(extra_options)
@@ -633,10 +695,9 @@ class ChunkedPipeline:
     def _read_data(self):
         self.logger.debug("Region = %s" % str(self.sub_region))
         t0 = time()
-        self.chunk_reader.load_data()
+        self.chunk_reader.load_data(output=self.radios)
         el = time() - t0
-        shp = self.chunk_reader.data.shape
-        self.logger.info("Read subvolume %s in %.2f s" % (str(shp), el))
+        self.logger.info("Read subvolume %s in %.2f s" % (str(self.radios.shape), el))
 
     @pipeline_step("flatfield", "Applying flat-field")
     def _flatfield(self):
@@ -689,7 +750,7 @@ class ChunkedPipeline:
     def _crop_radios(self):
         if self.use_margin:
             self._orig_radios = self.radios
-            if self.processing_options.get("reconstruction", {}).get("method", None) == "cone":
+            if self.processing_options.get("reconstruction", {}).get("method", None) in ("cone",):
                 return
             ((U, D), (L, R)) = self.margin
             self.logger.debug(
@@ -697,6 +758,7 @@ class ChunkedPipeline:
             )
             U, D, L, R = U or None, -D or None, L or None, -R or None
             self.radios = self.radios[:, U:D, L:R]  # view
+            self._radios_were_cropped = True
 
     @pipeline_step("sino_normalization", "Normalizing sinograms")
     def _normalize_sinos(self, radios=None):
@@ -725,6 +787,10 @@ class ChunkedPipeline:
             self._reconstruct_cone()
             return
 
+        if options["method"] == "mlem":
+            self.recs = self._reconstruct_mlem()
+            return
+
         for i in range(self.n_slices):
             self._tmp_sino[:] = self.radios[:, i, :]  # copy into contiguous array
             self.reconstruction.fbp(self._tmp_sino, output=self.recs[i])
@@ -754,6 +820,26 @@ class ChunkedPipeline:
             relative_z_position=((z_min + z_max) / self.process_config.binning_z / 2) - n_z_tot / 2,
         )
 
+    def _reconstruct_mlem(self):
+        """
+        This reconstructs the entire sinograms stack at once
+        """
+
+        n_angles, n_z, n_x = self.radios.shape
+
+        # FIXME
+        # can't do a discontiguous single copy...
+        # Initially done for Astra CB recons. But happens that MLEM Corrct also expects
+        # data with this order (nb_rows, nb_angles, nb_cols)
+        data_vwu = self._allocate_array((n_z, n_angles, n_x), np.float32, "sinos_mlem")
+        for i in range(n_z):
+            data_vwu[i] = self.radios[:, i, :]
+        # ---
+
+        return self.reconstruction.reconstruct(  # pylint: disable=E1101
+            data_vwu,
+        )
+
     @pipeline_step("histogram", "Computing histogram")
     def _compute_histogram(self, data=None):
         if data is None:
@@ -770,7 +856,8 @@ class ChunkedPipeline:
         self.writer.write_data(data)
         self.logger.info("Wrote %s" % self.writer.fname)
         self._write_histogram()
-        self.process_config.single_output_file_initialized = True
+        self.process_config.single_output_file_initialized = True  # COMPAT.
+        self.process_config._writer_initialized = True
 
     def _write_histogram(self):
         if "histogram" not in self.processing_steps:
@@ -829,24 +916,13 @@ class ChunkedPipeline:
         self._process_finalize()
 
     def _reset_reader_subregion(self):
-        if self._resume_from_step is None:
-            # Normal mode - read data from raw radios
-            self.chunk_reader._set_subregion(self.sub_region_xz)
-            self.chunk_reader._init_reader()
-            self.chunk_reader._loaded = False
-        else:
-            # Resume from a checkpoint. In this case, we have to re-initialize "datadump manager"
-            # sooner to configure start_xyz, end_xyz
-            self._init_data_dump()
+        if self._resume_from_step is not None:
             self.chunk_reader._set_subregion(self.datadump_manager.get_read_dump_subregion())
-            self.chunk_reader._loaded = False
-        if self._grouped_processing:
-            self._update_reader_configuration()
-            self.chunk_reader._set_files(self._read_options["files"])
+            self._init_data_dump()
+        self._init_reader()
 
     def _reset_sub_region(self, sub_region):
         self.set_subregion(sub_region)
-        # When sub_region is changed, all components involving files reading have to be updated
         self._reset_reader_subregion()
         self._init_flatfield()  # reset flatfield
         self._init_writer()

nabu/pipeline/fullfield/chunked_cuda.py

@@ -1,5 +1,5 @@
 from ...preproc.ccd_cuda import CudaLog, CudaCCDFilter
-from ...preproc.flatfield_cuda import CudaFlatFieldDataUrls
+from ...preproc.flatfield_cuda import CudaFlatField
 from ...preproc.shift_cuda import CudaVerticalShift
 from ...preproc.double_flatfield_cuda import CudaDoubleFlatField
 from ...preproc.phase_cuda import CudaPaganinPhaseRetrieval
@@ -11,6 +11,7 @@ from ...processing.unsharp_cuda import CudaUnsharpMask
 from ...processing.rotation_cuda import CudaRotation
 from ...processing.histogram_cuda import CudaPartialHistogram
 from ...reconstruction.fbp import Backprojector
+from ...reconstruction.hbp import HierarchicalBackprojector
 from ...reconstruction.cone import __have_astra__, ConebeamReconstructor
 from ...cuda.utils import get_cuda_context, __has_pycuda__, __pycuda_error_msg__
 from ..utils import pipeline_step
@@ -28,7 +29,7 @@ class CudaChunkedPipeline(ChunkedPipeline):
     """
 
     backend = "cuda"
-    FlatFieldClass = CudaFlatFieldDataUrls
+    FlatFieldClass = CudaFlatField
     DoubleFlatFieldClass = CudaDoubleFlatField
     CCDCorrectionClass = CudaCCDFilter
     PaganinPhaseRetrievalClass = CudaPaganinPhaseRetrieval
@@ -45,6 +46,7 @@ class CudaChunkedPipeline(ChunkedPipeline):
     SinoFilterClass = CudaSinoFilter
     FBPClass = Backprojector
     ConebeamClass = ConebeamReconstructor
+    HBPClass = HierarchicalBackprojector
     HistogramClass = CudaPartialHistogram
 
     def __init__(
@@ -91,7 +93,7 @@ class CudaChunkedPipeline(ChunkedPipeline):
         d_arr = getattr(self, d_name, None)
         if d_arr is None:
             self.logger.debug("Allocating %s: %s" % (name, str(shape)))
-            d_arr = garray.zeros(shape, dtype)
+            d_arr = garray.zeros(shape, dtype)  # pylint: disable=E0606
             setattr(self, d_name, d_arr)
         return d_arr
 
@@ -127,6 +129,8 @@ class CudaChunkedPipeline(ChunkedPipeline):
             U, D = U or None, -D or None
             # not sure why slicing can't be done before get()
             self.recs = self.recs.get()[U:D, ...]
+        elif self.processing_options["reconstruction"]["method"] == "mlem":
+            pass
         else:
             self.recs = self.recs.get()
 

nabu/pipeline/fullfield/computations.py

@@ -128,13 +128,7 @@ def estimate_required_memory(
         if process_config.rec_params["method"] == "cone":
             # In cone-beam reconstruction, need both sinograms and reconstruction inside GPU.
             # That's big!
-            # Even more if padding is done at the nabu side.
-            if rec_config["padding_type"] == "zeros":
-                total_memory_needed += 2 * data_volume_size
-            else:
-                total_memory_needed += (
-                    data_volume_size + get_next_power(2 * Nx) * Na * Nz * 4 * 4
-                )  # no idea why the last *4 is necessary
+            total_memory_needed += 2 * data_volume_size
 
     if debug:
         print(
@@ -216,6 +210,7 @@ def estimate_max_chunk_size(
         delta_z = 0
 
     mem = 0
+    # pylint: disable=E0606, E0601
     last_valid_delta_a = delta_a
     last_valid_delta_z = delta_z
     while True:

nabu/pipeline/fullfield/dataset_validator.py

@@ -19,12 +19,8 @@ class FullFieldDatasetValidator(DatasetValidatorBase):
         if self.nabu_config["preproc"]["flatfield"]:
             darks = self.dataset_info.darks
             assert len(darks) > 0, "Need at least one dark to perform flat-field correction"
-            for dark_id, dark_url in darks.items():
-                assert os.path.isfile(dark_url.file_path()), "Dark file %s not found" % dark_url.file_path()
             flats = self.dataset_info.flats
             assert len(flats) > 0, "Need at least one flat to perform flat-field correction"
-            for flat_id, flat_url in flats.items():
-                assert os.path.isfile(flat_url.file_path()), "Flat file %s not found" % flat_url.file_path()
 
     def _check_slice_indices(self):
         nx, nz = self.dataset_info.radio_dims

nabu/pipeline/fullfield/nabu_config.py

@@ -10,7 +10,7 @@ nabu_config = {
         },
         "hdf5_entry": {
             "default": "",
-            "help": "Entry in the HDF5 file, if applicable. Default is the first available entry.",
+            "help": "Which entry to process in the data HDF5 file. Default is the first entry. It can be a comma-separated list of entries, and/or a wildcard (* for all entries, or things like entry???1).",
             "validator": optional_string_validator,
             "type": "advanced",
         },
@@ -169,15 +169,9 @@ nabu_config = {
             "validator": generic_options_validator,
             "type": "advanced",
         },
-        "rotate_projections": {
-            "default": "",
-            "help": "Whether to rotate each projection image with a certain angle (in degree). By default (empty) no rotation is done.",
-            "validator": optional_nonzero_float_validator,
-            "type": "advanced",
-        },
         "rotate_projections_center": {
             "default": "",
-            "help": "Center of rotation when 'rotate_projections' 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 radio, i.e ((Nx-1)/2.0, (Ny-1)/2.0).",
             "validator": optional_tuple_of_floats_validator,
             "type": "advanced",
         },
@@ -247,10 +241,16 @@ nabu_config = {
     "reconstruction": {
         "method": {
             "default": "FBP",
-            "help": "Reconstruction method. Possible values: FBP, cone, none. If value is 'none', no reconstruction will be done.",
+            "help": "Reconstruction method. Possible values: FBP, HBP, cone, MLEM, none. If value is 'none', no reconstruction will be done.",
             "validator": reconstruction_method_validator,
             "type": "required",
         },
+        "implementation": {
+            "default": "",
+            "help": "Reconstruction method implementation. The same method can have several implementations. Can be 'nabu', 'corrct', 'astra'",
+            "validator": reconstruction_implementation_validator,
+            "type": "advanced",
+        },
         "angles_file": {
             "default": "",
             "help": "In the case you want to override the angles found in the files metadata. The angles are in degree.",
@@ -259,7 +259,7 @@ nabu_config = {
         },
         "rotation_axis_position": {
             "default": "sliding-window",
-            "help": "Rotation axis position. It can be a number or the name of an estimation method (empty value means the middle of the detector).\nThe following methods are available to find automatically the Center of Rotation (CoR):\n - centered : a fast and simple auto-CoR method. It only works when the CoR is not far from the middle of the detector. It does not work for half-tomography.\n - global : a slow but robust auto-CoR.\n - sliding-window : semi-automatically find the CoR with a sliding window. You have to specify on which side the CoR is (left, center, right). Please see the 'cor_options' parameter.\n - growing-window : automatically find the CoR with a sliding-and-growing window. You can tune the option with the parameter 'cor_options'.\n - sino-coarse-to-fine: Estimate CoR from sinogram. Only works for 360 degrees scans.\n - composite-coarse-to-fine: Estimate CoR from composite multi-angle images. Only works for 360 degrees scans.\n - fourier-angles: Estimate CoR from sino based on an angular correlation analysis. You can tune the option with the parameter 'cor_options'.\n - octave-accurate: Legacy from octave accurate COR estimation algorithm. It first estimates the COR with global fourier-based correlation, then refines this estimation with local correlation based on the variance of the difference patches. You can tune the option with the parameter 'cor_options'.",
+            "help": "Rotation axis position. It can be a number or the name of an estimation method (empty value means the middle of the detector).\nThe following methods are available to find automatically the Center of Rotation (CoR):\n - centered : a fast and simple auto-CoR method. It only works when the CoR is not far from the middle of the detector. It does not work for half-tomography.\n - global : a slow but robust auto-CoR.\n - sliding-window : semi-automatically find the CoR with a sliding window. You have to specify on which side the CoR is (left, center, right). Please see the 'cor_options' parameter.\n - growing-window : automatically find the CoR with a sliding-and-growing window. You can tune the option with the parameter 'cor_options'.\n - sino-coarse-to-fine: Estimate CoR from sinogram. Only works for 360 degrees scans.\n - composite-coarse-to-fine: Estimate CoR from composite multi-angle images. Only works for 360 degrees scans.\n - fourier-angles: Estimate CoR from sino based on an angular correlation analysis. You can tune the option with the parameter 'cor_options'.\n - octave-accurate: Legacy from octave accurate COR estimation algorithm. It first estimates the COR with global fourier-based correlation, then refines this estimation with local correlation based on the variance of the difference patches. You can tune the option with the parameter 'cor_options'.\n - vo: Method from Nghia Vo, based on double-wedge in sinogram Fourier transform (needs algotom python package)",
             "validator": cor_validator,
             "type": "required",
         },
@@ -283,7 +283,7 @@ nabu_config = {
         },
         "translation_movements_file": {
             "default": "",
-            "help": "A file where each line describes the horizontal and vertical translations of the sample (or detector). The order is 'horizontal, vertical'.",
+            "help": "A file where each line describes the horizontal and vertical translations of the sample (or detector). The order is 'horizontal, vertical'.\nIt can be created from a numpy array saved with 'numpy.savetxt'",
             "validator": optional_values_file_validator,
             "type": "advanced",
         },
@@ -331,16 +331,34 @@ nabu_config = {
         },
         "clip_outer_circle": {
             "default": "0",
-            "help": "Whether to set to zero voxels falling outside of the reconstruction region",
+            "help": "Whether to mask voxels falling outside of the reconstruction region",
             "validator": boolean_validator,
             "type": "optional",
         },
+        "outer_circle_value": {
+            "default": "0",
+            "help": "If 'clip_outer_circle' is enabled, value of the voxels falling outside of the reconstruction region.",
+            "validator": float_validator,
+            "type": "optional",
+        },
         "centered_axis": {
             "default": "1",
             "help": "If set to true, the reconstructed region is centered on the rotation axis, i.e the center of the image will be the rotation axis position.",
             "validator": boolean_validator,
             "type": "optional",
         },
+        "hbp_reduction_steps": {
+            "default": "2",
+            "help": "How many  reduction steps will be taken. At least 2. A Higher number may increase speed but may also increase the interpolation errors",
+            "validator": nonnegative_integer_validator,
+            "type": "advanced",
+        },
+        "hbp_legs": {
+            "default": "4",
+            "help": "Increasing this parameter help matching the GPU memory size for big slices. Reconstruction by fragments of the whole images. For very large slices it can be useful to increase this number to fit the memory",
+            "validator": nonnegative_integer_validator,
+            "type": "advanced",
+        },
         "start_x": {
             "default": "0",
             "help": "\nParameters for sub-volume reconstruction. Indices start at 0, and upper bounds are INCLUDED!\n----------------------------------------------------------------\n(x, y) are the dimension of a slice, and (z) is the 'vertical' axis\nBy default, all the volume is reconstructed slice by slice, along the axis 'z'.",
@@ -381,7 +399,7 @@ nabu_config = {
             "default": "200",
             "help": "\nParameters for iterative algorithms\n------------------------------------\nNumber of iterations",
             "validator": nonnegative_integer_validator,
-            "type": "unsupported",
+            "type": "advanced",
         },
         "optim_algorithm": {
             "default": "chambolle-pock",
@@ -587,4 +605,10 @@ renamed_keys = {
         "since": "2021.2.0",
         "message": "Option 'flatfield_enabled' has been renamed 'flatfield' in [preproc]",
     },
+    "rotate_projections": {
+        "section": "preproc",
+        "new_name": "",
+        "since": "2024.2.0",
+        "message": "Option 'rotate_projections' removed as it was duplicate of 'tilt_correction'. Please use the latter with a scalar value.",
+    },
 }