nabu 2024.1.0rc4__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/parse_reconstruction_log.py

@@ -0,0 +1,151 @@
+import numpy as np
+from os import path
+from datetime import datetime
+from ..utils import check_supported, convert_str_to_tuple
+from .utils import parse_params_values
+from .cli_configs import ShowReconstructionTimingsConfig
+
+try:
+    import matplotlib.pyplot as plt
+
+    __have_matplotlib__ = True
+except ImportError:
+    __have_matplotlib__ = False
+
+steps_to_measure = [
+    "Reading data",
+    "Applying flat-field",
+    "Applying double flat-field",
+    "Applying CCD corrections",
+    "Rotating projections",
+    "Performing phase retrieval",
+    "Performing unsharp mask",
+    "Taking logarithm",
+    "Applying radios movements",
+    "Normalizing sinograms",
+    "Building sinograms",  # deprecated
+    "Removing rings on sinograms",
+    "Reconstruction",
+    "Computing histogram",
+    "Saving data",
+]
+
+
+def extract_timings_from_volume_reconstruction_lines(lines, separator=" - "):
+    def extract_timestamp(line):
+        timestamp = line.split(separator)[0]
+        return datetime.strptime(timestamp, "%d-%m-%Y %H:%M:%S")
+
+    def extract_current_step(line):
+        return line.split(separator)[-1]
+
+    current_step = extract_current_step(lines[0])
+    t1 = extract_timestamp(lines[0])
+
+    res = {}
+    for line in lines[1:]:
+        line = line.strip()
+        if len(line.split(separator)) == 1:
+            continue
+        timestamp = line.strip().split(separator)[0]
+        t2 = datetime.strptime(timestamp, "%d-%m-%Y %H:%M:%S")
+
+        res.setdefault(current_step, [])
+        res[current_step].append((t2 - t1).seconds)
+
+        t1 = t2
+        current_step = extract_current_step(line)
+
+    return res
+
+
+def parse_logfile(fname, separator=" - "):
+    """
+    Returns
+    -------
+    timings: list of dict
+        List of dictionaries: one dict per reconstruction in the log file.
+        For each dict, the key is the pipeline step name, and the value is the list of timings for the different chunks.
+    """
+    with open(fname, "r") as f:
+        lines = f.readlines()
+
+    start_text = "Going to reconstruct slices"
+    end_text = "Merging reconstructions to"
+
+    rec_log_bounds = []
+    for i, line in enumerate(lines):
+        if start_text in line:
+            start_line = i
+        if end_text in line:
+            rec_log_bounds.append((start_line, i))
+            rec_file_basename = path.basename(line.split(end_text)[-1])
+
+    results = []
+    for bounds in rec_log_bounds:
+        start, end = bounds
+        timings = {}
+        res = extract_timings_from_volume_reconstruction_lines(lines[start:end], separator=separator)
+        for step in steps_to_measure:
+            if step in res:
+                timings[step] = res[step]
+        results.append(timings)
+    return results
+
+
+def display_timings_pie(timings, reduce_function=None, cutoffs=None):
+    reduce_function = reduce_function or np.median
+    cutoffs = cutoffs or (0, np.inf)
+
+    def _format_pie_text(pct, allvals):
+        # https://matplotlib.org/stable/gallery/pie_and_polar_charts/pie_and_donut_labels.html
+        absolute = int(np.round(pct / 100.0 * np.sum(allvals)))
+        return f"{pct:.1f}%\n({absolute:d} s)"
+
+    for run in timings:
+        fig = plt.figure()
+        pie_labels = []
+        pie_sizes = []
+        for step_name, step_timings in run.items():
+            t = reduce_function(step_timings)
+            if t > cutoffs[0] and t < cutoffs[1]:
+                # pie_labels.append(step_name)
+                pie_labels.append(step_name + "\n(%d s)" % t)
+                pie_sizes.append(t)
+        ax = fig.subplots()
+        # ax.pie(pie_sizes, labels=pie_labels, autopct=lambda pct: _format_pie_text(pct, pie_sizes)) # autopct='%1.1f%%')
+        ax.pie(pie_sizes, labels=pie_labels, autopct="%1.1f%%")
+
+        fig.show()
+    input("Press any key to continue")
+
+
+def parse_reclog_cli():
+    args = parse_params_values(
+        ShowReconstructionTimingsConfig, parser_description="Display reconstruction performances from a log file"
+    )
+    if not (__have_matplotlib__):
+        print("Need matplotlib to use this utility")
+        exit(1)
+
+    display_functions = {
+        "pie": display_timings_pie,
+    }
+
+    logfile = args["logfile"]
+    cutoff = args["cutoff"]
+    display_type = args["type"]
+
+    check_supported(display_type, display_functions.keys(), "Graphics display type")
+    if cutoff is not None:
+        cutoff = list(map(float, convert_str_to_tuple(cutoff)))
+
+    timings = parse_logfile(logfile)
+    display_functions[display_type](timings, cutoffs=cutoff)
+
+    return 0
+
+
+if __name__ == "__main__":
+    parse_reclog_cli()
+    exit(0)

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/prepare_weights_double.py

@@ -0,0 +1,163 @@
+import h5py
+import numpy as np
+from scipy.special import erf  # pylint: disable=all
+import sys
+import os
+from scipy.ndimage import gaussian_filter
+from nxtomo.nxobject.nxdetector import ImageKey
+from nabu.resources.nxflatfield import update_dataset_info_flats_darks
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
+from ..io.reader import load_images_from_dataurl_dict
+
+
+def main(argv=None):
+    """auxiliary program that can be called to create  default input detector profiles, for nabu helical,
+    concerning the weights of the pixels and the "double flat" renormalisation denominator.
+    The result is an hdf5 file that can be used as a "processes_file" in the nabu configuration and is used by nabu-helical.
+    In particulars cases the user may have fancy masks and correction map and will provide its own processes file,
+    and will not need this.
+
+    This code, and in particular the auxiliary function below (that by the way tomwer can use)
+    provide a default construction of such maps. The double-flat is set to one and
+    the weight is build on the basis of the flat fields   from the dataset with an apodisation on the borders
+    which allows to eliminate discontinuities in the contributions from the borders, above and below
+    for the z-translations, and on the left or roght border for half-tomo.
+
+    The usage is ::
+
+       nabu-helical-prepare-weights-double nexus_file_name entry_name
+
+    Then the resulting file can be used as processes file in the configuration file of nabu-helical
+
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+    if len(argv) not in [2, 3, 4, 5, 6]:
+        message = f""" Usage:
+            nabu-helical-prepare-weights-double nexus_file_name entry_name [target_file name [transition_width_vertical [rotation_axis_position [transition_width_vertical]]]]
+        """
+        print(message)
+        sys.exit(1)
+
+    file_name = argv[0]
+    if len(os.path.dirname(file_name)) == 0:
+        # To make sure that other utility routines can succesfully deal with path within the current directory
+        file_name = os.path.join(".", file_name)
+
+    # still tere was some problem with relative path and how they are dealt with in nxtomomill
+    # Better to use absolute path
+    file_name = os.path.abspath(file_name)
+
+    entry_name = argv[1]
+    process_file_name = "double.h5"
+
+    dataset_info = HDF5DatasetAnalyzer(file_name, extra_options={"h5_entry": entry_name})
+    update_dataset_info_flats_darks(dataset_info, flatfield_mode=1)
+
+    beam_profile = 0
+    my_flats = load_images_from_dataurl_dict(dataset_info.flats)
+
+    for key, flat in my_flats.items():
+        beam_profile += flat
+    beam_profile = beam_profile / len(list(dataset_info.flats.keys()))
+
+    transition_width_vertical = 50.0
+
+    # the following two line determines the horisontal transition
+    # by default a transition on the right ( corresponds to an axis close to the right border)
+
+    rotation_axis_position = beam_profile.shape[1] - 200
+    transition_width_horizontal = 100.0
+
+    if len(argv) in [3, 4, 5, 6]:
+        process_file_name = argv[2]
+        if len(argv) in [4, 5, 6]:
+            transition_width_vertical = float(argv[3])
+            if len(argv) in [5, 6]:
+                rotation_axis_position = (beam_profile.shape[1] - 1) / 2 + float(argv[4])
+                if len(argv) in [6]:
+                    transition_width_horizontal = 2 * (float(argv[5]))
+
+    create_heli_maps(
+        beam_profile,
+        process_file_name,
+        entry_name,
+        transition_width_vertical,
+        rotation_axis_position,
+        transition_width_horizontal,
+    )
+
+    # here we have been called by the cli. The return value 0 means OK
+    return 0
+
+
+def create_heli_maps(
+    profile,
+    process_file_name,
+    entry_name,
+    transition_width_vertical,
+    rotation_axis_position,
+    transition_width_horizontal,
+):
+    profile = profile / profile.max()
+    profile = profile.astype("f")
+
+    profile = gaussian_filter(profile, 10)
+
+    def compute_border_v(L, m, w):
+        x = np.arange(L)
+
+        d = (x - L + m).astype("f")
+        res_r = (1 - erf(d / w)) / 2
+
+        d = (x - m).astype("f")
+        res_l = (1 + erf(d / w)) / 2
+
+        return res_r * res_l
+
+    def compute_border_h(L, r, tw):
+        if r > (L - 1) / 2:
+            if tw > (L - r):
+                tw = max(1.0, L - r)
+
+            m = tw / 2
+            w = tw / 5
+
+            x = np.arange(L)
+
+            d = (x - L + m).astype("f")
+            res_r = (1 - erf(d / w)) / 2
+
+            return res_r
+
+        else:
+            if tw > r:
+                tw = max(1.0, r)
+
+            m = tw / 2
+            w = tw / 5
+
+            x = np.arange(L)
+
+            d = (x - m).astype("f")
+            res_l = (1 + erf(d / w)) / 2
+
+            return res_l
+
+    with h5py.File(process_file_name, mode="a") as fd:
+        path_weights = entry_name + "/weights_field/results/data"
+        path_double = entry_name + "/double_flatfield/results/data"
+
+        if path_weights in fd:
+            del fd[path_weights]
+        if path_double in fd:
+            del fd[path_double]
+
+        border = compute_border_h(profile.shape[1], rotation_axis_position, transition_width_horizontal)
+
+        border_v = compute_border_v(
+            profile.shape[0], round(transition_width_vertical / 2), transition_width_vertical / 5
+        )
+
+        fd[path_weights] = (profile * border) * border_v[:, None]
+        fd[path_double] = np.ones_like(profile)

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/reconstruct.py

@@ -0,0 +1,120 @@
+from .. import version
+from ..pipeline.config import parse_nabu_config_file
+from ..pipeline.config_validators import convert_to_int
+from .cli_configs import ReconstructConfig
+from .utils import parse_params_values
+
+
+def update_reconstruction_start_end(conf_dict, user_indices):
+    if len(user_indices) == 0:
+        return
+    rec_cfg = conf_dict["reconstruction"]
+    err = None
+
+    val_int, conv_err = convert_to_int(user_indices)
+    if conv_err is None:
+        start_z = user_indices
+        end_z = user_indices
+    else:
+        if user_indices in ["first", "middle", "last"]:
+            start_z = user_indices
+            end_z = user_indices
+        elif user_indices == "all":
+            start_z = 0
+            end_z = -1
+        elif "-" in user_indices:
+            try:
+                start_z, end_z = user_indices.split("-")
+                start_z = int(start_z)
+                end_z = int(end_z)
+            except Exception as exc:
+                err = "Could not interpret slice indices '%s': %s" % (user_indices, str(exc))
+        else:
+            err = "Could not interpret slice indices: %s" % user_indices
+        if err is not None:
+            print(err)
+            exit(1)
+    rec_cfg["start_z"] = start_z
+    rec_cfg["end_z"] = end_z
+
+
+def get_log_file(arg_logfile, legacy_arg_logfile, forbidden=None):
+    default_arg_val = ""
+    # Compat. log_file --> logfile
+    if legacy_arg_logfile != default_arg_val:
+        logfile = legacy_arg_logfile
+    else:
+        logfile = arg_logfile
+    #
+    if forbidden is None:
+        forbidden = []
+    for forbidden_val in forbidden:
+        if logfile == forbidden_val:
+            print("Error: --logfile argument cannot have the value %s" % forbidden_val)
+            exit(1)
+    if logfile == "":
+        logfile = True
+    return logfile
+
+
+def get_reconstructor(args, overwrite_options=None):
+    # Imports are done here, otherwise "nabu --version" takes forever
+    from ..pipeline.fullfield.processconfig import ProcessConfig
+    from ..pipeline.fullfield.reconstruction import FullFieldReconstructor
+
+    #
+
+    # A crash with scikit-cuda happens only on PPC64 platform if and nvidia-persistenced is running.
+    # On such machines, a warm-up has to be done.
+    import platform
+
+    if platform.machine() == "ppc64le":
+        try:
+            from silx.math.fft.cufft import CUFFT
+        except:  # can't catch narrower - cublasNotInitialized requires cublas !
+            CUFFT = None
+    #
+
+    logfile = get_log_file(args["logfile"], args["log_file"], forbidden=[args["input_file"]])
+    conf_dict = parse_nabu_config_file(args["input_file"])
+    update_reconstruction_start_end(conf_dict, args["slice"].strip())
+    if overwrite_options is not None:
+        for option_key, option_val in overwrite_options.items():
+            opt_section, opt_name = option_key.split("/")
+            conf_dict[opt_section][opt_name] = option_val
+
+    proc = ProcessConfig(conf_dict=conf_dict, create_logger=logfile)
+    logger = proc.logger
+
+    logger.info("Going to reconstruct slices (%d, %d)" % (proc.rec_region["start_z"], proc.rec_region["end_z"]))
+
+    # Get extra options
+    extra_options = {
+        "gpu_mem_fraction": args["gpu_mem_fraction"],
+        "cpu_mem_fraction": args["cpu_mem_fraction"],
+        "chunk_size": args["max_chunk_size"] if args["max_chunk_size"] > 0 else None,
+        "margin": args["phase_margin"],
+        "force_grouped_mode": bool(args["force_use_grouped_pipeline"]),
+    }
+
+    reconstructor = FullFieldReconstructor(proc, logger=logger, extra_options=extra_options)
+    return reconstructor
+
+
+def main():
+    args = parse_params_values(
+        ReconstructConfig,
+        parser_description=f"Perform a tomographic reconstruction.",
+        program_version="nabu " + version,
+    )
+
+    R = get_reconstructor(args)
+    proc = R.process_config
+
+    R.reconstruct()
+    R.finalize_files_saving()
+    return 0
+
+
+if __name__ == "__main__":
+    main()

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/reconstruct_helical.py

@@ -0,0 +1,116 @@
+from .. import version
+from ..resources.utils import is_hdf5_extension
+from ..pipeline.config import parse_nabu_config_file
+from ..pipeline.config_validators import convert_to_int
+from .cli_configs import ReconstructConfig
+from .utils import parse_params_values
+from .reconstruct import update_reconstruction_start_end, get_log_file
+
+
+def main_helical():
+    ReconstructConfig["dry_run"] = {
+        "help": "Stops after printing some information on the reconstruction layout.",
+        "default": 0,
+        "type": int,
+    }
+    ReconstructConfig["diag_zpro_run"] = {
+        "help": "run the pipeline without reconstructing but collecting the contributing radios slices for angles theta+n*360. The given argument is the number of thet in the interval  [0 ,180[. The same number is taken if available in [180,360[. And the whole is repated is available in [0,360[  for a total of 4*diag_zpro_run  possible exctracted contributions",
+        "default": 0,
+        "type": int,
+    }
+
+    args = parse_params_values(
+        ReconstructConfig,
+        parser_description=f"Perform a helical tomographic reconstruction",
+        program_version="nabu " + version,
+    )
+
+    # Imports are done here, otherwise "nabu --version" takes forever
+    from ..pipeline.helical.processconfig import ProcessConfig
+    from ..pipeline.helical.helical_reconstruction import HelicalReconstructorRegridded
+
+    #
+
+    # A crash with scikit-cuda happens only on PPC64 platform if and nvidia-persistenced is running.
+    # On such machines, a warm-up has to be done.
+    import platform
+
+    if platform.machine() == "ppc64le":
+        try:
+            from silx.math.fft.cufft import CUFFT
+        except:  # can't catch narrower - cublasNotInitialized requires cublas !
+            CUFFT = None
+    #
+
+    logfile = get_log_file(args["logfile"], args["log_file"], forbidden=[args["input_file"]])
+    conf_dict = parse_nabu_config_file(args["input_file"])
+    update_reconstruction_start_end(conf_dict, args["slice"].strip())
+
+    proc = ProcessConfig(conf_dict=conf_dict, create_logger=logfile)
+    logger = proc.logger
+
+    if "rotate_projections" in proc.processing_steps:
+        message = """ The rotate_projections step is activated. The Helical pipelines are not yet suited for  projection rotation
+        it will soon be implemented. For the moment
+        you should desactivate the rotation options in nabu.conf
+        """
+        raise ValueError(message)
+
+    # Determine which reconstructor to use
+    reconstructor_cls = None
+    phase_method = None
+    if "phase" in proc.processing_steps:
+        phase_method = proc.processing_options["phase"]["method"]
+
+    # fix the reconstruction roi if not given
+    if "reconstruction" in proc.processing_steps:
+        rec_config = proc.processing_options["reconstruction"]
+
+        rot_center = rec_config["rotation_axis_position"]
+        Nx, Ny = proc.dataset_info.radio_dims
+
+        if proc.nabu_config["reconstruction"]["auto_size"]:
+            if 2 * rot_center > Nx:
+                w = int(round(2 * rot_center))
+            else:
+                w = int(round(2 * Nx - 2 * rot_center))
+            rec_config["start_x"] = int(round(rot_center - w / 2))
+            rec_config["end_x"] = int(round(rot_center + w / 2))
+
+            rec_config["start_y"] = rec_config["start_x"]
+            rec_config["end_y"] = rec_config["end_x"]
+
+    reconstructor_cls = HelicalReconstructorRegridded
+
+    logger.debug("Using pipeline: %s" % reconstructor_cls.__name__)
+
+    # Get extra options
+    extra_options = {
+        "gpu_mem_fraction": args["gpu_mem_fraction"],
+        "cpu_mem_fraction": args["cpu_mem_fraction"],
+    }
+    extra_options.update(
+        {
+            ##### ??? "use_phase_margin": args["use_phase_margin"],
+            "max_chunk_size": args["max_chunk_size"] if args["max_chunk_size"] > 0 else None,
+            "phase_margin": args["phase_margin"],
+            "dry_run": args["dry_run"],
+            "diag_zpro_run": args["diag_zpro_run"],
+        }
+    )
+
+    R = reconstructor_cls(proc, logger=logger, extra_options=extra_options)
+
+    R.reconstruct()
+    if not R.dry_run:
+        R.merge_data_dumps()
+        if is_hdf5_extension(proc.nabu_config["output"]["file_format"]):
+            R.merge_hdf5_reconstructions()
+        R.merge_histograms()
+
+    # here we have been called by the cli. The return value 0 means OK
+    return 0
+
+
+if __name__ == "__main__":
+    main_helical()