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

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

@@ -5,10 +5,11 @@ 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
@@ -77,13 +78,14 @@ 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):
+    def __init__(self, url: None | DataUrl, angle: float | None = None):
         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}"
@@ -116,6 +118,10 @@ 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):
@@ -182,7 +188,7 @@ class AxisResource(object):
 
 class AxisRP:
     """
-    Configuration class for a tomwer :class:`AxisProcess`
+    Configuration class for a tomwer :class:`AxisTask`
 
     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
@@ -206,11 +212,12 @@ 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",
     )
 
@@ -225,17 +232,18 @@ 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
-        """Position to use for near calculation"""
+        """Estimated position of the center of rotation. Given by the user or computed from 'x_rotation_axis_pixel_position' and 'pixel_offset'"""
         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
@@ -244,17 +252,14 @@ class AxisRP:
         self.__look_at_stdmax = False
         """do the near search at X position which as the max Y column standard
         deviation"""
-        self.__near_wx = 5
+        self.__composite_window_size = 5
         """do the near search in an X window of size +-near_wx"""
-        self.__fine_stepx = 0.1
+        self.__composite_fine_step = 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,
@@ -274,37 +279,7 @@ class AxisRP:
 
     @mode.setter
     def mode(self, 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.__mode = AxisMode.from_value(mode)
         self.changed()
 
     @property
@@ -346,7 +321,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
@@ -361,32 +336,46 @@ class AxisRP:
             else:
                 self.__relative_value = float(value)
                 if self.frame_width is not None:
-                    self.__absolute_value = (
-                        self.__relative_value + (self.frame_width - 1) / 2.0
+                    self.__absolute_value = relative_pos_to_absolute(
+                        relative_pos=self.__relative_value, det_width=self.frame_width
                     )
             self.changed()
 
     @property
-    def estimated_cor(self):
+    def estimated_cor(self) -> Side | float | None:
         return self.__estimated_cor
 
     @estimated_cor.setter
-    def estimated_cor(self, value):
+    def estimated_cor(self, value: Side | float | None):
+        try:
+            value = Side.from_value(value)
+        except ValueError:
+            pass
         if self.__estimated_cor != value:
             self.__estimated_cor = value
             self.changed()
 
     @property
-    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()
+    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
 
     @property
     def axis_url_1(self):
@@ -470,16 +459,6 @@ 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
@@ -520,23 +499,24 @@ class AxisRP:
         self.__look_at_stdmax = stdmax
 
     @property
-    def near_wx(self):
-        return self.__near_wx
+    def composite_window_size(self):
+        return self.__composite_window_size
 
-    @near_wx.setter
-    def near_wx(self, width):
-        if self.__near_wx != width:
-            self.__near_wx = width
+    @composite_window_size.setter
+    def composite_window_size(self, width):
+        if self.__composite_window_size != width:
+            self.__composite_window_size = width
             self.changed()
 
     @property
-    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
+    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
             self.changed()
 
     @property
@@ -593,7 +573,7 @@ class AxisRP:
                 "near_pos",
                 "near_width",
             ):
-                raise KeyError(f"{key} is not recogized")
+                raise KeyError(f"{key} is not recognized")
         self.__composite_options = opts
 
     @property
@@ -607,7 +587,7 @@ class AxisRP:
             self.changed()
 
     def changed(self):
-        """callback to overwrite when the paramter value changed"""
+        """callback to overwrite when the parameter value changed"""
         pass
 
     def n_url(self):
@@ -640,21 +620,27 @@ class AxisRP:
             "POSITION_VALUE": self.relative_cor_value,
             "CALC_INPUT_TYPE": self.calculation_input_type.to_dict(),
             "ANGLE_MODE": self.angle_mode.value,
-            "USE_SINOGRAM": self.use_sinogram,
-            "SINOGRAM_LINE": self.sinogram_line if self.use_sinogram else "",
+            "SINOGRAM_LINE": (
+                self.sinogram_line if self.mode.requires_sinogram_index() 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.near_wx,
-            "FINE_STEP_X": self.fine_step_x,
+            "NEAR_WX": self.composite_window_size,
+            "FINE_STEP_X": self.composite_fine_step,
             "SCALE_IMG2_TO_IMG1": self.scale_img2_to_img1,
-            "NEAR_POSITION": self.estimated_cor,
+            "NEAR_POSITION": (
+                self.estimated_cor.value
+                if isinstance(self.estimated_cor, Side)
+                else 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
 
@@ -679,8 +665,6 @@ 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:
@@ -692,13 +676,13 @@ class AxisRP:
         if "LOOK_AT_STDMAX" in _dict:
             self.look_at_stdmax = _dict["LOOK_AT_STDMAX"]
         if "NEAR_WX" in _dict:
-            self.near_wx = _dict["NEAR_WX"]
+            self.composite_window_size = _dict["NEAR_WX"]
         if "FINE_STEP_X" in _dict:
-            self.fine_step_x = _dict["FINE_STEP_X"]
+            self.composite_fine_step = _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 = float(_dict["NEAR_POSITION"])
+            self.estimated_cor = _dict["NEAR_POSITION"]
         if "SINOGRAM_SUBSAMPLING" in _dict:
             self.sinogram_subsampling = _dict["SINOGRAM_SUBSAMPLING"]
         if "PADDING_MODE" in _dict:
@@ -707,8 +691,6 @@ 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):
@@ -717,17 +699,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.near_wx = axis_params.near_wx
-        self.fine_step_x = axis_params.fine_step_x
+        self.composite_window_size = axis_params.composite_window_size
+        self.composite_fine_step = axis_params.composite_fine_step
         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:
@@ -754,56 +736,63 @@ class AxisRP:
             AxisMode.sliding_window_radios,
             AxisMode.sliding_window_sinogram,
         ):
-            extra_info = f"side: {self.side}, use sinogram: {self.use_sinogram}"
+            extra_info = f"side: {self.estimated_cor}"
             results = ", ".join((results, extra_info))
         return results
 
     def get_nabu_cor_options_as_dict(self) -> str:
         options = {}
-        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 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.side == "near":
-            near_width = self.composite_options.get("near_width", 20.0)
-            options["near_width"] = near_width
+        # 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
 
         # 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("=")
-                    options[key] = value
+                    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."
+                        )
                 else:
-                    _logger.info(f"ignore option {opt}. Invalid synthax")
+                    _logger.info(f"ignore option {opt}. Invalid syntax")
         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/axis/side.py

@@ -0,0 +1,8 @@
+from silx.utils.enum import Enum as _Enum
+
+
+class Side(_Enum):
+    LEFT = "left"
+    RIGHT = "right"
+    CENTER = "center"
+    ALL = "all"

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

@@ -42,6 +42,10 @@ 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
@@ -495,22 +499,6 @@ 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,
@@ -530,7 +518,10 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
 
         cor_in_nabu_ref = tuple(
-            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
+            [
+                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
+                for cor in self.cors
+            ]
         )
         cor_in_nabu_ref = ",".join([str(cor) for cor in cor_in_nabu_ref])
         command = " ".join(
@@ -567,12 +558,15 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
             scan=self.scan,
             file_format=file_format,
             cors=[
-                self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors
+                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
+                for cor in self.cors
             ],
         )
         # convert back from abs ref to rel ref
         recons_vol_identifiers = {
-            self.convert_cor_from_abs_to_rel(self.scan, cor): identifiers
+            absolute_pos_to_relative(
+                absolute_pos=cor, det_width=self.scan.dim_1
+            ): identifiers
             for cor, identifiers in recons_vol_identifiers.items()
         }
         return ResultsLocalRun(
@@ -622,7 +616,10 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
 
         slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
         cor_in_nabu_ref = tuple(
-            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
+            [
+                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
+                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,6 +16,7 @@ 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,
@@ -131,7 +132,10 @@ 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 = scan.axis_params.relative_cor_value + (scan.dim_1 - 1) / 2.0
+            cor_nabu_ref = relative_pos_to_absolute(
+                relative_pos=scan.axis_params.relative_cor_value,
+                det_width=scan.dim_1,
+            )
             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,6 +31,7 @@ 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
@@ -53,7 +54,6 @@ 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 = _ReconstructorMultiCor.convert_cor_from_rel_to_abs(
-                    scan=scan,
-                    cor=cor,
+                cor_nabu_ref = relative_pos_to_absolute(
+                    relative_pos=scan.axis_params.relative_cor_value,
+                    det_width=scan.dim_1,
                 )
                 volume_identifiers = get_multi_cor_recons_volume_identifiers(
                     scan=scan,

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

@@ -28,6 +28,7 @@ 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,
@@ -360,15 +361,14 @@ 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:
-                # move the cor value to the nabu reference
-                cor_nabu_ref = (
-                    scan.axis_params.relative_cor_value + (scan.dim_1 - 1) / 2.0
+                cor_nabu_ref = relative_pos_to_absolute(
+                    relative_pos=scan.axis_params.relative_cor_value,
+                    det_width=scan.dim_1,
                 )
                 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.0
+    assert nxtomo_scan_360.axis_params.absolute_cor_value == 22.5
     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) == 49.5
-    assert relative_pos_to_absolute(relative_pos=0.0, det_width=101) == 50.0
+    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 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
+    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
 
     for det_width in (10, 20, 30, 50):
         for relative_cor_pos in (0, -2.3, -4.5):