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

tomwer/gui/reconstruction/axis/AxisOptionsWidget.py

@@ -2,17 +2,9 @@ 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):
@@ -22,50 +14,12 @@ 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())
@@ -76,75 +30,39 @@ 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)
 
-        # composite method advanced options
-        self._compositeOptsGroup = CompositeOptsGroup(
-            parent=self, axis_params=axis_params
-        )
-        self.layout().addWidget(self._compositeOptsGroup)
+        # add near options
+        self._nearOpts = _AxisNearOptsWidget(parent=self, axis_params=self._axis_params)
+        self.layout().addWidget(self._nearOpts)
 
         # 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._corOpts.editingFinished.connect(self._updateAdvancedCorOptions)
+        self._scaleOpt.toggled.connect(self._updateScaleOpt)
         self._qcbDataMode.currentIndexChanged.connect(self._updateInputType)
-        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)
+        self._axis_params.sigChanged.connect(self._updateMode)
 
-    def _axis_params_changed(self):
+    def _updateMode(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)
-            # 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 _updateScaleOpt(self, *arg, **kwargs):
+        self._axis_params.scale_img2_to_img1 = self.isImageScaled()
 
-    def setPaddingMode(self, mode):
-        index = self._qbPaddingMode.findText(mode)
-        if index >= 0:
-            self._qbPaddingMode.setCurrentIndex(index)
-        self._paddingModeChanged()
+    def isImageScaled(self):
+        return self._scaleOpt.isChecked()
 
-    def _updateAdvancedCorOptions(self, *args, **kwargs):
-        self._axis_params.extra_cor_options = self.getCorOptions()
-        self.sigChanged.emit()
+    def _updateInputType(self, *arg, **kwargs):
+        self._axis_params.calculation_input_type = self.getCalculationInputType()
 
     def getCalculationInputType(self, *arg, **kwargs):
         return AxisCalculationInput.from_value(self._qcbDataMode.currentText())
@@ -155,159 +73,81 @@ 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()
 
-    def setCorOptions(self, opts: str | None):
-        with block_signals(self._axis_params):
-            self._corOpts.clear()
-            if opts:
-                self._corOpts.setText(opts)
-                self._updateAdvancedCorOptions()
+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)
 
-    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)
+        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)
 
-class CompositeOptsGroup(qt.QGroupBox):
-    """Group box dedicated to the composite algorithms"""
+        # connect signal / Slot
+        self._stdMaxOpt.toggled.connect(self._lookForStxMaxChanged)
+        self._nearWX.valueChanged.connect(self._windowSizeChanged)
+        self._fineStepX.valueChanged.connect(self._fineStepXChanged)
 
-    sigChanged = qt.Signal()
-    """Emit when the options changed"""
+    def _lookForStxMaxChanged(self, *args, **kwargs):
+        self._axis_params.look_at_stdmax = self.isLookAtStdMax()
 
-    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 isLookAtStdMax(self) -> bool:
+        """
 
-        # 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)
+        :return: is the option for looking at max standard deviation is
+                 activated
+        """
+        return self._stdMaxOpt.isChecked()
 
-    def setAxisParams(self, axis_params):
-        with block_signals(self):
-            self.setConfiguration(axis_params.composite_options)
-        self._axis_params = axis_params
+    def _windowSizeChanged(self, *args, **kwargs):
+        self._axis_params.near_wx = self.getWindowSize()
 
-    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)
+    def getWindowSize(self) -> int:
+        """
+
+        :return: window size for near search
+        """
+        return self._nearWX.value()
+
+    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 setAxisParams(self, axis: QAxisRP):
+        """
+
+        :param axis: axis to edit
+        """
+        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)

tomwer/gui/reconstruction/axis/AxisSettingsWidget.py

@@ -152,7 +152,6 @@ 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()
 
@@ -231,14 +230,14 @@ class AxisSettingsWidget(qt.QWidget):
 
     # expose API
 
-    def setEstimatedCor(self, value):
-        self._mainWidget.setEstimatedCorValue(value=value)
+    def updateAutomaticallyEstimatedCor(self):
+        return self._mainWidget.updateAutomaticallyEstimatedCor()
 
-    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
-        return self._mainWidget.updateXRotationAxisPixelPositionOnNewScan()
+    def setUpdateAutomaticallyEstimatedCor(self, value):
+        self._mainWidget.setUpdateAutomaticallyEstimatedCor(value)
 
-    def setUpdateXRotationAxisPixelPositionOnNewScan(self, update: bool):
-        self._mainWidget.setUpdateXRotationAxisPixelPositionOnNewScan(update=update)
+    def setEstimatedCor(self, value):
+        self._mainWidget.setEstimatedCorValue(value=value)
 
     def getEstimatedCor(self):
         return self._mainWidget.getEstimatedCor()
@@ -267,12 +266,6 @@ 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()
@@ -499,8 +492,6 @@ 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,
@@ -526,9 +517,12 @@ 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._optionsWidget, "options")
+        self.addTab(self._optionsSA, "options")
         # simplify set up. Hide options
+        self._optionsSA.hide()
         self.addTab(self._inputWidget, "input")
 
         # set up
@@ -538,11 +532,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)
-        self._calculationWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
-            self.sigUpdateXRotAxisPixelPosOnNewScan
+        # not very nice but very convenient to have the setting near at the same level
+        self._calculationWidget._qleNearPosQLE.textChanged.connect(
+            self._inputWidget._changed
         )
 
     def _urlChanged(self):
@@ -550,7 +544,6 @@ 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):
@@ -569,10 +562,6 @@ 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()
@@ -586,25 +575,15 @@ 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 isYAxisInverted(self) -> bool:
-        return self._calculationWidget._estimatedCorWidget.isYAxisInverted()
+    def updateAutomaticallyEstimatedCor(self):
+        return self._calculationWidget.updateAutomaticallyEstimatedCor()
 
-    def setYAxisInverted(self, checked: bool):
-        return self._calculationWidget._estimatedCorWidget.setYAxisInverted(
-            checked=checked
-        )
+    def setUpdateAutomaticallyEstimatedCor(self, value):
+        self._calculationWidget.setUpdateAutomaticallyEstimatedCor(value)
 
 
 class _ShiftControl(qt.QWidget):

tomwer/gui/reconstruction/axis/AxisWidget.py

@@ -131,15 +131,18 @@ class AxisWidget(qt.QMainWindow):
                 if mode is axis_mode.AxisMode.manual:
                     self._setModeLockFrmSettings(False)
 
+    def updateAutomaticallyEstimatedCor(self):
+        return self._settingsWidget.updateAutomaticallyEstimatedCor()
+
+    def setUpdateAutomaticallyEstimatedCor(self, value):
+        self._settingsWidget.setUpdateAutomaticallyEstimatedCor(value)
+
     def setEstimatedCor(self, value):
         self._settingsWidget.setEstimatedCor(value=value)
 
     def getEstimatedCor(self):
         return self._settingsWidget.getEstimatedCor()
 
-    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
-        return self._settingsWidget.updateXRotationAxisPixelPositionOnNewScan()
-
     def _setModeLockFrmSettings(self, lock: bool):
         # only lock the push button
         with block_signals(self):
@@ -230,12 +233,9 @@ class AxisWidget(qt.QMainWindow):
 
         if self._scan is not None:
             self._scan.axis_params.sigAxisUrlChanged.disconnect(self._updatePlot)
-        update_x_rotation_axis_pixel_position = (
-            self._settingsWidget._mainWidget.updateXRotationAxisPixelPositionOnNewScan()
-        )
         if (
-            update_x_rotation_axis_pixel_position
-            and scan.x_rotation_axis_pixel_position is not None
+            scan.x_rotation_axis_pixel_position is not None
+            and self.updateAutomaticallyEstimatedCor()
         ):
             self.setEstimatedCor(scan.x_rotation_axis_pixel_position)
 
@@ -495,8 +495,6 @@ class AxisWidget(qt.QMainWindow):
         if self._imgA is not None and self._imgB is not None:
             self.setImages(imgA=self._imgA, imgB=self._imgB, flipB=self._flipB)
 
-    # expose API
-
     def getXShift(self):
         return self._settingsWidget.getXShift()
 
@@ -526,9 +524,3 @@ class AxisWidget(qt.QMainWindow):
 
     def setModeLock(self, mode):
         return self._settingsWidget.setModeLock(mode=mode)
-
-    def isYAxisInverted(self) -> bool:
-        return self._settingsWidget.isYAxisInverted()
-
-    def setYAxisInverted(self, checked: bool):
-        return self._settingsWidget.setYAxisInverted(checked=checked)