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

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):

tomwer/gui/reconstruction/axis/AxisWidget.py

@@ -131,18 +131,15 @@ 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):
@@ -233,9 +230,12 @@ 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 (
-            scan.x_rotation_axis_pixel_position is not None
-            and self.updateAutomaticallyEstimatedCor()
+            update_x_rotation_axis_pixel_position
+            and scan.x_rotation_axis_pixel_position is not None
         ):
             self.setEstimatedCor(scan.x_rotation_axis_pixel_position)
 
@@ -495,6 +495,8 @@ 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()
 
@@ -524,3 +526,9 @@ 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)

tomwer/gui/reconstruction/axis/CalculationWidget.py

@@ -4,11 +4,13 @@ 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__)
 
@@ -24,6 +26,8 @@ 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)
@@ -31,6 +35,7 @@ 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)
@@ -53,9 +58,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.sino_fourier_angles,
+                axis_mode.AxisMode.fourier_angles,
             ),
-            # composite corase to fine
+            # composite coarse to fine
             (
                 axis_mode.AxisMode.composite_coarse_to_fine,
                 axis_mode.AxisMode.near,
@@ -91,181 +96,52 @@ class CalculationWidget(qt.QWidget):
         )
         self._modeWidget.layout().addWidget(self._lockMethodPB)
 
-        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)
+        # estimated cor
+        self._estimatedCorWidget = EstimatedCORWidget(self, axis_params=axis_params)
+        self.layout().addWidget(self._estimatedCorWidget)
 
         # 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._qbPaddingMode.currentIndexChanged.connect(self._paddingModeChanged)
-        self._padding_widget.toggled.connect(self._paddingModeChanged)
-        self._corOpts.editingFinished.connect(self._corOptsChanged)
+        self._estimatedCorWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
+            self.sigUpdateXRotAxisPixelPosOnNewScan
+        )
+        self._estimatedCorWidget.sigYAxisInvertedChanged.connect(
+            self.sigYAxisInvertedChanged
+        )
 
         # set up interface
-        self._sideWidget.setVisible(False)
+        self._estimatedCorWidget._updateVisibleSides(mode=self.getMode())
         self.setAxisParams(axis_params)
-        self._nearValueCB.setChecked(True)
-        self._nearOptsWidget.setHidden(True)
 
     def getMethodLockPB(self) -> qt.QPushButton:
         return self._lockMethodPB
 
     def setEstimatedCorValue(self, value):
-        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
+        self._estimatedCorWidget.setEstimatedCor(value=value)
+        # note: force to update the side values.
+        self._estimatedCorWidget._updateVisibleSides(mode=self.getMode())
 
     def getEstimatedCor(self):
-        try:
-            return float(self._qleNearPosQLE.text())
-        except ValueError:
-            return 0
-
-    def updateAutomaticallyEstimatedCor(self):
-        return self._nearValueCB.isChecked()
+        return self._estimatedCorWidget.getEstimatedCor()
 
-    def setUpdateAutomaticallyEstimatedCor(self, checked):
-        self._nearValueCB.setChecked(checked)
+    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
+        return self._estimatedCorWidget.updateXRotationAxisPixelPositionOnNewScan()
 
-    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 setUpdateXRotationAxisPixelPositionOnNewScan(self, update: bool):
+        self._estimatedCorWidget.setUpdateXRotationAxisPixelPositionOnNewScan(
+            update=update
+        )
 
     def _modeChanged(self, *args, **kwargs):
         mode = self.getMode()
         with block_signals(self._qcbPosition):
             with block_signals(self._axis_params):
-                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._estimatedCorWidget._updateVisibleSides(mode)
                 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()
 
@@ -303,7 +179,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):
+    def setMode(self, mode: axis_mode.AxisMode):
         with block_signals(self._qcbPosition):
             index = self._qcbPosition.findText(mode.value)
             if index >= 0:
@@ -311,43 +187,13 @@ class CalculationWidget(qt.QWidget):
             else:
                 raise ValueError("Unable to find mode", mode)
             self._lockMethodPB.setVisible(mode not in (axis_mode.AxisMode.manual,))
-
-    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()
+            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 setAxisParams(self, axis):
         with block_signals(self):
@@ -359,16 +205,10 @@ 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)
-        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)
+
+    def setScan(self, scan: TomwerScanBase | None):
+        self._estimatedCorWidget.setPixelSize(pixel_size_m=scan.x_pixel_size)
+        self._estimatedCorWidget.setImageWidth(image_width=scan.dim_1)

tomwer/gui/reconstruction/axis/ControlWidget.py

@@ -5,6 +5,10 @@ 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
@@ -263,7 +267,9 @@ class _PositionInfoWidget(qt.QWidget):
             except Exception:
                 return
             else:
-                abs_value = float(rel_value) + (width - 1) / 2.0
+                abs_value = relative_pos_to_absolute(
+                    relative_pos=float(rel_value), det_width=width
+                )
                 self._absolutePositionQLE.setText(str(abs_value))
 
     def _updateRelativePosition(self, width):
@@ -273,5 +279,7 @@ class _PositionInfoWidget(qt.QWidget):
             except Exception:
                 return
             else:
-                rel_value = float(abs_value) - (width - 1) / 2.0
+                rel_value = absolute_pos_to_relative(
+                    absolute_pos=float(abs_value), det_width=width
+                )
                 self._relativePositionQLE.setText(str(rel_value))