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

tomwer/gui/reconstruction/axis/CalculationWidget.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+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__)
+
+
+class CalculationWidget(qt.QWidget):
+    """
+    Main widget to select the algorithm to use for COR calculation
+    Used as a tab of the AxisSettingsTabWidget
+    """
+
+    sigModeChanged = qt.Signal(str)
+    """signal emitted when the algorithm for computing COR changed"""
+
+    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)
+        qt.QWidget.__init__(self, parent)
+        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)
+
+        self.__rotAxisSelLabel = qt.QLabel("algorithm to compute cor")
+        self._modeWidget.layout().addWidget(self.__rotAxisSelLabel)
+        self._qcbPosition = QComboBoxIgnoreWheel(self)
+
+        algorithm_groups = (
+            # radio group
+            (
+                axis_mode.AxisMode.centered,
+                axis_mode.AxisMode.global_,
+                axis_mode.AxisMode.growing_window_radios,
+                axis_mode.AxisMode.sliding_window_radios,
+                axis_mode.AxisMode.octave_accurate_radios,
+            ),
+            # sino group
+            (
+                axis_mode.AxisMode.growing_window_sinogram,
+                axis_mode.AxisMode.sino_coarse_to_fine,
+                axis_mode.AxisMode.sliding_window_sinogram,
+                axis_mode.AxisMode.fourier_angles,
+            ),
+            # composite coarse to fine
+            (
+                axis_mode.AxisMode.composite_coarse_to_fine,
+                axis_mode.AxisMode.near,
+            ),
+            # read
+            (axis_mode.AxisMode.read,),
+            # manual
+            (axis_mode.AxisMode.manual,),
+        )
+        current_pos = 0
+        for i_grp, algorithm_group in enumerate(algorithm_groups):
+            if i_grp != 0:
+                self._qcbPosition.insertSeparator(current_pos)
+                current_pos += 1
+            for cor_algorithm in algorithm_group:
+                self._qcbPosition.addItem(cor_algorithm.value)
+                idx = self._qcbPosition.findText(cor_algorithm.value)
+                self._qcbPosition.setItemData(
+                    idx,
+                    axis_mode.AXIS_MODE_METADATAS[cor_algorithm].tooltip,
+                    qt.Qt.ToolTipRole,
+                )
+                current_pos += 1
+
+        self._modeWidget.layout().addWidget(self._qcbPosition)
+
+        # method lock button
+        self._lockMethodPB = PadlockButton(parent=self._modeWidget)
+        self._lockMethodPB.setToolTip(
+            "Lock the method to compute the cor. \n"
+            "This will automatically call the "
+            "defined algorithm each time a scan is received."
+        )
+        self._modeWidget.layout().addWidget(self._lockMethodPB)
+
+        # 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._lockMethodPB.sigLockChanged.connect(self.lockMode)
+        self._estimatedCorWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
+            self.sigUpdateXRotAxisPixelPosOnNewScan
+        )
+        self._estimatedCorWidget.sigYAxisInvertedChanged.connect(
+            self.sigYAxisInvertedChanged
+        )
+
+        # set up interface
+        self._estimatedCorWidget._updateVisibleSides(mode=self.getMode())
+        self.setAxisParams(axis_params)
+
+    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())
+
+    def getEstimatedCor(self):
+        return self._estimatedCorWidget.getEstimatedCor()
+
+    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
+        return self._estimatedCorWidget.updateXRotationAxisPixelPositionOnNewScan()
+
+    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._estimatedCorWidget._updateVisibleSides(mode)
+                self._axis_params.mode = mode.value
+            self._axis_params.changed()
+            self.sigModeChanged.emit(mode.value)
+
+    def isModeLock(self):
+        return self._lockMethodPB.isLocked()
+
+    def setModeLock(self, mode=None):
+        """set a specific mode and lock it.
+
+        :param mode: mode to lock. If None then keep the current mode
+        """
+        if mode is not None:
+            mode = axis_mode.AxisMode.from_value(mode)
+        if mode is None and axis_mode.AXIS_MODE_METADATAS[self.getMode()].is_lockable():
+            raise ValueError(
+                "Unable to lock the current mode is not an automatic algorithm"
+            )
+        elif (
+            mode != self.getMode() and axis_mode.AXIS_MODE_METADATAS[mode].is_lockable()
+        ):
+            raise ValueError("Unable to lock %s this is not a lockable mode")
+
+        if mode is not None:
+            self.setMode(mode)
+        if not self._lockMethodPB.isLocked():
+            with block_signals(self._lockMethodPB):
+                self._lockMethodPB.setLock(True)
+        self.lockMode(True)
+
+    def lockMode(self, lock):
+        with block_signals(self._lockMethodPB):
+            self._lockMethodPB.setLock(lock)
+            self._qcbPosition.setEnabled(not lock)
+
+        self.sigLockModeChanged.emit(lock)
+
+    def getMode(self):
+        """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
+        with block_signals(self._qcbPosition):
+            index = self._qcbPosition.findText(mode.value)
+            if index >= 0:
+                self._qcbPosition.setCurrentIndex(index)
+            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 setAxisParams(self, axis):
+        with block_signals(self):
+            if self._axis_params is not None:
+                self._axis_params.sigChanged.disconnect(self._axis_params_changed)
+            self._axis_params = axis
+            if self._axis_params.mode in (axis_mode.AxisMode.manual,):
+                # those mode cannot be handled by the auto calculation dialog
+                self._axis_params.mode = axis_mode.AxisMode.growing_window_radios
+            self._axis_params.sigChanged.connect(self._axis_params_changed)
+            self._axis_params_changed()
+
+    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)

tomwer/gui/reconstruction/axis/CompareImages.py

@@ -1,31 +1,5 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["v. Valls", "H. Payno"]
-__license__ = "MIT"
-__date__ = "26/02/2019"
+from __future__ import annotations
 
 import logging
 import weakref
@@ -100,7 +74,7 @@ class CompareImagesStatusBar(qt.QStatusBar):
     Use :meth:`setCompareWidget` to connect this toolbar to a specific
     :class:`CompareImages` widget.
 
-    :param Union[qt.QWidget,None] parent: Parent of this widget.
+    :param parent: Parent of this widget.
     """
 
     def __init__(self, parent=None):
@@ -127,7 +101,7 @@ class CompareImagesStatusBar(qt.QStatusBar):
         """
         Connect this tool bar to a specific :class:`CompareImages` widget.
 
-        :param Union[None,CompareImages] widget: The widget to connect with.
+        :param widget: The widget to connect with.
         """
         compareWidget = self.getCompareWidget()
         if compareWidget is not None:
@@ -142,11 +116,8 @@ class CompareImagesStatusBar(qt.QStatusBar):
             compareWidget.getPlot().sigPlotSignal.connect(self.__plotSignalReceived)
             compareWidget.sigConfigurationChanged.connect(self.__dataChanged)
 
-    def getCompareWidget(self):
-        """Returns the connected widget.
-
-        :rtype: CompareImages
-        """
+    def getCompareWidget(self) -> CompareImages:
+        """Returns the connected widget."""
         if self.__compareWidget is None:
             return None
         else:
@@ -167,13 +138,12 @@ class CompareImagesStatusBar(qt.QStatusBar):
         """Called when internal data from the connected widget changes."""
         self._updateStatusBar()
 
-    def _formatData(self, data):
+    def _formatData(self, data: int | float | None) -> str:
         """Format pixel of an image.
 
         It supports intensity, RGB, and RGBA.
 
-        :param Union[int,float,numpy.ndarray,str]: Value of a pixel
-        :rtype: str
+        :param data: Value of a pixel
         """
         if data is None:
             return "-"
@@ -287,11 +257,11 @@ class CompareImagesToolBar(qt.QToolBar):
         if widget is not None:
             widget.setVisualizationMode(mode)
 
-    def setCompareWidget(self, widget):
+    def setCompareWidget(self, widget: None | CompareImages):
         """
         Connect this tool bar to a specific :class:`CompareImages` widget.
 
-        :param Union[None,CompareImages] widget: The widget to connect with.
+        :param widget: The widget to connect the toolbar with.
         """
         compareWidget = self.getCompareWidget()
         if compareWidget is not None:
@@ -308,11 +278,8 @@ class CompareImagesToolBar(qt.QToolBar):
             widget.sigConfigurationChanged.connect(self.__updateSelectedActions)
         self.__updateSelectedActions()
 
-    def getCompareWidget(self):
-        """Returns the connected widget.
-
-        :rtype: CompareImages
-        """
+    def getCompareWidget(self) -> CompareImages:
+        """Returns the connected widget."""
         if self.__compareWidget is None:
             return None
         else:

tomwer/gui/reconstruction/axis/ControlWidget.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import logging
+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
+
+_logger = logging.getLogger(__file__)
+
+
+class ControlWidget(qt.QWidget):
+    """
+    Widget to lock, compute or validate the cor position and display it value as absolute or relative
+    This is the widget displayed at the bottom of the AxisOW
+    """
+
+    sigComputationRequest = qt.Signal()
+    """Signal emitted when user request a computation from the settings"""
+
+    sigValidateRequest = qt.Signal()
+    """Signal emitted when user validate the current settings"""
+
+    sigLockCORValueChanged = qt.Signal(bool)
+    """Signal emitted when the user lock the cor value. Param: True if lock"""
+
+    def __init__(self, parent):
+        qt.QWidget.__init__(self, parent)
+        self.setLayout(qt.QVBoxLayout())
+
+        # display 'center' information
+        self._positionInfo = _PositionInfoWidget(parent=self)
+        self.layout().addWidget(self._positionInfo)
+
+        self._buttons = qt.QWidget(parent=self)
+        self._buttons.setLayout(qt.QHBoxLayout())
+        self.layout().addWidget(self._buttons)
+
+        self._lockBut = PadlockButton(parent=self)
+        self._lockBut.setAutoDefault(False)
+        self._lockBut.setDefault(False)
+
+        self._buttons.layout().addWidget(self._lockBut)
+        self._lockLabel = qt.QLabel("lock cor value", parent=self)
+        self._buttons.layout().addWidget(self._lockLabel)
+
+        spacer = qt.QWidget(self)
+        spacer.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum)
+        self._buttons.layout().addWidget(spacer)
+
+        self._computeBut = qt.QPushButton("compute", parent=self)
+        self._buttons.layout().addWidget(self._computeBut)
+        style = qt.QApplication.style()
+        applyIcon = style.standardIcon(qt.QStyle.SP_DialogApplyButton)
+        self._applyBut = qt.QPushButton(applyIcon, "validate", parent=self)
+        self._buttons.layout().addWidget(self._applyBut)
+        self.layout().addWidget(self._buttons)
+
+        # set up
+        self._positionInfo.setPosition(None, None)
+
+        # make connection
+        self._computeBut.pressed.connect(self._needComputation)
+        self._applyBut.pressed.connect(self._validate)
+        self._lockBut.sigLockChanged.connect(self._lockValueChanged)
+
+    def hideLockButton(self) -> None:
+        self._lockLabel.hide()
+        self._lockBut.hide()
+
+    def hideApplyButton(self) -> None:
+        self._applyBut.hide()
+
+    def _lockValueChanged(self):
+        self.sigLockCORValueChanged.emit(self._lockBut.isLocked())
+        self._computeBut.setEnabled(not self._lockBut.isLocked())
+
+    def _needComputation(self, *arg, **kwargs):
+        """callback when the radio line changed"""
+        self.sigComputationRequest.emit()
+
+    def _validate(self):
+        self.sigValidateRequest.emit()
+
+    def setPosition(self, relative_cor, abs_cor):
+        self._positionInfo.setPosition(relative_cor=relative_cor, abs_cor=abs_cor)
+
+    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()
+
+    def setValueLock(self, lock):
+        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_params = None
+        self._defaultBackgroundColor = None
+        qt.QWidget.__init__(self, parent)
+        self.setLayout(qt.QGridLayout())
+        centerLabel = qt.QLabel("center", parent=self)
+        centerLabel.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum)
+        font = centerLabel.font()
+        font.setBold(True)
+        centerLabel.setFont(font)
+
+        self.layout().addWidget(centerLabel, 0, 0, 1, 1)
+        self.layout().addWidget(qt.QLabel(" (relative):"), 0, 1, 1, 1)
+
+        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._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)
+        font = centerLabel.font()
+        font.setBold(False)
+        centerLabel.setFont(font)
+
+        self.layout().addWidget(centerLabel, 1, 0, 1, 1)
+        self.layout().addWidget(qt.QLabel(" (absolute):"), 1, 1, 1, 1)
+        self._absolutePositionQLE = qt.QLineEdit("", parent=self)
+        self._absolutePositionQLE.setValidator(self._positionValidator)
+        self._absolutePositionQLE.setSizePolicy(
+            qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum
+        )
+        self._absolutePositionQLE.setStyleSheet("color: #ff8c00")
+        self.layout().addWidget(self._absolutePositionQLE, 1, 2, 1, 1)
+
+        if axis:
+            self.setAxisParams(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:
+            value = float(self._relativePositionQLE.text())
+            # make sure we only emit the signal if the value changed (and when the Qline has been edited).
+            if self._axis_params.relative_cor_value is None or (
+                self._axis_params is not None
+                and not numpy.isclose(
+                    value, self._axis_params.relative_cor_value, atol=1e-3
+                )
+            ):
+                self.sigRelativeValueSet.emit(value)
+
+    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:
+            value = float(self._absolutePositionQLE.text())
+            # make sure we only emit the signal if the value changed (and when the Qline has been edited).
+            if self._axis_params.absolute_cor_value is None or (
+                self._axis_params is not None
+                and not numpy.isclose(
+                    value, self._axis_params.absolute_cor_value, atol=1e-3
+                )
+            ):
+                self.sigAbsolueValueSet.emit(value)
+
+    def setAxisParams(self, axis):
+        assert isinstance(axis, QAxisRP)
+        if axis == self._axis_params:
+            return
+        self._axis_params = axis
+
+    def getPosition(self):
+        return float(self._relativePositionQLE.text())
+
+    def setPosition(self, relative_cor: float | None, abs_cor: float | None):
+        if relative_cor is None:
+            self._relativePositionQLE.setText("?")
+        elif isinstance(relative_cor, str):
+            self._relativePositionQLE.setText(relative_cor)
+        else:
+            self._relativePositionQLE.setText(f"{relative_cor:.3f}")
+        if abs_cor is None:
+            self._absolutePositionQLE.setText("?")
+        else:
+            self._absolutePositionQLE.setText(f"{abs_cor:.3f}")
+
+    def _updateAbsolutePosition(self, width):
+        if width is not None:
+            try:
+                rel_value = float(self._relativePositionQLE.text())
+            except Exception:
+                return
+            else:
+                abs_value = relative_pos_to_absolute(
+                    relative_pos=float(rel_value), det_width=width
+                )
+                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 = absolute_pos_to_relative(
+                    absolute_pos=float(abs_value), det_width=width
+                )
+                self._relativePositionQLE.setText(str(rel_value))