tomwer 1.3.0.dev2__py3-none-any.whl → 1.3.0rc10__py3-none-any.whl

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

@@ -38,8 +38,9 @@ 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
@@ -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 tomoscan.io import HDF5File, get_swmr_mode
 
 _logger = logging.getLogger(__name__)
 if not has_composite_cor_finder:
@@ -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,
 ):
@@ -188,7 +233,7 @@ def compute_cor_nabu_growing_window_sinogram(
 
     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=has_darks and has_flats,
@@ -321,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(
@@ -363,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,
 ):
@@ -389,7 +456,7 @@ def compute_cor_nabu_sliding_window_sinogram(
 
     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=has_darks and has_flats,
@@ -397,14 +464,6 @@ def compute_cor_nabu_sliding_window_sinogram(
         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
     )
@@ -437,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(
@@ -452,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
@@ -468,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,
@@ -497,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(
@@ -532,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
@@ -550,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:
@@ -604,6 +807,8 @@ class AxisTask(
         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__(
@@ -731,15 +936,14 @@ class AxisTask(
             entry = "entry"
             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 = {
@@ -960,7 +1164,7 @@ class AxisTask(
         :return:
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=get_swmr_mode()) 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)
@@ -971,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 HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
             axis_nodes = AxisTask._get_process_nodes(
                 root_node=h5f[entry], process=AxisTask
             )

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

@@ -1,33 +1,3 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 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.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "15/10/2019"
-
-
 import logging
 
 from silx.utils.enum import Enum as _Enum
@@ -35,6 +5,55 @@ from silx.utils.enum import Enum as _Enum
 _logger = logging.getLogger(__name__)
 
 
+class AxisModeMetadata:
+    """
+    Util class to store metadata regarding processing of a mode.
+
+    Ease processing and display
+    Maybe this function should be part of nabu ?
+    """
+
+    def __init__(
+        self,
+        lockable,
+        tooltip="",
+        computing_constrains=(),
+        allows_padding=False,
+        valid_inputs=(),
+        valid_sides=(),
+    ) -> None:
+        self._lockable = lockable
+        self._tooltip = tooltip
+        self._computing_constrains = computing_constrains
+        self._allows_padding = allows_padding
+        self._valid_inputs = valid_inputs
+        self._valid_sides = valid_sides
+
+    @property
+    def is_lockable(self) -> bool:
+        return self._lockable
+
+    @property
+    def tooltip(self) -> str:
+        return self._tooltip
+
+    @property
+    def computing_constrains(self) -> tuple:
+        return self._computing_constrains
+
+    @property
+    def allows_padding(self) -> bool:
+        return self._allows_padding
+
+    @property
+    def valid_inputs(self) -> tuple:
+        return self._valid_inputs
+
+    @property
+    def valid_sides(self) -> tuple:
+        return self._valid_sides
+
+
 class _InputType(_Enum):
     SINOGRAM = "sinogram"
     RADIOS_X2 = "2 radios"
@@ -55,6 +74,8 @@ class AxisMode(_Enum):
     sliding_window_radios = "radios-sliding-window"
     sino_coarse_to_fine = "sino-coarse-to-fine"
     composite_coarse_to_fine = "composite-coarse-to-fine"
+    sino_fourier_angles = "sino-fourier-angles"
+    octave_accurate_radios = "radios-octave-accurate"
     read = "read"
     # alias to composite_coarse_to_fine with near mode
     near = "near"
@@ -76,24 +97,114 @@ class AxisMode(_Enum):
         return super().from_value(value=value)
 
 
-_VALID_INPUTS = {
-    AxisMode.centered: (_InputType.RADIOS_X2,),
-    AxisMode.global_: (_InputType.RADIOS_X2,),
-    AxisMode.manual: (_InputType.RADIOS_X2,),
-    AxisMode.growing_window_radios: (_InputType.RADIOS_X2,),
-    AxisMode.sliding_window_radios: (_InputType.RADIOS_X2,),
-    AxisMode.sliding_window_sinogram: (_InputType.SINOGRAM,),
-    AxisMode.growing_window_sinogram: (_InputType.SINOGRAM,),
-    AxisMode.sino_coarse_to_fine: (_InputType.SINOGRAM,),
-    AxisMode.composite_coarse_to_fine: (
-        _InputType.COMPOSITE,
-    ),  # in fact it is more an n radio constrain
-    AxisMode.read: None,
-    AxisMode.near: (_InputType.COMPOSITE,),  # in fact it is more an n radio constrain
-}
-
-_AXIS_MODE_CONSTRAIN = {
-    AxisMode.sino_coarse_to_fine: (_Constrain.FULL_TURN,),
-    AxisMode.composite_coarse_to_fine: (_Constrain.FULL_TURN,),
-    AxisMode.near: (_Constrain.FULL_TURN,),
+AXIS_MODE_METADATAS = {
+    # manual
+    AxisMode.manual: AxisModeMetadata(
+        lockable=False,
+        tooltip="Enter or find manually the COR value",
+        computing_constrains=(),
+        allows_padding=False,
+        valid_inputs=(_InputType.RADIOS_X2,),
+    ),
+    # read
+    AxisMode.read: AxisModeMetadata(
+        lockable=False,
+        tooltip="Read COR value from a file",
+        computing_constrains=(),
+        allows_padding=False,
+        valid_inputs=None,
+    ),
+    # radio algorithm
+    AxisMode.centered: AxisModeMetadata(
+        lockable=True,
+        tooltip="Dedicated to fullfield. Previously named 'accurate'",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+    ),
+    AxisMode.global_: AxisModeMetadata(
+        lockable=True,
+        tooltip="Algorithm which can work for both half acquisition and standard ('full field') acquisition",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+    ),
+    AxisMode.growing_window_radios: AxisModeMetadata(
+        lockable=True,
+        tooltip="A auto-Cor method",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+        valid_sides=("left", "right", "center", "all"),
+    ),
+    AxisMode.sliding_window_radios: AxisModeMetadata(
+        lockable=True,
+        tooltip="A method for estimating semi-automatically the CoR position. You have to provide a hint on where the CoR is (left, center, right).",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
+    AxisMode.octave_accurate_radios: AxisModeMetadata(
+        lockable=True,
+        tooltip="Same method as the 'accurate' octave code",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+        valid_sides=("center",),
+    ),
+    # sinogram algorithm
+    AxisMode.growing_window_sinogram: AxisModeMetadata(
+        lockable=True,
+        tooltip="A auto-Cor method",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+        valid_sides=("left", "right", "center", "all"),
+    ),
+    AxisMode.sliding_window_sinogram: AxisModeMetadata(
+        lockable=True,
+        tooltip="A method for estimating semi-automatically the CoR position. You have to provide a hint on where the CoR is (left, center, right).",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
+    AxisMode.sino_coarse_to_fine: AxisModeMetadata(
+        lockable=True,
+        tooltip="Estimate CoR from sinogram. Only works for 360 degrees scans.",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+    ),
+    AxisMode.sino_fourier_angles: AxisModeMetadata(
+        lockable=True,
+        tooltip="",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+        valid_sides=(
+            "left",
+            "right",
+            "center",
+            "near",
+        ),
+    ),
+    # coarse-to-fine algorithm
+    AxisMode.composite_coarse_to_fine: AxisModeMetadata(
+        lockable=True,
+        tooltip="A auto-Cor method",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.COMPOSITE,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
+    AxisMode.near: AxisModeMetadata(
+        lockable=True,
+        tooltip="Alias to composite_coarse_to_fine",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.COMPOSITE,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
 }