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

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

@@ -5,11 +5,10 @@ from collections import namedtuple
 
 import numpy
 from silx.io.url import DataUrl
+from silx.utils.deprecation import deprecated
 from silx.utils.enum import Enum as _Enum
 from tomoscan.esrf.scan.utils import get_data
 
-from tomwer.core.process.reconstruction.utils.cor import relative_pos_to_absolute
-from tomwer.core.process.reconstruction.axis.side import Side
 from tomwer.core.scan.scanbase import TomwerScanBase
 
 from .anglemode import CorAngleMode
@@ -78,14 +77,13 @@ class AxisResource(object):
     """Paganin configuration for axis calculation. To simplify we have only one
     static configuration for now. Otherwise complicate stuff"""
 
-    def __init__(self, url: None | DataUrl, angle: float | None = None):
+    def __init__(self, url):
         assert url is None or isinstance(url, DataUrl)
         assert url is None or url.is_valid()
         self.__url = url
         self.__raw_data = None
         self.__norme_data = None
         self.__norm_paganin = None
-        self.__angle = angle
 
     def __str__(self):
         return f"{type(self)}, url: {self.__url.path() if self.__url else None}"
@@ -118,10 +116,6 @@ class AxisResource(object):
     def normalized_data(self, data):
         self.__norme_data = data
 
-    @property
-    def angle(self) -> float | None:
-        return self.__angle
-
     def normalize_data(self, scan, log_):
         """Normalize data for axis calculation"""
         if not isinstance(scan, TomwerScanBase):
@@ -188,7 +182,7 @@ class AxisResource(object):
 
 class AxisRP:
     """
-    Configuration class for a tomwer :class:`AxisTask`
+    Configuration class for a tomwer :class:`AxisProcess`
 
     note: every modification on the parameters will process a call fo changed
     except `axis_url_1` and `axis_url_2` which will produce a call to the
@@ -212,12 +206,11 @@ class AxisRP:
         "FINE_STEP_X",
         "SCALE_IMG2_TO_IMG1",
         "NEAR_POSITION",
-        "MOTOR_OFFSET",
-        "X_ROTATION_AXIS_PIXEL_POSITION",
         "SINOGRAM_SUBSAMPLING",
         "PADDING_MODE",
         "FLIP_LR",
         "COMPOSITE_OPTS",
+        "SIDE",
         "COR_OPTIONS",
     )
 
@@ -232,18 +225,17 @@ class AxisRP:
         None is not processing"""
         self.__angle_mode = CorAngleMode.use_0_180
         """Angle to use for radios"""
-        self.__x_rotation_axis_pixel_position = None
-        """rotation axis position obtained from motor"""
-        self.__x_rotation_axis_pos_px_offset = 0.0
-        """motor offset to be used to compute the 'estimated_cor' from 'x_rotation_axis_pixel_position'"""
         self.__estimated_cor = 0.0
-        """Estimated position of the center of rotation. Given by the user or computed from 'x_rotation_axis_pixel_position' and 'pixel_offset'"""
+        """Position to use for near calculation"""
         self.__axis_url_1 = AxisResource(url=None)
         """first data url to use for axis cor calculation"""
         self.__axis_url_2 = AxisResource(url=None)
         """second data url to use for axis cor calculation"""
         self.__calculation_input_type = AxisCalculationInput.transmission
         """Type of input (emission, absorption, with or without paganin)"""
+        self.__use_sinogram = False
+        """Do we want to use the sinogram of the radios for computing center
+        of rotation"""
         self.__sinogram_line = "middle"
         """Line of the radios to use for getting the sinogram"""
         self.__sinogram_subsampling = 10
@@ -252,14 +244,17 @@ class AxisRP:
         self.__look_at_stdmax = False
         """do the near search at X position which as the max Y column standard
         deviation"""
-        self.__composite_window_size = 5
+        self.__near_wx = 5
         """do the near search in an X window of size +-near_wx"""
-        self.__composite_fine_step = 0.1
+        self.__fine_stepx = 0.1
         """shift step x for fine shifting image"""
         self.__scale_img2_to_img1 = False
         """do image scaling"""
         self.__padding_mode = None
         self.__frame_width = None
+        self.__side = "right"
+        """side of the cor. Requested by nabu cor algorithms growing-window
+        and sliding-window"""
         self.__flip_lr = True
         self.__composite_options = {
             "theta": DEFAULT_CMP_THETA,
@@ -279,7 +274,37 @@ class AxisRP:
 
     @mode.setter
     def mode(self, mode):
-        self.__mode = AxisMode.from_value(mode)
+        if isinstance(mode, str):
+            try:
+                name = mode
+                if name in ("global_", "global"):
+                    name = AxisMode.global_.name
+                elif name == "accurate":
+                    _logger.info(
+                        f"convert axis mode {name} to {AxisMode.centered.name} (renamed)"
+                    )
+                    name = AxisMode.centered.name
+                elif name == "growing-window":
+                    _logger.warning(
+                        f"growing-window mode has been removed. Replace it by {AxisMode.growing_window_radios.value}"
+                    )
+                    name = AxisMode.growing_window_radios.name
+                elif name == "sliding-window":
+                    _logger.warning(
+                        f"sliding-window mode has been removed. Replace it by {AxisMode.sliding_window_radios.value}"
+                    )
+                    name = AxisMode.sliding_window_radios.name
+                try:
+                    _mode = getattr(AxisMode, name)
+                except Exception:
+                    _mode = AxisMode.from_value(name)
+            except Exception:
+                raise ValueError(f"Fail to create axis mode from {mode}")
+        else:
+            if not isinstance(mode, AxisMode):
+                raise TypeError(f"mode is expected to be an instance of {AxisMode}")
+            _mode = mode
+        self.__mode = _mode
         self.changed()
 
     @property
@@ -321,7 +346,7 @@ class AxisRP:
     def set_relative_value(self, value):
         if not isinstance(value, (int, float, str, type(None))):
             raise TypeError(
-                f"value is expected to be an instance of {int}, {float}, {str}, or {None}. {type(value)} provided"
+                f"value is expected to be an instance of {int} {float}, {str} or {None}. {type(value)} provided"
             )
         if value is None:
             changed = self.__relative_value is not None
@@ -336,46 +361,32 @@ class AxisRP:
             else:
                 self.__relative_value = float(value)
                 if self.frame_width is not None:
-                    self.__absolute_value = relative_pos_to_absolute(
-                        relative_pos=self.__relative_value, det_width=self.frame_width
+                    self.__absolute_value = (
+                        self.__relative_value + (self.frame_width - 1) / 2.0
                     )
             self.changed()
 
     @property
-    def estimated_cor(self) -> Side | float | None:
+    def estimated_cor(self):
         return self.__estimated_cor
 
     @estimated_cor.setter
-    def estimated_cor(self, value: Side | float | None):
-        try:
-            value = Side.from_value(value)
-        except ValueError:
-            pass
+    def estimated_cor(self, value):
         if self.__estimated_cor != value:
             self.__estimated_cor = value
             self.changed()
 
     @property
-    def x_rotation_axis_pos_px_offset(self) -> float:
-        return self.__x_rotation_axis_pos_px_offset
-
-    @x_rotation_axis_pos_px_offset.setter
-    def x_rotation_axis_pos_px_offset(self, value: float):
-        assert isinstance(
-            value, float
-        ), f"x_rotation_axis_pos_px_offset should be a float. Got {type(value)}"
-        self.__x_rotation_axis_pos_px_offset = value
-
-    @property
-    def x_rotation_axis_pixel_position(self) -> float | None:
-        return self.__x_rotation_axis_pixel_position
-
-    @x_rotation_axis_pixel_position.setter
-    def x_rotation_axis_pixel_position(self, value: float | None):
-        assert isinstance(
-            value, (float, type(None))
-        ), f"x_rotation_axis_pixel_position should be None or a float. Got{type(value)}"
-        self.__x_rotation_axis_pixel_position = value
+    def side(self):
+        return self.__side
+
+    @side.setter
+    def side(self, side):
+        if side not in ("all", "left", "right", "center", "near"):
+            raise ValueError(f"side '{side}' is not managed")
+        if self.__side != side:
+            self.__side = side
+            self.changed()
 
     @property
     def axis_url_1(self):
@@ -459,6 +470,16 @@ class AxisRP:
             self.__calculation_input_type = type_
             self.changed()
 
+    @property
+    def use_sinogram(self):
+        return self.__use_sinogram
+
+    @use_sinogram.setter
+    def use_sinogram(self, sinogram):
+        if self.__use_sinogram != sinogram:
+            self.__use_sinogram = sinogram
+            self.changed()
+
     @property
     def sinogram_line(self):
         return self.__sinogram_line
@@ -499,24 +520,23 @@ class AxisRP:
         self.__look_at_stdmax = stdmax
 
     @property
-    def composite_window_size(self):
-        return self.__composite_window_size
+    def near_wx(self):
+        return self.__near_wx
 
-    @composite_window_size.setter
-    def composite_window_size(self, width):
-        if self.__composite_window_size != width:
-            self.__composite_window_size = width
+    @near_wx.setter
+    def near_wx(self, width):
+        if self.__near_wx != width:
+            self.__near_wx = width
             self.changed()
 
     @property
-    def composite_fine_step(self):
-        """Fine step along x axis"""
-        return self.__composite_fine_step
-
-    @composite_fine_step.setter
-    def composite_fine_step(self, step_size):
-        if self.__composite_fine_step != step_size:
-            self.__composite_fine_step = step_size
+    def fine_step_x(self):
+        return self.__fine_stepx
+
+    @fine_step_x.setter
+    def fine_step_x(self, step_size):
+        if self.__fine_stepx != step_size:
+            self.__fine_stepx = step_size
             self.changed()
 
     @property
@@ -573,7 +593,7 @@ class AxisRP:
                 "near_pos",
                 "near_width",
             ):
-                raise KeyError(f"{key} is not recognized")
+                raise KeyError(f"{key} is not recogized")
         self.__composite_options = opts
 
     @property
@@ -587,7 +607,7 @@ class AxisRP:
             self.changed()
 
     def changed(self):
-        """callback to overwrite when the parameter value changed"""
+        """callback to overwrite when the paramter value changed"""
         pass
 
     def n_url(self):
@@ -620,27 +640,21 @@ class AxisRP:
             "POSITION_VALUE": self.relative_cor_value,
             "CALC_INPUT_TYPE": self.calculation_input_type.to_dict(),
             "ANGLE_MODE": self.angle_mode.value,
-            "SINOGRAM_LINE": (
-                self.sinogram_line if self.mode.requires_sinogram_index() else ""
-            ),
+            "USE_SINOGRAM": self.use_sinogram,
+            "SINOGRAM_LINE": self.sinogram_line if self.use_sinogram else "",
             "SINOGRAM_SUBSAMPLING": self.sinogram_subsampling,
             "AXIS_URL_1": axis_urls_1,
             "AXIS_URL_2": axis_urls_2,
             "LOOK_AT_STDMAX": self.look_at_stdmax,
-            "NEAR_WX": self.composite_window_size,
-            "FINE_STEP_X": self.composite_fine_step,
+            "NEAR_WX": self.near_wx,
+            "FINE_STEP_X": self.fine_step_x,
             "SCALE_IMG2_TO_IMG1": self.scale_img2_to_img1,
-            "NEAR_POSITION": (
-                self.estimated_cor.value
-                if isinstance(self.estimated_cor, Side)
-                else self.estimated_cor
-            ),
+            "NEAR_POSITION": self.estimated_cor,
             "PADDING_MODE": self.padding_mode,
             "FLIP_LR": self.flip_lr,
             "COMPOSITE_OPTS": self.composite_options,
+            "SIDE": self.side,
             "COR_OPTIONS": self.extra_cor_options,
-            "MOTOR_OFFSET": self.x_rotation_axis_pos_px_offset,
-            "X_ROTATION_AXIS_PIXEL_POSITION": self.x_rotation_axis_pixel_position,
         }
         return _dict
 
@@ -665,6 +679,8 @@ class AxisRP:
             self.calculation_input_type = AxisCalculationInput.from_value(
                 _dict["CALC_INPUT_TYPE"]
             )
+        if "USE_SINOGRAM" in _dict:
+            self.use_sinogram = _dict["USE_SINOGRAM"]
         if "ANGLE_MODE" in _dict:
             self.angle_mode = CorAngleMode.from_value(_dict["ANGLE_MODE"])
         if "SINOGRAM_LINE" in _dict:
@@ -676,13 +692,13 @@ class AxisRP:
         if "LOOK_AT_STDMAX" in _dict:
             self.look_at_stdmax = _dict["LOOK_AT_STDMAX"]
         if "NEAR_WX" in _dict:
-            self.composite_window_size = _dict["NEAR_WX"]
+            self.near_wx = _dict["NEAR_WX"]
         if "FINE_STEP_X" in _dict:
-            self.composite_fine_step = _dict["FINE_STEP_X"]
+            self.fine_step_x = _dict["FINE_STEP_X"]
         if "SCALE_IMG2_TO_IMG1" in _dict:
             self.scale_img2_to_img1 = _dict["SCALE_IMG2_TO_IMG1"]
         if "NEAR_POSITION" in _dict:
-            self.estimated_cor = _dict["NEAR_POSITION"]
+            self.estimated_cor = float(_dict["NEAR_POSITION"])
         if "SINOGRAM_SUBSAMPLING" in _dict:
             self.sinogram_subsampling = _dict["SINOGRAM_SUBSAMPLING"]
         if "PADDING_MODE" in _dict:
@@ -691,6 +707,8 @@ class AxisRP:
             self.flip_lr = bool(_dict["FLIP_LR"])
         if "COMPOSITE_OPTS" in _dict:
             self.composite_options = _dict["COMPOSITE_OPTS"]
+        if "SIDE" in _dict:
+            self.side = _dict["SIDE"]
         self.extra_cor_options = _dict.get("COR_OPTIONS", "")
 
     def copy(self, axis_params, copy_axis_url=True, copy_flip_lr=True):
@@ -699,17 +717,17 @@ class AxisRP:
         self.frame_width = axis_params.frame_width
         self.set_relative_value(axis_params.relative_cor_value)
         self.calculation_input_type = axis_params.calculation_input_type
+        self.use_sinogram = axis_params.use_sinogram
         self.angle_mode = axis_params.angle_mode
         self.sinogram_line = axis_params.sinogram_line
         self.sinogram_subsampling = axis_params.sinogram_subsampling
         self.look_at_stdmax = axis_params.look_at_stdmax
-        self.composite_window_size = axis_params.composite_window_size
-        self.composite_fine_step = axis_params.composite_fine_step
+        self.near_wx = axis_params.near_wx
+        self.fine_step_x = axis_params.fine_step_x
         self.scale_img2_to_img1 = axis_params.scale_img2_to_img1
         self.estimated_cor = axis_params.estimated_cor
-        self.x_rotation_axis_pixel_position = axis_params.x_rotation_axis_pixel_position
-        self.x_rotation_axis_pos_px_offset = axis_params.x_rotation_axis_pos_px_offset
         self.padding_mode = axis_params.padding_mode
+        self.side = axis_params.side
         self.composite_options = axis_params.composite_options
         self.extra_cor_options = axis_params.extra_cor_options
         if copy_axis_url:
@@ -736,63 +754,56 @@ class AxisRP:
             AxisMode.sliding_window_radios,
             AxisMode.sliding_window_sinogram,
         ):
-            extra_info = f"side: {self.estimated_cor}"
+            extra_info = f"side: {self.side}, use sinogram: {self.use_sinogram}"
             results = ", ".join((results, extra_info))
         return results
 
     def get_nabu_cor_options_as_dict(self) -> str:
         options = {}
-        # provide side. Scalar if a first guess is provided else a value in ('left', 'right', 'center', 'all')
-        if (
-            isinstance(self.estimated_cor, Side)
-            and AXIS_MODE_METADATAS[self.mode].valid_sides
-        ):
-            options["side"] = self.estimated_cor.value
-        elif AXIS_MODE_METADATAS[self.mode].allows_estimated_cor_as_numerical_value:
-            options["side"] = self.estimated_cor
-
-        if self.mode in (AxisMode.composite_coarse_to_fine, AxisMode.near):
-            options["near_width"] = self.composite_options.get(
-                "near_width", DEFAULT_CMP_NEAR_WIDTH
-            )
-            options["theta_interval"] = self.composite_options.get(
-                "theta_interval", DEFAULT_CMP_THETA
-            )
-            options["oversampling"] = self.composite_options.get(
-                "oversampling", DEFAULT_CMP_OVERSAMPLING
-            )
-            options["n_subsampling_y"] = self.composite_options.get(
-                "n_subsampling_y", DEFAULT_CMP_N_SUBSAMPLING_Y
-            )
-            options["take_log"] = self.composite_options.get(
-                "take_log", DEFAULT_CMP_TAKE_LOG
-            )
+        if self.mode is AxisMode.near:
+            self.side = "near"
+        request_side = len(AXIS_MODE_METADATAS[self.mode].valid_sides) > 0
+        if request_side:
+
+            if self.side == "near":
+                options["side"] = self.composite_options.get(
+                    "near_pos", self.estimated_cor
+                )
+            else:
+                options["side"] = self.side
 
-        # provide radio indices or sinogram index
-        if self.mode.requires_radio_indices:
-            # warning: nabu expect radio angles to be in rad, in nxtomo and tomwer they are in degrees
-            options["radio_angles"] = (
-                numpy.deg2rad(self.axis_url_1.angle or 0.0),
-                numpy.deg2rad(self.axis_url_2.angle or 180.0),
-            )
-        if self.mode.requires_sinogram_index:
-            options["slice_idx"] = self.sinogram_line
+        if self.side == "near":
+            near_width = self.composite_options.get("near_width", 20.0)
+            options["near_width"] = near_width
 
         # append "extra_cor_options" to already handled cor options
-        # expected values: low_pass, high_pass
         extra_cor_options = self.extra_cor_options.replace(" ", "")
 
         if extra_cor_options != "":
             for opt in self.extra_cor_options.replace(" ", "").split(";"):
                 if len(opt.split("=")) == 2:
                     key, value = opt.split("=")
-                    if key in ("low_pass", "high_pass"):
-                        value = float(value)
-                        options[key] = value
-                    else:
-                        _logger.warning(
-                            f"key {key} is not recognized by nabu. Ignore it."
-                        )
+                    options[key] = value
                 else:
-                    _logger.info(f"ignore option {opt}. Invalid syntax")
+                    _logger.info(f"ignore option {opt}. Invalid synthax")
         return options
+
+    @deprecated(replacement="get_nabu_cor_options_as_str", since_version="1.1")
+    def get_nabu_cor_options(self) -> str:
+        return self.get_nabu_cor_options_as_str()
+
+    def get_nabu_cor_options_as_str(self) -> str:
+        """return cor option for nabu"""
+
+        def cast_key_value(key, value):
+            if key in ("side",):
+                return f"{key}='{value}'"
+            else:
+                return f"{key}={value}"
+
+        return " ; ".join(
+            [
+                cast_key_value(key, value)
+                for key, value in self.get_nabu_cor_options_as_dict().items()
+            ]
+        )

tomwer/core/process/reconstruction/nabu/nabuscores.py

@@ -42,10 +42,6 @@ from tomwer.core.process.reconstruction.nabu.utils import (
     slice_index_to_int,
     get_nabu_multicor_file_prefix,
 )
-from tomwer.core.process.reconstruction.utils.cor import (
-    relative_pos_to_absolute,
-    absolute_pos_to_relative,
-)
 from tomwer.core.process.reconstruction.nabu.target import Target
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.slurm import get_slurm_script_name, is_slurm_available
@@ -287,7 +283,7 @@ class _Reconstructor(_NabuBaseReconstructor):
         )
 
         results = {}
-        if self.advancement is not None:
+        if self.advancement:
             self.advancement.total = len(self.nabu_configs)
         for var_value, config in self.nabu_configs.items():
             if self._cancelled:
@@ -312,7 +308,7 @@ class _Reconstructor(_NabuBaseReconstructor):
                 process_name=self.process_name,
             )
             # specific treatment for cor: rename output files
-            if self.advancement is not None:
+            if self.advancement:
                 self.advancement.update()
         return results
 
@@ -499,6 +495,22 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         else:
             raise ValueError(f"{self.target} is not recognized as a valid target")
 
+    @staticmethod
+    def convert_cor_from_rel_to_abs(scan, cor):
+        if scan.dim_1 is not None:
+            return cor + (scan.dim_1 - 1) / 2.0
+        else:
+            _logger.warning("enable to get image half width. Set it to 1024")
+            return cor + 1024
+
+    @staticmethod
+    def convert_cor_from_abs_to_rel(scan, cor):
+        if scan.dim_1 is not None:
+            return cor - (scan.dim_1 - 1) / 2.0
+        else:
+            _logger.warning("enable to get image half width. Set it to 1024")
+            return cor - 1024
+
     def _run_nabu_multicor_locally(
         self,
         conf_file: str,
@@ -518,10 +530,7 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
 
         cor_in_nabu_ref = tuple(
-            [
-                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
-                for cor in self.cors
-            ]
+            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
         )
         cor_in_nabu_ref = ",".join([str(cor) for cor in cor_in_nabu_ref])
         command = " ".join(
@@ -558,15 +567,12 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
             scan=self.scan,
             file_format=file_format,
             cors=[
-                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
-                for cor in self.cors
+                self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors
             ],
         )
         # convert back from abs ref to rel ref
         recons_vol_identifiers = {
-            absolute_pos_to_relative(
-                absolute_pos=cor, det_width=self.scan.dim_1
-            ): identifiers
+            self.convert_cor_from_abs_to_rel(self.scan, cor): identifiers
             for cor, identifiers in recons_vol_identifiers.items()
         }
         return ResultsLocalRun(
@@ -616,10 +622,7 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
 
         slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
         cor_in_nabu_ref = tuple(
-            [
-                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
-                for cor in self.cors
-            ]
+            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
         )
         cor_in_nabu_ref = ",".join([str(cor) for cor in cor_in_nabu_ref])
 

tomwer/core/process/reconstruction/nabu/nabuslices.py

@@ -16,7 +16,6 @@ from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.utils.slurm import is_slurm_available
 from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.process.reconstruction.nabu.utils import slice_index_to_int
-from tomwer.core.process.reconstruction.utils.cor import relative_pos_to_absolute
 from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.core.process.reconstruction.output import (
     PROCESS_FOLDER_RECONSTRUCTED_SLICES,
@@ -132,10 +131,7 @@ def run_slices_reconstruction(
     if scan.axis_params is not None and scan.axis_params.relative_cor_value is not None:
         if "reconstruction" in config:
             # move the cor value to the nabu reference
-            cor_nabu_ref = relative_pos_to_absolute(
-                relative_pos=scan.axis_params.relative_cor_value,
-                det_width=scan.dim_1,
-            )
+            cor_nabu_ref = scan.axis_params.relative_cor_value + (scan.dim_1 - 1) / 2.0
             config["reconstruction"]["rotation_axis_position"] = str(cor_nabu_ref)
     _logger.info(f"set nabu reconstruction parameters to {scan}")
 

tomwer/core/process/reconstruction/saaxis/saaxis.py

@@ -31,7 +31,6 @@ from tomwer.core.process.reconstruction.scores import (
     get_disk_mask_radius,
 )
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from tomwer.core.process.reconstruction.utils.cor import relative_pos_to_absolute
 from tomwer.core.process.task import Task
 from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -54,6 +53,7 @@ from tomwer.core.process.reconstruction.nabu.utils import (
     get_multi_cor_recons_volume_identifiers,
     get_nabu_multicor_file_prefix,
 )
+from tomwer.core.process.reconstruction.nabu.nabuscores import _ReconstructorMultiCor
 
 from .params import SAAxisParams
 
@@ -316,9 +316,9 @@ class SAAxisTask(
                 continue
 
             for cor in cors:
-                cor_nabu_ref = relative_pos_to_absolute(
-                    relative_pos=cor,
-                    det_width=scan.dim_1,
+                cor_nabu_ref = _ReconstructorMultiCor.convert_cor_from_rel_to_abs(
+                    scan=scan,
+                    cor=cor,
                 )
                 volume_identifiers = get_multi_cor_recons_volume_identifiers(
                     scan=scan,

tomwer/core/process/reconstruction/sadeltabeta/sadeltabeta.py

@@ -28,7 +28,6 @@ from tomwer.core.process.reconstruction.nabu.nabucommon import (
     ResultsWithStd,
 )
 from tomwer.core.process.reconstruction.nabu.nabuslices import SingleSliceRunner
-from tomwer.core.process.reconstruction.utils.cor import relative_pos_to_absolute
 from tomwer.core.process.reconstruction.scores import (
     ComputedScore,
     ScoreMethod,
@@ -361,14 +360,15 @@ class SADeltaBetaTask(
 
     def _config_preprocessing(self, scan, config, delta_beta_s, output_dir) -> dict:
         config.get("phase", {}).pop("beam_shape", None)
+        # if scan contains some center of position copy it to nabu
         if (
             scan.axis_params is not None
             and scan.axis_params.relative_cor_value is not None
         ):
             if "reconstruction" in config:
-                cor_nabu_ref = relative_pos_to_absolute(
-                    relative_pos=scan.axis_params.relative_cor_value,
-                    det_width=scan.dim_1,
+                # move the cor value to the nabu reference
+                cor_nabu_ref = (
+                    scan.axis_params.relative_cor_value + (scan.dim_1 - 1) / 2.0
                 )
                 config["reconstruction"]["rotation_axis_position"] = str(cor_nabu_ref)
 

tomwer/core/process/reconstruction/tests/test_axis.py

@@ -42,5 +42,5 @@ def test_read_x_rotation_axis_pixel_position(nxtomo_scan_360):  # noqa F811
 
     nxtomo_scan_360.clear_caches()
     task.run()
-    assert nxtomo_scan_360.axis_params.absolute_cor_value == 22.5
+    assert nxtomo_scan_360.axis_params.absolute_cor_value == 22.0
     assert nxtomo_scan_360.axis_params.relative_cor_value == 12.5

tomwer/core/process/reconstruction/tests/test_utils.py

@@ -10,11 +10,11 @@ def test_cor_conversion():
     """
     test absolute_pos_to_relative and relative_pos_to_absolute functions
     """
-    assert relative_pos_to_absolute(relative_pos=0.0, det_width=100) == 50.0
-    assert relative_pos_to_absolute(relative_pos=0.0, det_width=101) == 50.5
+    assert relative_pos_to_absolute(relative_pos=0.0, det_width=100) == 49.5
+    assert relative_pos_to_absolute(relative_pos=0.0, det_width=101) == 50.0
 
-    assert absolute_pos_to_relative(absolute_pos=20, det_width=500) == -230.0
-    assert absolute_pos_to_relative(absolute_pos=300, det_width=500) == 50.0
+    assert absolute_pos_to_relative(absolute_pos=20, det_width=500) == -229.5
+    assert absolute_pos_to_relative(absolute_pos=300, det_width=500) == 50.5
 
     for det_width in (10, 20, 30, 50):
         for relative_cor_pos in (0, -2.3, -4.5):