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

tomwer/gui/reconstruction/axis/InputWidget.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import logging
+
+from silx.gui import qt
+
+from tomwer.core.process.reconstruction.axis import mode as axis_mode
+from tomwer.core.process.reconstruction.axis.anglemode import CorAngleMode
+from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.synctools.axis import QAxisRP
+from .ManualFramesSelection import ManualFramesSelection
+
+_logger = logging.getLogger(__name__)
+
+
+class InputWidget(qt.QWidget):
+    """
+    Widget used to define the radios or the sinogram to be used for computing the cor
+    Used as a tab of the AxisSettingsTabWidget
+    """
+
+    sigChanged = qt.Signal()
+    """Signal emitted when input changed"""
+
+    _sigUrlChanged = qt.Signal()
+    """Signal emit when url to be used changed"""
+
+    def __init__(self, parent=None, axis_params=None):
+        assert isinstance(axis_params, QAxisRP)
+        self._blockUpdateAxisParams = False
+        super().__init__(parent)
+        self.setLayout(qt.QVBoxLayout())
+
+        # radio input
+        self._radioGB = qt.QGroupBox(self)
+        self._radioGB.setTitle("radios")
+        self._radioGB.setLayout(qt.QVBoxLayout())
+        self._radioGB.setCheckable(True)
+        self.layout().addWidget(self._radioGB)
+        ## angle mode
+        self._angleModeWidget = _AngleSelectionWidget(
+            parent=self, axis_params=axis_params
+        )
+        self._radioGB.layout().addWidget(self._angleModeWidget)
+        self._axis_params = axis_params
+
+        # sinogram input
+        self._sinogramGB = qt.QGroupBox(self)
+        self._sinogramGB.setLayout(qt.QFormLayout())
+
+        self._sinogramGB.setTitle("sinogram")
+        self._sinogramGB.setCheckable(True)
+        self.layout().addWidget(self._sinogramGB)
+        ##  sinogram line
+        self._sinogramLineSB = _SliceSelector(self)
+        self._sinogramGB.layout().addRow("line", self._sinogramLineSB)
+        ##  sinogram subsampling
+        self._sinogramSubsampling = qt.QSpinBox(self)
+        self._sinogramSubsampling.setRange(1, 1000)
+        self._sinogramSubsampling.setValue(10)
+        self._sinogramGB.layout().addRow("subsampling", self._sinogramSubsampling)
+
+        self._spacer = qt.QWidget(self)
+        self._spacer.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
+        self.layout().addWidget(self._spacer)
+
+        # set up
+        self._sinogramGB.setChecked(False)
+
+        # connect signal / slot
+        self._sinogramGB.toggled.connect(self._sinogramChecked)
+        self._radioGB.toggled.connect(self._radiosChecked)
+        self._sinogramSubsampling.valueChanged.connect(self._changed)
+        self._sinogramLineSB.sigChanged.connect(self._changed)
+        self._angleModeWidget.sigChanged.connect(self._sigUrlChanged)
+
+    def setScan(self, scan: TomwerScanBase):
+        if scan is not None:
+            self._angleModeWidget.setScan(scan)
+            self._angleModeWidget.setScanRange(scan.scan_range)
+
+    def setAxisParams(self, axis_params):
+        with block_signals(axis_params):
+            with block_signals(self._axis_params):
+                self._blockUpdateAxisParams = True
+
+                if axis_params is not None:
+                    assert isinstance(axis_params, QAxisRP)
+                    with block_signals(self._sinogramGB):
+                        self._sinogramChecked(
+                            axis_params.mode.requires_sinogram_index(), on_load=True
+                        )
+                    self._sinogramLineSB.setSlice(axis_params.sinogram_line)
+                    self._sinogramSubsampling.setValue(axis_params.sinogram_subsampling)
+                self._angleModeWidget.setAxisParams(axis_params)
+                self._axis_params = axis_params
+
+        self._blockUpdateAxisParams = False
+
+    def getSinogramLine(self) -> str | int:
+        return self._sinogramLineSB.getSlice()
+
+    def getSinogramSubsampling(self) -> int:
+        return self._sinogramSubsampling.value()
+
+    def _sinogramChecked(self, checked, on_load=False):
+        with block_signals(self._radioGB):
+            with block_signals(self._sinogramGB):
+                if checked:
+                    self._radioGB.setChecked(False)
+                    self._sinogramGB.setChecked(True)
+                elif self._radioGB.isEnabled():
+                    self._radioGB.setChecked(not checked)
+                elif on_load:
+                    self._sinogramGB.setChecked(checked)
+                else:
+                    # ignore it if radio disabled
+                    self._sinogramGB.setChecked(True)
+        self._changed()
+
+    def _radiosChecked(self, checked, on_load=False):
+        with block_signals(self._radioGB):
+            with block_signals(self._sinogramGB):
+                if checked:
+                    self._sinogramGB.setChecked(False)
+                    self._radioGB.setChecked(True)
+                elif self._sinogramGB.isEnabled():
+                    self._sinogramGB.setChecked(not checked)
+                elif on_load:
+                    self._radioGB.setChecked(checked)
+                else:
+                    # ignore it if sinogram disabled
+                    self._radioGB.setChecked(True)
+        self._changed()
+
+    def _changed(self, *args, **kwargs):
+        self._updateAxisParams()
+        self.sigChanged.emit()
+
+    def _updateAxisParams(self):
+        if not self._blockUpdateAxisParams:
+            self._axis_params.sinogram_line = self.getSinogramLine()
+            self._axis_params.sinogram_subsampling = self.getSinogramSubsampling()
+
+    def setValidInputs(self, modes: list | tuple):
+        """
+        Define possible inputs.
+
+        :raises: ValueError if modes are invalid
+        """
+        modes = set(modes)
+        for mode in modes:
+            try:
+                axis_mode._InputType.from_value(mode)
+            except Exception:
+                raise ValueError(
+                    f"mode {mode} should be an instance of {axis_mode._InputType}"
+                )
+        if len(modes) == 2:
+            self._sinogramGB.setEnabled(True)
+            self._radioGB.setEnabled(True)
+        elif len(modes) > 2:
+            raise ValueError(f"invalid input {modes}")
+        elif len(modes) < 0:
+            raise ValueError("modes is empty")
+        else:
+            mode = axis_mode._InputType.from_value(modes.pop())
+            if mode is axis_mode._InputType.SINOGRAM:
+                self._sinogramGB.setEnabled(True)
+                self._radioGB.setEnabled(False)
+                self._sinogramGB.setChecked(True)
+            elif mode is axis_mode._InputType.RADIOS_X2:
+                self._radioGB.setEnabled(True)
+                self._sinogramGB.setEnabled(False)
+                self._radioGB.setChecked(True)
+            elif mode is axis_mode._InputType.COMPOSITE:
+                # those mode are neither sinogram neither radio. Now one of the two will be checked but without any much meaning
+                self._radioGB.setEnabled(False)
+                self._sinogramGB.setEnabled(False)
+            else:
+                raise ValueError(f"Nothing implemented for {mode.value}")
+
+
+class _AngleSelectionWidget(qt.QWidget):
+    """Group box to select the angle to used for cor calculation
+    (0-180, 90-270 or manual)"""
+
+    sigChanged = qt.Signal()
+    """signal emitted when the selected angle changed"""
+
+    def __init__(self, parent=None, axis_params=None):
+        assert isinstance(axis_params, QAxisRP)
+        qt.QWidget.__init__(
+            self,
+            parent=parent,
+        )
+        self.setLayout(qt.QVBoxLayout())
+        self._groupBoxMode = qt.QGroupBox(
+            self, title="Angles to use for axis calculation"
+        )
+        self._groupBoxMode.setLayout(qt.QHBoxLayout())
+        self.layout().addWidget(self._groupBoxMode)
+
+        self._corButtonsGps = qt.QButtonGroup(parent=self)
+        self._corButtonsGps.setExclusive(True)
+        self._qrbCOR_0_180 = qt.QRadioButton("0-180", parent=self)
+        self._groupBoxMode.layout().addWidget(self._qrbCOR_0_180)
+        self._qrbCOR_90_270 = qt.QRadioButton("90-270", parent=self)
+        self._qrbCOR_90_270.setToolTip(
+            "pick radio closest to angles 90° and "
+            "270°. If disable mean that the scan "
+            "range is 180°"
+        )
+        self._groupBoxMode.layout().addWidget(self._qrbCOR_90_270)
+        self._qrbCOR_manual = qt.QRadioButton("other", parent=self)
+        self._qrbCOR_manual.setVisible(True)
+        self._groupBoxMode.layout().addWidget(self._qrbCOR_manual)
+        # add all button to the button group
+        for b in (self._qrbCOR_0_180, self._qrbCOR_90_270, self._qrbCOR_manual):
+            self._corButtonsGps.addButton(b)
+
+        self.setAxisParams(axis_params)
+
+        self._manualFrameSelection = ManualFramesSelection(self)
+        self.layout().addWidget(self._manualFrameSelection)
+        self._manualFrameSelection.setVisible(False)
+
+        # connect signal / Slot
+        self._corButtonsGps.buttonClicked.connect(self._angleModeChanged)
+        self._manualFrameSelection.sigChanged.connect(self._changed)
+
+    def setScan(self, scan: TomwerScanBase):
+        if scan is not None:
+            self.setScanRange(scan.scan_range)
+        self._manualFrameSelection.setScan(scan=scan)
+
+    def setScanRange(self, scanRange):
+        if scanRange == 180:
+            self._qrbCOR_90_270.setEnabled(False)
+            # force using 0-180 if was using 90-270
+            if self._qrbCOR_90_270.isChecked():
+                self._qrbCOR_0_180.setChecked(True)
+                self._axis_params.angle_mode = CorAngleMode.use_0_180
+        else:
+            self._qrbCOR_90_270.setEnabled(True)
+
+    def setAngleMode(self, mode):
+        """
+
+        :param mode: mode to use (can be manual , 90-270 or 0-180)
+        """
+        assert isinstance(mode, CorAngleMode)
+        if mode == CorAngleMode.use_0_180:
+            self._qrbCOR_0_180.setChecked(True)
+        elif mode == CorAngleMode.use_90_270:
+            self._qrbCOR_90_270.setChecked(True)
+        else:
+            self._qrbCOR_manual.setChecked(True)
+
+    def getAngleMode(self) -> CorAngleMode:
+        """
+
+        :return: the angle to use for the axis calculation
+        """
+        if self._qrbCOR_90_270.isChecked():
+            return CorAngleMode.use_90_270
+        elif self._qrbCOR_0_180.isChecked():
+            return CorAngleMode.use_0_180
+        else:
+            return CorAngleMode.manual_selection
+
+    def setAxisParams(self, axis_params):
+        with block_signals(self):
+            self._axis_params = axis_params
+            # set up
+            self.setAngleMode(axis_params.angle_mode)
+
+    def _angleModeChanged(self, *args, **kwargs):
+        self._axis_params.angle_mode = self.getAngleMode()
+        if self.getAngleMode() is CorAngleMode.manual_selection:
+            self._axis_params.angle_mode_extra = (
+                self._manualFrameSelection.getFramesUrl()
+            )
+        else:
+            self._axis_params.angle_mode_extra = None
+        self._manualFrameSelection.setVisible(
+            self.getAngleMode() is CorAngleMode.manual_selection
+        )
+        self._changed()
+
+    def _changed(self):
+        self.sigChanged.emit()
+
+
+class _SliceSelector(qt.QWidget):
+    sigChanged = qt.Signal()
+    """signal emit when the selected slice change"""
+
+    def __init__(self, parent):
+        qt.QWidget.__init__(self, parent)
+        self.setLayout(qt.QHBoxLayout())
+        self.setContentsMargins(0, 0, 0, 0)
+        self.layout().setContentsMargins(0, 0, 0, 0)
+        self._modeCB = QComboBoxIgnoreWheel(self)
+        self._modeCB.addItem("middle")
+        self._modeCB.addItem("other")
+        self.layout().addWidget(self._modeCB)
+        self._otherSB = qt.QSpinBox(self)
+        self._otherSB.setRange(0, 10000)
+        self.layout().addWidget(self._otherSB)
+
+        # connect signal / slot
+        self._otherSB.valueChanged.connect(self._valueChanged)
+        self._modeCB.currentIndexChanged.connect(self._modeChanged)
+        # set up
+        self._modeChanged()
+
+    def getSlice(self) -> int | str:
+        "return a specific slice index or 'middle'"
+        if self.getMode() == "middle":
+            return "middle"
+        else:
+            return self._otherSB.value()
+
+    def setSlice(self, slice_):
+        if slice_ is None:
+            return
+        if slice_ == "middle":
+            idx = self._modeCB.findText("middle")
+            self._modeCB.setCurrentIndex(idx)
+        else:
+            idx = self._modeCB.findText("other")
+            self._modeCB.setCurrentIndex(idx)
+            self._otherSB.setValue(slice_)
+        self.sigChanged.emit()
+
+    def getMode(self):
+        return self._modeCB.currentText()
+
+    def _valueChanged(self):
+        self.sigChanged.emit()
+
+    def _modeChanged(self, *args, **kwargs):
+        self._otherSB.setVisible(self.getMode() == "other")
+        self._valueChanged()

tomwer/gui/reconstruction/axis/ManualFramesSelection.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import logging
+from bisect import bisect_left
+
+from silx.gui import qt
+from silx.io.url import DataUrl
+
+from tomwer.core.scan.scanbase import TomwerScanBase
+
+_logger = logging.getLogger(__name__)
+
+
+class ManualFramesSelection(qt.QWidget):
+    """Allows to select frame - angle to be used."""
+
+    sigChanged = qt.Signal()
+    """Signal emit when the frame selection changes"""
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self._anglesAvailable = []
+        # cache of the angles available from the current defined frames. Must be sorted !!!
+        self.setLayout(qt.QGridLayout())
+        self.layout().addWidget(qt.QLabel("frame 1", self), 0, 0, 1, 1)
+        self._frame1CB = qt.QComboBox(self)
+        self._frame1CB.setEditable(True)
+        self.layout().addWidget(self._frame1CB, 0, 1, 1, 1)
+
+        self.layout().addWidget(qt.QLabel("frame 2", self), 1, 0, 1, 1)
+        self._frame2CB = qt.QComboBox(self)
+        self._frame2CB.setEditable(True)
+        self.layout().addWidget(self._frame2CB, 1, 1, 1, 1)
+        self._findAssociatedAnglePB = qt.QPushButton("+180°", self)
+        button_180_font = self.font()
+        button_180_font.setPixelSize(10)
+        self._findAssociatedAnglePB.setFont(button_180_font)
+        self._findAssociatedAnglePB.setFixedWidth(30)
+        self._findAssociatedAnglePB.setSizePolicy(
+            qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum
+        )
+        self.layout().addWidget(self._findAssociatedAnglePB, 1, 2, 1, 1)
+        self._flipLRCB = qt.QCheckBox("flip L-R")
+        self._flipLRCB.setChecked(True)
+        self.layout().addWidget(self._flipLRCB, 1, 3, 1, 1)
+
+        self._flipLRCB.toggled.connect(self._changed)
+        self._frame1CB.currentIndexChanged.connect(self._changed)
+        self._frame2CB.currentIndexChanged.connect(self._changed)
+        self._findAssociatedAnglePB.released.connect(self._findAssociatedAngle)
+
+    def _findAssociatedAngle(self):
+        if self._frame1CB.count() == 0 or len(self._anglesAvailable) == 0:
+            _logger.warning("no angles available, unable to get '+180°' frame")
+        else:
+            angle = float(self._frame1CB.currentText())
+            # look for the closest 'associated' angle.
+            # as the angles are not limited to [0-360] we need to check for any value.
+            # if the angle is on the first part of the acquisition we expect to find it near angle +180
+            # if it is on the second part (for 360 degree) we expect to find it on the first part (0-180)
+            closest_pls_180_angle = self._getClosestAssociatedAngle(
+                angle + 180.0, self._anglesAvailable
+            )
+            score_add = abs(closest_pls_180_angle - angle)
+            closest_minus_180_angle = self._getClosestAssociatedAngle(
+                angle - 180.0, self._anglesAvailable
+            )
+            score_sub = abs(closest_minus_180_angle - angle)
+            if score_add >= score_sub:
+                closest_180_angle = closest_pls_180_angle
+            else:
+                closest_180_angle = closest_minus_180_angle
+            item_idx = self._frame2CB.findText(self._angleToStr(closest_180_angle))
+            if item_idx < 0:
+                _logger.error(f"Unable to find item for angle {closest_180_angle}")
+            else:
+                self._frame2CB.setCurrentIndex(item_idx)
+
+    @staticmethod
+    def _getClosestAssociatedAngle(angle: float, angles: tuple) -> float:
+        """
+        return the angle closest angle to 'angle' from 'angles'
+
+        :warning: angles should be already sorted !!!
+        """
+        if angles is None or len(angles) == 0:
+            return None
+        if angle in angles:
+            return angle
+        pos = bisect_left(angles, angle)
+        if pos == 0:
+            return angles[0]
+        elif pos > len(angles) - 1:
+            return angles[-1]
+        else:
+            left_angle = angles[pos - 1]
+            right_angle = angles[pos]
+            if abs(right_angle - angle) > abs(left_angle - angle):
+                return left_angle
+            else:
+                return right_angle
+
+    def _changed(self):
+        self.sigChanged.emit()
+
+    @staticmethod
+    def _angleToStr(angle: float) -> str:
+        return f"{float(angle):0.3f}"
+
+    def setScan(self, scan: TomwerScanBase | None) -> None:
+        self._anglesAvailable.clear()
+        self._frame1CB.clear()
+        self._frame2CB.clear()
+        if scan is None:
+            return
+        current_angle1 = self._getFrame1Angle()
+        current_angle2 = self._getFrame2Angle()
+        for proj_angle, proj_url in scan.get_proj_angle_url().items():
+            try:
+                angle = self._angleToStr(proj_angle)
+            except Exception:
+                angle = proj_angle
+            else:
+                self._anglesAvailable.append(float(proj_angle))
+            self._frame1CB.addItem(angle, proj_url)
+            self._frame2CB.addItem(angle, proj_url)
+
+        self._anglesAvailable.sort()
+
+        idx = self._frame1CB.findText(current_angle1)
+        if idx >= 0:
+            self._frame1CB.setCurrentIndex(idx)
+        if current_angle1 == current_angle2:
+            # if the two current angle are close then we consider it is better to look for angleX - angleX + 180 angles
+            # instead of finding back angles
+            self._findAssociatedAngle()
+        else:
+            idx = self._frame1CB.findText(current_angle1)
+            if idx >= 0:
+                self._frame1CB.setCurrentIndex(idx)
+
+            idx = self._frame2CB.findText(current_angle2)
+            if idx >= 0:
+                self._frame2CB.setCurrentIndex(idx)
+
+    def getFramesUrl(self, as_txt=False) -> tuple:
+        """
+        Return a tuple of (frame 1 url, frame 2 url). Url can be None
+        """
+        if as_txt:
+            return self.getFrame1Url().path(), self.getFrame2Url().path()
+        else:
+            return self.getFrame1Url(), self.getFrame2Url()
+
+    def getFrame1Url(self) -> DataUrl | None:
+        return self._frame1CB.currentData()
+
+    def getFrame2Url(self) -> DataUrl | None:
+        return self._frame2CB.currentData()
+
+    def _getFrame1Angle(self) -> str | None:
+        return self._frame1CB.currentText()
+
+    def _getFrame2Angle(self) -> str | None:
+        return self._frame2CB.currentText()
+
+    def isFrame2LRFLip(self):
+        return self._flipLRCB.isChecked()

tomwer/gui/reconstruction/axis/__init__.py

@@ -1,2 +1,2 @@
-from .axis import AxisWindow  # noqa F401
-from .radioaxis import RadioAxisWindow  # noqa F401
+from .AxisMainWindow import AxisMainWindow  # noqa F401
+from .AxisWidget import AxisWidget  # noqa F401

tomwer/gui/reconstruction/darkref/__init__.py

@@ -1,27 +0,0 @@
-# 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__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "09/02/2018"

tomwer/gui/reconstruction/darkref/darkrefcopywidget.py

@@ -1,36 +1,7 @@
-# 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__ = ["C. Nemoz", "H. Payno"]
-__license__ = "MIT"
-__date__ = "13/08/2021"
-
+from __future__ import annotations
 
 import logging
 import shutil
-from typing import Union
 
 from silx.gui import qt
 from silx.gui.dialog.DataFileDialog import DataFileDialog
@@ -169,7 +140,7 @@ class RefCopyWidget(qt.QGroupBox):
         """
 
         :param parent: Qt parent
-        :param str save_dir: where the dark and flats 'references' are stored
+        :param save_dir: where the dark and flats 'references' are stored
         """
         qt.QGroupBox.__init__(self, "activate", parent)
         self.__save_dir = save_dir
@@ -180,7 +151,7 @@ class RefCopyWidget(qt.QGroupBox):
             """
             The copy action happen after the reduced (computed) darks and flats. It can be activate or not. \n\n
             Reduced darks and / or flats can be registered and then copy to scan without darks or flat. \n
-            You can set manually Darks and flat (button displayed when the mode auto is unchcked.) \n
+            You can set manually Darks and flat (button displayed when the mode auto is unchecked.) \n
             Otherwise if the mode 'auto' is activated then each time he meets scan with dark and / or flat it will register those as the one to be copied. \n
 
             Then each time the copy action meets scan without reduced dark and / or flat it will copy them. \n
@@ -306,8 +277,8 @@ class RefCopyWidget(qt.QGroupBox):
         """
         return self.isChecked()
 
-    def save_darks_to_be_copied(self, darks: Union[DataUrl, dict]):
+    def save_darks_to_be_copied(self, darks: DataUrl | dict):
         DarkRefsCopy.save_darks_to_be_copied(data=darks, save_dir=self.__save_dir)
 
-    def save_flats_to_be_copied(self, flats: Union[DataUrl, dict]):
+    def save_flats_to_be_copied(self, flats: DataUrl | dict):
         DarkRefsCopy.save_flats_to_be_copied(data=flats, save_dir=self.__save_dir)

tomwer/gui/reconstruction/darkref/darkrefwidget.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__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "10/01/2018"
+from __future__ import annotations
 
 
 import logging