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

tomwer/gui/reconstruction/axis/CalculationWidget.py

@@ -4,13 +4,11 @@ import logging
 
 from silx.gui import qt
 
-from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.process.reconstruction.axis import mode as axis_mode
 from tomwer.gui.utils.buttons import PadlockButton
 from tomwer.gui.utils.qt_utils import block_signals
 from tomwer.synctools.axis import QAxisRP
 from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel
-from tomwer.gui.reconstruction.axis.EstimatedCORWidget import EstimatedCORWidget
 
 _logger = logging.getLogger(__name__)
 
@@ -26,8 +24,6 @@ class CalculationWidget(qt.QWidget):
 
     sigLockModeChanged = qt.Signal(bool)
     """signal emitted when the mode has been lock or unlock"""
-    sigUpdateXRotAxisPixelPosOnNewScan = qt.Signal()
-    sigYAxisInvertedChanged = qt.Signal(bool)
 
     def __init__(self, parent, axis_params):
         assert isinstance(axis_params, QAxisRP)
@@ -35,7 +31,6 @@ class CalculationWidget(qt.QWidget):
         self._axis_params = None
         self.setLayout(qt.QVBoxLayout())
 
-        # algorithm
         self._modeWidget = qt.QWidget(parent=self)
         self._modeWidget.setLayout(qt.QHBoxLayout())
         self.layout().addWidget(self._modeWidget)
@@ -58,9 +53,9 @@ class CalculationWidget(qt.QWidget):
                 axis_mode.AxisMode.growing_window_sinogram,
                 axis_mode.AxisMode.sino_coarse_to_fine,
                 axis_mode.AxisMode.sliding_window_sinogram,
-                axis_mode.AxisMode.fourier_angles,
+                axis_mode.AxisMode.sino_fourier_angles,
             ),
-            # composite coarse to fine
+            # composite corase to fine
             (
                 axis_mode.AxisMode.composite_coarse_to_fine,
                 axis_mode.AxisMode.near,
@@ -96,52 +91,181 @@ class CalculationWidget(qt.QWidget):
         )
         self._modeWidget.layout().addWidget(self._lockMethodPB)
 
-        # estimated cor
-        self._estimatedCorWidget = EstimatedCORWidget(self, axis_params=axis_params)
-        self.layout().addWidget(self._estimatedCorWidget)
+        self._optsWidget = qt.QWidget(self)
+        self._optsWidget.setLayout(qt.QVBoxLayout())
+        self.layout().addWidget(self._optsWidget)
+
+        # padding option
+        self._padding_widget = qt.QGroupBox("padding mode")
+        self._padding_widget.setCheckable(True)
+        self._optsWidget.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)
+
+        # side option
+        self._sideWidget = qt.QWidget(self)
+        self._sideWidget.setLayout(qt.QHBoxLayout())
+        self._optsWidget.layout().addWidget(self._sideWidget)
+        self._sideWidget.layout().addWidget(qt.QLabel("side:", self))
+        self._sideCB = QComboBoxIgnoreWheel(self._optsWidget)
+        self._sideWidget.layout().addWidget(self._sideCB)
+        self._sideCB.setToolTip(
+            "Define a side for the sliding and growing" "window algorithms"
+        )
+
+        # near mode options
+        self._nearOptsWidget = qt.QWidget(parent=self)
+        self._nearOptsWidget.setLayout(qt.QVBoxLayout())
+        self._optsWidget.layout().addWidget(self._nearOptsWidget)
+
+        #    near value lock button
+        self._nearValueCB = qt.QCheckBox(
+            "Update automatically if `x_rotation_axis_pixel_position` found"
+        )
+        self._nearValueCB.setToolTip(
+            "If the acquisition contains an "
+            "estimation of the COR value then "
+            "will set it automatically as estimated "
+            "value."
+        )
+        self._nearOptsWidget.layout().addWidget(self._nearValueCB)
+
+        #    LineEdit position value
+        self._qleValueW = qt.QWidget(self._nearOptsWidget)
+        self._qleValueW.setLayout(qt.QFormLayout())
+        self._nearOptsWidget.layout().addWidget(self._qleValueW)
+
+        self._qleNearPosQLE = qt.QLineEdit("0", self._nearOptsWidget)
+        validator = qt.QDoubleValidator(self._qleNearPosQLE)
+        self._qleNearPosQLE.setValidator(validator)
+        self._qleValueW.layout().addRow(
+            "estimated value (in relative):", self._qleNearPosQLE
+        )
+
+        # cor_options
+        self._corOptsWidget = qt.QWidget(self)
+        self._corOptsWidget.setLayout(qt.QHBoxLayout())
+        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().addWidget(qt.QLabel("cor advanced options"))
+        self._corOptsWidget.layout().addWidget(self._corOpts)
+        self._optsWidget.layout().addWidget(self._corOptsWidget)
 
         # connect signal / slot
         self._qcbPosition.currentIndexChanged.connect(self._modeChanged)
+        self._qleNearPosQLE.editingFinished.connect(self._nearValueChanged)
+        self._sideCB.currentTextChanged.connect(self._sideChanged)
         self._lockMethodPB.sigLockChanged.connect(self.lockMode)
-        self._estimatedCorWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
-            self.sigUpdateXRotAxisPixelPosOnNewScan
-        )
-        self._estimatedCorWidget.sigYAxisInvertedChanged.connect(
-            self.sigYAxisInvertedChanged
-        )
+        self._qbPaddingMode.currentIndexChanged.connect(self._paddingModeChanged)
+        self._padding_widget.toggled.connect(self._paddingModeChanged)
+        self._corOpts.editingFinished.connect(self._corOptsChanged)
 
         # set up interface
-        self._estimatedCorWidget._updateVisibleSides(mode=self.getMode())
+        self._sideWidget.setVisible(False)
         self.setAxisParams(axis_params)
+        self._nearValueCB.setChecked(True)
+        self._nearOptsWidget.setHidden(True)
 
     def getMethodLockPB(self) -> qt.QPushButton:
         return self._lockMethodPB
 
     def setEstimatedCorValue(self, value):
-        self._estimatedCorWidget.setEstimatedCor(value=value)
-        # note: force to update the side values.
-        self._estimatedCorWidget._updateVisibleSides(mode=self.getMode())
+        if value is not None:
+            self._qleNearPosQLE.setText(str(value))
+            # note: keep self._axis_params up to date.
+            if self._axis_params:
+                self._axis_params.estimated_cor = value
 
     def getEstimatedCor(self):
-        return self._estimatedCorWidget.getEstimatedCor()
+        try:
+            return float(self._qleNearPosQLE.text())
+        except ValueError:
+            return 0
 
-    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
-        return self._estimatedCorWidget.updateXRotationAxisPixelPositionOnNewScan()
+    def updateAutomaticallyEstimatedCor(self):
+        return self._nearValueCB.isChecked()
 
-    def setUpdateXRotationAxisPixelPositionOnNewScan(self, update: bool):
-        self._estimatedCorWidget.setUpdateXRotationAxisPixelPositionOnNewScan(
-            update=update
-        )
+    def setUpdateAutomaticallyEstimatedCor(self, checked):
+        self._nearValueCB.setChecked(checked)
+
+    def setSide(self, side):
+        if side is not None:
+            idx = self._sideCB.findText(side)
+            if idx >= 0:
+                self._sideCB.setCurrentIndex(idx)
+
+    def getSide(self):
+        return self._sideCB.currentText()
 
     def _modeChanged(self, *args, **kwargs):
         mode = self.getMode()
         with block_signals(self._qcbPosition):
             with block_signals(self._axis_params):
-                self._estimatedCorWidget._updateVisibleSides(mode)
+                self._corOptsWidget.setVisible(
+                    mode
+                    not in (
+                        axis_mode.AxisMode.manual,
+                        axis_mode.AxisMode.read,
+                    )
+                )
+
+                self._padding_widget.setVisible(
+                    axis_mode.AXIS_MODE_METADATAS[mode].allows_padding
+                )
+                if axis_mode.AXIS_MODE_METADATAS[mode].is_lockable:
+                    self._lockMethodPB.setVisible(True)
+                else:
+                    self._lockMethodPB.setVisible(False)
+                    self.lockMode(False)
+
+                sides_visible = len(axis_mode.AXIS_MODE_METADATAS[mode].valid_sides) > 0
+                self._sideWidget.setVisible(sides_visible)
+                if sides_visible is True:
+                    self._updateSideVisible(mode)
+                self._nearOptsWidget.setVisible(self.getSide() == "near")
                 self._axis_params.mode = mode.value
             self._axis_params.changed()
             self.sigModeChanged.emit(mode.value)
 
+    def _updateSideVisible(self, mode: axis_mode.AxisMode):
+        mode = axis_mode.AxisMode.from_value(mode)
+        if len(axis_mode.AXIS_MODE_METADATAS[mode].valid_sides) == 0:
+            return
+        else:
+            current_value = self._axis_params.side
+            with block_signals(self._sideCB):
+                self._sideCB.clear()
+                values = axis_mode.AXIS_MODE_METADATAS[mode].valid_sides
+                for value in values:
+                    self._sideCB.addItem(value)
+                idx = self._sideCB.findText(current_value)
+                if idx == -1:
+                    # if side doesn't exists, propose right as default when possible
+                    idx = self._sideCB.findText("right")
+                if idx >= 0:
+                    self._sideCB.setCurrentIndex(idx)
+            self._axis_params.side = self.getSide()
+
     def isModeLock(self):
         return self._lockMethodPB.isLocked()
 
@@ -179,11 +303,7 @@ class CalculationWidget(qt.QWidget):
         """Return algorithm to use for axis calculation"""
         return axis_mode.AxisMode.from_value(self._qcbPosition.currentText())
 
-    def setMode(self, mode: axis_mode.AxisMode):
-        if mode == self.getMode():
-            # when set mode the estimated cor might changed.
-            # that we want to avoid.
-            return
+    def setMode(self, mode):
         with block_signals(self._qcbPosition):
             index = self._qcbPosition.findText(mode.value)
             if index >= 0:
@@ -191,13 +311,43 @@ class CalculationWidget(qt.QWidget):
             else:
                 raise ValueError("Unable to find mode", mode)
             self._lockMethodPB.setVisible(mode not in (axis_mode.AxisMode.manual,))
-            mode_metadata = axis_mode.AXIS_MODE_METADATAS[mode]
-            estimated_cor_widget_visible = (
-                mode_metadata.allows_estimated_cor_as_numerical_value
-                or len(mode_metadata.valid_sides) > 0
-            )
-            self._estimatedCorWidget.setVisible(estimated_cor_widget_visible)
-            self._estimatedCorWidget._updateVisibleSides(mode=mode)
+
+    def _nearValueChanged(self, *args, **kwargs):
+        self._axis_params.estimated_cor = self.getEstimatedCor()
+
+    def _paddingModeChanged(self, *args, **kwargs):
+        self._axis_params.padding_mode = self.getPaddingMode()
+
+    def _corOptsChanged(self, *args, **kwargs):
+        self._axis_params.extra_cor_options = self.getCorOptions()
+
+    def _sideChanged(self, *args, **kwargs):
+        side = self.getSide()
+        if side not in ("", None):
+            self._axis_params.side = side
+        self._nearOptsWidget.setVisible(side == "near")
+
+    def getCorOptions(self):
+        return self._corOpts.text()
+
+    def setCorOptions(self, opts: str | None):
+        with block_signals(self._axis_params):
+            self._corOpts.clear()
+            if opts:
+                self._corOpts.setText(opts)
+                self._corOptsChanged()
+
+    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 setAxisParams(self, axis):
         with block_signals(self):
@@ -209,10 +359,16 @@ class CalculationWidget(qt.QWidget):
                 self._axis_params.mode = axis_mode.AxisMode.growing_window_radios
             self._axis_params.sigChanged.connect(self._axis_params_changed)
             self._axis_params_changed()
+            self._sideChanged()
 
     def _axis_params_changed(self, *args, **kwargs):
         self.setMode(self._axis_params.mode)
-
-    def setScan(self, scan: TomwerScanBase | None):
-        self._estimatedCorWidget.setPixelSize(pixel_size_m=scan.x_pixel_size)
-        self._estimatedCorWidget.setImageWidth(image_width=scan.dim_1)
+        self.setEstimatedCorValue(self._axis_params.estimated_cor)
+        self.setSide(self._axis_params.side)
+        sides_visible = (
+            len(axis_mode.AXIS_MODE_METADATAS[self._axis_params.mode].valid_sides) > 0
+        )
+        self._sideWidget.setVisible(sides_visible)
+        self._updateSideVisible(mode=self._axis_params.mode)
+        self.setPaddingMode(self._axis_params.padding_mode)
+        self.setCorOptions(self._axis_params.extra_cor_options)

tomwer/gui/reconstruction/axis/ControlWidget.py

@@ -5,10 +5,6 @@ import numpy
 
 from silx.gui import qt
 
-from tomwer.core.process.reconstruction.utils.cor import (
-    absolute_pos_to_relative,
-    relative_pos_to_absolute,
-)
 from tomwer.gui.utils.buttons import PadlockButton
 from tomwer.gui.settings import EDITING_BACKGROUND_COLOR
 from tomwer.synctools.axis import QAxisRP
@@ -267,9 +263,7 @@ class _PositionInfoWidget(qt.QWidget):
             except Exception:
                 return
             else:
-                abs_value = relative_pos_to_absolute(
-                    relative_pos=float(rel_value), det_width=width
-                )
+                abs_value = float(rel_value) + (width - 1) / 2.0
                 self._absolutePositionQLE.setText(str(abs_value))
 
     def _updateRelativePosition(self, width):
@@ -279,7 +273,5 @@ class _PositionInfoWidget(qt.QWidget):
             except Exception:
                 return
             else:
-                rel_value = absolute_pos_to_relative(
-                    absolute_pos=float(abs_value), det_width=width
-                )
+                rel_value = float(abs_value) - (width - 1) / 2.0
                 self._relativePositionQLE.setText(str(rel_value))

tomwer/gui/reconstruction/axis/InputWidget.py

@@ -6,10 +6,17 @@ from silx.gui import qt
 
 from tomwer.core.process.reconstruction.axis import mode as axis_mode
 from tomwer.core.process.reconstruction.axis.anglemode import CorAngleMode
+from tomwer.core.process.reconstruction.axis.params import (
+    DEFAULT_CMP_N_SUBSAMPLING_Y,
+    DEFAULT_CMP_OVERSAMPLING,
+    DEFAULT_CMP_TAKE_LOG,
+    DEFAULT_CMP_THETA,
+)
 from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.utils.qt_utils import block_signals
 from tomwer.synctools.axis import QAxisRP
+from .CalculationWidget import CalculationWidget
 from .ManualFramesSelection import ManualFramesSelection
 
 _logger = logging.getLogger(__name__)
@@ -48,24 +55,74 @@ class InputWidget(qt.QWidget):
 
         # sinogram input
         self._sinogramGB = qt.QGroupBox(self)
-        self._sinogramGB.setLayout(qt.QFormLayout())
+        self._sinogramGB.setLayout(qt.QVBoxLayout())
+        self._standardSinogramOpts = qt.QGroupBox(self)
+        self._sinogramGB.layout().addWidget(self._standardSinogramOpts)
+        self._standardSinogramOpts.setLayout(qt.QFormLayout())
+        self._standardSinogramOpts.layout().setContentsMargins(0, 0, 0, 0)
+        self._standardSinogramOpts.setTitle("standard options")
 
         self._sinogramGB.setTitle("sinogram")
         self._sinogramGB.setCheckable(True)
         self.layout().addWidget(self._sinogramGB)
         ##  sinogram line
         self._sinogramLineSB = _SliceSelector(self)
-        self._sinogramGB.layout().addRow("line", self._sinogramLineSB)
+        self._standardSinogramOpts.layout().addRow("line", self._sinogramLineSB)
         ##  sinogram subsampling
         self._sinogramSubsampling = qt.QSpinBox(self)
         self._sinogramSubsampling.setRange(1, 1000)
         self._sinogramSubsampling.setValue(10)
-        self._sinogramGB.layout().addRow("subsampling", self._sinogramSubsampling)
+        self._standardSinogramOpts.layout().addRow(
+            "subsampling", self._sinogramSubsampling
+        )
 
         self._spacer = qt.QWidget(self)
         self._spacer.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
         self.layout().addWidget(self._spacer)
 
+        ## options for the composite mode
+        self._compositeOpts = qt.QGroupBox(self)
+        self._compositeOpts.setTitle("composite options")
+        self._sinogramGB.layout().addWidget(self._compositeOpts)
+        self._compositeOpts.setLayout(qt.QFormLayout())
+        self._compositeOpts.layout().setContentsMargins(0, 0, 0, 0)
+        self._thetaSB = qt.QSpinBox(self)
+        self._thetaSB.setRange(0, 360)
+        self._thetaSB.setValue(DEFAULT_CMP_THETA)
+        self._thetaSB.setToolTip("a radio will be picked each theta degres")
+        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._compositeOpts.layout().addRow(self._thetaLabel, self._thetaSB)
+
+        self._oversamplingSB = qt.QSpinBox(self)
+        self._oversamplingSB.setValue(DEFAULT_CMP_OVERSAMPLING)
+        self._oversamplingSB.setToolTip("sinogram oversampling")
+        self._compositeOpts.layout().addRow("oversampling", self._oversamplingSB)
+
+        self._nearwidthSB = qt.QSpinBox(self)
+        self._nearwidthSB.setRange(-40000, 40000)
+        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._compositeOpts.layout().addRow(self._nearwidthLabel, self._nearwidthSB)
+
+        self._subsamplingYSB = qt.QSpinBox(self)
+        self._subsamplingYSB.setValue(DEFAULT_CMP_N_SUBSAMPLING_Y)
+        self._subsamplingYSB.setToolTip("sinogram number of subsampling along y")
+        self._compositeOpts.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._compositeOpts.layout().addRow(self._takeTheLogLabel, self._takeLogCB)
+
         # set up
         self._sinogramGB.setChecked(False)
 
@@ -74,6 +131,11 @@ class InputWidget(qt.QWidget):
         self._radioGB.toggled.connect(self._radiosChecked)
         self._sinogramSubsampling.valueChanged.connect(self._changed)
         self._sinogramLineSB.sigChanged.connect(self._changed)
+        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)
         self._angleModeWidget.sigChanged.connect(self._sigUrlChanged)
 
     def setScan(self, scan: TomwerScanBase):
@@ -89,11 +151,10 @@ class InputWidget(qt.QWidget):
                 if axis_params is not None:
                     assert isinstance(axis_params, QAxisRP)
                     with block_signals(self._sinogramGB):
-                        self._sinogramChecked(
-                            axis_params.mode.requires_sinogram_index(), on_load=True
-                        )
+                        self._sinogramChecked(axis_params.use_sinogram, on_load=True)
                     self._sinogramLineSB.setSlice(axis_params.sinogram_line)
                     self._sinogramSubsampling.setValue(axis_params.sinogram_subsampling)
+                    self.setCompositeOptions(axis_params.composite_options)
                 self._angleModeWidget.setAxisParams(axis_params)
                 self._axis_params = axis_params
 
@@ -141,8 +202,10 @@ class InputWidget(qt.QWidget):
 
     def _updateAxisParams(self):
         if not self._blockUpdateAxisParams:
+            self._axis_params.use_sinogram = self._sinogramGB.isChecked()
             self._axis_params.sinogram_line = self.getSinogramLine()
             self._axis_params.sinogram_subsampling = self.getSinogramSubsampling()
+            self._axis_params.composite_options = self.getCompositeOptions()
 
     def setValidInputs(self, modes: list | tuple):
         """
@@ -167,21 +230,102 @@ class InputWidget(qt.QWidget):
             raise ValueError("modes is empty")
         else:
             mode = axis_mode._InputType.from_value(modes.pop())
-            if mode is axis_mode._InputType.SINOGRAM:
+            if mode in (axis_mode._InputType.SINOGRAM, axis_mode._InputType.COMPOSITE):
                 self._sinogramGB.setEnabled(True)
                 self._radioGB.setEnabled(False)
                 self._sinogramGB.setChecked(True)
+                self._compositeOpts.setEnabled(mode is axis_mode._InputType.COMPOSITE)
+                self._standardSinogramOpts.setEnabled(
+                    mode is not axis_mode._InputType.COMPOSITE
+                )
             elif mode is axis_mode._InputType.RADIOS_X2:
                 self._radioGB.setEnabled(True)
                 self._sinogramGB.setEnabled(False)
                 self._radioGB.setChecked(True)
-            elif mode is axis_mode._InputType.COMPOSITE:
-                # those mode are neither sinogram neither radio. Now one of the two will be checked but without any much meaning
-                self._radioGB.setEnabled(False)
-                self._sinogramGB.setEnabled(False)
             else:
                 raise ValueError(f"Nothing implemented for {mode.value}")
 
+    def getCompositeOptions(self) -> dict:
+        return {
+            "theta": self.getTheta(),
+            "oversampling": self.getOversampling(),
+            "n_subsampling_y": self.getSubsamplingY(),
+            "take_log": self.getTakeLog(),
+            "near_pos": self.getNearpos(),
+            "near_width": self.getNearwidth(),
+        }
+
+    def setCompositeOptions(self, opts: dict) -> None:
+        if not isinstance(opts, dict):
+            raise TypeError("opts should be an instance of dict")
+        for key in opts.keys():
+            if key not in (
+                "theta",
+                "oversampling",
+                "n_subsampling_y",
+                "take_log",
+                "near_pos",
+                "near_width",
+            ):
+                raise KeyError(f"{key} is not recogized")
+            theta = opts.get("theta", None)
+            if theta is not None:
+                self.setTheta(theta=theta)
+            oversampling = opts.get("oversampling", None)
+            if oversampling is not None:
+                self.setOversampling(oversampling)
+            n_subsampling_y = opts.get("n_subsampling_y", None)
+            if n_subsampling_y is not None:
+                self.setSubsamplingY(n_subsampling_y)
+
+            near_width = opts.get("near_width", None)
+            if near_width is not None:
+                self.setNearwidth(near_width)
+
+            take_log = opts.get("take_log", None)
+            if take_log is not None:
+                self.setTakeLog(take_log)
+
+    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 getNearpos(self) -> int:
+        cal_widget = self.parentWidget().widget(0)
+        assert isinstance(cal_widget, CalculationWidget)
+        return cal_widget.getEstimatedCor()
+
+    def setNearpos(self, value) -> int:
+        cal_widget = self.parentWidget().widget(0)
+        assert isinstance(cal_widget, CalculationWidget)
+        cal_widget.setNearPosition(value)
+
+    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)
+
 
 class _AngleSelectionWidget(qt.QWidget):
     """Group box to select the angle to used for cor calculation