nabu 2023.2.1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

doc/conf.py

@@ -19,7 +19,7 @@ sys.path.insert(0, os.path.abspath("../"))
 # -- Project information -----------------------------------------------------
 
 project = "Nabu"
-copyright = "2022, ESRF"
+copyright = "2019-2024, ESRF"
 author = "Pierre Paleo"
 
 # -- General configuration ---------------------------------------------------

doc/doc_config.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+from nabu.resources.nabu_config import nabu_config
+
+
+def generate(file_):
+    def write(content):
+        print(content, file=file_)
+    for section, values in nabu_config.items():
+        if section == "about":
+            continue
+        write("## %s\n" % section)
+        for key, val in values.items():
+            if val["type"] == "unsupported":
+                continue
+            write(val["help"] + "\n")
+            write(
+                "```ini\n%s = %s\n```"
+                % (key, val["default"])
+            )
+
+
+
+if __name__ == "__main__":
+
+    import sys, os
+    print(os.path.abspath(__file__))
+    exit(0)
+
+    fname = "/tmp/test.md"
+    with open(fname, "w") as f:
+        generate(f)

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2023.2.1"
+__version__ = "2024.1.0-rc3"
 __nabu_modules__ = [
     "app",
     "cuda",
@@ -7,6 +7,7 @@ __nabu_modules__ = [
     "misc",
     "opencl",
     "pipeline",
+    "processing",
     "preproc",
     "reconstruction",
     "resources",

nabu/app/bootstrap_stitching.py

@@ -43,7 +43,7 @@ def guess_tomo_objects(my_str: str) -> tuple:
 def bootstrap_stitching():
     args = parse_params_values(
         BootstrapStitchingConfig,
-        parser_description="Initialize a nabu configuration file",
+        parser_description="Initialize a 'nabu-stitching' configuration file",
     )
 
     prefilled_values = {}

nabu/app/cli_configs.py

@@ -3,8 +3,10 @@
 #
 
 # Default configuration for "bootstrap" command
-from nabu.stitching.config import StitchingType
-from tomoscan.framereducerbase import ReduceMethod
+from nabu.stitching.definitions import StitchingType
+from nabu.pipeline.config_validators import str2bool
+
+from tomoscan.framereducer.method import ReduceMethod
 
 
 BootstrapConfig = {
@@ -327,6 +329,11 @@ StitchingConfig = {
         "help": "Logging level. Can be 'debug', 'info', 'warning', 'error'. Default is 'info'.",
         "default": "info",
     },
+    "--only-create-master-file": {
+        "help": "Will create the master file with all sub files (volumes or scans). It expects the processing to be finished. It can happen if all slurm job have been submitted but you've been kicked out of the cluster of if you need to relaunch manually some failling job slurm for any reason",
+        "default": False,
+        "action": "store_true",
+    },
 }
 
 # Default configuration for "stitching-bootstrap" command
@@ -446,6 +453,102 @@ CreateDistortionMapHorizontallyMatchedFromPolyConfig = {
     },
 }
 
+DiagToRotConfig = {
+    "--diag_file": dict(
+        required=True, help="The reconstruction file obtained by nabu-helical using the diag_zpro_run option", type=str
+    ),
+    "--entry_name": dict(
+        required=False,
+        help="entry_name. Defauls is entry0000",
+        default="entry0000",
+    ),
+    "--near": dict(
+        required=False,
+        help="This is a relative offset respect to the center of the radios. The cor will be searched around the provided value. If not given the optinal parameter original_scan must be the original nexus file; and the estimated core will be taken there. The netry_name parameter also must be provided in this case",
+        default=None,
+        type=float,
+    ),
+    "--original_scan": dict(
+        required=False,
+        help="The original nexus file. Required only if near parameter is not given",
+        default=None,
+        type=str,
+    ),
+    "--entry_name": dict(
+        required=False,
+        help="The original nexus file entry name. Required only if near parameter is not given",
+        default=None,
+        type=str,
+    ),
+    "--near_width": dict(
+        required=False,
+        help="For the horizontal correlation, searching the cor. The radius around the near value",
+        default=20,
+        type=int,
+    ),
+    "--low_pass": dict(
+        required=False,
+        help="Data are filtered horizontally. details smaller than the provided value are filtered out. Default is 1( gaussian sigma)",
+        default=1.0,
+        type=float,
+    ),
+    "--high_pass": dict(
+        required=False,
+        help="Data are filtered horizontally. Bumps larger than the provided value are filtered out. Default is 10( gaussian sigma)",
+        default=10,
+        type=int,
+    ),
+    "--linear_interpolation": dict(
+        required=False, help="If True(default) the cor will vary linearly with z_transl", default=True, type=str2bool
+    ),
+    "--use_l1_norm": dict(
+        required=False,
+        default=True,
+        help="If false then a L2 norm will be used for the error metric, considering the overlaps, if true L1 norm will be considered",
+        type=str2bool,
+    ),
+    "--cor_file": dict(required=True, help="The file where the information to correct the cor are written", type=str),
+}
+
+DiagToPixConfig = {
+    "--diag_file": dict(
+        required=True, help="The reconstruction file obtained by nabu-helical using the diag_zpro_run option", type=str
+    ),
+    "--entry_name": dict(required=False, help="entry_name. Defauls is entry0000", default="entry0000", type=str),
+    "--search_radius_v": dict(
+        required=False,
+        help="For the vertical correlation, The maximal error in pixels of one turn respect to a contiguous one. Default is 20 ",
+        default=20,
+        type=int,
+    ),
+    "--nexus_target": dict(
+        required=False,
+        help="If given, the mentioned file will be edited with the proper pixel size, the proper COR, and corrected x_translations",
+        default=None,
+        type=str,
+    ),
+    "--nexus_source": dict(
+        required=False,
+        help="Optionaly given, used only if nexus_target has been give. The nexus file will be edited and written on nexus_target. Otherwise nexus_target is considered to be the source",
+        default=None,
+        type=str,
+    ),
+}
+
+CorrectRotConfig = {
+    "--cor_file": dict(required=True, help="The file produce by diag_to_rot", type=str),
+    "--entry_name": dict(required=False, help="entry_name. Defauls is entry0000", default="entry0000", type=str),
+    "--nexus_target": dict(
+        required=True,
+        help="The given file will be edited with the proper pixel size, the proper COR, and corrected x_translations",
+        default=None,
+        type=str,
+    ),
+    "--nexus_source": dict(
+        required=True, help="The nexus file will be edited and written on nexus_target", default=None, type=str
+    ),
+}
+
 
 ReduceDarkFlatConfig = {
     "dataset": {"help": "Dataset (NXtomo or EDF folder) to be treated", "mandatory": True},
@@ -504,3 +607,20 @@ ReduceDarkFlatConfig = {
         "required": False,
     },
 }
+
+ShowReconstructionTimingsConfig = {
+    "logfile": {
+        "help": "Path to the log file.",
+        "default": "",
+        "mandatory": True,
+    },
+    "cutoff": {
+        "help": "Cut-off parameter. Timings below this value will be discarded. For a upper-bound cutoff, provide a value in the form 'low, high'",
+        "default": None,
+    },
+    "type": {
+        "help": "How to display the result. Default is a pie chart. Possible values are: pie, bars, violin",
+        "default": "pie",
+        "type": str,
+    },
+}

nabu/app/composite_cor.py

@@ -5,8 +5,10 @@ import numpy as np
 import re
 
 from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
-from nabu.pipeline.estimators import CompositeCOREstimator
+from nabu.pipeline.estimators import CompositeCOREstimator, estimate_cor
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
+from nabu.resources.utils import extract_parameters
+from nxtomo.application.nxtomo import NXtomo
 from .. import version
 from .cli_configs import CompositeCorConfig
 from .utils import parse_params_values
@@ -82,6 +84,29 @@ def composite_cor_entry_point(args_dict):
 
         dataset_info = HDF5DatasetAnalyzer(nexus_name, extra_options={"h5_entry": args.entry_name})
         update_dataset_info_flats_darks(dataset_info, flatfield_mode=1)
+
+        ### JL start ###
+        # Extract CoR parameters from configuration file
+        try:
+            cor_options = extract_parameters(args.cor_options, sep=";")
+        except Exception as exc:
+            msg = "Could not extract parameters from cor_options: %s" % (str(exc))
+            raise ValueError(msg)
+        ### JL end ###
+
+        # JL start ###
+        #: next bit will be done in estimate
+        # if "near_pos" not in args.cor_options:
+        #    scan = NXtomo()
+        #    scan.load(file_path=nexus_name, data_path=args.entry_name)
+        #    estimated_near = scan.instrument.detector.estimated_cor_from_motor
+        #
+        #    cor_options = args.cor_options + f" ; near_pos = {estimated_near} "
+        #
+        # else:
+        #    cor_options = args.cor_options
+        ### JL end ###
+
         cor_finder = CompositeCOREstimator(
             dataset_info,
             oversampling=args.oversampling,
@@ -89,7 +114,7 @@ def composite_cor_entry_point(args_dict):
             n_subsampling_y=args.n_subsampling_y,
             take_log=True,
             spike_threshold=0.04,
-            cor_options=args.cor_options,
+            cor_options=cor_options,
             norm_order=1,
         )
 

nabu/app/correct_rot.py

@@ -0,0 +1,70 @@
+from .. import version
+from os import environ
+
+import argparse
+import shutil
+import os
+import sys
+import re
+import h5py
+import numpy as np
+
+
+from ..resources.logger import LoggerOrPrint
+from .utils import parse_params_values
+from .cli_configs import CorrectRotConfig
+from silx.io.dictdump import h5todict
+
+from nxtomo.application.nxtomo import NXtomo
+
+import h5py
+from nabu.utils import DictToObj
+
+
+def main(user_args=None):
+    """Applies the correction found by diag_to_rot to a nexus file"""
+
+    if user_args is None:
+        user_args = sys.argv[1:]
+
+    args = DictToObj(
+        parse_params_values(
+            CorrectRotConfig,
+            parser_description=main.__doc__,
+            program_version="nabu " + version,
+            user_args=user_args,
+        )
+    )
+
+    # now we read the results of the diag_to_rot utility, they are in the cor_file parameter
+    # of the cli
+    cor_data = DictToObj(h5todict(args.cor_file, "/"))
+
+    my_cor = cor_data.cor[0]
+    # we will take my_cor as cor at the first angular position
+    # and then we correct the x_translation at the other angles
+
+    # We now load the nexus that we wish to correct
+    nx_tomo = NXtomo().load(args.nexus_source, args.entry_name)
+
+    # The cor_file that we use for correction
+    # is providing us with the z_m that gives for each
+    # cor position found in the cor array the corresponding value of
+    # the translation along z (in meters)
+    z_translation = nx_tomo.sample.z_translation.value
+    z_translation = z_translation - z_translation[0]
+
+    # now we interpolate to find the correction
+    # for each position of the encoders
+    cors = np.interp(z_translation, cor_data.z_m, cor_data.cor)
+
+    # this is the correction
+    x_correction = nx_tomo.instrument.detector.x_pixel_size.value * (cors - my_cor)  # we are in meters here
+
+    # and we apply it to the nexus that we have loaded
+    nx_tomo.sample.x_translation = nx_tomo.sample.x_translation.value + x_correction
+
+    # finally we write it to the corrected nexus file
+    nx_tomo.save(file_path=args.nexus_target, data_path=args.entry_name, overwrite=True)
+
+    return 0

nabu/app/create_distortion_map_from_poly.py

@@ -9,7 +9,7 @@ from ..utils import DictToObj
 from ..resources.logger import Logger, LoggerOrPrint
 
 
-def horizontal_match_entry_point(user_args=None):
+def create_distortion_maps_entry_point(user_args=None):
     """This application builds  two arrays. Let us call them map_x and map_z. Both are 2D arrays with shape given by (nz, nx).
     These maps are meant to be used to generate a corrected detector image, using them to obtain  the pixel (i,j) of the corrected
     image by interpolating the raw data at position ( map_z(i,j), map_x(i,j) ).
@@ -45,26 +45,40 @@ def horizontal_match_entry_point(user_args=None):
         user_args = sys.argv[1:]
         args_dict = parse_params_values(
             CreateDistortionMapHorizontallyMatchedFromPolyConfig,
-            parser_description=horizontal_match.__doc__,
+            parser_description=create_maps_x_and_z.__doc__,
             program_version="nabu " + version,
             user_args=user_args,
         )
-    horizontal_match(args_dict)
-    # here we have been called by the cli. The return value 0 means OK
+
+    logger = Logger("create_distortion_maps", level=user_args["loglevel"], logfile="create_distortion_maps.log")
+
+    coords_source_x, coords_source_z, new_axis_pos = create_maps_x_and_z(args_dict)
+
+    with h5py.File(args_dict["target_file"], "w") as f:
+        f["coords_source_x"] = coords_source_x
+        f["coords_source_z"] = coords_source_z
+
+    if new_axis_pos is not None:
+        logger.info("New axis position at %e it was previously  %e " % (new_axis_pos, args_dict["axis_pos"]))
+
     return 0
 
 
-def horizontal_match(args_dict):
+def create_maps_x_and_z(args_dict):
     """This method is meant for those applications which wants to use the functionalities of the poly2map
     entry point through a standar python API.
     The argument arg_dict must contain the keys that you can find in cli_configs.py:
-                      CreateDistortionMapHorizontallyMatchedFromPolyConfig
+                    CreateDistortionMapHorizontallyMatchedFromPolyConfig
     Look at this files for variables and their meaning and defaults
+    Parameters::
+       args_dict : dict
+             a dictionary containing keys : center_x, center_z, nz, nx,  c2, c4, axis_pos
+    return:
+           max_x, map_z, new_rot_pos
+
     """
     args = DictToObj(args_dict)
 
-    logger = Logger("horizontal_match", level=args.loglevel, logfile="horizontal_match.log")
-
     nz, nx = args.nz, args.nx
     center_x, center_z = (args.center_x, args.center_z)
 
@@ -115,15 +129,25 @@ def horizontal_match(args_dict):
     coords_source_z = coords_z * distances_data_sources / distances_goal + center_z
     coords_source_x = coords_x * distances_data_sources / distances_goal + center_x
 
-    with h5py.File(args.target_file, "w") as f:
-        f["coords_source_x"] = coords_source_x
-        f["coords_source_z"] = coords_source_z
+    new_axis_pos = None
 
     if args.axis_pos is not None:
-        coord_axis = args.axis_pos - center_x
-        new_pos = (polynomial(coord_axis) - final_grid_shift) / final_grid_rescaling + center_x
-        logger.info("New axis position at %e it was previously  %e " % (new_pos, args.axis_pos))
-
-        return new_pos
-    else:
-        return None
+        # here we search on the central line a point new_axis_pos
+        # such  that
+        # coords_source_x[ i_central_y,  nuova_axis_pos ] == axis_pos
+        #
+        n_y, n_x = coords_source_x.shape
+        x_coordinates_central_line = coords_source_x[n_y // 2]
+
+        if np.any(np.less_equal(np.diff(x_coordinates_central_line), 0)):
+            message = """ Error in the coordinates map, the X coordinates are not monotonous on the central line """
+            raise ValueError(message)
+        i1 = np.searchsorted(x_coordinates_central_line, args.axis_pos)
+        i1 = np.clip(i1, 1, n_x - 1)
+        i0 = i1 - 1
+        val0 = x_coordinates_central_line[i0]
+        val1 = x_coordinates_central_line[i1]
+        fract = (args.axis_pos - val0) / (val1 - val0)
+        new_axis_pos = i0 * (1 - fract) + i1 * fract
+
+    return coords_source_x, coords_source_z, new_axis_pos