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

tomwer/gui/reconstruction/axis/EstimatedCORWidget.py

@@ -0,0 +1,383 @@
+from __future__ import annotations
+
+from silx.gui import qt
+from processview.gui.DropDownWidget import DropDownWidget
+from tomwer.synctools.axis import QAxisRP
+from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.gui.utils.buttons import PadlockButton
+from tomwer.gui.reconstruction.axis.EstimatedCorComboBox import EstimatedCorComboBox
+from tomwer.core.process.reconstruction.axis.side import Side
+from tomwer.core.process.reconstruction.axis import mode as axis_mode
+from tomwer.gui.fonts import FONT_SMALL
+from tomwer.gui.utils.scrollarea import QDoubleSpinBoxIgnoreWheel
+from pyunitsystem.metricsystem import MetricSystem
+
+
+class EstimatedCORWidget(qt.QGroupBox):
+    """
+    Widget to define the estimated center of rotation.
+    (based on the motor offset and the 'x_rotation_axis_pixel_position')
+    """
+
+    sigValueChanged = qt.Signal()
+    """Emit when one of the value changed"""
+    sigUpdateXRotAxisPixelPosOnNewScan = qt.Signal()
+    """Emit when user want to stop / activate x rotation axis pixel position when a new scan arrives"""
+    sigYAxisInvertedChanged = qt.Signal(bool)
+
+    def __init__(self, parent, axis_params: QAxisRP):
+        self._axis_params = axis_params
+        self._imageWidth = None
+
+        super().__init__(parent)
+        self.setLayout(qt.QGridLayout())
+        # estimated cor
+        self._estimatedCORLabel = qt.QLabel("Estimated CoR (relative)", self)
+        self.layout().addWidget(self._estimatedCORLabel, 0, 0, 1, 1)
+
+        self._estimatedCORQCB = EstimatedCorComboBox(self)
+        self.layout().addWidget(self._estimatedCORQCB, 0, 1, 1, 1)
+
+        # offset calibration
+        self._offsetWidgetDropdown = DropDownWidget(
+            parent=self, direction=qt.Qt.LayoutDirection.RightToLeft
+        )
+        self._offsetWidget = _OffsetCalibration(parent=self, axis_params=axis_params)
+        self.layout().addWidget(self._offsetWidgetDropdown, 1, 0, 2, 2)
+        self._offsetWidgetDropdown.setWidget(self._offsetWidget)
+
+        # set up
+        self._offsetWidgetDropdown.setChecked(False)
+
+        # connect signal / slot
+        self._estimatedCORQCB.sigEstimatedCorChanged.connect(self._corChanged)
+        self._offsetWidget.sigOffsetChanged.connect(
+            self._updateEstimatedCorFromMotorOffsetWidget
+        )
+        self._offsetWidget.sigXRotationAxisPixelPositionChanged.connect(
+            self._updateEstimatedCorFromMotorOffsetWidget
+        )
+        self._offsetWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
+            self.sigUpdateXRotAxisPixelPosOnNewScan
+        )
+        self._offsetWidget.sigYAxisInvertedChanged.connect(self.sigYAxisInvertedChanged)
+
+    def getEstimatedCor(self):
+        return self._estimatedCORQCB.getCurrentCorValue()
+
+    def setEstimatedCor(
+        self, value: float | Side | str, provided_with_offset: bool = False
+    ):
+
+        if isinstance(value, float):
+            if self._offsetWidget.isYAxisInverted():
+                value = -1.0 * value
+
+            if provided_with_offset:
+                value_with_offset = value
+                value_without_offset = value - self._offsetWidget.getOffset()
+            else:
+                value_with_offset = value + self._offsetWidget.getOffset()
+                value_without_offset = value
+            with block_signals(self._offsetWidget):
+                self._offsetWidget.setXRotationAxisPixelPosition(
+                    value_without_offset, apply_flip=False
+                )
+        else:
+            # case this is a side
+            value_with_offset = value
+
+        self._estimatedCORQCB.setCurrentCorValue(value_with_offset)
+
+        with block_signals(self._axis_params):
+            self._axis_params.estimated_cor = value_with_offset
+
+    def _corChanged(self, value):
+        assert value is None or isinstance(value, (float, Side, None))
+        with block_signals(self._axis_params):
+            self._axis_params.estimated_cor = value
+        self.sigValueChanged.emit()
+
+    def _updateVisibleSides(self, mode: axis_mode.AxisMode):
+        """
+        Update the visibility and selection of sides (Left, Center, Right)
+        for the Estimated Center of Rotation (CoR) ComboBox based on the
+        provided axis mode and a calculated CoR guess.
+
+        This method adjusts the available sides and determines the new
+        side (Left, Center, or Right) based on the position of a CoR guess
+        relative to the width of the image. The image is divided into thirds:
+        - Left: From -infinity to the first third.
+        - Center: From the first third to the second third.
+        - Right: From the second third to infinity.
+
+        If the CoR guess is not valid or falls outside the calculated bounds,
+        a default valid side is selected.
+
+        Behavior:
+        ---------
+        - By default if the method allows it, the side will be the estimated CoR.
+        - If the method does not allow it, it will update the visible sides in
+        the Estimated CoR ComboBox based on the valid sides defined in the axis
+        mode metadata and dynamically determines the new side (Left, Center, Right)
+        based on the CoR guess position within the image width.
+
+        """
+        mode = axis_mode.AxisMode.from_value(mode)
+        self._estimatedCORQCB.setSidesVisible(
+            axis_mode.AXIS_MODE_METADATAS[mode].valid_sides
+        )
+        first_guess_available = axis_mode.AXIS_MODE_METADATAS[
+            mode
+        ].allows_estimated_cor_as_numerical_value
+        self._estimatedCORQCB.setFirstGuessAvailable(first_guess_available)
+
+        if first_guess_available:
+            # if the first guess is valid, when the sides visibility is modify we want to activate it.
+            self._estimatedCORQCB.selectFirstGuess()
+        elif not isinstance(self._estimatedCORQCB.getCurrentCorValue(), Side):
+            # else if the current side cannot be re-used, pick the next one available
+            if axis_mode.AXIS_MODE_METADATAS[mode].valid_sides:
+                with block_signals(self._estimatedCORQCB):
+                    cor_guess = self._estimatedCORQCB.getCurrentCorValue()
+                    if cor_guess is not None and self._imageWidth is not None:
+                        left_boundary = -float("inf")
+                        right_boundary = float("inf")
+                        middle_left_boundary = (
+                            self._imageWidth / 3 - self._imageWidth / 2
+                        )
+                        middle_right_boundary = (
+                            2 * self._imageWidth / 3 - self._imageWidth / 2
+                        )
+
+                        if left_boundary <= cor_guess < middle_left_boundary:
+                            new_side = Side.LEFT
+                        elif middle_left_boundary <= cor_guess < middle_right_boundary:
+                            new_side = Side.CENTER
+                        elif middle_right_boundary <= cor_guess <= right_boundary:
+                            new_side = Side.RIGHT
+                        else:
+                            new_side = axis_mode.AXIS_MODE_METADATAS[mode].valid_sides[
+                                0
+                            ]  # Handle out-of-bound cases if needed
+                    else:
+                        new_side = axis_mode.AXIS_MODE_METADATAS[mode].valid_sides[0]
+                    self._estimatedCORQCB.setCurrentCorValue(new_side)
+                    self._axis_params.estimated_cor = new_side
+
+    def _updateEstimatedCorFromMotorOffsetWidget(self):
+        self._estimatedCORQCB.setCurrentCorValue(self._offsetWidget.getEstimatedCor())
+        self.sigValueChanged.emit()
+
+    def setImageWidth(self, image_width: float | None):
+        self._imageWidth = image_width
+
+    # expose API
+    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
+        return self._offsetWidget.updateXRotationAxisPixelPositionOnNewScan()
+
+    def setUpdateXRotationAxisPixelPositionOnNewScan(self, update: bool):
+        self._offsetWidget.setUpdateXRotationAxisPixelPositionOnNewScan(update=update)
+
+    def setPixelSize(self, pixel_size_m: float | None) -> None:
+        self._offsetWidget.setPixelSize(pixel_size_m=pixel_size_m)
+
+    def isYAxisInverted(self) -> bool:
+        return self._offsetWidget.isYAxisInverted()
+
+    def setYAxisInverted(self, checked: bool):
+        return self._offsetWidget.setYAxisInverted(checked=checked)
+
+
+class _OffsetCalibration(qt.QGroupBox):
+
+    sigOffsetChanged = qt.Signal()
+    sigXRotationAxisPixelPositionChanged = qt.Signal()
+    sigUpdateXRotAxisPixelPosOnNewScan = qt.Signal()
+    sigYAxisInvertedChanged = qt.Signal(bool)
+
+    def __init__(self, parent, axis_params: QAxisRP):
+        super().__init__(parent)
+        self._axis_params = axis_params
+
+        self.setLayout(qt.QVBoxLayout())
+
+        # x_rotation_axis_pixel_position
+        self._xRotationAxisPixelPositionGroup = qt.QGroupBox("NXtomo metadata ")
+        self._xRotationAxisPixelPositionGroup.setLayout(qt.QGridLayout())
+        self.layout().addWidget(self._xRotationAxisPixelPositionGroup)
+        self._xRotationAxisPixelPositionLabel = qt.QLabel(
+            "x_rotation_axis_pixel_position"
+        )
+        self._xRotationAxisPixelPositionGroup.layout().addWidget(
+            self._xRotationAxisPixelPositionLabel, 0, 0, 2, 1
+        )
+        self._xRotationAxisPixelPositionDSB = QDoubleSpinBoxIgnoreWheel(self)
+        self._xRotationAxisPixelPositionDSB.setDecimals(2)
+        self._xRotationAxisPixelPositionDSB.setRange(-float("inf"), float("inf"))
+        self._xRotationAxisPixelPositionDSB.setSuffix(" px")
+        self._xRotationAxisPixelPositionDSB.setEnabled(False)
+        self._xRotationAxisPixelPositionGroup.layout().addWidget(
+            self._xRotationAxisPixelPositionDSB, 0, 1, 2, 1
+        )
+        self._xRotationAxisPixelPositionKeepUpdatedCB = qt.QCheckBox(
+            "Update with\n new scan"
+        )
+        self._xRotationAxisPixelPositionKeepUpdatedCB.setFont(FONT_SMALL)
+        self._xRotationAxisPixelPositionKeepUpdatedCB.setToolTip(
+            "Updates the value when a new scan arrives.\n"
+            "Once updated this will change the numerical value of the estimated cor (from estimated relative cor)"
+        )
+        self._xRotationAxisPixelPositionGroup.layout().addWidget(
+            self._xRotationAxisPixelPositionKeepUpdatedCB, 0, 2, 1, 1
+        )
+        self._yAxisInvertedCB = qt.QCheckBox("Y axis inverted")
+        self._yAxisInvertedCB.setFont(FONT_SMALL)
+        self._yAxisInvertedCB.setToolTip(
+            "Sometime the y axis can be inverted (like on ID11).\nIn this case the estimation of the CoR has a flip that must be handled downstream"
+        )
+        self._xRotationAxisPixelPositionGroup.layout().addWidget(
+            self._yAxisInvertedCB, 1, 2, 1, 1
+        )
+
+        # offset group
+        self._offsetGroup = qt.QGroupBox("Custom Offset")
+        self._offsetGroup.setLayout(qt.QFormLayout())
+        self.layout().addWidget(self._offsetGroup)
+
+        # offset
+        self._offsetSB = QDoubleSpinBoxIgnoreWheel(self)
+        self._offsetSB.setSuffix(" px")
+        self._offsetSB.setDecimals(2)
+        self._offsetSB.setRange(-float("inf"), float("inf"))
+        self._offsetSB.setEnabled(False)
+        self._offsetGroup.layout().addRow("Offset", self._offsetSB)
+
+        # motor offset
+        self._motorOffsetSB = QDoubleSpinBoxIgnoreWheel(self)
+        self._motorOffsetSB.setSuffix(" mm")
+        self._motorOffsetSB.setDecimals(4)
+        self._motorOffsetSB.setRange(-float("inf"), float("inf"))
+        self._offsetGroup.layout().addRow("Y Motor Offset", self._motorOffsetSB)
+
+        # pixel size
+        self._pixelSizeSB = QDoubleSpinBoxIgnoreWheel(self)
+        self._pixelSizeSB.setSuffix(" µm")
+        self._pixelSizeSB.setDecimals(3)
+        self._pixelSizeSB.setRange(0, float("inf"))
+
+        # Add a horizontal layout for the pixel size and the padlock
+        pixelSizeLayout = qt.QHBoxLayout()
+
+        # Add the spin box to the layout
+        pixelSizeLayout.addWidget(self._pixelSizeSB)
+
+        # Add a padlock button
+        self._pixelSizePadlock = PadlockButton(self)
+        self._pixelSizePadlock.setChecked(True)  # Default to locked
+        self._pixelSizePadlock.setFixedSize(24, 24)
+        self._pixelSizePadlock.setToolTip("Lock/Unlock pixel size")
+        pixelSizeLayout.addWidget(self._pixelSizePadlock)
+
+        # Add the layout to the offset group
+        self._offsetGroup.layout().addRow("Pixel Size", pixelSizeLayout)
+
+        # Initialize the spin box as disabled (locked by default)
+        self._pixelSizeSB.setEnabled(False)
+
+        # Connect signal to handle locking behavior
+        self._pixelSizePadlock.toggled.connect(self._togglePixelSizeLock)
+
+        # set up
+        self._xRotationAxisPixelPositionKeepUpdatedCB.setChecked(True)
+        self._yAxisInvertedCB.setChecked(False)
+
+        # connect signal / slot
+        self._offsetSB.editingFinished.connect(self._offsetEdited)
+        self._xRotationAxisPixelPositionKeepUpdatedCB.toggled.connect(
+            self.sigUpdateXRotAxisPixelPosOnNewScan
+        )
+        self._motorOffsetSB.valueChanged.connect(self._motorOffsetChanged)
+        self._pixelSizeSB.valueChanged.connect(self._pixelSizeChanged)
+        self._yAxisInvertedCB.toggled.connect(self._yAxisInverted)
+
+    def getXRotationAxisPixelPosition(self) -> float:
+        return self._xRotationAxisPixelPositionDSB.value()
+
+    def updateXRotationAxisPixelPositionOnNewScan(self) -> bool:
+        return self._xRotationAxisPixelPositionKeepUpdatedCB.isChecked()
+
+    def setUpdateXRotationAxisPixelPositionOnNewScan(self, update):
+        self._xRotationAxisPixelPositionKeepUpdatedCB.setChecked(update)
+
+    def setXRotationAxisPixelPosition(
+        self, value: float, apply_flip: bool = True
+    ) -> float:
+        """Set the 'x_rotation_axis_pixel_position' and flip it if necessary"""
+        if apply_flip and self.isYAxisInverted():
+            value = -1.0 * value
+        self._xRotationAxisPixelPositionDSB.setValue(value)
+        return value
+
+    def getOffset(self) -> float:
+        return self._offsetSB.value()
+
+    def setOffset(self, value: float) -> None:
+        self._offsetSB.setValue(value)
+        self._offsetEdited()
+
+    def _offsetEdited(self):
+        with block_signals(self):
+            self._axis_params.x_rotation_axis_pos_px_offset = self.getOffset()
+        self.sigOffsetChanged.emit()
+
+    def _motorOffsetChanged(self):
+        """Recalculate the offset when the motor offset changes."""
+        if self._pixelSizeSB.value() and self._motorOffsetSB.value():
+            pixel_size_m = self._pixelSizeSB.value() * MetricSystem.MICROMETER.value
+            motor_offset_m = self._motorOffsetSB.value() * MetricSystem.MILLIMETER.value
+            with block_signals(self):
+                self.setOffset(motor_offset_m / pixel_size_m)
+            self.sigOffsetChanged.emit()
+
+    def _pixelSizeChanged(self):
+        """Recalculate the offset when the pixel size changes."""
+        if self._pixelSizeSB.value() and self._motorOffsetSB.value():
+            pixel_size_m = self._pixelSizeSB.value() * MetricSystem.MICROMETER.value
+            motor_offset_m = self._motorOffsetSB.value() * MetricSystem.MILLIMETER.value
+            with block_signals(self):
+                self.setOffset(motor_offset_m / pixel_size_m)
+            self.sigOffsetChanged.emit()
+
+    def _xRotationAxisPixelPositionEdited(self):
+        with block_signals(self._axis_params):
+            self._axis_params.x_rotation_axis_pixel_position = (
+                self.getXRotationAxisPixelPosition()
+            )
+        self.sigXRotationAxisPixelPositionChanged.emit()
+
+    def _yAxisInverted(self):
+        self.setXRotationAxisPixelPosition(
+            value=-1.0 * self.getXRotationAxisPixelPosition(),
+            apply_flip=False,
+        )
+        self._xRotationAxisPixelPositionEdited()
+
+    def isYAxisInverted(self) -> bool:
+        return self._yAxisInvertedCB.isChecked()
+
+    def setYAxisInverted(self, checked: bool):
+        self._yAxisInvertedCB.setChecked(checked)
+
+    def getEstimatedCor(self) -> float:
+        return self.getXRotationAxisPixelPosition() + self.getOffset()
+
+    def setPixelSize(self, pixel_size_m: float | None):
+        if pixel_size_m is None:
+            self._pixelSizeSB.clear()
+        else:
+            self._pixelSizeSB.setValue(pixel_size_m / MetricSystem.MICROMETER.value)
+
+    def _togglePixelSizeLock(self, locked: bool):
+        """Lock or unlock the pixel size spin box."""
+        self._pixelSizeSB.setEnabled(not locked)

tomwer/gui/reconstruction/axis/EstimatedCorComboBox.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from silx.gui import qt
+from tomwer.core.process.reconstruction.axis.side import Side
+from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel
+from tomwer.gui.utils.qt_utils import block_signals
+
+
+class _EstimatedCorValidator(qt.QDoubleValidator):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setDecimals(3)
+
+    def validate(self, a0: str, a1: int):
+        """validate float or string that could be part of the side values..."""
+        for value in Side.values():
+            if value.startswith(a0):
+                return (qt.QDoubleValidator.Acceptable, a0, a1)
+        return super().validate(a0, a1)
+
+
+class EstimatedCorComboBox(QComboBoxIgnoreWheel):
+    """
+    Combobox that display the sides available according to the cor algorithm (left, right, center, all)
+    and a dedicated item for cor given manually.
+
+    This combobox is also editable and and make sure the 'estimated cor' item is up to date according to the QCombobox current value
+    """
+
+    ESTIMATED_COR_ITEM_DATA = "estimated_cor"
+
+    sigEstimatedCorChanged = qt.Signal(object)
+    """Emit when the estimated cor changed. Value can be a float (cor value) or a Side"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.addItem("0.0", self.ESTIMATED_COR_ITEM_DATA)
+        for side in Side:
+            self.addItem(side.value, side)
+
+        self.setValidator(_EstimatedCorValidator())
+        self.setEditable(True)
+
+        self.setToolTip(
+            """Estimated position of the center of rotation (COR) to be given to the cor algorithms. \n
+            If you don't have a fair estimate you can provide only a side
+            """
+        )
+        # connect signal / slot
+        self.lineEdit().editingFinished.connect(self._corHasBeenEdited)
+        self.currentIndexChanged.connect(self._corChanged)
+
+    def _corHasBeenEdited(self):
+        current_cor = self.getCurrentCorValue()
+        if isinstance(current_cor, float):
+            # keep the item up to date
+            self._setCorItemValue(current_cor)
+        self.sigEstimatedCorChanged.emit(current_cor)
+
+    def _corChanged(self):
+        self.sigEstimatedCorChanged.emit(self.getCurrentCorValue())
+
+    def getCurrentCorValue(self) -> Side | float:
+        try:
+            return float(self.currentText())
+        except ValueError:
+            return Side(self.currentText())
+
+    def setCurrentCorValue(self, value: float | Side):
+        if isinstance(value, float):
+            self._setCorItemValue(value)
+        else:
+            side = Side(value)
+            item = self.findData(side)
+            self.setCurrentIndex(item)
+
+    def _setCorItemValue(self, value: float):
+        item_index = self.findData(self.ESTIMATED_COR_ITEM_DATA)
+        view = self.view()
+        hidden = view.isRowHidden(item_index)
+        with block_signals(self):
+            self.setItemText(item_index, f"{value:.2f}")
+            view.setRowHidden(item_index, hidden)
+
+    def get_hidden_sides(self) -> tuple[Side]:
+        """Return all sides currently hidden"""
+        view = self.view()
+        return tuple(
+            filter(
+                lambda side: view.isRowHidden(self.findData(side)),
+                [Side(side) for side in Side],
+            )
+        )
+
+    def setSidesVisible(self, sides: tuple[Side]):
+        """Set side to be visible to the user"""
+        sides_visibles = tuple([Side(side) for side in sides])
+        view = self.view()
+        for side in Side:
+            item_idx = self.findData(side)
+            view.setRowHidden(item_idx, side not in sides_visibles)
+
+        need_new_current_value = self.getCurrentCorValue() in self.get_hidden_sides()
+        if need_new_current_value:
+            # if the current side used cannot be used fall back to the estimated cor from motor
+            self.setCurrentIndex(self.findData(self.ESTIMATED_COR_ITEM_DATA))
+
+    def setFirstGuessAvailable(self, available: bool):
+        """
+        For some method (only growing window at the moment) a first guess (estimated cor as a float) cannot be given
+        """
+        view = self.view()
+        item_index = self.findData(self.ESTIMATED_COR_ITEM_DATA)
+        view.setRowHidden(item_index, not available)
+
+    def selectFirstGuess(self):
+        item_index = self.findData(self.ESTIMATED_COR_ITEM_DATA)
+        self.setCurrentIndex(item_index)