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

tomwer/gui/reconstruction/axis/AxisMainWindow.py

@@ -0,0 +1,275 @@
+"""
+contains gui relative to axis calculation using sinogram
+"""
+
+from __future__ import annotations
+
+import logging
+
+from silx.gui import qt
+from tomwer.gui.utils.qt_utils import block_signals
+
+from tomwer.core.process.reconstruction.axis.mode import AxisMode
+from tomwer.core.process.reconstruction.utils.cor import (
+    absolute_pos_to_relative,
+    relative_pos_to_absolute,
+)
+from tomwer.core.scan.scanbase import TomwerScanBase
+
+from ...utils.scandescription import ScanNameLabelAndShape
+from .AxisWidget import AxisWidget
+from .ControlWidget import ControlWidget
+
+_logger = logging.getLogger(__file__)
+
+
+class AxisMainWindow(qt.QMainWindow):
+    """
+    Main window for the center of rotation search.
+    It displays:
+    * scan information
+    * AxisWidget
+    * allows to set the cor value as absolute and relative and edit it
+    """
+
+    sigComputationRequested = qt.Signal()
+    """emit when the user request for computation"""
+
+    sigApply = qt.Signal()
+    """emit when the user validate the axis value"""
+
+    sigLockCORValueChanged = qt.Signal(bool)
+    """bool: True if locked"""
+
+    sigLockModeChanged = qt.Signal()
+    """Signal emitted when the lock mode on the mode change"""
+
+    sigModeChanged = qt.Signal(str)
+    """signal emit when the mode is changed"""
+
+    sigSinogramReady = qt.Signal()
+    """signal emit when the sinogram load is complete and processing ready"""
+
+    sigAxisEditionLocked = qt.Signal(bool)
+    """Signal emitted when the status of the reconstruction parameters edition
+    change"""
+
+    def __init__(self, axis_params, parent=None, backend=None):
+        super().__init__(parent)
+
+        self._mainWidget = qt.QWidget(self)
+        self._mainWidget.setLayout(qt.QVBoxLayout())
+
+        # add scan name
+        self._scan_label = ScanNameLabelAndShape(parent=self)
+        self._mainWidget.layout().addWidget(self._scan_label)
+
+        self.setDockOptions(qt.QMainWindow.AnimatedDocks)
+
+        # Axis Widget
+        self._axis_params = axis_params
+        self._axisWidget = AxisWidget(
+            parent=self, axis_params=axis_params, backend=backend
+        )
+        self._mainWidget.layout().addWidget(self._axisWidget)
+        self.setCentralWidget(self._mainWidget)
+
+        # append cor editor to the radio axis widget
+        self._controlWidget = ControlWidget(parent=self)
+        self._controlWidget.setSizePolicy(
+            qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum
+        )
+        self._controlDockWidget = qt.QDockWidget(parent=self)
+        self._controlDockWidget.setSizePolicy(
+            qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum
+        )
+        self._controlDockWidget.layout().setContentsMargins(0, 0, 0, 0)
+        self._controlDockWidget.layout().setSpacing(0)
+        self._controlDockWidget.setMaximumHeight(150)
+        self._controlDockWidget.setWidget(self._controlWidget)
+        self._controlDockWidget.setFeatures(qt.QDockWidget.DockWidgetMovable)
+        self._axisWidget.addDockWidget(
+            qt.Qt.RightDockWidgetArea, self._controlDockWidget
+        )
+
+        # set up
+        if self._axis_params.mode is AxisMode.manual:
+            self._controlWidget.setPosition(
+                self._axis_params.relative_cor_value,
+                self._axis_params.absolute_cor_value,
+            )
+        self._controlWidget._positionInfo.setAxisParams(self._axis_params)
+
+        # connect signal / slots
+        self._controlWidget.sigComputationRequest.connect(self.sigComputationRequested)
+        self._controlWidget.sigValidateRequest.connect(self.sigApply)
+        self._controlWidget.sigLockCORValueChanged.connect(self._CORValueLocked)
+        self._axisWidget.sigLockModeChanged.connect(self.sigLockModeChanged)
+        self._axisWidget.sigPositionChanged.connect(self._setPositionFrmTuple)
+        self._controlWidget._positionInfo.sigRelativeValueSet.connect(
+            self._forceRelativePosition
+        )
+        self._controlWidget._positionInfo.sigAbsolueValueSet.connect(
+            self._forceAbsolutePosition
+        )
+
+    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._axisWidget._settingsWidget._mainWidget.setUpdateXRotationAxisPixelPositionOnNewScan(
+            value
+        )
+
+    def manual_uses_full_image(self, value):
+        self._axisWidget.manual_uses_full_image(value)
+
+    def _modeChanged(self):
+        self.getAxisParams().mode = self.getMode()
+
+    def _CORValueLocked(self, lock):
+        if lock:
+            self.setMode(AxisMode.manual)
+        self.setModeLock(lock)
+        self.sigLockCORValueChanged.emit(lock)
+
+    def _setPositionFrmTuple(self, value):
+        self.setPosition(relative_value=value[0])
+
+    def setPosition(self, relative_value: float, absolute_value: float = None) -> None:
+        if (
+            absolute_value is None
+            and self._axis_params.frame_width is not None
+            and relative_value is not None
+        ):
+            try:
+                absolute_value = relative_pos_to_absolute(
+                    relative_pos=relative_value, det_width=self._axis_params.frame_width
+                )
+            except TypeError:
+                absolute_value = None
+        if (
+            relative_value is None
+            and self._axis_params.frame_width is not None
+            and absolute_value is not None
+        ):
+            try:
+                relative_value = absolute_pos_to_relative(
+                    absolute_pos=absolute_value, det_width=self._axis_params.frame_width
+                )
+            except TypeError:
+                relative_value = None
+        self._controlWidget.setPosition(
+            relative_cor=relative_value, abs_cor=absolute_value
+        )
+        if relative_value is not None:
+            self._axisWidget.setXShift(relative_value)
+        else:
+            self._axisWidget.resetShift()
+
+    def getAxisParams(self):
+        return self._axis_params
+
+    def setScan(self, scan: TomwerScanBase, set_position: bool = False):
+        """
+        set the gui for this scan
+
+        :param scan:
+        """
+        self._axisWidget.setScan(scan=scan)
+        if set_position is True and scan.axis_params is not None:
+            self.setPosition(
+                scan.axis_params.relative_cor_value, scan.axis_params.relative_cor_value
+            )
+        elif set_position is False:
+            if scan.dim_1 is not None:
+                # 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()
+
+    def _setModeLockFrmSettings(self, lock):
+        with block_signals(self):
+            self._axisWidget._setModeLockFrmSettings(lock)
+
+    def _setValueLockFrmSettings(self, lock):
+        with block_signals(self):
+            self.setValueLock(lock)
+
+    def setModeLock(self, lock):
+        assert type(lock) is bool
+        self._axisWidget.setLocked(lock)
+
+    def isModeLock(self):
+        return self._axisWidget.isModeLock()
+
+    def isValueLock(self):
+        return self._controlWidget.isValueLock()
+
+    def setValueLock(self, lock):
+        self._controlWidget.setValueLock(lock)
+
+    def setReconsParams(self, recons_params):
+        self._axis_params = recons_params
+        self._axisWidget.setReconsParams(axis=recons_params)
+        if recons_params.mode is AxisMode.manual:
+            self._controlWidget.setPosition(
+                self._axis_params.relative_cor_value,
+                self._axis_params.absolute_cor_value,
+            )
+
+    # expose API
+    def hideLockButton(self) -> None:
+        self._controlWidget.hideLockButton()
+
+    def hideApplyButton(self) -> None:
+        self._controlWidget.hideApplyButton()
+
+    def setMode(self, mode):
+        mode = AxisMode.from_value(mode)
+        self._axisWidget.setMode(mode)
+        self._axis_params.mode = mode
+        self.sigModeChanged.emit(mode.value)
+
+    def getMode(self):
+        return self._axisWidget.getMode()
+
+    def getEstimatedCor(self) -> float:
+        return self._axisWidget.getEstimatedCor()
+
+    def setEstimatedCor(self, value: float):
+        self._axisWidget.setEstimatedCor(value=value)
+
+    def getAutoUpdateEstimatedCor(self):
+        return self._axisWidget.updateXRotationAxisPixelPositionOnNewScan()
+
+    def isYAxisInverted(self) -> bool:
+        return self._axisWidget.isYAxisInverted()
+
+    def setYAxisInverted(self, checked: bool):
+        return self._axisWidget.setYAxisInverted(checked=checked)

tomwer/gui/reconstruction/axis/AxisOptionsWidget.py

@@ -0,0 +1,313 @@
+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):
+    """
+    GUI to define (advanced) option of the AxisTask
+
+    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())
+
+        self._qcbDataMode = qt.QComboBox(parent=self)
+        for data_mode in AxisCalculationInput:
+            # paganin is not managed for sinogram
+            self._qcbDataMode.addItem(data_mode.name(), data_mode)
+        self._qcbDataMode.hide()
+
+        self.layout().addWidget(self._commonOpts)
+
+        # composite method advanced options
+        self._compositeOptsGroup = CompositeOptsGroup(
+            parent=self, axis_params=axis_params
+        )
+        self.layout().addWidget(self._compositeOptsGroup)
+
+        # 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._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)
+
+    def _axis_params_changed(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 setPaddingMode(self, mode):
+        index = self._qbPaddingMode.findText(mode)
+        if index >= 0:
+            self._qbPaddingMode.setCurrentIndex(index)
+        self._paddingModeChanged()
+
+    def _updateAdvancedCorOptions(self, *args, **kwargs):
+        self._axis_params.extra_cor_options = self.getCorOptions()
+        self.sigChanged.emit()
+
+    def getCalculationInputType(self, *arg, **kwargs):
+        return AxisCalculationInput.from_value(self._qcbDataMode.currentText())
+
+    def setCalculationInputType(self, calculation_type):
+        calculation_type = AxisCalculationInput.from_value(calculation_type)
+        index_dm = self._qcbDataMode.findText(calculation_type.name())
+        self._qcbDataMode.setCurrentIndex(index_dm)
+
+    def setAxisParams(self, axis):
+        self._axis_params = axis
+        with block_signals(self):
+            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()
+
+    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)
+
+
+class CompositeOptsGroup(qt.QGroupBox):
+    """Group box dedicated to the composite algorithms"""
+
+    sigChanged = qt.Signal()
+    """Emit when the options changed"""
+
+    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)
+
+        # 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)
+
+    def setAxisParams(self, axis_params):
+        with block_signals(self):
+            self.setConfiguration(axis_params.composite_options)
+        self._axis_params = axis_params
+
+    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)