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

nabu/app/prepare_weights_double.py

@@ -1,17 +1,16 @@
 import h5py
 import numpy as np
 from scipy.special import erf  # pylint: disable=all
-from scipy.special import erf
 import sys
 import os
 from scipy.ndimage import gaussian_filter
-from tomoscan.esrf.scan.hdf5scan import ImageKey, HDF5TomoScan
+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():
+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.
@@ -31,50 +30,81 @@ def main():
     Then the resulting file can be used as processes file in the configuration file of nabu-helical
 
     """
-    if len(sys.argv) not in [3, 4, 5]:
+    if argv is None:
+        argv = sys.argv[1:]
+    if len(argv) not in [2, 3, 4, 5, 6]:
         message = f""" Usage:
-            {os.path.basename(sys.argv[0])}   nexus_file_name entry_name [target_file name [transition_width]]
+            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 = sys.argv[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)
 
-    entry_name = sys.argv[2]
-    process_file_name = "double.h5"
-    transition_width = 50.0
+    # 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)
 
-    if len(sys.argv) in [4, 5]:
-        process_file_name = sys.argv[3]
-        if len(sys.argv) in [5]:
-            transition_width = float(sys.argv[4])
+    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)
 
-    mappe = 0
+    beam_profile = 0
     my_flats = load_images_from_dataurl_dict(dataset_info.flats)
 
     for key, flat in my_flats.items():
-        mappe += flat
-    mappe = mappe / len(list(dataset_info.flats.keys()))
-
-    create_heli_maps(mappe, process_file_name, entry_name, transition_width)
+        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):
+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(L, m, w):
+    def compute_border_v(L, m, w):
         x = np.arange(L)
 
         d = (x - L + m).astype("f")
@@ -85,6 +115,35 @@ def create_heli_maps(profile, process_file_name, entry_name, transition_width):
 
         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"
@@ -94,9 +153,11 @@ def create_heli_maps(profile, process_file_name, entry_name, transition_width):
         if path_double in fd:
             del fd[path_double]
 
-        border = compute_border(profile.shape[1], 20, 13.33)
+        border = compute_border_h(profile.shape[1], rotation_axis_position, transition_width_horizontal)
 
-        border_v = compute_border(profile.shape[0], round(transition_width / 2), transition_width / 4)
+        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)

nabu/app/reconstruct.py

@@ -57,7 +57,7 @@ def get_log_file(arg_logfile, legacy_arg_logfile, forbidden=None):
     return logfile
 
 
-def get_reconstructor(args):
+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
@@ -78,6 +78,10 @@ def get_reconstructor(args):
     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

nabu/app/reconstruct_helical.py

@@ -13,6 +13,12 @@ def main_helical():
         "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",
@@ -89,6 +95,7 @@ def main_helical():
             "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"],
         }
     )
 

nabu/app/reduce_dark_flat.py

@@ -7,10 +7,10 @@ from nabu.app.cli_configs import ReduceDarkFlatConfig
 from .utils import parse_params_values
 from .. import version
 
-from tomoscan.framereducerbase import ReduceMethod
+from tomoscan.framereducer.method import ReduceMethod
 from tomoscan.scanbase import TomoScanBase
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
-from tomoscan.scanfactory import ScanFactory
+from tomoscan.factory import Factory
 from silx.io.url import DataUrl
 
 
@@ -153,6 +153,9 @@ def reduce_dark_flat(
 
 
 def main(argv=None):
+    """
+    Compute reduce dark(s) and flat(s) of a dataset
+    """
     if argv is None:
         argv = sys.argv[1:]
 
@@ -163,7 +166,7 @@ def main(argv=None):
         user_args=argv,
     )
 
-    scan = ScanFactory.create_scan_object(args["dataset"], entry=args["entry"])
+    scan = Factory.create_scan_object(args["dataset"], entry=args["entry"])
     exit(
         reduce_dark_flat(
             scan=scan,

nabu/app/rotate.py

@@ -6,12 +6,12 @@ from multiprocessing import cpu_count
 from multiprocessing.pool import ThreadPool
 import numpy as np
 from tomoscan.io import HDF5File
-from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan
+from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 from ..io.utils import get_first_hdf5_entry
-from ..misc.rotation import Rotation
+from ..processing.rotation import Rotation
 from ..resources.logger import Logger, LoggerOrPrint
 from ..pipeline.config_validators import optional_tuple_of_floats_validator, boolean_validator
-from ..misc.rotation_cuda import CudaRotation, __has_pycuda__
+from ..processing.rotation_cuda import CudaRotation, __has_pycuda__
 from .utils import parse_params_values
 from .cli_configs import RotateRadiosConfig
 
@@ -42,7 +42,7 @@ class HDF5ImagesStackRotation:
         if entry is None or entry == "":
             entry = get_first_hdf5_entry(input_file)
         self.entry = entry
-        self.dataset_info = HDF5TomoScan(input_file, entry=entry)
+        self.dataset_info = NXtomoScan(input_file, entry=entry)
 
     def _get_rotation(self, angle, center):
         if self.use_cuda:

nabu/app/stitching.py

@@ -31,7 +31,21 @@ def main():
 
     stitching_config = dict_to_config_obj(conf_dict)
     stitching_config.settle_inputs()
-    if stitching_config.slurm_config.partition in (None, ""):
+    if args["only_create_master_file"]:
+        # option to ease creation of the master in the following cases:
+        # * user has submitted all the job but has been quicked out of the cluster
+        # * only a few slurm job for some random version (cluster update...) and user want to retriger only those job and process the aggragation only. On those cases no need to redo it all.
+        tomo_objs = []
+        for _, sub_config in split_stitching_configuration_to_slurm_job(stitching_config, yield_configuration=True):
+            tomo_objs.append(sub_config.get_output_object().get_identifier().to_str())
+
+        post_processing = StitchingPostProcAggregation(
+            existing_objs_ids=tomo_objs,
+            stitching_config=stitching_config,
+        )
+        post_processing.process()
+
+    elif stitching_config.slurm_config.partition in (None, ""):
         # case 1: run locally
         _logger.info(f"run stitching locally with {stitching_config}")
 
@@ -60,7 +74,7 @@ def main():
         # 2.2 wait for future to be done and concatenate the result
         post_processing = StitchingPostProcAggregation(
             futures=futures,
-            stitching_config=stitching_config.to_dict(),
+            stitching_config=stitching_config,
         )
         post_processing.process()
 

nabu/app/tests/test_reduce_dark_flat.py

@@ -1,8 +1,24 @@
 import os
 import pytest
-from tomoscan.scanbase import ComputeMethod
 from nabu.app.reduce_dark_flat import reduce_dark_flat
-from nabu.conftest import hdf5_scan  # noqa F401
+
+#####
+from tomoscan.test.utils import NXtomoMockContext
+
+
+@pytest.fixture(scope="function")
+def hdf5_scan(tmp_path):
+    """simple fixture to create a scan and provide it to another function"""
+    test_dir = tmp_path / "my_hdf5_scan"
+    with NXtomoMockContext(
+        scan_path=str(test_dir),
+        n_proj=10,
+        n_ini_proj=10,
+    ) as scan:
+        yield scan
+
+
+######
 
 
 @pytest.mark.parametrize("dark_method", (None, "first", "mean"))

nabu/app/validator.py

@@ -6,7 +6,7 @@ import sys
 import os
 import h5py
 import tomoscan.validator
-from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan
+from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
 
 
@@ -15,11 +15,11 @@ def get_scans(path, entries: str):
     res = []
     if EDFTomoScan.is_tomoscan_dir(path):
         res.append(EDFTomoScan(scan=path))
-    elif HDF5TomoScan.is_tomoscan_dir(path):
+    elif NXtomoScan.is_tomoscan_dir(path):
         if entries == "__all__":
-            entries = HDF5TomoScan.get_valid_entries(path)
+            entries = NXtomoScan.get_valid_entries(path)
         for entry in entries:
-            res.append(HDF5TomoScan(path, entry))
+            res.append(NXtomoScan(path, entry))
     else:
         raise TypeError(f"{path} does not looks like a folder containing .EDF or a valid nexus file ")
     return res