tomwer 1.4.0__py3-none-any.whl → 1.4.0rc0__py3-none-any.whl

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

@@ -1,14 +1,23 @@
-"""contain the AxisTask class
+"""contain the AxisProcess
 """
 
 from __future__ import annotations
 
 import logging
 
-from nabu.pipeline.estimators import estimate_cor
+import numpy
+from nabu.estimation.cor import (
+    CenterOfRotation,
+    CenterOfRotationAdaptiveSearch,
+    CenterOfRotationGrowingWindow,
+    CenterOfRotationSlidingWindow,
+    CenterOfRotationOctaveAccurate,
+)
+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 tomwer.core.utils.deprecation import deprecated_warning
 
 import tomwer.version
 from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
@@ -33,8 +42,19 @@ from .params import (
 )
 from .projectiontype import ProjectionType
 
-_logger = logging.getLogger(__name__)
+try:
+    from nabu.pipeline.estimators import CompositeCOREstimator
+except ImportError:
+    has_composite_cor_finder = False
+else:
+    has_composite_cor_finder = True
+from silx.io.url import DataUrl
+from silx.io.utils import h5py_read_dataset
+from silx.io.utils import open as open_hdf5
 
+_logger = logging.getLogger(__name__)
+if not has_composite_cor_finder:
+    _logger.warning("No composite cor finder found at nabu level")
 # vertically, work on a window having only a percentage of the frame.
 pc_height = 10.0 / 100.0
 # horizontally. Global method supposes the COR is more or less in center
@@ -85,6 +105,191 @@ def adapt_tomwer_scan_to_nabu(scan: TomwerScanBase):
     return dataset_infos
 
 
+def compute_cor_nabu_growing_window(
+    radio_1: numpy.ndarray,
+    radio_2: numpy.ndarray,
+    side: str,
+    padding_mode,
+    flip_frame_2_lr=True,
+    horz_fft_width=False,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param radio_1:
+    :param radio_2:
+    :param padding_mode: padding mode
+    :param side: side of the cor
+    :param flip_frame_2_lr: if True will left-right flip the second frame
+    :param horz_fft_width:
+
+    :return:
+    """
+    nabu_class = CenterOfRotationGrowingWindow(horz_fft_width=horz_fft_width)
+    # value return is relative
+    res = nabu_class.find_shift(
+        img_1=radio_1,
+        img_2=numpy.fliplr(radio_2) if flip_frame_2_lr else radio_2,
+        side=side,
+        roi_yxhw=None,
+        padding_mode=padding_mode,
+        median_filt_shape=None,
+    )
+    if isinstance(res, numpy.ndarray):
+        if len(res) == 1:
+            return 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"
+            )
+    else:
+        return res
+
+
+def compute_cor_nabu_growing_window_radios(
+    scan: TomwerScanBase,
+) -> float | None:
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param scan: scan for which we want to get the reconstruction parameters
+    """
+    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,
+) -> float | None:
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param 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="sino-growing-window",
+        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()
+    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_scan_sino_coarse_to_fine(scan):
+    """
+    Compute center of rotation from `sino-coarse-to-fine` algorithm for given
+    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=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_composite_coarse_to_fine(scan: TomwerScanBase):
+    """
+    Compute center of rotation from `sino-coarse-to-fine` algorithm for given
+    scan
+    :param scan:
+    :return:
+    """
+    if not has_composite_cor_finder:
+        _logger.error("unable to find nabu CompositeCOREstimator")
+        return None
+
+    (
+        theta,
+        n_subsampling_y,
+        oversampling,
+        take_log,
+        near_pos,
+        near_width,
+    ) = get_composite_options(scan)
+
+    # as the new corfinder is not yet merged in the main branch
+    # allow some tolerance for the "side" argument that is there only
+    # in the new one
+
+    cor_options = scan.axis_params.get_nabu_cor_options_as_dict()
+    for key in "low_pass", "high_pass":
+        if key in cor_options:
+            cor_options[key] = int(cor_options[key])
+    corfinder = CompositeCOREstimator(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        theta_interval=theta,
+        n_subsampling_y=n_subsampling_y,
+        oversampling=oversampling,
+        cor_options=cor_options,
+        logger=_logger,
+        take_log=take_log,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def get_composite_options(scan) -> tuple:
     theta = scan.axis_params.composite_options.get("theta", DEFAULT_CMP_THETA)
     n_subsampling_y = scan.axis_params.composite_options.get(
@@ -102,6 +307,216 @@ def get_composite_options(scan) -> tuple:
     return theta, n_subsampling_y, oversampling, take_log, near_pos, near_width
 
 
+def compute_scan_cor_nabu_growing_window(scan) -> float | None:
+    """
+    Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
+    value.
+
+    :param scan: scan to process
+    """
+    if not scan.axis_params.use_sinogram:
+        radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
+        if radio_1 is None or radio_2 is None:
+            raise NoAxisUrl("Unable to find projections for nabu axis calculation")
+    else:
+        radio_1, radio_2 = None, None
+
+    _logger.info(
+        "compute scan axis from nabu CenterOfRotationGrowingWindow with padding "
+        "mode {} and side {}. Use sinogram: {}".format(
+            scan.axis_params.padding_mode,
+            scan.axis_params.side,
+            scan.axis_params.use_sinogram,
+        )
+    )
+
+    if scan.axis_params.use_sinogram:
+        return compute_cor_nabu_growing_window_sinogram(scan=scan)
+    else:
+        return compute_cor_nabu_growing_window_radios(scan=scan)
+
+
+def compute_cor_nabu_sliding_window(
+    radio_1: numpy.ndarray,
+    radio_2: numpy.ndarray,
+    side: str,
+    padding_mode,
+    flip_frame_2_lr=True,
+    horz_fft_width=False,
+) -> float | None:
+    """
+    Call nabu.preproc.alignement.CenterOfRotationSlidingWindow.find_shift
+
+    :param radio_1:
+    :param radio_2:
+    :param padding_mode:
+    :param side: side of the cor
+    :param horz_fft_width:
+    :param flip_frame_2_lr: if True will left-right flip the second frame
+    :param half_acq_cor_guess: The approximate position of the rotation axis
+                               from the image center. Optional. When given a
+                               special algorithm is used which can work also
+                               in half-tomo conditions.
+    """
+    nabu_class = CenterOfRotationSlidingWindow(horz_fft_width=horz_fft_width)
+    res = nabu_class.find_shift(
+        img_1=radio_1,
+        img_2=numpy.fliplr(radio_2) if flip_frame_2_lr else radio_2,
+        side=side,
+        roi_yxhw=None,
+        median_filt_shape=None,
+    )
+    return res
+
+
+def compute_cor_nabu_sliding_window_radios(
+    scan: TomwerScanBase,
+) -> float | None:
+    """
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase 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
+
+    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: TomwerScanBase,
+) -> float | None:
+    """
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase 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="sino-sliding-window",
+        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_cor_nabu_sliding_window(scan: TomwerScanBase) -> float | None:
+    """
+    Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
+    value.
+
+    :param scan: scan to process
+    """
+    if not scan.axis_params.use_sinogram:
+        radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
+        if radio_1 is None or radio_2 is None:
+            raise NoAxisUrl("Unable to find projections for nabu axis calculation")
+    else:
+        radio_1 = radio_2 = None
+
+    _logger.info(
+        "compute scan axis from nabu CenterOfRotationSlidingWindow with padding "
+        "mode {} and side {}. Use sinogram: {}".format(
+            scan.axis_params.padding_mode,
+            scan.axis_params.side,
+            scan.axis_params.use_sinogram,
+        )
+    )
+
+    if scan.axis_params.use_sinogram:
+        return compute_cor_nabu_sliding_window_sinogram(scan=scan)
+    else:
+        return compute_cor_nabu_sliding_window_radios(scan=scan)
+
+
+def compute_scan_fourier_angles(scan: TomwerScanBase) -> float | None:
+    """
+    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: TomwerScanBase,
+) -> float | None:
+    """
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
+
+    :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 read_scan_x_rotation_axis_pixel_position(scan: TomwerScanBase):
     """read center of rotation estimation from metadata"""
     if isinstance(scan, EDFTomoScan):
@@ -115,6 +530,214 @@ def read_scan_x_rotation_axis_pixel_position(scan: TomwerScanBase):
     return res
 
 
+def compute_scan_octave_accurate(scan: TomwerScanBase) -> float | None:
+    """
+    Compute center of rotation from `octave-accurate` algorithm
+    scan
+    """
+    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()
+    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: TomwerScanBase,
+) -> float | None:
+    """
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
+    """
+    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(
+    radio_1: numpy.ndarray,
+    radio_2: numpy.ndarray,
+    padding_mode,
+    flip_frame_2_lr=True,
+    horz_fft_width=False,
+    vert_fft_width=False,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotation.find_shift
+
+    :param radio_1:
+    :param radio_2:
+    :param padding_mode:
+    :param horz_fft_width:
+    :param flip_frame_2_lr: if True will left-right flip the second frame
+    :param half_acq_cor_guess: The approximate position of the rotation axis
+                               from the image center. Optional. When given a
+                               special algorithm is used which can work also
+                               in half-tomo conditions.
+
+    :return:
+    """
+    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,
+        roi_yxhw=None,
+        padding_mode=padding_mode,
+        median_filt_shape=None,
+    )
+
+
+def compute_scan_cor_nabu_centered(scan: TomwerScanBase) -> float | None:
+    """
+    Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
+    value.
+
+    :param scan: scan to process
+    """
+    assert scan.axis_params is not None
+    radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
+    if radio_1 is None or radio_2 is None:
+        raise NoAxisUrl("Unable to find projections for nabu axis calculation")
+
+    _logger.info(
+        "compute scan axis from nabu CenterOfRotation with padding "
+        "mode %s" % scan.axis_params.padding_mode
+    )
+
+    return compute_cor_nabu_centered_radios(scan)
+
+
+def compute_cor_nabu_global(
+    radio_1: numpy.ndarray,
+    radio_2: numpy.ndarray,
+    padding_mode,
+    flip_frame_2_lr=True,
+    horz_fft_width=False,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotation.find_shift
+
+    :param radio_1:
+    :param radio_2:
+    :param padding_mode:
+    :param horz_fft_width:
+    :param flip_frame_2_lr: if True will left-right flip the second frame
+    :return:
+    """
+    nabu_class = CenterOfRotationAdaptiveSearch(horz_fft_width=horz_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,
+        roi_yxhw=None,
+        padding_mode=padding_mode,
+        median_filt_shape=None,
+    )
+
+
+def compute_cor_nabu_global_radios(
+    scan: TomwerScanBase,
+) -> float | None:
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :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
+
+    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: TomwerScanBase) -> float | None:
+    """
+    Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
+    value.
+
+    :param scan: scan to process
+    """
+    assert scan.axis_params is not None
+    radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
+    if radio_1 is None or radio_2 is None:
+        raise NoAxisUrl("Unable to find projections for nabu axis calculation")
+
+    _logger.info(
+        "compute scan axis from nabu CenterOfRotation with padding "
+        "mode %s" % scan.axis_params.padding_mode
+    )
+    return compute_cor_nabu_global_radios(scan)
+
+
+def get_stdmax_column(x: numpy.ndarray) -> float:
+    """
+
+    :return: column index of the maximal standard deviation
+    """
+    kernel_size = 5
+    length = len(x)
+    r = range(length - kernel_size)
+    y = numpy.empty(length - kernel_size)
+    for i in r:
+        s = numpy.std(x[i : i + kernel_size])
+        y[i] = s
+
+    return y.argmax()
+
+
 class NoAxisUrl(Exception):
     pass
 
@@ -130,6 +753,21 @@ class AxisTask(
     Process used to compute the center of rotation of a scan
     """
 
+    _CALCULATIONS_METHODS = {
+        AxisMode.centered: compute_scan_cor_nabu_centered,
+        AxisMode.global_: compute_scan_cor_nabu_global,
+        AxisMode.sliding_window_sinogram: compute_scan_cor_nabu_sliding_window,
+        AxisMode.sliding_window_radios: compute_scan_cor_nabu_sliding_window,
+        AxisMode.growing_window_sinogram: compute_scan_cor_nabu_growing_window,
+        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,
+        AxisMode.read: read_scan_x_rotation_axis_pixel_position,
+    }
+
     def __init__(
         self,
         process_id=None,
@@ -304,12 +942,12 @@ class AxisTask(
             _logger.error(e)
 
     @staticmethod
-    def get_input_radios(scan) -> tuple:
+    def get_inputs_urls(scan):
         """Make sure we have valid projections to be used for axis calculation
 
         :param scan: scan to check
         :raise: NoAxisUrl if fails to found
-        :return: tuple of AxisResource
+        :return: the two projections to be used for axis calculation
         """
         if (
             scan.axis_params
@@ -317,13 +955,16 @@ class AxisTask(
             and scan.axis_params.axis_url_1.url
         ):
             return scan.axis_params.axis_url_1, scan.axis_params.axis_url_2
-
-        return scan.get_opposite_projections(mode=scan.axis_params.angle_mode)
+        else:
+            _radio_1, _radio_2 = scan.get_opposite_projections(
+                mode=scan.axis_params.angle_mode
+            )
+        return _radio_1, _radio_2
 
     @staticmethod
     def get_inputs(scan):
         assert isinstance(scan, TomwerScanBase)
-        radio_1, radio_2 = AxisTask.get_input_radios(scan=scan)
+        radio_1, radio_2 = AxisTask.get_inputs_urls(scan=scan)
         if radio_1 and radio_2:
             mess = " ".join(
                 ("input radios are", radio_1.url.path(), "and", radio_2.url.path())
@@ -406,8 +1047,14 @@ class AxisTask(
             self._axis_params.frame_width = scan.dim_1
             self._axis_params.set_relative_value(position)
             scan_name = scan.path or "undef scan"
+            if scan.axis_params.use_sinogram:
+                method = "sinogram"
+            else:
+                method = scan.axis_params.mode.value
             r_cor_value = scan.axis_params.relative_cor_value
-            mess = f"Compute axis position ({r_cor_value}) with {scan.axis_params.mode.value}"
+            mess = (
+                f"Compute axis position ({r_cor_value}) with {method} for {scan_name}"
+            )
             _logger.info(mess)
         return scan
 
@@ -430,30 +1077,18 @@ class AxisTask(
 
         :param scan: scan for which we compute the center of rotation
         :return: position of the rotation axis. Use the `.AxisMode` defined
-                 by the `.ReconsParams` of the `.AxisTask`
+                 by the `.ReconsParams` of the `.AxisProcess`
         """
         mode = self._axis_params.mode
-        if mode is AxisMode.manual:
+        if mode in (AxisMode.manual,):
             # If mode is read or manual the position_value is not computed and
             # we will keep the actual one (should have been defined previously)
             res = self._axis_params.relative_cor_value
-        elif mode is AxisMode.read:
-            res = read_scan_x_rotation_axis_pixel_position(scan=scan)
+        elif mode in self._CALCULATIONS_METHODS:
+            _logger.info("use radios, mode is %s" % mode.value)
+            res = self._CALCULATIONS_METHODS[mode](scan)
         else:
-            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
-
-            res = estimate_cor(
-                method=mode.value,
-                dataset_info=adapt_tomwer_scan_to_nabu(scan=scan),
-                do_flatfield=has_darks and has_flats,
-                cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
-            )
-            # convert back to relative
-            res = _absolute_pos_to_relative_with_warning(
-                absolute_pos=res, det_width=scan.dim_1
-            )
-
+            raise NotImplementedError("Method for", mode, "is not defined")
         return res
 
     @docstring(Task.program_name)
@@ -470,3 +1105,77 @@ class AxisTask(
     @staticmethod
     def definition():
         return "Compute center of rotation"
+
+    @staticmethod
+    def get_cor_frm_process_file(process_file, entry, as_url=False) -> float | None:
+        """
+        Read cor position from a tomwer_process file
+
+        :param process_file:
+        :param entry:
+        :return:
+        """
+        if entry is None:
+            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)
+                    return None
+                elif len(entries) > 1:
+                    raise ValueError("several entry found, entry should be " "specify")
+                else:
+                    entry = list(entries.keys())[0]
+                    _logger.info("take %s as default entry" % entry)
+
+        with open_hdf5(process_file) as h5f:
+            axis_nodes = AxisTask._get_process_nodes(
+                root_node=h5f[entry], process=AxisTask
+            )
+            index_to_path = {}
+            for key, index in axis_nodes.items():
+                index_to_path[index] = key
+
+            if len(axis_nodes) == 0:
+                return None
+            # take the last processed dark ref
+            last_process_index = sorted(list(axis_nodes.values()))[-1]
+            last_process_dark = index_to_path[last_process_index]
+            if (len(index_to_path)) > 1:
+                _logger.debug(
+                    "several processing found for dark-ref,"
+                    "take the last one: %s" % last_process_dark
+                )
+
+            res = None
+            if "results" in h5f[last_process_dark].keys():
+                results_node = h5f[last_process_dark]["results"]
+                if "center_of_rotation" in results_node.keys():
+                    if as_url:
+                        res = DataUrl(
+                            file_path=process_file,
+                            data_path="/".join((results_node, "center_of_rotation")),
+                            scheme="h5py",
+                        )
+                    else:
+                        res = h5py_read_dataset(results_node["center_of_rotation"])
+            return res
+
+
+class AxisProcess(AxisTask):
+    def __init__(
+        self,
+        process_id=None,
+        varinfo=None,
+        inputs=None,
+        node_id=None,
+        node_attrs=None,
+        execinfo=None,
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.reconstruction.axis.axis.AxisProcess",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="AxisTask",
+        )
+        super().__init__(process_id, varinfo, inputs, node_id, node_attrs, execinfo)