nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

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

@@ -1,151 +0,0 @@
-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/build/lib/build/lib/build/lib/nabu/app/prepare_weights_double.py

@@ -1,163 +0,0 @@
-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/build/lib/build/lib/build/lib/nabu/app/reconstruct.py

@@ -1,120 +0,0 @@
-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/build/lib/build/lib/build/lib/nabu/app/reconstruct_helical.py

@@ -1,116 +0,0 @@
-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()