tomwer 1.4.0rc0__tar.gz → 1.4.0rc2__tar.gz

{tomwer-1.4.0rc0/src/tomwer.egg-info → tomwer-1.4.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tomwer
-Version: 1.4.0rc0
+Version: 1.4.0rc2
 Summary: "tomography workflow tools"
 Home-page: https://gitlab.esrf.fr/tomotools/tomwer
 Author: Henri Payno, Pierre Paleo, Pierre-Olivier Autran, Jérôme Lesaint, Alessandro Mirone
@@ -28,7 +28,7 @@ Requires-Dist: silx[full]>=2.0
 Requires-Dist: tomoscan>=2.1.0a18
 Requires-Dist: nxtomo>=1.3.0dev4
 Requires-Dist: nxtomomill>=1.1.0a0
-Requires-Dist: processview>=1.3
+Requires-Dist: processview>=1.4.3
 Requires-Dist: ewoks>=0.1.1
 Requires-Dist: sluurp>=0.4.0
 Requires-Dist: packaging

{tomwer-1.4.0rc0 → tomwer-1.4.0rc2}/setup.cfg

@@ -37,7 +37,7 @@ install_requires =
 	tomoscan>=2.1.0a18
 	nxtomo>=1.3.0dev4
 	nxtomomill>=1.1.0a0
-	processview>=1.3
+	processview>=1.4.3
 	ewoks>=0.1.1
 	sluurp>=0.4.0
 	packaging

tomwer-1.4.0rc2/src/orangecontrib/tomwer/tutorials/test_cor.ows

@@ -0,0 +1,19 @@
+<?xml version='1.0' encoding='utf-8'?>
+<scheme version="2.0" title="" description="">
+	<nodes>
+		<node id="0" name="center of rotation finder" qualified_name="orangecontrib.tomwer.widgets.reconstruction.AxisOW.AxisOW" project_name="tomwer" version="" title="center of rotation finder" position="(375.0, 146.0)" />
+		<node id="1" name="scan selector" qualified_name="orangecontrib.tomwer.widgets.control.DataSelectorOW.DataSelectorOW" project_name="tomwer" version="" title="scan selector" position="(150.0, 115.0)" />
+	</nodes>
+	<links>
+		<link id="0" source_node_id="1" sink_node_id="0" source_channel="data" sink_channel="data" enabled="true" source_channel_id="data" sink_channel_id="data" />
+	</links>
+	<annotations />
+	<thumbnail />
+	<node_properties>
+		<properties node_id="0" format="literal">{'_ewoks_default_inputs': {'data': None, 'axis_params': {'MODE': 'sino-coarse-to-fine', 'POSITION_VALUE': None, 'CALC_INPUT_TYPE': 'transmission_nopag', 'ANGLE_MODE': '0-180', 'SINOGRAM_LINE': 'middle', 'SINOGRAM_SUBSAMPLING': 10, 'AXIS_URL_1': '', 'AXIS_URL_2': '', 'LOOK_AT_STDMAX': False, 'NEAR_WX': 5, 'FINE_STEP_X': 0.1, 'SCALE_IMG2_TO_IMG1': False, 'NEAR_POSITION': 'right', 'PADDING_MODE': 'edge', 'FLIP_LR': True, 'COMPOSITE_OPTS': {'theta': 5, 'oversampling': 4, 'n_subsampling_y': 40, 'take_log': True, 'near_width': 40}, 'COR_OPTIONS': '', 'MOTOR_OFFSET': 0.0, 'X_ROTATION_AXIS_PIXEL_POSITION': 0.0}, 'gui': {'mode_is_lock': False, 'value_is_lock': False, 'auto_update_estimated_cor': True, 'y_axis_inverted': True}}, 'controlAreaVisible': True, 'savedWidgetGeometry': b'\x01\xd9\xd0\xcb\x00\x03\x00\x00\x00\x00\x017\x00\x00\x00\xe5\x00\x00\x06H\x00\x00\x03\xa6\x00\x00\x017\x00\x00\x01\n\x00\x00\x06H\x00\x00\x03\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x07\x80\x00\x00\x017\x00\x00\x01\n\x00\x00\x06H\x00\x00\x03\xa6', '__version__': 1}</properties>
+		<properties node_id="1" format="literal">{'_scanIDs': ['hdf5:scan:/home/payno/Datasets/tomography/bamboo_hercules/bambou_hercules_0001/bambou_hercules_0001_0000.nx?path=/entry0000'], 'controlAreaVisible': True, 'savedWidgetGeometry': b'\x01\xd9\xd0\xcb\x00\x03\x00\x00\x00\x00\n\xa0\x00\x00\x01Z\x00\x00\x0b\xcb\x00\x00\x03\x06\x00\x00\n\xa0\x00\x00\x01Z\x00\x00\x0b\xcb\x00\x00\x03\x06\x00\x00\x00\x01\x00\x00\x00\x00\x07\x80\x00\x00\n\xa0\x00\x00\x01Z\x00\x00\x0b\xcb\x00\x00\x03\x06', '__version__': 1}</properties>
+	</node_properties>
+	<session_state>
+		<window_groups />
+	</session_state>
+</scheme>

{tomwer-1.4.0rc0 → tomwer-1.4.0rc2}/src/orangecontrib/tomwer/widgets/reconstruction/AxisOW.py

@@ -141,16 +141,6 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
 
         self._layout.addWidget(self._widget)
 
-        # expose API
-        self.setMode = self._widget.setMode
-        self.getMode = self._widget.getMode
-        self.getEstimatedCor = self._widget.getEstimatedCor
-        self.setEstimatedCor = self._widget.setEstimatedCor
-        self.getAxisParams = self._widget.getAxisParams
-        self.setValueLock = self._widget.setValueLock
-        self._setModeLockFrmSettings = self._widget._setModeLockFrmSettings
-        self._setValueLockFrmSettings = self._widget._setValueLockFrmSettings
-
         # load settings
         try:
             if "mode_is_lock" in gui_settings:
@@ -170,6 +160,7 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
                 "auto_update_estimated_cor", True
             )
             self._widget.setAutoUpdateEstimatedCor(auto_update_estimated_cor)
+            self._widget.setYAxisInverted(gui_settings.get("y_axis_inverted", False))
 
         except Exception as e:
             logger.warning(f"Fail to load settings. Error is {str(e)}")
@@ -184,11 +175,14 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
         self._processingStack.sigComputationEnded.connect(self._scanProcessed)
 
         self._axis_params.sigChanged.connect(self._updateSettingsVals)
+        self._widget._axisWidget._settingsWidget._mainWidget._calculationWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
+            self._updateSettingsVals
+        )
         self._widget.sigAxisEditionLocked.connect(self._updateSettingsVals)
         self._widget.sigModeChanged.connect(self._updateSettingsVals)
         self._widget.sigLockModeChanged.connect(self._updateSettingsVals)
 
-        self._widget._axisWidget._settingsWidget._mainWidget._calculationWidget._nearValueCB.toggled.connect(
+        self._widget._axisWidget._settingsWidget._mainWidget._calculationWidget._estimatedCorWidget.sigValueChanged.connect(
             self._updateSettingsVals
         )
 
@@ -353,6 +347,7 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
                 "mode_is_lock": self.isModeLocked(),
                 "value_is_lock": self.isValueLock(),
                 "auto_update_estimated_cor": self._widget.getAutoUpdateEstimatedCor(),
+                "y_axis_inverted": self._widget.isYAxisInverted(),
             },
         }
 
@@ -458,9 +453,6 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
                         "serialize_output_data": False,
                     }
                 )
-                for patch in self._patches:
-                    mode, function = patch
-                    processing_class._CALCULATIONS_METHODS[mode] = function
                 processing_class.run()
             self._updatePosition(scan=self.__scan)
             if self.isModeLocked() or self.isValueLock():

{tomwer-1.4.0rc0 → tomwer-1.4.0rc2}/src/orangecontrib/tomwer/widgets/reconstruction/NabuVolumeOW.py

@@ -312,8 +312,10 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
                     )
                     drac_processed_datasets.append(icatReconstructedDataset)
 
-        if len(drac_processed_datasets) > 0:
-            self.Outputs.data_portal_processed_datasets.send(drac_processed_datasets)
+            if len(drac_processed_datasets) > 0:
+                self.Outputs.data_portal_processed_datasets.send(
+                    drac_processed_datasets
+                )
 
         if future_tomo_obj is not None:
             self.Outputs.future_out.send(future_tomo_obj)

{tomwer-1.4.0rc0 → tomwer-1.4.0rc2}/src/tomwer/app/axis.py

@@ -169,9 +169,6 @@ def main(argv):
         _logger.setLevel(logging.DEBUG)
 
     axis_params = QAxisRP()
-    axis_params.use_sinogram = options.use_sinogram
-    if scan.dim_2 is not None:
-        axis_params.sinogram_line = scan.dim_2 // 2
 
     window = _AxisProcessGUI(scan=scan, axis_params=axis_params)
     window.setWindowTitle("axis")

{tomwer-1.4.0rc0 → tomwer-1.4.0rc2}/src/tomwer/app/multipag.py

@@ -23,6 +23,10 @@ from tomwer.core.process.reconstruction.darkref.darkrefs import (
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
     SADeltaBetaTask,
 )
+from tomwer.core.process.reconstruction.utils.cor import (
+    relative_pos_to_absolute,
+    absolute_pos_to_relative,
+)
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.resource import increase_max_number_file
@@ -136,13 +140,17 @@ class SADeltaBetaWindow(_SADeltaBetaWindow):
 
     def _relativeValueEdited(self):
         old = self._absoluteCORValueQLE.blockSignals(True)
-        value = self._relativeCORValueQLE.value() + (self._imageWidth - 1) / 2.0
+        value = relative_pos_to_absolute(
+            relative_pos=self._relativeCORValueQLE.value(), det_width=self._imageWidth
+        )
         self._absoluteCORValueQLE.setValue(value)
         self._absoluteCORValueQLE.blockSignals(old)
 
-    def _absolueValueEdited(self):
+    def _absoluteValueEdited(self):
         old = self._relativeCORValueQLE.blockSignals(True)
-        value = self._absoluteCORValueQLE.value() - (self._imageWidth - 1) / 2.0
+        value = absolute_pos_to_relative(
+            absolute_pos=self._absoluteCORValueQLE.value(), det_width=self._imageWidth
+        )
         self._relativeCORValueQLE.setValue(value)
         self._relativeCORValueQLE.blockSignals(old)
 

tomwer-1.4.0rc2/src/tomwer/core/process/reconstruction/axis/axis.py

@@ -0,0 +1,472 @@
+"""contain the AxisTask class
+"""
+
+from __future__ import annotations
+
+import logging
+
+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
+
+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
+from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.utils import docstring
+
+from .mode import AxisMode
+from .params import (
+    DEFAULT_CMP_N_SUBSAMPLING_Y,
+    DEFAULT_CMP_NEAR_POS,
+    DEFAULT_CMP_NEAR_WIDTH,
+    DEFAULT_CMP_OVERSAMPLING,
+    DEFAULT_CMP_TAKE_LOG,
+    DEFAULT_CMP_THETA,
+    AxisRP,
+)
+from .projectiontype import ProjectionType
+
+_logger = logging.getLogger(__name__)
+
+# 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
+# % of the detector:
+
+pc_width = 50.0 / 100.0
+
+
+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
+    """
+    if det_width is None:
+        det_width = 2048
+        _logger.warning("unable to find image width. Set width to 2048")
+    else:
+        det_width = det_width
+    return absolute_pos_to_relative(absolute_pos=absolute_pos, det_width=det_width)
+
+
+def adapt_tomwer_scan_to_nabu(scan: TomwerScanBase):
+    """simple util to convert tomwer scan to a nabu DataAnalizer and
+    updating infos regarding flat and dark if needed
+    """
+    dataset_infos = scan.to_nabu_dataset_analyser()
+    if isinstance(scan, NXtomoScan):
+        try:
+            update_dataset_info_flats_darks(
+                dataset_infos,
+                flatfield_mode=None,
+            )
+        except ValueError as exception:
+            # nabu raise an error if no darks / flats set. But this can make sense at this stage if the NXtomo has no
+            # raw dark / flat and is already normalized. In this case only fire a warning
+            if (
+                scan.reduced_darks is not None
+                and len(scan.reduced_darks) > 0
+                and scan.reduced_flats is not None
+                and len(scan.reduced_flats) > 0
+            ):
+                raise exception
+            else:
+                _logger.warning(
+                    "Fail to update nabu dataset info flats and darks. Expected if the dataset contains already normalized projections"
+                )
+
+    return dataset_infos
+
+
+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
+    )
+    oversampling = scan.axis_params.composite_options.get(
+        "oversampling", DEFAULT_CMP_OVERSAMPLING
+    )
+    take_log = scan.axis_params.composite_options.get("take_log", DEFAULT_CMP_TAKE_LOG)
+
+    near_pos = scan.axis_params.composite_options.get("near_pos", DEFAULT_CMP_NEAR_POS)
+    near_width = scan.axis_params.composite_options.get(
+        "near_width", DEFAULT_CMP_NEAR_WIDTH
+    )
+    return theta, n_subsampling_y, oversampling, take_log, near_pos, near_width
+
+
+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:
+        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
+
+
+class NoAxisUrl(Exception):
+    pass
+
+
+class AxisTask(
+    Task,
+    SuperviseProcess,
+    input_names=("data",),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data",),
+):
+    """
+    Process used to compute the center of rotation of a scan
+    """
+
+    def __init__(
+        self,
+        process_id=None,
+        varinfo=None,
+        inputs=None,
+        node_id=None,
+        node_attrs=None,
+        execinfo=None,
+    ):
+        Task.__init__(
+            self,
+            varinfo=varinfo,
+            inputs=inputs,
+            node_id=node_id,
+            node_attrs=node_attrs,
+            execinfo=execinfo,
+        )
+        if "recons_params" in inputs:
+            raise KeyError("do not use 'recons_params' but use 'axis_params' instead")
+        axis_params = inputs.get("axis_params", None)
+        if isinstance(axis_params, dict):
+            axis_params = AxisRP.from_dict(axis_params)
+        elif not (axis_params is None or isinstance(axis_params, AxisRP)):
+            raise TypeError(
+                "'axis_params' is expected to be None or an instance of AxisRP or a dict"
+            )
+
+        SuperviseProcess.__init__(self, process_id=process_id)
+        self._mode_calculation_fct = {}
+        """dict with function pointer to call for making the mode calculation.
+        Function should have only one 'scan' parameter as input"""
+
+        self._axis_params = axis_params or AxisRP()
+        """Axis reconstruction parameters to apply"""
+        self._locked = False
+        """Boolean used to lock reconstruction parameters edition"""
+        self._recons_params_before_lock = None
+        """Recons parameters register before locking the position"""
+
+    def set_configuration(self, configuration):
+        if "_rpSetting" in configuration:
+            recons_params = AxisRP.from_dict(configuration["_rpSetting"])
+        else:
+            recons_params = AxisRP.from_dict(configuration)
+        self.set_recons_params(recons_params=recons_params)
+
+    def set_recons_params(self, recons_params):
+        assert isinstance(recons_params, AxisRP)
+        self._axis_params = recons_params
+
+    def lock_position_value(self, lock=True):
+        """
+        lock the position currently computed or defined by the user.
+        In this case we will lock the axis as defined 'fixed' with the current
+        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 != AxisMode.manual:
+                self._axis_params.mode = AxisMode.manual
+        else:
+            if self._recons_params_before_lock:
+                self._axis_params.load_from_dict(
+                    self._recons_params_before_lock
+                )  # noqa
+
+    def run(self):
+        """
+        Compute the position value then get ready to the next. And call
+
+        .. note:: this simply call `compute`.
+                  But this is needed for the AxisProcessThreaded class
+        """
+        scan = data_identifier_to_scan(self.inputs.data)
+        if scan is None:
+            self.outputs.data = None
+            return
+
+        if isinstance(scan, TomwerScanBase):
+            scan = scan
+        elif isinstance(scan, dict):
+            scan = ScanFactory.create_scan_object_frm_dict(scan)
+        else:
+            raise ValueError(f"input type {scan} is not managed")
+
+        _logger.info("start axis calculation for %s" % scan.path)
+        self._axis_params.frame_width = scan.dim_1
+        cor = error = None
+        try:
+            scan_res = self.compute(scan=scan)
+        except Exception as e:
+            scan_res = None
+            error = e
+        else:
+            if isinstance(scan_res, TomwerScanBase):
+                cor = scan_res.axis_params.relative_cor_value
+            elif scan_res is None:
+                if scan.axis_params.relative_cor_value is not None:
+                    cor = scan.axis_params.relative_cor_value
+            elif isinstance(scan_res, float):
+                cor = scan_res
+            else:
+                assert isinstance(scan_res, dict)
+                b_dict = scan_res
+                if TomwerScanBase._DICT_AXIS_KEYS in scan_res:
+                    b_dict = scan_res["axis_params"]
+                cor = b_dict["POSITION_VALUE"]
+        finally:
+            if cor != "...":
+                self._process_end(scan, cor=cor, error=error)
+
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan_res.to_dict()
+        else:
+            self.outputs.data = scan_res
+
+    def _process_end(self, scan, cor, error=None):
+        assert isinstance(scan, TomwerScanBase)
+        if scan.process_file is not None:
+            entry = "entry"
+            if isinstance(scan, NXtomoScan):
+                entry = scan.entry
+            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 = {
+                logconfig.DOC_TITLE: self._scheme_title,
+                logconfig.SCAN_ID: scan.path,
+            }
+            if error is not None:
+                info = " ".join(
+                    (
+                        "fail to compute axis position for scan",
+                        str(scan.path),
+                        "reason is ",
+                        str(error),
+                    )
+                )
+                _logger.processFailed(info, extra=extra)
+                ProcessManager().notify_dataset_state(
+                    dataset=scan, process=self, state=DatasetState.FAILED, details=info
+                )
+            elif scan.axis_params.relative_cor_value is None:
+                info = " ".join(
+                    ("fail to compute axis position for scan", str(scan.path))
+                )
+                _logger.processFailed(info, extra=extra)
+                ProcessManager().notify_dataset_state(
+                    dataset=scan, process=self, state=DatasetState.FAILED, details=info
+                )
+            else:
+                info = "axis calculation defined for {}: {} (using {})".format(
+                    str(scan.path),
+                    str(scan.axis_params.relative_cor_value),
+                    scan.axis_params.mode.value,
+                )
+                _logger.processSucceed(info, extra=extra)
+                ProcessManager().notify_dataset_state(
+                    dataset=scan, process=self, state=DatasetState.SUCCEED, details=info
+                )
+        except Exception as e:
+            _logger.error(e)
+
+    @staticmethod
+    def get_input_radios(scan) -> tuple:
+        """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
+        """
+        if (
+            scan.axis_params
+            and scan.axis_params.axis_url_1
+            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)
+
+    @staticmethod
+    def get_inputs(scan):
+        assert isinstance(scan, TomwerScanBase)
+        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())
+            )
+            _logger.info(mess)
+            log_ = scan.axis_params.projection_type is ProjectionType.transmission
+
+            # if necessary normalize data
+            if radio_1.normalized_data is None:
+                radio_1.normalize_data(scan, log_=log_)
+            if radio_2.normalized_data is None:
+                radio_2.normalize_data(scan, log_=log_)
+
+            if scan.axis_params.paganin_preproc:
+                data_1 = radio_1.normalized_data_paganin
+                data_2 = radio_2.normalized_data_paganin
+            else:
+                data_1 = radio_1.normalized_data
+                data_2 = radio_2.normalized_data
+
+            if scan.axis_params.scale_img2_to_img1:
+                data_2 = image.scale_img2_to_img1(img_1=data_1, img_2=data_2)
+            return data_1, data_2
+        else:
+            _logger.info("fail to find any inputs")
+            return None, None
+
+    def compute(self, scan, wait=True):
+        """
+        Compute the position value for the scan
+
+        :param scan:
+        :param wait: used for threaded process. True if we want to end the
+                          computation before releasing hand.
+        :return: scan as a TomoBase
+        """
+        assert scan is not None
+        if isinstance(scan, dict):
+            _logger.warning("convert scan from a dict")
+            _scan = ScanFactory.create_scan_object_frm_dict(scan)
+        else:
+            _scan = scan
+        assert isinstance(_scan, TomwerScanBase)
+        # if the scan has no tomo reconstruction parameters yet create them
+        if _scan.axis_params is None:
+            _scan.axis_params = AxisRP()
+
+        # copy axis recons parameters. We skip the axis_url which are specific
+        # to the scan
+        _scan.axis_params.copy(
+            self._axis_params, copy_axis_url=False, copy_flip_lr=False
+        )
+        assert scan.axis_params is not None
+        return self._process_computation(scan=_scan)
+
+    def scan_ready(self, scan):
+        _logger.info(scan, "processed")
+
+    def _process_computation(self, scan):
+        """
+
+        :param TomwerScanBase scan: scan for which we want to compute the axis
+                              position.
+        :return: scan as a TomoBase or a dict if serialize_output_data activated
+        """
+        _logger.info("compute center of rotation for %s" % scan.path)
+        try:
+            position = self.compute_axis_position(scan)
+        except NotImplementedError as e:
+            scan.axis_params.set_relative_value(None)
+            raise e
+        except ValueError as e:
+            scan_name = scan.path or "undef scan"
+            scan.axis_params.set_relative_value(None)
+            raise Exception(
+                f"Fail to compute axis position for {scan_name} reason is {e}"
+            )
+        else:
+            scan.axis_params.set_relative_value(position)
+            self._axis_params.frame_width = scan.dim_1
+            self._axis_params.set_relative_value(position)
+            scan_name = scan.path or "undef scan"
+            r_cor_value = scan.axis_params.relative_cor_value
+            mess = f"Compute axis position ({r_cor_value}) with {scan.axis_params.mode.value}"
+            _logger.info(mess)
+        return scan
+
+    def setMode(self, mode, value):
+        if mode is AxisMode.manual:
+            self._axis_params.cor_position = value
+        else:
+            raise NotImplementedError("mode not implemented yet")
+
+    def define_calculation_mode(self, mode: AxisMode, fct_pointer):
+        """Register the function to call of the given mode
+
+        :param mode: the mode to register
+        :param fct_pointer: pointer to the function to call
+        """
+        self._mode_calculation_fct[mode] = fct_pointer
+
+    def compute_axis_position(self, scan):
+        """
+
+        :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`
+        """
+        mode = self._axis_params.mode
+        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 is AxisMode.read:
+            res = read_scan_x_rotation_axis_pixel_position(scan=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
+            )
+
+        return res
+
+    @docstring(Task.program_name)
+    @staticmethod
+    def program_name():
+        return "tomwer_axis"
+
+    @docstring(Task.program_version)
+    @staticmethod
+    def program_version():
+        return tomwer.version.version
+
+    @docstring(Task.definition)
+    @staticmethod
+    def definition():
+        return "Compute center of rotation"