tomwer 1.3.27__py3-none-any.whl → 1.4.0rc0__py3-none-any.whl

tomwer/gui/reconstruction/nabu/volume.py

@@ -1,34 +1,6 @@
 # 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__ = "04/08/2020"
-
-
-import typing
+from __future__ import annotations
+
 from asyncio.log import logger
 
 from silx.gui import qt
@@ -36,6 +8,7 @@ from silx.gui import qt
 from tomwer.core.process.reconstruction.nabu.utils import (
     _NabuStages,
 )
+from tomwer.core.utils.dictutils import concatenate_dict
 from tomwer.gui import icons
 from tomwer.gui.configuration.action import (
     BasicConfigurationAction,
@@ -48,6 +21,11 @@ from tomwer.gui.reconstruction.nabu.nabuconfig.output import (
     NabuOutputLocationWidget,
     QNabuFileFormatComboBox,
 )
+from tomwer.gui.reconstruction.nabu.platform import NabuPlatformSettings
+from tomwer.gui.settings import (
+    TAB_LABEL_RECONSTRUCTION_SETTINGS,
+    TAB_LABEL_PLATFORM_SETTINGS,
+)
 
 
 class SliceSelector(qt.QWidget):
@@ -57,6 +35,7 @@ class SliceSelector(qt.QWidget):
     """
 
     valueChanged = qt.Signal()
+    """emit when the slice value change"""
 
     def __init__(
         self, label, auto_alias, is_end, grid_layout, index_layout, parent=None
@@ -184,10 +163,10 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         )
         self._redefineNabuFileFormat.setCheckable(True)
         self._redefineNabuFileFormat.setLayout(qt.QVBoxLayout())
-        self._fileformatCB = QNabuFileFormatComboBox(self._redefineNabuFileFormat)
-        self._redefineNabuFileFormat.layout().addWidget(self._fileformatCB)
+        self._fileFormatCB = QNabuFileFormatComboBox(self._redefineNabuFileFormat)
+        self._redefineNabuFileFormat.layout().addWidget(self._fileFormatCB)
         self.layout().addWidget(self._redefineNabuFileFormat, 4, 0, 1, 2)
-        self.registerWidget(self._fileformatCB, "advanced")
+        self.registerWidget(self._fileFormatCB, "advanced")
         self.registerWidget(self._redefineNabuFileFormat, "advanced")
 
         # redefine output location
@@ -202,35 +181,9 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         self.registerWidget(self._redefineNabuOutputLocation, "advanced")
         self.registerWidget(self._outputLocationWidget, "advanced")
 
-        # gpu percentage
-        self._labelGPUFract = qt.QLabel("GPU percentage usage", self)
-        self.layout().addWidget(self._labelGPUFract, 50, 0, 1, 1)
-        self.registerWidget(self._labelGPUFract, "advanced")
-        self._spbGPUFract = qt.QSpinBox(self)
-        self._spbGPUFract.setSingleStep(10)
-        self._spbGPUFract.setSuffix("%")
-        self._spbGPUFract.setMinimum(1)
-        self._spbGPUFract.setMaximum(100)
-        self.layout().addWidget(self._spbGPUFract, 50, 1, 1, 1)
-        self._spbGPUFract.setToolTip("Which fraction of GPU memory to use.")
-        self.registerWidget(self._spbGPUFract, "advanced")
-
-        # cpu percentage
-        self._labelCPUFract = qt.QLabel("CPU percentage usage", self)
-        self.layout().addWidget(self._labelCPUFract, 51, 0, 1, 1)
-        self.registerWidget(self._labelCPUFract, "advanced")
-        self._spbCPUFract = qt.QSpinBox(self)
-        self._spbCPUFract.setSingleStep(10)
-        self._spbCPUFract.setSuffix("%")
-        self._spbCPUFract.setMinimum(1)
-        self._spbCPUFract.setMaximum(100)
-        self.layout().addWidget(self._spbCPUFract, 52, 1, 1, 1)
-        self._spbCPUFract.setToolTip("Which fraction of CPU memory to use.")
-        self.registerWidget(self._spbCPUFract, "advanced")
-
-        # opt use phase paganin
-        self._usePhaseQCB = qt.QCheckBox("Use phase paganin")
-        self.layout().addWidget(self._usePhaseQCB, 53, 0, 1, 2)
+        # opt use phase Paganin
+        self._usePhaseQCB = qt.QCheckBox("Use phase Paganin")
+        self.layout().addWidget(self._usePhaseQCB, 52, 0, 1, 2)
         self.registerWidget(self._usePhaseQCB, "advanced")
         self._usePhaseQCB.setToolTip(
             "Whether to use a margin when " "performing phase retrieval."
@@ -243,8 +196,6 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
 
         # set up
         self._histogramCB.setChecked(True)
-        self._spbGPUFract.setValue(90)
-        self._spbCPUFract.setValue(90)
         self._usePhaseQCB.setChecked(True)
         self._redefineNabuFileFormat.setChecked(False)
         self._redefineNabuOutputLocation.setChecked(False)
@@ -253,8 +204,6 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         # connect signal / slot
         self._fromSlice.valueChanged.connect(self._triggerSigConfChanged)
         self._toSlice.valueChanged.connect(self._triggerSigConfChanged)
-        self._spbGPUFract.valueChanged.connect(self._triggerSigConfChanged)
-        self._spbCPUFract.valueChanged.connect(self._triggerSigConfChanged)
         self._usePhaseQCB.toggled.connect(self._triggerSigConfChanged)
         self._outputLocationWidget._outputDirQLE.editingFinished.connect(
             self._triggerSigConfChanged
@@ -274,7 +223,7 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         else:
             return None
 
-    def setNabuOutputLocation(self, location: typing.Optional[str]):
+    def setNabuOutputLocation(self, location: str | None):
         if location is None:
             self._redefineNabuOutputLocation.setChecked(False)
         else:
@@ -287,37 +236,25 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
 
     def getNabuFileFormat(self):
         if self.redefineNabuFileFormat():
-            return self._fileformatCB.currentText()
+            return self._fileFormatCB.currentText()
         else:
             return None
 
-    def setNabuFileFormat(self, file_format: typing.Optional[str]):
+    def setNabuFileFormat(self, file_format: str | None):
         if file_format is None:
             self._redefineNabuFileFormat.setChecked(False)
         else:
             assert isinstance(file_format, str)
             self._redefineNabuFileFormat.setChecked(True)
-            idx = self._fileformatCB.findText(file_format)
+            idx = self._fileFormatCB.findText(file_format)
             if idx < 0:
                 logger.error(f"unable to find file format {file_format}")
             else:
-                self._fileformatCB.setCurrentIndex(idx)
+                self._fileFormatCB.setCurrentIndex(idx)
 
     def _triggerSigConfChanged(self, *args, **kwargs):
         self.sigConfigChanged.emit()
 
-    def getCPUFract(self):
-        return self._spbCPUFract.value() / 100.0
-
-    def setCPUFract(self, value):
-        return self._spbCPUFract.setValue(int(value * 100.0))
-
-    def getGPUFract(self):
-        return self._spbGPUFract.value() / 100.0
-
-    def setGPUFract(self, value):
-        return self._spbGPUFract.setValue(int(value * 100.0))
-
     def getStartZ(self):
         return self._fromSlice.value()
 
@@ -352,8 +289,6 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         return {
             "start_z": self.getStartZ(),
             "end_z": self.getEndZ(),
-            "gpu_mem_fraction": self.getGPUFract(),
-            "cpu_mem_fraction": self.getCPUFract(),
             "use_phase_margin": self.phasePaganinRequested(),
             "postproc": {
                 "output_histogram": int(self.isHistogramRequested()),
@@ -369,10 +304,6 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
             self.setStartZ(config["start_z"])
         if "end_z" in config:
             self.setEndZ(config["end_z"])
-        if "gpu_mem_fraction" in config:
-            self.setGPUFract(config["gpu_mem_fraction"])
-        if "cpu_mem_fraction" in config:
-            self.setCPUFract(config["cpu_mem_fraction"])
         if "use_phase_margin" in config:
             self.setPhasePaganinRequested(config["use_phase_margin"])
         if "postproc" in config:
@@ -406,6 +337,47 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         return self._configuration_level
 
 
+class NabuVolumeTabWidget(qt.QTabWidget):
+    """
+    Widget that integrate the reconstruction settings and the platform (local) settings
+    """
+
+    sigConfigChanged = qt.Signal()
+
+    def __init__(self, parent: qt.QWidget | None = ...) -> None:
+        super().__init__(parent)
+        self._configurationLevel = ConfigurationLevel.OPTIONAL
+        self._nabuSettingsWidget = NabuVolumeWidget(parent=self)
+        self.addTab(self._nabuSettingsWidget, TAB_LABEL_RECONSTRUCTION_SETTINGS)
+
+        self._platformSettingsWidget = NabuPlatformSettings(parent=self)
+        self.addTab(self._platformSettingsWidget, TAB_LABEL_PLATFORM_SETTINGS)
+
+        # connect signal / slot
+        self._nabuSettingsWidget.sigConfigChanged.connect(self.sigConfigChanged)
+        self._platformSettingsWidget.sigConfigChanged.connect(self.sigConfigChanged)
+
+    def getConfiguration(self) -> dict:
+        return concatenate_dict(
+            self._nabuSettingsWidget.getConfiguration(),
+            self._platformSettingsWidget.getConfiguration(),
+        )
+
+    def setConfiguration(self, config: dict) -> None:
+        self._nabuSettingsWidget.setConfiguration(config=config)
+        self._platformSettingsWidget.setConfiguration(config=config)
+
+    def setConfigurationLevel(self, level):
+        self._configurationLevel = ConfigurationLevel(level)
+        self._nabuSettingsWidget.setConfigurationLevel(level=self._configurationLevel)
+        self._platformSettingsWidget.setConfigurationLevel(
+            level=self._configurationLevel
+        )
+
+    def getConfigurationLevel(self):
+        return self._configuration_level
+
+
 class NabuVolumeWindow(qt.QMainWindow):
     """
     Widget to define settings for a volume reconstruction
@@ -419,7 +391,7 @@ class NabuVolumeWindow(qt.QMainWindow):
 
         self.setWindowFlags(qt.Qt.Widget)
 
-        self._mainWidget = NabuVolumeWidget(parent=self)
+        self._mainWidget = NabuVolumeTabWidget(parent=self)
         self.setCentralWidget(self._mainWidget)
 
         # add toolbar

tomwer/gui/reconstruction/normalization/intensity.py

@@ -1,40 +1,11 @@
 # 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.
-#
-# ###########################################################################*/
 """
 contains gui relative to intensity normalization
 """
 
+from __future__ import annotations
 
-__authors__ = [
-    "H. Payno",
-]
-__license__ = "MIT"
-__date__ = "23/06/2021"
 
-
-import typing
 import weakref
 
 from silx.gui import qt
@@ -155,7 +126,7 @@ class SinoNormWindow(qt.QMainWindow):
         else:
             return None
 
-    def setScan(self, scan: typing.Union[None, TomwerScanBase]):
+    def setScan(self, scan: TomwerScanBase | None):
         self._scan = weakref.ref(scan)
         self._centralWidget.setScan(scan=scan)
         self._optsWidget.setScan(scan=scan)
@@ -199,7 +170,7 @@ class _Viewer(qt.QTabWidget):
         self._sinoView.sigSinoLoadEnded.connect(self._updateSinogramROI)
         self._projView.sigROIChanged.connect(self._updateSinogramROI)
 
-    def setScan(self, scan: typing.Union[None, TomwerScanBase]):
+    def setScan(self, scan: TomwerScanBase | None):
         """
 
         :param scan: scan to handle
@@ -685,6 +656,7 @@ class _NormIntensityControl(ControlWidget):
 
 class _NormIntensityScalarValue(qt.QWidget):
     sigValueChanged = qt.Signal(float)
+    """emit when the scalar value to norm intensity change"""
 
     def __init__(self, parent=None):
         qt.QWidget.__init__(self, parent=parent)
@@ -711,6 +683,7 @@ class _NormIntensityDatasetWidget(qt.QWidget):
     _FILE_PATH_LOCAL_VALUE = "scan master file"
 
     sigConfigurationChanged = qt.Signal()
+    """emit when configuration change"""
 
     def __init__(self, parent=None):
         qt.QWidget.__init__(self, parent)

tomwer/gui/reconstruction/normalization/test/test_intensity.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.process.reconstruction.normalization.params import (
+    Method as NormalizationMethod,
+)
+from tomwer.core.process.reconstruction.normalization.params import (
+    _ValueSource as NormalizationSource,
+)
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.gui.reconstruction.normalization.intensity import SinoNormWindow
+
+
+class TestNormIntensityWindow(TestCaseQt):
+    def setUp(self):
+        super(TestNormIntensityWindow, self).setUp()
+        self._widget = SinoNormWindow(parent=None)
+        self._tmp_dir = tempfile.mkdtemp()
+        scan_path = os.path.join(self._tmp_dir, "my_scan_2")
+        self.scan = MockNXtomo(
+            scan_path=scan_path,
+            n_ini_proj=10,
+            n_proj=10,
+            n_alignement_proj=2,
+            create_final_flat=False,
+            create_ini_dark=True,
+            create_ini_flat=True,
+            n_refs=1,
+        ).scan
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self.qapp.processEvents()
+        self._widget = None
+        shutil.rmtree(self._tmp_dir)
+        super(TestNormIntensityWindow, self).tearDown()
+
+    def test(self):
+        self._widget.setScan(self.scan)
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        self._widget.setCurrentMethod(NormalizationMethod.NONE)
+        self.qapp.processEvents()
+        assert self._widget.getConfiguration() == {"source": "none", "method": "none"}
+
+        self._widget.setCurrentMethod(NormalizationMethod.CHEBYSHEV)
+        self.qapp.processEvents()
+        assert self._widget.getConfiguration() == {
+            "method": "chebyshev",
+            "source": "none",
+        }
+
+        self._widget.setCurrentMethod(NormalizationMethod.SUBTRACTION)
+        self.qapp.processEvents()
+        self._widget.setCurrentSource(NormalizationSource.MANUAL_ROI)
+        self.qapp.processEvents()
+        output_configuration = self._widget.getConfiguration()
+        assert output_configuration["method"] == "subtraction"
+        assert output_configuration["source"] == "manual ROI"
+        assert "start_x" in output_configuration
+        assert "end_x" in output_configuration
+        assert "start_y" in output_configuration
+        assert "end_y" in output_configuration
+        assert "calc_fct" in output_configuration
+        self._widget.setCurrentMethod(NormalizationMethod.DIVISION)
+        self.qapp.processEvents()
+        self._widget.setCurrentSource(NormalizationSource.DATASET)
+        self.qapp.processEvents()
+        output_configuration = self._widget.getConfiguration()
+        assert output_configuration["method"] == "division"
+        assert output_configuration["source"] == "from dataset"
+        assert "dataset_url" in output_configuration
+
+        self._widget.setCurrentMethod(NormalizationMethod.DIVISION)
+        self.qapp.processEvents()
+        self._widget.setCurrentSource(NormalizationSource.MANUAL_SCALAR)
+        self.qapp.processEvents()
+        output_configuration = self._widget.getConfiguration()
+        assert output_configuration["method"] == "division"
+        assert output_configuration["source"] == "scalar"
+        assert "value" in output_configuration

tomwer/gui/reconstruction/saaxis/corrangeselector.py

@@ -1,43 +1,12 @@
-# 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.
-#
-# ###########################################################################*/
 """
 contains gui relative to semi-automatic axis calculation
 """
 
-
-__authors__ = [
-    "H. Payno",
-]
-__license__ = "MIT"
-__date__ = "26/02/2021"
-
+from __future__ import annotations
 
 import functools
 import logging
 import weakref
-from typing import Union
 
 import numpy
 from silx.gui import icons as silxicons
@@ -137,10 +106,10 @@ class SinogramViewer(_SinogramViewer):
         """
         For now we can only modify the estimated cor
 
-        :param float min:
-        :param float max:
-        :param float estimated_cor:
-        :param int display_n_recons: the grid created by all cor observe
+        :param min:
+        :param max:
+        :param estimated_cor:
+        :param display_n_recons: the grid created by all cor observe
         :return:
         """
         self._min = cor_min
@@ -333,7 +302,7 @@ class _ReconstructionModeGB(qt.QGroupBox):
         else:
             raise ValueError("No reconstruction mode selected")
 
-    def setReconstructionMode(self, mode: Union[str, ReconstructionMode]) -> None:
+    def setReconstructionMode(self, mode: ReconstructionMode | str) -> None:
         mode = ReconstructionMode.from_value(mode)
         if mode is ReconstructionMode.TILT_CORRECTION:
             self._tiltCorrectionRB.setChecked(True)
@@ -354,7 +323,7 @@ class _ReconstructionModeGB(qt.QGroupBox):
         else:
             raise ValueError(f"mode {mode} is not handled")
 
-    def setReconstructionSlices(self, slice_: Union[dict, int, str]):
+    def setReconstructionSlices(self, slice_: dict | int | str):
         slice_name = None
         if slice_ == "middle" or isinstance(slice_, int) or len(slice_) == 1:
             self.setReconstructionMode(ReconstructionMode.VERTICAL)
@@ -450,7 +419,7 @@ class _DetectionAccuracyGB(qt.QGroupBox):
     def setResearchWidth(self, width: float):
         """set research width
 
-        :param float width: center of rotation research width
+        :param width: center of rotation research width
         """
         return self._accuracySlider.setValue(width)
 
@@ -524,7 +493,7 @@ class _EstimatedCorWidget(qt.QGroupBox):
                 return 0.0
             elif mode in ("abs", "absolute"):
                 if self._frameWidth is not None:
-                    return self._frameWidth / 2.0
+                    return (self._frameWidth - 1) / 2.0
                 else:
                     return self._MIDDLE_COR_TXT
             else:
@@ -550,7 +519,7 @@ class _EstimatedCorWidget(qt.QGroupBox):
             old = self.blockSignals(True)
             old_mcor = self._manualCORAbs.blockSignals(True)
             self._manualCORAbs.setValue(
-                self._manualCORRel.value() + self._frameWidth / 2.0
+                self._manualCORRel.value() + (self._frameWidth - 1) / 2.0
             )
             self._manualCORAbs.blockSignals(old_mcor)
             self.blockSignals(old)
@@ -560,26 +529,24 @@ class _EstimatedCorWidget(qt.QGroupBox):
             old = self.blockSignals(True)
             old_mcor = self._manualCORRel.blockSignals(True)
             self._manualCORRel.setValue(
-                self._manualCORAbs.value() - self._frameWidth / 2.0
+                self._manualCORAbs.value() - (self._frameWidth - 1) / 2.0
             )
             self._manualCORRel.blockSignals(old_mcor)
             self.blockSignals(old)
 
-    def setFrameWidth(self, width):
+    def setFrameWidth(self, width: float):
         self._frameWidth = width
         # if necessary auto reset of the absolute value
         if self._manualCORAbs.value() == self._manualCORRel.value():
             self._relativePositionChanged()
 
-    def getFrameWidth(self):
+    def getFrameWidth(self) -> float:
         return self._frameWidth
 
-    def setCorValue(self, value):
+    def setCorValue(self, value: str | float) -> None:
         """
 
-        :param Union[str,float] value: if a float expected to be given as the
-                                       relative value
-        :return:
+        :param value: if a float expected to be given as the relative value
         """
         if value is None:
             pass
@@ -590,7 +557,7 @@ class _EstimatedCorWidget(qt.QGroupBox):
             self._manualCORRel.setValue(float(value))
             self._manualCORRel.editingFinished.emit()
 
-    def setAbsoluteCorValue(self, value):
+    def setAbsoluteCorValue(self, value: str | float):
         if value is None:
             pass
         elif value == self._MIDDLE_COR_TXT: