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

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

@@ -1,55 +1,20 @@
-# coding: utf-8
-###########################################################################
-# Copyright (C) 2016 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################
-
-"""contain the AxisProcess
+"""contain the AxisTask class
 """
 
-__authors__ = ["C.Nemoz", "H.Payno"]
-__license__ = "MIT"
-__date__ = "19/03/2019"
+from __future__ import annotations
 
 import logging
-from typing import Optional, Union
 
-import numpy
-from nabu.estimation.cor import (
-    CenterOfRotation,
-    CenterOfRotationAdaptiveSearch,
-    CenterOfRotationGrowingWindow,
-    CenterOfRotationSlidingWindow,
-    CenterOfRotationOctaveAccurate,
-)
-from nabu.pipeline.estimators import SinoCORFinder, CORFinder
+from nabu.pipeline.estimators import estimate_cor
 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
 from tomwer.core.process.task import Task
 from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils import image, logconfig
@@ -68,19 +33,8 @@ from .params import (
 )
 from .projectiontype import ProjectionType
 
-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
@@ -89,9 +43,7 @@ pc_height = 10.0 / 100.0
 pc_width = 50.0 / 100.0
 
 
-def _absolute_pos_to_relative_with_warning(
-    absolute_pos: float, det_width: Optional[int]
-):
+def _absolute_pos_to_relative_with_warning(absolute_pos: float, det_width: int | None):
     """
     nabu returns the value as absolute. tomwer needs it as relative
     Also handle the case (unlikely) the detector width cannot be found
@@ -133,196 +85,7 @@ 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 str side: side of the cor
-    :param bool 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,
-):
-    """
-    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,
-):
-    """
-    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
-
-    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):
+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(
         "n_subsampling_y", DEFAULT_CMP_N_SUBSAMPLING_Y
@@ -339,446 +102,19 @@ def get_composite_options(scan):
     return theta, n_subsampling_y, oversampling, take_log, near_pos, near_width
 
 
-def compute_scan_cor_nabu_growing_window(scan):
-    """
-    Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
-    value.
-
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
-    """
-    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")
+def read_scan_x_rotation_axis_pixel_position(scan: TomwerScanBase):
+    """read center of rotation estimation from metadata"""
+    if isinstance(scan, EDFTomoScan):
+        raise TypeError("EDFTomoScan have not information about estimated cor position")
     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,
-):
-    """
-    Call nabu.preproc.alignement.CenterOfRotationSlidingWindow.find_shift
-
-    :param radio_1:
-    :param radio_2:
-    :param padding_mode:
-    :param str side: side of the cor
-    :param horz_fft_width:
-    :param bool 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 = 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,
-        padding_mode=padding_mode,
-        median_filt_shape=None,
-    )
-    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,
-):
-    """
-    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
-
-    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):
-    """
-    Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
-    value.
-
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
-    """
-    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):
-    """
-    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,
-    )
+        res = scan.x_rotation_axis_pixel_position
+        if res is None:
+            _logger.error(
+                f"unable to find x_rotation_axis_pixel_position from {scan.get_identifier()}"
+            )
     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(
-    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 bool 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):
-    """
-    Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
-    value.
-
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
-
-    """
-    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 bool 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,
-):
-    """
-    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
-    value.
-
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
-
-    """
-    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:
-    """
-
-    :param x:
-    :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
 
@@ -792,25 +128,8 @@ class AxisTask(
 ):
     """
     Process used to compute the center of rotation of a scan
-
-    :param axis_params: parameters to configure the axis process
-    :type: AxisRP
     """
 
-    _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,
-    }
-
     def __init__(
         self,
         process_id=None,
@@ -867,12 +186,12 @@ class AxisTask(
         In this case we will lock the axis as defined 'fixed' with the current
         value
 
-        :param bool lock: if true lock the currently existing position value
+        :param lock: if true lock the currently existing position value
         """
         self._locked = lock
         if lock:
             self._recons_params_before_lock = self._axis_params.to_dict()
-            if self._axis_params not in (AxisMode.manual, AxisMode.read):
+            if self._axis_params != AxisMode.manual:
                 self._axis_params.mode = AxisMode.manual
         else:
             if self._recons_params_before_lock:
@@ -985,13 +304,12 @@ class AxisTask(
             _logger.error(e)
 
     @staticmethod
-    def get_inputs_urls(scan):
+    def get_input_radios(scan) -> tuple:
         """Make sure we have valid projections to be used for axis calculation
 
-        :param TomwerScanBase scan: scan to check
+        :param scan: scan to check
         :raise: NoAxisUrl if fails to found
-        :return: the two projections to be used for axis calculation
-        :rtype: tuple of AxisResource
+        :return: tuple of AxisResource
         """
         if (
             scan.axis_params
@@ -999,16 +317,13 @@ class AxisTask(
             and scan.axis_params.axis_url_1.url
         ):
             return scan.axis_params.axis_url_1, scan.axis_params.axis_url_2
-        else:
-            _radio_1, _radio_2 = scan.get_opposite_projections(
-                mode=scan.axis_params.angle_mode
-            )
-        return _radio_1, _radio_2
+
+        return scan.get_opposite_projections(mode=scan.axis_params.angle_mode)
 
     @staticmethod
     def get_inputs(scan):
         assert isinstance(scan, TomwerScanBase)
-        radio_1, radio_2 = AxisTask.get_inputs_urls(scan=scan)
+        radio_1, radio_2 = AxisTask.get_input_radios(scan=scan)
         if radio_1 and radio_2:
             mess = " ".join(
                 ("input radios are", radio_1.url.path(), "and", radio_2.url.path())
@@ -1040,8 +355,8 @@ class AxisTask(
         """
         Compute the position value for the scan
 
-        :param TomwerScanBase scan:
-        :param bool wait: used for threaded process. True if we want to end the
+        :param scan:
+        :param wait: used for threaded process. True if we want to end the
                           computation before releasing hand.
         :return: scan as a TomoBase
         """
@@ -1091,14 +406,8 @@ 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 {method} for {scan_name}"
-            )
+            mess = f"Compute axis position ({r_cor_value}) with {scan.axis_params.mode.value}"
             _logger.info(mess)
         return scan
 
@@ -1108,10 +417,10 @@ class AxisTask(
         else:
             raise NotImplementedError("mode not implemented yet")
 
-    def define_calculation_mode(self, mode, fct_pointer):
+    def define_calculation_mode(self, mode: AxisMode, fct_pointer):
         """Register the function to call of the given mode
 
-        :param AxisMode mode: the mode to register
+        :param mode: the mode to register
         :param fct_pointer: pointer to the function to call
         """
         self._mode_calculation_fct[mode] = fct_pointer
@@ -1120,21 +429,31 @@ class AxisTask(
         """
 
         :param scan: scan for which we compute the center of rotation
-        :type: TomoScan
         :return: position of the rotation axis. Use the `.AxisMode` defined
-                 by the `.ReconsParams` of the `.AxisProcess`
-        :rtype: float or None (if fail to compute the axis position)
+                 by the `.ReconsParams` of the `.AxisTask`
         """
         mode = self._axis_params.mode
-        if mode in (AxisMode.manual, AxisMode.read):
+        if mode is 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 in self._CALCULATIONS_METHODS:
-            _logger.info("use radios, mode is %s" % mode.value)
-            res = self._CALCULATIONS_METHODS[mode](scan)
+        elif mode is AxisMode.read:
+            res = read_scan_x_rotation_axis_pixel_position(scan=scan)
         else:
-            raise NotImplementedError("Method for", mode, "is not defined")
+            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
+            )
+
         return res
 
     @docstring(Task.program_name)
@@ -1151,79 +470,3 @@ class AxisTask(
     @staticmethod
     def definition():
         return "Compute center of rotation"
-
-    @staticmethod
-    def get_cor_frm_process_file(
-        process_file, entry, as_url=False
-    ) -> Union[None, float]:
-        """
-        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)