tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/gui/reconstruction/axis/axis.py

@@ -40,6 +40,7 @@ from silx.utils.deprecation import deprecated
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.utils.buttons import PadlockButton
+from tomwer.gui.settings import EDITING_BACKGROUND_COLOR
 from tomwer.synctools.axis import QAxisRP
 
 from ...utils.scandescription import ScanNameLabelAndShape
@@ -135,7 +136,7 @@ class AxisWindow(qt.QMainWindow):
         self._selectionGB._selectionChanged(self._selectionGB.getSelection())
 
         # connect signal / slots
-        self._axisWidget.sigValidateRequest.connect(self._repeatValidateRequest)
+        self._axisWidget.sigValidateRequest.connect(self.sigApply)
         self._axisWidget.sigComputationRequested.connect(self._computationRequested)
         self._axisWidget.sigLockModeChanged.connect(self._lockModeChanged)
         self._selectionGB.sigSelectionChanged.connect(self._axisWidget._axisTypeChanged)
@@ -202,11 +203,8 @@ class AxisWindow(qt.QMainWindow):
     def _computationReady(self):
         self.sigComputationRequested.emit()
 
-    def _repeatValidateRequest(self):
-        self.sigApply.emit()
-
     def setPosition(self, frm: float, value: float):
-        self._axisWidget.setPosition(value_ref_tomwer=value)
+        self._axisWidget.setPosition(relative_value=value)
 
 
 class _AxisWidget(qt.QMainWindow):
@@ -276,18 +274,36 @@ class _AxisWidget(qt.QMainWindow):
             )
 
         # connect signal / slots
-        self._controlWidget.sigComputationRequest.connect(
-            self._repeatComputationRequest
-        )
-        self._controlWidget.sigValidateRequest.connect(self._repeatValidateRequest)
+        self._controlWidget.sigComputationRequest.connect(self.sigComputationRequested)
+        self._controlWidget.sigValidateRequest.connect(self.sigValidateRequest)
         self._controlWidget.sigLockCORValueChanged.connect(self._CORValueLocked)
-        self._radioAxis.sigLockModeChanged.connect(self._lockModeChanged)
+        self._radioAxis.sigLockModeChanged.connect(self.sigLockModeChanged)
         self._radioAxis.sigPositionChanged.connect(self._setPositionFrmTuple)
+        self._controlWidget._positionInfo.sigRelativeValueSet.connect(
+            self._forceRelativePosition
+        )
+        self._controlWidget._positionInfo.sigAbsolueValueSet.connect(
+            self._forceAbsolutePosition
+        )
 
         # set up
         self.addPlot(self._radioAxis)
         self.setActiveWidget(self._radioAxis)
 
+    def _forceRelativePosition(self, value: float):
+        self.setMode(AxisMode.manual)
+        self.setPosition(
+            relative_value=value,
+            absolute_value=None,
+        )
+
+    def _forceAbsolutePosition(self, value: float):
+        self.setMode(AxisMode.manual)
+        self.setPosition(
+            relative_value=None,
+            absolute_value=value,
+        )
+
     def setAutoUpdateEstimatedCor(self, value):
         self._radioAxis.setUpdateAutomaticallyEstimatedCor(value)
 
@@ -298,9 +314,6 @@ class _AxisWidget(qt.QMainWindow):
     def getMode(self):
         return self._radioAxis.getMode()
 
-    def _sinoAxisReady(self):
-        self.sigSinogramReady.emit()
-
     def manual_uses_full_image(self, value):
         self._radioAxis.manual_uses_full_image(value)
 
@@ -308,15 +321,6 @@ class _AxisWidget(qt.QMainWindow):
         self.getAxis().mode = self.getMode()
         self.getAxis().use_sinogram = self.useSinogram()
 
-    def _lockModeChanged(self):
-        self.sigLockModeChanged.emit()
-
-    def _repeatComputationRequest(self):
-        self.sigComputationRequested.emit()
-
-    def _repeatValidateRequest(self):
-        self.sigValidateRequest.emit()
-
     def setMode(self, mode):
         mode = AxisMode.from_value(mode)
         self.setActiveWidget(self._radioAxis)
@@ -349,11 +353,9 @@ class _AxisWidget(qt.QMainWindow):
         self._settingsDockWidget.setWidget(widget)
 
     def _setPositionFrmTuple(self, value):
-        self.setPosition(value_ref_tomwer=value[0])
+        self.setPosition(relative_value=value[0])
 
-    def setPosition(
-        self, value_ref_tomwer: float, value_ref_nabu: float = None
-    ) -> None:
+    def setPosition(self, relative_value: float, absolute_value: float = None) -> None:
         """
 
         :param float value_ref_tomwer: center of rotation value on tomwer
@@ -363,19 +365,28 @@ class _AxisWidget(qt.QMainWindow):
         :raises: ValueError if the frm parameter is not recognized
         """
         if (
-            value_ref_nabu is None
+            absolute_value is None
+            and self._axis_params.frame_width is not None
+            and relative_value is not None
+        ):
+            try:
+                absolute_value = relative_value + self._axis_params.frame_width / 2.0
+            except TypeError:
+                absolute_value = None
+        if (
+            relative_value is None
             and self._axis_params.frame_width is not None
-            and value_ref_tomwer is not None
+            and absolute_value is not None
         ):
             try:
-                value_ref_nabu = value_ref_tomwer + self._axis_params.frame_width / 2.0
+                relative_value = absolute_value - self._axis_params.frame_width / 2.0
             except TypeError:
-                value_ref_nabu = None
+                relative_value = None
         self._controlWidget.setPosition(
-            value_ref_tomwer=value_ref_tomwer, value_ref_nabu=value_ref_nabu
+            value_ref_tomwer=relative_value, value_ref_nabu=absolute_value
         )
-        if value_ref_tomwer is not None:
-            self._radioAxis.setXShift(value_ref_tomwer)
+        if relative_value is not None:
+            self._radioAxis.setXShift(relative_value)
         else:
             self._radioAxis.resetShift()
 
@@ -399,10 +410,21 @@ class _AxisWidget(qt.QMainWindow):
             )
         elif set_position is False:
             if scan.dim_1 is not None:
-                self._controlWidget._updateAbsolutePosition(width=scan.dim_1)
-
-    def _applyRequested(self) -> None:
-        self.sigApply.emit()
+                # if absolute position is know and relative position not (in the case the user already define absolute position only):
+                has_absolute_val_already = not self._controlWidget._positionInfo._absolutePositionQLE.text().startswith(
+                    (".", "?")
+                )
+                has_relative_val_already = not self._controlWidget._positionInfo._relativePositionQLE.text().startswith(
+                    (".", "?")
+                )
+                if (
+                    self.getMode() is AxisMode.manual
+                    and has_absolute_val_already
+                    and not has_relative_val_already
+                ):
+                    self._controlWidget._updateRelativePosition(width=scan.dim_1)
+                else:
+                    self._controlWidget._updateAbsolutePosition(width=scan.dim_1)
 
     def _computationRequested(self) -> None:
         self.sigComputationRequested.emit()
@@ -527,6 +549,9 @@ class _ControlWidget(qt.QWidget):
     def _updateAbsolutePosition(self, width):
         self._positionInfo._updateAbsolutePosition(width=width)
 
+    def _updateRelativePosition(self, width):
+        self._positionInfo._updateRelativePosition(width=width)
+
     def isValueLock(self):
         return self._lockBut.isLocked()
 
@@ -534,11 +559,25 @@ class _ControlWidget(qt.QWidget):
         self._lockBut.setLock(lock)
 
 
+class _PositionInfoValidator(qt.QDoubleValidator):
+    def validate(self, a0: str, a1: int):
+        if "..." in a0 or a0 == "?":
+            return (qt.QDoubleValidator.Acceptable, a0, a1)
+        else:
+            return super().validate(a0, a1)
+
+
 class _PositionInfoWidget(qt.QWidget):
     """Widget used to display information relative to the current position"""
 
+    sigRelativeValueSet = qt.Signal(float)
+    """Emit when the user define manually the relative value"""
+    sigAbsolueValueSet = qt.Signal(float)
+    """Emit when the user define manually the absolute value"""
+
     def __init__(self, parent, axis=None):
         self._axis = None
+        self._defaultBackgroundColor = None
         qt.QWidget.__init__(self, parent)
         self.setLayout(qt.QGridLayout())
         centerLabel = qt.QLabel("center", parent=self)
@@ -550,13 +589,14 @@ class _PositionInfoWidget(qt.QWidget):
         self.layout().addWidget(centerLabel, 0, 0, 1, 1)
         self.layout().addWidget(qt.QLabel(" (relative):"), 0, 1, 1, 1)
 
-        self._relativePositionLabel = qt.QLineEdit("", parent=self)
-        self._relativePositionLabel.setReadOnly(True)
-        self._relativePositionLabel.setSizePolicy(
+        self._relativePositionQLE = qt.QLineEdit("", parent=self)
+        self._positionValidator = _PositionInfoValidator(self)
+        self._relativePositionQLE.setValidator(self._positionValidator)
+        self._relativePositionQLE.setSizePolicy(
             qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum
         )
-        self._relativePositionLabel.setStyleSheet("color: red")
-        self.layout().addWidget(self._relativePositionLabel, 0, 2, 1, 1)
+        self._relativePositionQLE.setStyleSheet("color: red")
+        self.layout().addWidget(self._relativePositionQLE, 0, 2, 1, 1)
 
         centerLabel = qt.QLabel("center", parent=self)
         centerLabel.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum)
@@ -566,17 +606,77 @@ class _PositionInfoWidget(qt.QWidget):
 
         self.layout().addWidget(centerLabel, 1, 0, 1, 1)
         self.layout().addWidget(qt.QLabel(" (absolute):"), 1, 1, 1, 1)
-        self._absolutePositionLabel = qt.QLineEdit("", parent=self)
-        self._absolutePositionLabel.setReadOnly(True)
-        self._absolutePositionLabel.setSizePolicy(
+        self._absolutePositionQLE = qt.QLineEdit("", parent=self)
+        self._absolutePositionQLE.setValidator(self._positionValidator)
+        self._absolutePositionQLE.setSizePolicy(
             qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum
         )
-        self._absolutePositionLabel.setStyleSheet("color: #ff8c00")
-        self.layout().addWidget(self._absolutePositionLabel, 1, 2, 1, 1)
+        self._absolutePositionQLE.setStyleSheet("color: #ff8c00")
+        self.layout().addWidget(self._absolutePositionQLE, 1, 2, 1, 1)
 
         if axis:
             self.setAxis(axis)
 
+        # connect signal / slot
+        self._relativePositionQLE.textEdited.connect(
+            self._userStartEditingRelativePosition
+        )
+        self._relativePositionQLE.editingFinished.connect(
+            self._userUpdatedRelativePosition
+        )
+        self._absolutePositionQLE.textEdited.connect(
+            self._userStartEditingAbsolutePosition
+        )
+
+        self._absolutePositionQLE.editingFinished.connect(
+            self._userUpdatedAbsolutePosition
+        )
+
+    def _getDefaultBackgroundColor(self):
+        if self._defaultBackgroundColor is None:
+            self._defaultBackgroundColor = self.palette().color(
+                self._absolutePositionQLE.backgroundRole()
+            )
+        return self._defaultBackgroundColor
+
+    def _userStartEditingRelativePosition(self, *args, **kwargs):
+        palette = self.palette()
+        palette.setColor(
+            self._relativePositionQLE.backgroundRole(), EDITING_BACKGROUND_COLOR
+        )
+        self._relativePositionQLE.setPalette(palette)
+
+    def _userStartEditingAbsolutePosition(self, *args, **kwargs):
+        palette = self.palette()
+        palette.setColor(
+            self._absolutePositionQLE.backgroundRole(), EDITING_BACKGROUND_COLOR
+        )
+        self._absolutePositionQLE.setPalette(palette)
+
+    def _userUpdatedRelativePosition(self, *args, **kwargs):
+        palette = self.palette()
+        palette.setColor(
+            self._relativePositionQLE.backgroundRole(),
+            self._getDefaultBackgroundColor(),
+        )
+        self._relativePositionQLE.setPalette(palette)
+        if self._relativePositionQLE.text().startswith((".", "?")):
+            return
+        else:
+            self.sigRelativeValueSet.emit(float(self._relativePositionQLE.text()))
+
+    def _userUpdatedAbsolutePosition(self, *args, **kwargs):
+        palette = self.palette()
+        palette.setColor(
+            self._absolutePositionQLE.backgroundRole(),
+            self._getDefaultBackgroundColor(),
+        )
+        self._absolutePositionQLE.setPalette(palette)
+        if self._absolutePositionQLE.text().startswith((".", "?")):
+            return
+        else:
+            self.sigAbsolueValueSet.emit(float(self._absolutePositionQLE.text()))
+
     def setAxis(self, axis):
         assert isinstance(axis, QAxisRP)
         if axis == self._axis:
@@ -595,22 +695,36 @@ class _PositionInfoWidget(qt.QWidget):
             )
 
     def getPosition(self):
-        return float(self._relativePositionLabel.text())
+        return float(self._relativePositionQLE.text())
 
     def setPosition(self, relative_cor: Optional[float], abs_cor: Optional[float]):
         if relative_cor is None:
-            self._relativePositionLabel.setText("?")
+            self._relativePositionQLE.setText("?")
         elif isinstance(relative_cor, str):
-            self._relativePositionLabel.setText(relative_cor)
+            self._relativePositionQLE.setText(relative_cor)
         else:
-            self._relativePositionLabel.setText(f"{relative_cor:.3f}")
+            self._relativePositionQLE.setText(f"{relative_cor:.3f}")
         if abs_cor is None:
-            self._absolutePositionLabel.setText("?")
+            self._absolutePositionQLE.setText("?")
         else:
-            self._absolutePositionLabel.setText(f"{abs_cor:.3f}")
+            self._absolutePositionQLE.setText(f"{abs_cor:.3f}")
 
     def _updateAbsolutePosition(self, width):
-        rel_value = self._relativePositionLabel.text()
-        if rel_value.isnumeric() and width is not None:
-            abs_value = float(rel_value) + width / 2.0
-            self._absolutePositionLabel.setText(str(abs_value))
+        if width is not None:
+            try:
+                rel_value = float(self._relativePositionQLE.text())
+            except Exception:
+                return
+            else:
+                abs_value = float(rel_value) + width / 2.0
+                self._absolutePositionQLE.setText(str(abs_value))
+
+    def _updateRelativePosition(self, width):
+        if width is not None:
+            try:
+                abs_value = float(self._absolutePositionQLE.text())
+            except Exception:
+                return
+            else:
+                rel_value = float(abs_value) - width / 2.0
+                self._relativePositionQLE.setText(str(rel_value))