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

tomwer/core/process/reconstruction/utils/cor.py

@@ -1,12 +1,16 @@
 def relative_pos_to_absolute(relative_pos: float, det_width: int):
     """
-    convert relative center of rotation to absolute
+    Convert relative center of rotation to absolute.
     """
-    return relative_pos + (det_width - 1) / 2.0
+    # Compute the midpoint differently for even and odd widths
+    midpoint = det_width / 2.0
+    return relative_pos + midpoint
 
 
 def absolute_pos_to_relative(absolute_pos: float, det_width: int):
     """
-    convert absolute center of rotation to relative
+    Convert absolute center of rotation to relative.
     """
-    return absolute_pos - (det_width - 1) / 2.0
+    # Compute the midpoint differently for even and odd widths
+    midpoint = det_width / 2.0
+    return absolute_pos - midpoint

tomwer/core/process/tests/test_nabu.py

@@ -402,9 +402,7 @@ class TestNabuAndAxis(unittest.TestCase):
         nabu_rotation_axis_value = self.get_saved_rotation_axis(nabu_conf_files[0])
         self.assertEqual(
             nabu_rotation_axis_value,
-            str(
-                self.scan._axis_params.relative_cor_value + (self.scan.dim_1 - 1) / 2.0
-            ),
+            str(self.scan._axis_params.relative_cor_value + (self.scan.dim_1 / 2.0)),
         )
 
 

tomwer/core/scan/scanbase.py

@@ -279,7 +279,6 @@ class TomwerScanBase(TomwerObject):
     def get_opposite_projections(self, mode) -> tuple:
         """
         Return the two best opposite projections for the required mode.
-
         """
         radios_with_angle = self.projections_with_angle()
         angles = numpy.array(
@@ -322,9 +321,10 @@ class TomwerScanBase(TomwerObject):
         nearest_c1 = find_nearest(angles=angles, angle=couples[0])
         nearest_c2 = find_nearest(angles=angles, angle=couples[1])
         if nearest_c1 is not None and nearest_c2 is not None:
-            radio_0 = AxisResource(radios_with_angle[nearest_c1])
-            radio_1 = AxisResource(radios_with_angle[nearest_c2])
-            return radio_0, radio_1
+            return (
+                AxisResource(radios_with_angle[nearest_c1], angle=nearest_c1),
+                AxisResource(radios_with_angle[nearest_c2], angle=nearest_c2),
+            )
         else:
             return None, None
 

tomwer/core/scan/tests/test_process_registration.py

@@ -40,24 +40,6 @@ class TestProcessRegistration(unittest.TestCase):
     def tearDown(self):
         shutil.rmtree(self.tmp_dir)
 
-    def testGetCorValues(self):
-        from tomwer.core.process.reconstruction.axis import AxisTask
-
-        for i in range(20):
-            results = {"center_of_rotation": i}
-            Task._register_process(
-                self.scan.process_file,
-                process=AxisTask,
-                entry=self.scan.entry,
-                configuration=None,
-                results=results,
-                process_index=i,
-            )
-        cor_value = AxisTask.get_cor_frm_process_file(
-            self.scan.process_file, entry=self.scan.entry
-        )
-        self.assertEqual(cor_value, 19)
-
     def testGetProcessNodes(self):
         """insure it return the last dark process based on the processing index"""
 

tomwer/gui/fonts.py

@@ -0,0 +1,5 @@
+from silx.gui import qt
+
+FONT_IMPORTANT = qt.QFont("Arial", 12)
+FONT_MEDIUM = qt.QFont("Arial", 10)
+FONT_SMALL = qt.QFont("Arial", 8)

tomwer/gui/reconstruction/axis/AxisMainWindow.py

@@ -10,6 +10,10 @@ from silx.gui import qt
 from tomwer.gui.utils.qt_utils import block_signals
 
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
+from tomwer.core.process.reconstruction.utils.cor import (
+    absolute_pos_to_relative,
+    relative_pos_to_absolute,
+)
 from tomwer.core.scan.scanbase import TomwerScanBase
 
 from ...utils.scandescription import ScanNameLabelAndShape
@@ -124,17 +128,15 @@ class AxisMainWindow(qt.QMainWindow):
         )
 
     def setAutoUpdateEstimatedCor(self, value):
-        self._axisWidget.setUpdateAutomaticallyEstimatedCor(value)
-
-    def getAutoUpdateEstimatedCor(self):
-        return self._axisWidget.updateAutomaticallyEstimatedCor()
+        self._axisWidget._settingsWidget._mainWidget.setUpdateXRotationAxisPixelPositionOnNewScan(
+            value
+        )
 
     def manual_uses_full_image(self, value):
         self._axisWidget.manual_uses_full_image(value)
 
     def _modeChanged(self):
         self.getAxisParams().mode = self.getMode()
-        self.getAxisParams().use_sinogram = self.useSinogram()
 
     def _CORValueLocked(self, lock):
         if lock:
@@ -152,8 +154,8 @@ class AxisMainWindow(qt.QMainWindow):
             and relative_value is not None
         ):
             try:
-                absolute_value = (
-                    relative_value + (self._axis_params.frame_width - 1) / 2.0
+                absolute_value = relative_pos_to_absolute(
+                    relative_pos=relative_value, det_width=self._axis_params.frame_width
                 )
             except TypeError:
                 absolute_value = None
@@ -163,8 +165,8 @@ class AxisMainWindow(qt.QMainWindow):
             and absolute_value is not None
         ):
             try:
-                relative_value = (
-                    absolute_value - (self._axis_params.frame_width - 1) / 2.0
+                relative_value = absolute_pos_to_relative(
+                    absolute_pos=absolute_value, det_width=self._axis_params.frame_width
                 )
             except TypeError:
                 relative_value = None
@@ -262,3 +264,12 @@ class AxisMainWindow(qt.QMainWindow):
 
     def setEstimatedCor(self, value: float):
         self._axisWidget.setEstimatedCor(value=value)
+
+    def getAutoUpdateEstimatedCor(self):
+        return self._axisWidget.updateXRotationAxisPixelPositionOnNewScan()
+
+    def isYAxisInverted(self) -> bool:
+        return self._axisWidget.isYAxisInverted()
+
+    def setYAxisInverted(self, checked: bool):
+        return self._axisWidget.setYAxisInverted(checked=checked)

tomwer/gui/reconstruction/axis/AxisOptionsWidget.py

@@ -2,9 +2,17 @@ from __future__ import annotations
 
 from silx.gui import qt
 
+from tomwer.core.process.reconstruction.axis.mode import AxisMode, AXIS_MODE_METADATAS
 from tomwer.synctools.axis import QAxisRP
 from tomwer.core.process.reconstruction.axis.params import AxisCalculationInput
 from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel, QSpinBoxIgnoreWheel
+from tomwer.core.process.reconstruction.axis.params import (
+    DEFAULT_CMP_N_SUBSAMPLING_Y,
+    DEFAULT_CMP_OVERSAMPLING,
+    DEFAULT_CMP_TAKE_LOG,
+    DEFAULT_CMP_THETA,
+)
 
 
 class AxisOptionsWidget(qt.QWidget):
@@ -14,12 +22,50 @@ class AxisOptionsWidget(qt.QWidget):
     Used as a tab of the AxisSettingsTabWidget
     """
 
+    sigChanged = qt.Signal()
+    """Emit when the options changed"""
+
     def __init__(self, parent, axis_params):
         qt.QWidget.__init__(self, parent=parent)
         assert isinstance(axis_params, QAxisRP)
         self._axis_params = axis_params
         self.setLayout(qt.QVBoxLayout())
 
+        # cor_options
+        self._corOptsWidget = qt.QWidget(self)
+        self._corOptsWidget.setLayout(qt.QFormLayout())
+        self._corOpts = qt.QLineEdit(self)
+        self._corOpts.setToolTip(
+            "Options for methods finding automatically the rotation axis position. 'side', 'near_pos' and 'near_width' are already provided by dedicated interface. The parameters are separated by commas and passed as 'name=value'. Mind the semicolon separator (;)."
+        )
+        self._corOpts.setPlaceholderText("low_pass=1; high_pass=20")
+        self._corOptsWidget.layout().addRow("cor advanced options", self._corOpts)
+        self.layout().addWidget(self._corOptsWidget)
+
+        # padding option
+        self._padding_widget = qt.QGroupBox("padding mode")
+        self._padding_widget.setCheckable(True)
+        self.layout().addWidget(self._padding_widget)
+        self._padding_widget.setLayout(qt.QHBoxLayout())
+
+        self._qbPaddingMode = QComboBoxIgnoreWheel(self._padding_widget)
+        for _mode in (
+            "constant",
+            "edge",
+            "linear_ramp",
+            "maximum",
+            "mean",
+            "median",
+            "minimum",
+            "reflect",
+            "symmetric",
+            "wrap",
+        ):
+            self._qbPaddingMode.addItem(_mode)
+        def_index = self._qbPaddingMode.findText("edge")
+        self._qbPaddingMode.setCurrentIndex(def_index)
+        self._padding_widget.layout().addWidget(self._qbPaddingMode)
+
         # define common options
         self._commonOpts = qt.QWidget(parent=self)
         self._commonOpts.setLayout(qt.QFormLayout())
@@ -30,39 +76,75 @@ class AxisOptionsWidget(qt.QWidget):
             self._qcbDataMode.addItem(data_mode.name(), data_mode)
         self._qcbDataMode.hide()
 
-        # add scale option
-        self._scaleOpt = qt.QCheckBox(parent=self)
-        self._commonOpts.layout().addRow("scale the two images", self._scaleOpt)
         self.layout().addWidget(self._commonOpts)
 
-        # add near options
-        self._nearOpts = _AxisNearOptsWidget(parent=self, axis_params=self._axis_params)
-        self.layout().addWidget(self._nearOpts)
+        # composite method advanced options
+        self._compositeOptsGroup = CompositeOptsGroup(
+            parent=self, axis_params=axis_params
+        )
+        self.layout().addWidget(self._compositeOptsGroup)
 
         # set up
         self.setCalculationInputType(self._axis_params.calculation_input_type)
+        self._compositeOptsGroup.setVisible(
+            self._axis_params.mode in (AxisMode.near, AxisMode.composite_coarse_to_fine)
+        )
 
         # connect signal / slot
-        self._scaleOpt.toggled.connect(self._updateScaleOpt)
+        self._corOpts.editingFinished.connect(self._updateAdvancedCorOptions)
         self._qcbDataMode.currentIndexChanged.connect(self._updateInputType)
-        self._axis_params.sigChanged.connect(self._updateMode)
+        self._axis_params.sigChanged.connect(self._axis_params_changed)
+        self._qbPaddingMode.currentIndexChanged.connect(self._paddingModeChanged)
+        self._padding_widget.toggled.connect(self._paddingModeChanged)
+        self._compositeOptsGroup.sigChanged.connect(self.sigChanged)
 
-    def _updateMode(self):
+    def _axis_params_changed(self):
         with block_signals(self):
+            # update according to AxisCalculationInput
             index = self._qcbDataMode.findText(
                 self._axis_params.calculation_input_type.name()
             )
             if index >= 0:
                 self._qcbDataMode.setCurrentIndex(index)
-
-    def _updateScaleOpt(self, *arg, **kwargs):
-        self._axis_params.scale_img2_to_img1 = self.isImageScaled()
-
-    def isImageScaled(self):
-        return self._scaleOpt.isChecked()
+            # update advanced cor options visibility (not relevant if mode is manual or read)
+            axis_mode = self._axis_params.mode
+            self._corOptsWidget.setVisible(
+                axis_mode
+                not in (
+                    AxisMode.manual,
+                    AxisMode.read,
+                )
+            )
+            # update cor options value
+            self.setCorOptions(self._axis_params.extra_cor_options)
+            self.setPaddingMode(self._axis_params.padding_mode)
+            self._padding_widget.setVisible(
+                AXIS_MODE_METADATAS[axis_mode].allows_padding
+            )
 
     def _updateInputType(self, *arg, **kwargs):
         self._axis_params.calculation_input_type = self.getCalculationInputType()
+        self.sigChanged.emit()
+
+    def _paddingModeChanged(self, *args, **kwargs):
+        self._axis_params.padding_mode = self.getPaddingMode()
+        self.sigChanged.emit()
+
+    def getPaddingMode(self):
+        if self._padding_widget.isChecked():
+            return self._qbPaddingMode.currentText()
+        else:
+            return None
+
+    def setPaddingMode(self, mode):
+        index = self._qbPaddingMode.findText(mode)
+        if index >= 0:
+            self._qbPaddingMode.setCurrentIndex(index)
+        self._paddingModeChanged()
+
+    def _updateAdvancedCorOptions(self, *args, **kwargs):
+        self._axis_params.extra_cor_options = self.getCorOptions()
+        self.sigChanged.emit()
 
     def getCalculationInputType(self, *arg, **kwargs):
         return AxisCalculationInput.from_value(self._qcbDataMode.currentText())
@@ -73,81 +155,159 @@ class AxisOptionsWidget(qt.QWidget):
         self._qcbDataMode.setCurrentIndex(index_dm)
 
     def setAxisParams(self, axis):
-        self._nearOpts.setAxisParams(axis=axis)
         self._axis_params = axis
         with block_signals(self):
-            self._scaleOpt.setChecked(axis.scale_img2_to_img1)
             index = self._qcbDataMode.findText(axis.calculation_input_type.name())
             self._qcbDataMode.setCurrentIndex(index)
+            self._compositeOptsGroup.setAxisParams(axis)
 
+    def getCorOptions(self):
+        return self._corOpts.text()
 
-class _AxisNearOptsWidget(qt.QWidget):
-    """GUI dedicated to the near options"""
-
-    def __init__(self, parent, axis_params):
-        qt.QWidget.__init__(self, parent=parent)
-        assert isinstance(axis_params, QAxisRP)
-        self._axis_params = axis_params
-
-        self.setLayout(qt.QFormLayout())
-
-        self._stdMaxOpt = qt.QCheckBox(parent=self)
-        self.layout().addRow("look at max standard deviation", self._stdMaxOpt)
-
-        self._nearWX = qt.QSpinBox(parent=self)
-        self._nearWX.setMinimum(1)
-        self._nearWX.setValue(5)
-        self.layout().addRow("window size", self._nearWX)
-
-        self._fineStepX = qt.QDoubleSpinBox(parent=self)
-        self._fineStepX.setMinimum(0.05)
-        self._fineStepX.setSingleStep(0.05)
-        self._fineStepX.setMaximum(1.0)
-        self.layout().addRow("fine step x", self._fineStepX)
-
-        # connect signal / Slot
-        self._stdMaxOpt.toggled.connect(self._lookForStxMaxChanged)
-        self._nearWX.valueChanged.connect(self._windowSizeChanged)
-        self._fineStepX.valueChanged.connect(self._fineStepXChanged)
-
-    def _lookForStxMaxChanged(self, *args, **kwargs):
-        self._axis_params.look_at_stdmax = self.isLookAtStdMax()
-
-    def isLookAtStdMax(self) -> bool:
-        """
+    def setCorOptions(self, opts: str | None):
+        with block_signals(self._axis_params):
+            self._corOpts.clear()
+            if opts:
+                self._corOpts.setText(opts)
+                self._updateAdvancedCorOptions()
 
-        :return: is the option for looking at max standard deviation is
-                 activated
-        """
-        return self._stdMaxOpt.isChecked()
+    def setMode(self, mode: AxisMode):
+        composite_opts_visible = AxisMode.from_value(mode) in (
+            AxisMode.composite_coarse_to_fine,
+            AxisMode.near,
+        )
+        self._compositeOptsGroup.setVisible(composite_opts_visible)
 
-    def _windowSizeChanged(self, *args, **kwargs):
-        self._axis_params.near_wx = self.getWindowSize()
 
-    def getWindowSize(self) -> int:
-        """
+class CompositeOptsGroup(qt.QGroupBox):
+    """Group box dedicated to the composite algorithms"""
 
-        :return: window size for near search
-        """
-        return self._nearWX.value()
+    sigChanged = qt.Signal()
+    """Emit when the options changed"""
 
-    def _fineStepXChanged(self, *args, **kwargs):
-        self._axis_params.fine_step_x = self.getFineStepX()
-
-    def getFineStepX(self) -> float:
-        """
-
-        :return: fine step x for near calculation
-        """
-        return self._fineStepX.value()
+    def __init__(self, title="composite options", parent=None, axis_params=None):
+        self._axis_params = axis_params
+        super().__init__(title, parent)
+        ## options for the composite mode
+        self.setLayout(qt.QFormLayout())
+        self.layout().setContentsMargins(0, 0, 0, 0)
+
+        self._thetaSB = QSpinBoxIgnoreWheel(self)
+        self._thetaSB.setRange(0, 360)
+        self._thetaSB.setValue(DEFAULT_CMP_THETA)
+        self._thetaSB.setToolTip("a radio will be picked each theta degrees")
+        self._thetaLabel = qt.QLabel("angle interval (in degree)", self)
+        self._thetaLabel.setToolTip(
+            "algorithm will take one projection each 'angle interval'. Also know as 'theta'"
+        )
+        self.layout().addRow(self._thetaLabel, self._thetaSB)
+
+        self._oversamplingSB = QSpinBoxIgnoreWheel(self)
+        self._oversamplingSB.setRange(1, 999999)
+        self._oversamplingSB.setValue(DEFAULT_CMP_OVERSAMPLING)
+        self._oversamplingSB.setToolTip("sinogram oversampling")
+        self.layout().addRow("oversampling", self._oversamplingSB)
+
+        self._nearWidthSB = QSpinBoxIgnoreWheel(self)
+        self._nearWidthSB.setRange(1, 999999)
+        self._nearWidthSB.setValue(0)
+        self._nearWidthSB.setToolTip("position to be used with near option")
+        self._nearWidthLabel = qt.QLabel("near width", self)
+        self._nearWidthLabel.setToolTip("position to be used with near option")
+        self.layout().addRow(self._nearWidthLabel, self._nearWidthSB)
+
+        self._subsamplingYSB = QSpinBoxIgnoreWheel(self)
+        self._subsamplingYSB.setRange(1, 999999)
+        self._subsamplingYSB.setValue(DEFAULT_CMP_N_SUBSAMPLING_Y)
+        self._subsamplingYSB.setToolTip("sinogram number of subsampling along y")
+        self.layout().addRow("n_subsampling_y", self._subsamplingYSB)
+
+        self._takeLogCB = qt.QCheckBox(self)
+        self._takeLogCB.setToolTip("Take logarithm")
+        self._takeLogCB.setChecked(DEFAULT_CMP_TAKE_LOG)
+        self._takeTheLogLabel = qt.QLabel("linearisation (-log(I/I0))")
+        self._takeTheLogLabel.setToolTip(
+            "take (-log(I/I0)) as input. Also know as 'take_log' option"
+        )
+        self.layout().addRow(self._takeTheLogLabel, self._takeLogCB)
 
-    def setAxisParams(self, axis: QAxisRP):
-        """
+        # connect signal / slot
+        self._thetaSB.valueChanged.connect(self._changed)
+        self._oversamplingSB.valueChanged.connect(self._changed)
+        self._subsamplingYSB.valueChanged.connect(self._changed)
+        self._nearWidthSB.valueChanged.connect(self._changed)
+        self._takeLogCB.toggled.connect(self._changed)
 
-        :param axis: axis to edit
-        """
+    def setAxisParams(self, axis_params):
         with block_signals(self):
-            self._axis_params = axis
-            self._stdMaxOpt.setChecked(axis.look_at_stdmax)
-            self._nearWX.setValue(axis.near_wx)
-            self._fineStepX.setValue(axis.fine_step_x)
+            self.setConfiguration(axis_params.composite_options)
+        self._axis_params = axis_params
+
+    def _changed(self):
+        if self._axis_params is not None:
+            self._axis_params.composite_options = self.getConfiguration()
+        self.sigChanged.emit()
+
+    def getTheta(self) -> int:
+        return self._thetaSB.value()
+
+    def setTheta(self, theta: int) -> None:
+        self._thetaSB.setValue(theta)
+
+    def getOversampling(self) -> int:
+        return self._oversamplingSB.value()
+
+    def setOversampling(self, oversampling: int) -> None:
+        self._oversamplingSB.setValue(oversampling)
+
+    def getNearWidth(self) -> int:
+        return self._nearWidthSB.value()
+
+    def setNearWidth(self, value) -> int:
+        return self._nearWidthSB.setValue(value)
+
+    def getSubSamplingY(self) -> int:
+        return self._subsamplingYSB.value()
+
+    def setSubSamplingY(self, subsampling: int) -> None:
+        self._subsamplingYSB.setValue(subsampling)
+
+    def getTakeLog(self) -> bool:
+        return self._takeLogCB.isChecked()
+
+    def setTakeLog(self, log: bool) -> None:
+        self._takeLogCB.setChecked(log)
+
+    def getConfiguration(self) -> dict:
+
+        return {
+            "theta": self.getTheta(),
+            "oversampling": self.getOversampling(),
+            "n_subsampling_y": self.getSubSamplingY(),
+            "take_log": self.getTakeLog(),
+            "near_width": self.getNearWidth(),
+        }
+
+    def setConfiguration(self, opts: dict) -> None:
+        if not isinstance(opts, dict):
+            raise TypeError("opts should be an instance of dict")
+        # theta
+        theta = opts.get("theta", None)
+        if theta is not None:
+            self.setTheta(theta=theta)
+        # oversampling
+        oversampling = opts.get("oversampling", None)
+        if oversampling is not None:
+            self.setOversampling(oversampling)
+        # n subsampling y
+        n_subsampling_y = opts.get("n_subsampling_y", None)
+        if n_subsampling_y is not None:
+            self.setSubSamplingY(n_subsampling_y)
+        # near_width
+        near_width = opts.get("near_width", None)
+        if near_width is not None:
+            self.setNearWidth(near_width)
+        # take log
+        take_log = opts.get("take_log", None)
+        if take_log is not None:
+            self.setTakeLog(take_log)

tomwer/gui/reconstruction/axis/AxisSettingsWidget.py

@@ -152,6 +152,7 @@ class AxisSettingsWidget(qt.QWidget):
         with block_signals(self._axisParams):
             self._axisParams.mode = mode
             self._mainWidget._calculationWidget.setMode(mode)
+            self._mainWidget._optionsWidget.setMode(mode)
             self._updateAxisView()
         self._axisParams.sigChanged.emit()
 
@@ -230,15 +231,15 @@ class AxisSettingsWidget(qt.QWidget):
 
     # expose API
 
-    def updateAutomaticallyEstimatedCor(self):
-        return self._mainWidget.updateAutomaticallyEstimatedCor()
-
-    def setUpdateAutomaticallyEstimatedCor(self, value):
-        self._mainWidget.setUpdateAutomaticallyEstimatedCor(value)
-
     def setEstimatedCor(self, value):
         self._mainWidget.setEstimatedCorValue(value=value)
 
+    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
+        return self._mainWidget.updateXRotationAxisPixelPositionOnNewScan()
+
+    def setUpdateXRotationAxisPixelPositionOnNewScan(self, update: bool):
+        self._mainWidget.setUpdateXRotationAxisPixelPositionOnNewScan(update=update)
+
     def getEstimatedCor(self):
         return self._mainWidget.getEstimatedCor()
 
@@ -266,6 +267,12 @@ class AxisSettingsWidget(qt.QWidget):
     def setModeLock(self, mode):
         return self._mainWidget.setModeLock(mode=mode)
 
+    def isYAxisInverted(self) -> bool:
+        return self._mainWidget.isYAxisInverted()
+
+    def setYAxisInverted(self, checked: bool):
+        return self._mainWidget.setYAxisInverted(checked=checked)
+
 
 class ManualAxisSelectionWidget(qt.QWidget):
     sigResetZoomRequested = qt.Signal()
@@ -492,6 +499,8 @@ class AxisSettingsTabWidget(qt.QTabWidget):
     sigModeChanged = qt.Signal(str)
     """Signal emit when mode (algorithm) is changed"""
 
+    sigUpdateXRotAxisPixelPosOnNewScan = qt.Signal()
+
     def __init__(
         self,
         recons_params: QAxisRP | None,
@@ -517,12 +526,9 @@ class AxisSettingsTabWidget(qt.QTabWidget):
             spacer.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
             widget.layout().addWidget(spacer)
 
-        self._optionsSA = qt.QScrollArea(parent=self)
-        self._optionsSA.setWidget(self._optionsWidget)
         self.addTab(self._calculationWidget, "calculation")
-        self.addTab(self._optionsSA, "options")
+        self.addTab(self._optionsWidget, "options")
         # simplify set up. Hide options
-        self._optionsSA.hide()
         self.addTab(self._inputWidget, "input")
 
         # set up
@@ -532,11 +538,11 @@ class AxisSettingsTabWidget(qt.QTabWidget):
         # connect signal / slot
         self._calculationWidget.sigLockModeChanged.connect(self.sigLockModeChanged)
         self.sigModeChanged.connect(self._updatePossibleInput)
+        self.sigModeChanged.connect(self._updatePossibleOptions)
         self._inputWidget._sigUrlChanged.connect(self._urlChanged)
         self._calculationWidget.sigModeChanged.connect(self.sigModeChanged)
-        # not very nice but very convenient to have the setting near at the same level
-        self._calculationWidget._qleNearPosQLE.textChanged.connect(
-            self._inputWidget._changed
+        self._calculationWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
+            self.sigUpdateXRotAxisPixelPosOnNewScan
         )
 
     def _urlChanged(self):
@@ -544,6 +550,7 @@ class AxisSettingsTabWidget(qt.QTabWidget):
 
     def setScan(self, scan):
         if scan is not None:
+            self._calculationWidget.setScan(scan)
             self._inputWidget.setScan(scan)
 
     def setAxisParams(self, axis):
@@ -562,6 +569,10 @@ class AxisSettingsTabWidget(qt.QTabWidget):
             self._inputWidget.setEnabled(True)
             self._inputWidget.setValidInputs(valid_inputs)
 
+    def _updatePossibleOptions(self):
+        mode = self.getMode()
+        self._optionsWidget.setMode(mode)
+
     # expose API
     def isModeLock(self) -> bool:
         return self._calculationWidget.isModeLock()
@@ -575,15 +586,25 @@ class AxisSettingsTabWidget(qt.QTabWidget):
     def getEstimatedCor(self):
         return self._calculationWidget.getEstimatedCor()
 
+    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
+        return self._calculationWidget.updateXRotationAxisPixelPositionOnNewScan()
+
+    def setUpdateXRotationAxisPixelPositionOnNewScan(self, update: bool):
+        self._calculationWidget.setUpdateXRotationAxisPixelPositionOnNewScan(
+            update=update
+        )
+
     def getMode(self):
         """Return algorithm to use for axis calculation"""
         return self._calculationWidget.getMode()
 
-    def updateAutomaticallyEstimatedCor(self):
-        return self._calculationWidget.updateAutomaticallyEstimatedCor()
+    def isYAxisInverted(self) -> bool:
+        return self._calculationWidget._estimatedCorWidget.isYAxisInverted()
 
-    def setUpdateAutomaticallyEstimatedCor(self, value):
-        self._calculationWidget.setUpdateAutomaticallyEstimatedCor(value)
+    def setYAxisInverted(self, checked: bool):
+        return self._calculationWidget._estimatedCorWidget.setYAxisInverted(
+            checked=checked
+        )
 
 
 class _ShiftControl(qt.QWidget):