tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/core/process/reconstruction/axis/axis.py

@@ -38,17 +38,18 @@ from nabu.estimation.cor import (
     CenterOfRotationAdaptiveSearch,
     CenterOfRotationGrowingWindow,
     CenterOfRotationSlidingWindow,
+    CenterOfRotationOctaveAccurate,
 )
-from nabu.pipeline.estimators import SinoCORFinder
+from nabu.pipeline.estimators import SinoCORFinder, CORFinder
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
-from silx.utils.deprecation import deprecated_warning
+from tomwer.core.utils.deprecation import deprecated_warning
 
 import tomwer.version
 from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
 from tomwer.core.process.task import Task
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils import image, logconfig
@@ -75,7 +76,7 @@ else:
     has_composite_cor_finder = True
 from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
-from tomoscan.io import HDF5File
+from silx.io.utils import open as open_hdf5
 
 _logger = logging.getLogger(__name__)
 if not has_composite_cor_finder:
@@ -108,7 +109,7 @@ def adapt_tomwer_scan_to_nabu(scan: TomwerScanBase):
     updating infos regarding flat and dark if needed
     """
     dataset_infos = scan.to_nabu_dataset_analyser()
-    if isinstance(scan, HDF5TomoScan):
+    if isinstance(scan, NXtomoScan):
         try:
             update_dataset_info_flats_darks(
                 dataset_infos,
@@ -173,6 +174,50 @@ def compute_cor_nabu_growing_window(
         return res
 
 
+def compute_cor_nabu_growing_window_radios(
+    scan: TomwerScanBase,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="growing-window",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()  # Returns absolute cor
+    if isinstance(res, numpy.ndarray):
+        if len(res) == 1:
+            res = res[0]
+        else:
+            raise ValueError(
+                "nabu rsult is expected to be a scalar, numpy array found. Please upgrade nabu this issue is expected to be solved"
+            )
+
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_cor_nabu_growing_window_sinogram(
     scan: TomwerScanBase,
 ):
@@ -183,12 +228,15 @@ def compute_cor_nabu_growing_window_sinogram(
 
     :return:
     """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
     corfinder = SinoCORFinder(
         dataset_info=adapt_tomwer_scan_to_nabu(scan),
-        method="growing-window",
+        method="sino-growing-window",
         slice_idx=scan.axis_params.sinogram_line or "middle",
         subsampling=scan.axis_params.sinogram_subsampling,
-        do_flatfield=True,
+        do_flatfield=has_darks and has_flats,
         cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
     )
@@ -213,12 +261,15 @@ def compute_scan_sino_coarse_to_fine(scan):
     :param scan:
     :return:
     """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
     corfinder = SinoCORFinder(
         dataset_info=adapt_tomwer_scan_to_nabu(scan),
         method=AxisMode.sino_coarse_to_fine.value,
         slice_idx=scan.axis_params.sinogram_line or "middle",
         subsampling=scan.axis_params.sinogram_subsampling,
-        do_flatfield=True,
+        do_flatfield=has_darks and has_flats,
         cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
     )
@@ -252,8 +303,6 @@ def compute_scan_composite_coarse_to_fine(scan: TomwerScanBase):
     # allow some tolerance for the "side" argument that is there only
     # in the new one
 
-    extra_args = {}
-
     cor_options = scan.axis_params.get_nabu_cor_options_as_dict()
     for key in "low_pass", "high_pass":
         if key in cor_options:
@@ -266,7 +315,6 @@ def compute_scan_composite_coarse_to_fine(scan: TomwerScanBase):
         cor_options=cor_options,
         logger=_logger,
         take_log=take_log,
-        **extra_args,
     )
     res = corfinder.find_cor()
     return _absolute_pos_to_relative_with_warning(
@@ -318,13 +366,7 @@ def compute_scan_cor_nabu_growing_window(scan):
     if scan.axis_params.use_sinogram:
         return compute_cor_nabu_growing_window_sinogram(scan=scan)
     else:
-        return compute_cor_nabu_growing_window(
-            radio_1=radio_1.copy(),
-            radio_2=radio_2.copy(),
-            side=scan.axis_params.side,
-            padding_mode=scan.axis_params.padding_mode,
-            flip_frame_2_lr=scan.axis_params.flip_lr,
-        )
+        return compute_cor_nabu_growing_window_radios(scan=scan)
 
 
 def compute_cor_nabu_sliding_window(
@@ -360,17 +402,45 @@ def compute_cor_nabu_sliding_window(
         padding_mode=padding_mode,
         median_filt_shape=None,
     )
-    # now fixed but on some version nabu could return a numpy array instead of float
-    if isinstance(res, numpy.ndarray):
-        if len(res) == 1:
-            res = res[0]
-        else:
-            raise ValueError(
-                "nabu result is expected to be a scalar, numpy array found. Please upgrade nabu this issue is expected to be solved"
-            )
     return res
 
 
+def compute_cor_nabu_sliding_window_radios(
+    scan,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="sliding-window",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()  # Returns absolute cor.
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_cor_nabu_sliding_window_sinogram(
     scan,
 ):
@@ -381,24 +451,19 @@ def compute_cor_nabu_sliding_window_sinogram(
 
     :return:
     """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
     corfinder = SinoCORFinder(
         dataset_info=adapt_tomwer_scan_to_nabu(scan),
-        method="sliding-window",
+        method="sino-sliding-window",
         slice_idx=scan.axis_params.sinogram_line or "middle",
         subsampling=scan.axis_params.sinogram_subsampling,
-        do_flatfield=True,
+        do_flatfield=has_darks and has_flats,
         cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
     )
     res = corfinder.find_cor()
-    # now fixed but on some version nabu could return a numpy array instead of float
-    if isinstance(res, numpy.ndarray):
-        if len(res) == 1:
-            res = res[0]
-        else:
-            raise ValueError(
-                "nabu result is expected to be a scalar, numpy array found. Please upgrade nabu this issue is expected to be solved"
-            )
     return _absolute_pos_to_relative_with_warning(
         absolute_pos=res, det_width=scan.dim_1
     )
@@ -431,13 +496,129 @@ def compute_scan_cor_nabu_sliding_window(scan):
     if scan.axis_params.use_sinogram:
         return compute_cor_nabu_sliding_window_sinogram(scan=scan)
     else:
-        return compute_cor_nabu_sliding_window(
-            radio_1=radio_1.copy(),
-            radio_2=radio_2.copy(),
-            side=scan.axis_params.side,
-            padding_mode=scan.axis_params.padding_mode,
-            flip_frame_2_lr=scan.axis_params.flip_lr,
-        )
+        return compute_cor_nabu_sliding_window_radios(scan=scan)
+
+
+def compute_scan_fourier_angles(scan):
+    """
+    run 'scan_fourier_angles' algorithm for the requested scan
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    corfinder = SinoCORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="fourier-angles",
+        slice_idx=scan.axis_params.sinogram_line or "middle",
+        subsampling=scan.axis_params.sinogram_subsampling,
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        logger=_logger,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
+def compute_scan_octave_accurate_radios(
+    scan,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="octave-accurate",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
+def compute_scan_octave_accurate(scan):
+    """
+    Compute center of rotation from `octave-accurate` algorithm
+    scan
+    :param scan:
+    :return:
+    """
+    cor_options = scan.axis_params.get_nabu_cor_options_as_dict()
+    radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
+    extra_options = {}
+    for key in "low_pass", "high_pass":
+        if key in cor_options:
+            extra_options[key] = float(cor_options[key])
+
+    corfinder = CenterOfRotationOctaveAccurate(cor_options=cor_options)
+    res = corfinder.find_shift(
+        img_1=radio_1,
+        img_2=numpy.fliplr(radio_2) if scan.axis_params.flip_lr else radio_2,
+        side=scan.axis_params.side,
+        padding_mode=scan.axis_params.padding_mode,
+        **extra_options,
+    )
+    return res
+
+
+def compute_cor_nabu_centered_radios(
+    scan,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="centered",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
 
 
 def compute_cor_nabu_centered(
@@ -446,6 +627,7 @@ def compute_cor_nabu_centered(
     padding_mode,
     flip_frame_2_lr=True,
     horz_fft_width=False,
+    vert_fft_width=False,
 ):
     """
     Call nabu.preproc.alignement.CenterOfRotation.find_shift
@@ -462,7 +644,9 @@ def compute_cor_nabu_centered(
 
     :return:
     """
-    nabu_class = CenterOfRotation(horz_fft_width=horz_fft_width)
+    nabu_class = CenterOfRotation(
+        horz_fft_width=horz_fft_width, vert_fft_width=vert_fft_width
+    )
     return nabu_class.find_shift(
         img_1=radio_1,
         img_2=numpy.fliplr(radio_2) if flip_frame_2_lr else radio_2,
@@ -491,12 +675,7 @@ def compute_scan_cor_nabu_centered(scan):
         "mode %s" % scan.axis_params.padding_mode
     )
 
-    return compute_cor_nabu_centered(
-        radio_1=radio_1.copy(),
-        radio_2=radio_2.copy(),
-        padding_mode=scan.axis_params.padding_mode,
-        flip_frame_2_lr=scan.axis_params.flip_lr,
-    )
+    return compute_cor_nabu_centered_radios(scan)
 
 
 def compute_cor_nabu_global(
@@ -526,6 +705,42 @@ def compute_cor_nabu_global(
     )
 
 
+def compute_cor_nabu_global_radios(
+    scan: TomwerScanBase,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="global",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_scan_cor_nabu_global(scan):
     """
     Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
@@ -544,13 +759,7 @@ def compute_scan_cor_nabu_global(scan):
         "compute scan axis from nabu CenterOfRotation with padding "
         "mode %s" % scan.axis_params.padding_mode
     )
-
-    return compute_cor_nabu_global(
-        radio_1=radio_1.copy(),
-        radio_2=radio_2.copy(),
-        padding_mode=scan.axis_params.padding_mode,
-        flip_frame_2_lr=scan.axis_params.flip_lr,
-    )
+    return compute_cor_nabu_global_radios(scan)
 
 
 def get_stdmax_column(x: numpy.ndarray) -> float:
@@ -597,6 +806,9 @@ class AxisTask(
         AxisMode.growing_window_radios: compute_scan_cor_nabu_growing_window,
         AxisMode.sino_coarse_to_fine: compute_scan_sino_coarse_to_fine,
         AxisMode.composite_coarse_to_fine: compute_scan_composite_coarse_to_fine,
+        AxisMode.near: compute_scan_composite_coarse_to_fine,
+        AxisMode.sino_fourier_angles: compute_scan_fourier_angles,
+        AxisMode.octave_accurate_radios: compute_scan_octave_accurate,
     }
 
     def __init__(
@@ -722,17 +934,16 @@ class AxisTask(
         assert isinstance(scan, TomwerScanBase)
         if scan.process_file is not None:
             entry = "entry"
-            if isinstance(scan, HDF5TomoScan):
+            if isinstance(scan, NXtomoScan):
                 entry = scan.entry
-            with scan.acquire_process_file_lock():
-                self.register_process(
-                    process_file=scan.process_file,
-                    entry=entry,
-                    results={"center_of_rotation": cor if cor is not None else "-"},
-                    configuration=self._axis_params.to_dict(),
-                    process_index=scan.pop_process_index(),
-                    overwrite=True,
-                )
+            self.register_process(
+                process_file=scan.process_file,
+                entry=entry,
+                results={"center_of_rotation": cor if cor is not None else "-"},
+                configuration=self._axis_params.to_dict(),
+                process_index=scan.pop_process_index(),
+                overwrite=True,
+            )
 
         try:
             extra = {
@@ -953,7 +1164,7 @@ class AxisTask(
         :return:
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = AxisTask._get_process_nodes(root_node=h5f, process=AxisTask)
                 if len(entries) == 0:
                     _logger.info("unable to find a Axis process in %s" % process_file)
@@ -964,7 +1175,7 @@ class AxisTask(
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with open_hdf5(process_file) as h5f:
             axis_nodes = AxisTask._get_process_nodes(
                 root_node=h5f[entry], process=AxisTask
             )