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/compare_volumes.py

@@ -0,0 +1,94 @@
+from math import ceil
+from posixpath import join
+import numpy as np
+from tomoscan.io import HDF5File
+from .cli_configs import CompareVolumesConfig
+from ..utils import clip_circle
+from .utils import parse_params_values
+from ..io.utils import get_first_hdf5_entry, hdf5_entry_exists
+from ..io.reader import get_hdf5_dataset_shape
+
+
+def idx_1d_to_3d(idx, shape):
+    nz, ny, nx = shape
+    x = idx % nx
+    idx2 = (idx - x) // nx
+    y = idx2 % ny
+    z = (idx2 - y) // ny
+    return (z, y, x)
+
+
+def compare_volumes(fname1, fname2, h5_path, chunk_size, do_stats, stop_at_thresh, clip_outer_circle=False):
+    result = None
+    f1 = HDF5File(fname1, "r")
+    f2 = HDF5File(fname2, "r")
+    try:
+        # Check that data is in the provided hdf5 path
+        for fname in [fname1, fname2]:
+            if not hdf5_entry_exists(fname, h5_path):
+                result = "File %s do not has data in %s" % (fname, h5_path)
+                return
+        # Check shapes
+        shp1 = get_hdf5_dataset_shape(fname1, h5_path)
+        shp2 = get_hdf5_dataset_shape(fname2, h5_path)
+        if shp1 != shp2:
+            result = "Volumes do not have the same shape: %s vs %s" % (shp1, shp2)
+            return
+        # Compare volumes
+        n_steps = ceil(shp1[0] / chunk_size)
+        for i in range(n_steps):
+            start = i * chunk_size
+            end = min((i + 1) * chunk_size, shp1[0])
+            data1 = f1[h5_path][start:end, :, :]
+            data2 = f2[h5_path][start:end, :, :]
+            abs_diff = np.abs(data1 - data2)
+            if clip_outer_circle:
+                for j in range(abs_diff.shape[0]):
+                    abs_diff[j] = clip_circle(abs_diff[j], radius=0.9 * min(abs_diff.shape[1:]))
+            coord_argmax = idx_1d_to_3d(np.argmax(abs_diff), data1.shape)
+            if do_stats:
+                mean = np.mean(abs_diff)
+                std = np.std(abs_diff)
+                maxabs = np.max(abs_diff)
+                print("Chunk %d: mean = %e std = %e max = %e" % (i, mean, std, maxabs))
+            if stop_at_thresh is not None and abs_diff[coord_argmax] > stop_at_thresh:
+                coord_argmax_absolute = (start + coord_argmax[0],) + coord_argmax[1:]
+                result = "abs_diff[%s] = %e" % (coord_argmax_absolute, abs_diff[coord_argmax])
+                return
+    except Exception as exc:
+        result = "Error: %s" % (str(exc))
+        raise
+    finally:
+        f1.close()
+        f2.close()
+        return result
+
+
+def compare_volumes_cli():
+    args = parse_params_values(
+        CompareVolumesConfig, parser_description="A command-line utility for comparing two volumes."
+    )
+
+    fname1 = args["volume1"]
+    fname2 = args["volume2"]
+    h5_path = args["hdf5_path"]
+    if h5_path == "":
+        entry = args["entry"].strip() or None
+        if entry is None:
+            entry = get_first_hdf5_entry(fname1)
+        h5_path = join(entry, "reconstruction/results/data")
+    do_stats = bool(args["statistics"])
+    chunk_size = args["chunk_size"]
+    stop_at_thresh = args["stop_at"] or None
+    if stop_at_thresh is not None:
+        stop_at_thresh = float(stop_at_thresh)
+
+    res = compare_volumes(fname1, fname2, h5_path, chunk_size, do_stats, stop_at_thresh)
+    if res is not None:
+        print(res)
+
+    return 0
+
+
+if __name__ == "__main__":
+    compare_volumes_cli()

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/composite_cor.py

@@ -0,0 +1,144 @@
+import logging
+import os
+import sys
+import numpy as np
+import re
+
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
+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
+from ..utils import DictToObj
+import json
+
+
+class NumpyArrayEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return json.JSONEncoder.default(self, obj)
+
+
+def main(user_args=None):
+    "Application to extract with the composite cor finder the center of rotation for a scan or a series of scans"
+
+    if user_args is None:
+        user_args = sys.argv[1:]
+
+    args_dict = parse_params_values(
+        CompositeCorConfig,
+        parser_description=main.__doc__,
+        program_version="nabu " + version,
+        user_args=user_args,
+    )
+    composite_cor_entry_point(args_dict)
+    # here we have been called by the cli. The return value 0 means OK
+    return 0
+
+
+def composite_cor_entry_point(args_dict):
+    args = DictToObj(args_dict)
+
+    if len(os.path.dirname(args.filename_template)) == 0:
+        # To make sure that other utility routines can succesfully deal with path within the current directory
+        args.filename_template = os.path.join(".", args.filename_template)
+
+    args.filename_template = os.path.abspath(args.filename_template)
+    if args.first_stage is not None:
+        if args.num_of_stages is None:
+            args.num_of_stages = 1
+        # if the first_stage parameter has been given then
+        # we are using numbers to form the names of the files.
+        # The filename must containe a XX..X substring which will be replaced
+        pattern = re.compile("[X]+")
+        ps = pattern.findall(args.filename_template)
+        if len(ps) == 0:
+            message = f""" You have specified the "first_stage" parameter, with an integer.
+            Therefore the "filename_template" parameter is expected to containe a XX..X subsection
+            but none was found in the passed parameter which is {args.filename_template}
+            """
+            raise ValueError(message)
+        ls = list(map(len, ps))
+        idx = np.argmax(ls)
+
+        args.filename_template = args.filename_template.replace(ps[idx], "{i_stage:" + "0" + str(ls[idx]) + "d}")
+
+    if args.num_of_stages is None:
+        # this way it works also in the simple case where
+        # only the filename is provided together with the cor options
+        num_of_stages = 1
+        first_stage = 0
+    else:
+        num_of_stages = args.num_of_stages
+        first_stage = args.first_stage
+    cor_list = []
+    for iz in range(first_stage, first_stage + num_of_stages):
+        if args.num_of_stages is not None:
+            nexus_name = args.filename_template.format(i_stage=iz)
+        else:
+            nexus_name = args.filename_template
+
+        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,
+            theta_interval=args.theta_interval,
+            n_subsampling_y=args.n_subsampling_y,
+            take_log=True,
+            spike_threshold=0.04,
+            cor_options=cor_options,
+            norm_order=1,
+        )
+
+        cor_position = cor_finder.find_cor()
+
+        cor_list.append(cor_position)
+
+    cor_list = np.array(cor_list).T
+
+    if args.output_file is not None:
+        output_name = args.output_file
+    else:
+        output_name = os.path.splitext(args.filename_template)[0] + "_cors.txt"
+
+    if output_name.endswith(".json"):
+        with open(output_name, "w") as fp:
+            json.dump(
+                dict(rotation_axis_position=cor_list[0], rotation_axis_position_list=cor_list),
+                fp,
+                indent=4,
+                cls=NumpyArrayEncoder,
+            )
+    else:
+        np.savetxt(
+            output_name,
+            cor_list,
+        )

build/lib/build/lib/build/lib/build/lib/build/lib/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

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/create_distortion_map_from_poly.py

@@ -0,0 +1,153 @@
+from .. import version
+import numpy as np
+import h5py
+import argparse
+import sys
+from .cli_configs import CreateDistortionMapHorizontallyMatchedFromPolyConfig
+from .utils import parse_params_values
+from ..utils import DictToObj
+from ..resources.logger import Logger, LoggerOrPrint
+
+
+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) ).
+
+    This map is determined by a user given  polynomial  P(rs) in the radial variable  rs = sqrt( (z-center_z)**2 + (x-center_x)**2 ) / (nx/2)
+    where center_z and center_x give the center around which the deformation is centered.
+
+    The perfect  position (zp,xp) , that would be observed on a perfect detector, of a photon observed at pixel (z,x) of the distorted detector is:
+
+       (zp, xp) = (center_z,  center_x) +  P(rs) *  ( z - center_z  , x - center_x )
+
+    The polynomial is given by P(rs) = rs *(1 + c2 * rs**2 + c4 * rs**4)
+
+    The map is rescaled and reshifted so that a perfect match is realised at the borders of a horizontal line passing by the center. This ensures coerence
+    with the procedure of pixel size calibration which is performed moving a needle horizontally and reading the motor positions at the extreme positions.
+
+    The maps are written in the target file, creating it as hdf5 file,  in the datasets
+
+        "/coords_source_x"
+        "/coords_source_z"
+
+    The URLs of these two maps can be used for the detector correction of type "map_xz"
+    in the nabu configuration file as in this example
+
+         [dataset]
+         ...
+         detector_distortion_correction = map_xz
+         detector_distortion_correction_options = map_x="silx:./map_coordinates.h5?path=/coords_source_x" ;  map_z="silx:./map_coordinates.h5?path=/coords_source_z"
+
+    """
+
+    if user_args is None:
+        user_args = sys.argv[1:]
+        args_dict = parse_params_values(
+            CreateDistortionMapHorizontallyMatchedFromPolyConfig,
+            parser_description=create_maps_x_and_z.__doc__,
+            program_version="nabu " + version,
+            user_args=user_args,
+        )
+
+    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 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
+    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)
+
+    nz, nx = args.nz, args.nx
+    center_x, center_z = (args.center_x, args.center_z)
+
+    c4 = args.c4
+    c2 = args.c2
+
+    polynomial = np.poly1d([c4, 0, c2, 0, 1, 0.0])
+    # change of variable
+    cofv = np.poly1d([1.0 / (nx / 2), 0])
+    polynomial = nx / 2 * polynomial(cofv)
+
+    left_border = 0 - center_x
+    right_border = nx - 1 - center_x
+
+    def get_rescaling_shift(left_border, right_border, polynomial):
+        dl = polynomial(left_border)
+        dr = polynomial(right_border)
+
+        rescaling = (dr - dl) / (right_border - left_border)
+        shift = -left_border * rescaling + dl
+        return rescaling, shift
+
+    final_grid_rescaling, final_grid_shift = get_rescaling_shift(left_border, right_border, polynomial)
+
+    coords_z, coords_x = np.indices([nz, nx])
+
+    coords_z = ((coords_z - center_z) * final_grid_rescaling).astype("d")
+    coords_x = ((coords_x - center_x) * final_grid_rescaling + final_grid_shift).astype("d")
+
+    distances_goal = np.sqrt(coords_z * coords_z + coords_x * coords_x)
+
+    distances_unknown = distances_goal
+
+    pp_deriv = polynomial.deriv()
+
+    # iteratively finding the positions to interpolated at by newton method
+    for i in range(10):
+        errors = polynomial(distances_unknown) - distances_goal
+        derivative = pp_deriv(distances_unknown)
+        distances_unknown = distances_unknown - errors / derivative
+
+    distances_data_sources = distances_unknown
+
+    # avoid 0/0
+    distances_data_sources[distances_goal < 1] = 1
+    distances_goal[distances_goal < 1] = 1
+
+    coords_source_z = coords_z * distances_data_sources / distances_goal + center_z
+    coords_source_x = coords_x * distances_data_sources / distances_goal + center_x
+
+    new_axis_pos = None
+
+    if args.axis_pos is not 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