tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/gui/reconstruction/axis/radioaxis.py

@@ -1,35 +1,3 @@
-# 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 axis calculation using radios
-"""
-
-__authors__ = ["C. Nemoz", "H. Payno"]
-__license__ = "MIT"
-__date__ = "25/02/2019"
-
 import enum
 import logging
 import os
@@ -56,6 +24,8 @@ from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils import image
 from tomwer.gui.utils.buttons import PadlockButton
 from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.gui.settings import EDITING_BACKGROUND_COLOR
+from tomwer.gui.utils.step import StepSizeSelectorWidget
 from tomwer.synctools.axis import QAxisRP
 
 from .CompareImages import CompareImages
@@ -488,16 +458,10 @@ class RadioAxisWindow(qt.QMainWindow):
 
         with block_signals(self):
             try:
-                try:
-                    self._plot.setData(
-                        image1=self._shiftedImgA,
-                        image2=self._shiftedImgB,
-                        updateColormap=False,
-                    )
-                except TypeError:
-                    self._plot.setData(
-                        image1=self._shiftedImgA, image2=self._shiftedImgB
-                    )
+                self._plot.setData(
+                    image1=self._shiftedImgA,
+                    image2=self._shiftedImgB,
+                )
             except ValueError:
                 _logger.warning(
                     "Unable to set images. Maybe there is some "
@@ -671,12 +635,12 @@ class _AxisManual(qt.QWidget):
         self._manualSelectionWidget.sigResetZoomRequested.connect(
             self._requestZoomReset
         )
-        self._imgOpts.sigSubsamplingChanged.connect(self._subsamplingChanged)
-        self._mainWidget.sigUrlChanged.connect(self._urlChanged)
+        self._imgOpts.sigSubsamplingChanged.connect(self.sigSubsamplingChanged)
+        self._mainWidget.sigUrlChanged.connect(self.sigUrlChanged)
 
         # expose API
-        self.getShiftStep = self._displacementSelector.getShiftStep
-        self.setShiftStep = self._displacementSelector.setShiftStep
+        self.getShiftStep = self._displacementSelector.getStepSize
+        self.setShiftStep = self._displacementSelector.setStepSize
         self.sigRoiChanged = self._roiControl.sigRoiChanged
         self.sigAuto = self._shiftControl.sigAuto
         self.getROIOrigin = self._roiControl.getROIOrigin
@@ -696,12 +660,6 @@ class _AxisManual(qt.QWidget):
     def manual_uses_full_image(self, value):
         self._roiControl.manual_uses_full_image(value)
 
-    def _urlChanged(self):
-        self.sigUrlChanged.emit()
-
-    def _subsamplingChanged(self):
-        self.sigSubsamplingChanged.emit()
-
     def _incrementLeftShift(self):
         self._incrementShift("left")
 
@@ -843,7 +801,13 @@ class _AxisManualSelection(qt.QWidget):
     def __init__(self, parent, shift_mode):
         qt.QWidget.__init__(self, parent)
         self.setLayout(qt.QVBoxLayout())
-        self._displacementSelector = _DisplacementSelector(parent=self)
+        self._displacementSelector = StepSizeSelectorWidget(
+            parent=self,
+            fine_value=0.1,
+            medium_value=1.0,
+            rough_value=None,
+            dtype=float,
+        )
         self.layout().addWidget(self._displacementSelector)
 
         self._shiftControl = _ShiftControl(parent=self, shift_mode=shift_mode)
@@ -856,10 +820,7 @@ class _AxisManualSelection(qt.QWidget):
         self.layout().addWidget(self._imgOpts)
 
         # connect signal / slot
-        self._roiControl.sigResetZoomRequested.connect(self._requestZoomReset)
-
-    def _requestZoomReset(self):
-        self.sigResetZoomRequested.emit()
+        self._roiControl.sigResetZoomRequested.connect(self.sigResetZoomRequested)
 
 
 class _ROIControl(qt.QGroupBox):
@@ -895,8 +856,8 @@ class _ROIControl(qt.QGroupBox):
 
         # connect signal / Slot
         self._roiButton.toggled.connect(self._roiDefinition.setEnabled)
-        self._fullImgButton.toggled.connect(self._requestZoomReset)
-        self._roiButton.toggled.connect(self._requestZoomReset)
+        self._fullImgButton.toggled.connect(self.sigResetZoomRequested)
+        self._roiButton.toggled.connect(self.sigResetZoomRequested)
 
         # expose API
         self.sigRoiChanged = self._roiDefinition.sigRoiChanged
@@ -919,9 +880,6 @@ class _ROIControl(qt.QGroupBox):
         else:
             self._roiButton.setChecked(True)
 
-    def _requestZoomReset(self):
-        self.sigResetZoomRequested.emit()
-
 
 class _ROIDefinition(qt.QWidget):
     """
@@ -1165,12 +1123,39 @@ class _ShiftInformation(qt.QWidget):
     class _ShiftLineEdit(qt.QLineEdit):
         def __init__(self, *args, **kwargs):
             qt.QLineEdit.__init__(self, *args, **kwargs)
+            self._defaultBackgroundColor = None
+            # validator
             validator = qt.QDoubleValidator(parent=self, decimals=2)
             self.setValidator(validator)
+            self._getDefaultBackgroundColor()
+            # connect signal / slot
+            self.textEdited.connect(self._userEditing)
+            self.editingFinished.connect(self._userEndEditing)
 
         def sizeHint(self):
             return qt.QSize(40, 10)
 
+        def _getDefaultBackgroundColor(self):
+            if self._defaultBackgroundColor is None:
+                self._defaultBackgroundColor = self.palette().color(
+                    self.backgroundRole()
+                )
+            return self._defaultBackgroundColor
+
+        def _userEditing(self, *args, **kwargs):
+            palette = self.palette()
+            palette.setColor(self.backgroundRole(), EDITING_BACKGROUND_COLOR)
+            self.setPalette(palette)
+
+        def _userEndEditing(self, *args, **kwargs):
+            print("user end editing")
+            palette = self.palette()
+            palette.setColor(
+                self.backgroundRole(),
+                self._getDefaultBackgroundColor(),
+            )
+            self.setPalette(palette)
+
     sigShiftChanged = qt.Signal(float, float)
     """Signal emitted ony when xLE and yLE edition is finished"""
 
@@ -1213,69 +1198,6 @@ class _ShiftInformation(qt.QWidget):
         self.sigShiftChanged.emit(float(self._xLE.text()), float(self._yLE.text()))
 
 
-class _DisplacementSelector(qt.QGroupBox):
-    """
-    Group box to define the displacement step value
-    """
-
-    def __init__(self, parent):
-        qt.QGroupBox.__init__(self, "shift step", parent)
-        self.setLayout(qt.QVBoxLayout())
-        self._buttonGrp = qt.QButtonGroup(parent=self)
-        self._buttonGrp.setExclusive(True)
-
-        self._rawButton = qt.QRadioButton("Rough (1 pixel)", parent=self)
-        self.layout().addWidget(self._rawButton)
-        self._buttonGrp.addButton(self._rawButton)
-
-        self._fineButton = qt.QRadioButton("Fine (0.1 pixel)", parent=self)
-        self.layout().addWidget(self._fineButton)
-        self._buttonGrp.addButton(self._fineButton)
-
-        self._manualWidget = qt.QWidget(parent=self)
-        self._manualWidget.setLayout(qt.QHBoxLayout())
-        self._manualWidget.layout().setContentsMargins(0, 0, 0, 0)
-        self._manualWidget.layout().setSpacing(0)
-        self._manualButton = qt.QRadioButton("Manual", parent=self._manualWidget)
-        self._manualWidget.layout().addWidget(self._manualButton)
-        self._manualLE = qt.QLineEdit("0.5", parent=self._manualWidget)
-        validator = qt.QDoubleValidator(parent=self._manualLE, decimals=2)
-        validator.setBottom(0.0)
-        self._manualLE.setValidator(validator)
-        self._manualWidget.layout().addWidget(self._manualLE)
-
-        self.layout().addWidget(self._manualWidget)
-        self._manualLE.setEnabled(False)
-        self._buttonGrp.addButton(self._manualButton)
-
-        self._rawButton.setChecked(True)
-
-        # signal / slot connection
-        self._manualButton.toggled.connect(self._manualLE.setEnabled)
-
-    def getShiftStep(self):
-        """
-
-        :return: displacement shift defined
-        :rtype: float
-        """
-        if self._rawButton.isChecked():
-            return 1.0
-        elif self._fineButton.isChecked():
-            return 0.1
-        else:
-            return float(self._manualLE.text())
-
-    def setShiftStep(self, value):
-        """
-
-        :param float value: shift step
-        """
-        assert type(value) is float
-        self._manualButton.setChecked(True)
-        self._manualLE.setText(str(value))
-
-
 class _AxisOptionsWidget(qt.QWidget):
     """GUI to tune the axis algorithm"""
 
@@ -1501,9 +1423,7 @@ class AxisTabWidget(qt.QTabWidget):
         self.getEstimatedCor = self._calculationWidget.getEstimatedCor
 
         # connect signal / slot
-        self._calculationWidget.sigLockModeChanged.connect(
-            self._propagateSigLockModeChanged
-        )
+        self._calculationWidget.sigLockModeChanged.connect(self.sigLockModeChanged)
         self.sigModeChanged.connect(self._updatePossibleInput)
         self._inputWidget._sigUrlChanged.connect(self._urlChanged)
         # not very nice but very convenient to have the setting near at the same level
@@ -1526,9 +1446,6 @@ class AxisTabWidget(qt.QTabWidget):
     def _urlChanged(self):
         self.sigUrlChanged.emit()
 
-    def _propagateSigLockModeChanged(self, lock):
-        self.sigLockModeChanged.emit(lock)
-
     def getMode(self):
         """Return algorithm to use for axis calculation"""
         return self._calculationWidget.getMode()
@@ -1546,17 +1463,12 @@ class AxisTabWidget(qt.QTabWidget):
     def _updatePossibleInput(self):
         """Update Input tab according to the current mode"""
         current_mode = self.getMode()
-        if current_mode not in axis_mode._VALID_INPUTS:
-            raise ValueError(
-                f"valid input should have been defined for the mode {current_mode.value}"
-            )
+        valid_inputs = axis_mode.AXIS_MODE_METADATAS[current_mode].valid_inputs
+        if valid_inputs is None:
+            self._inputWidget.setEnabled(False)
         else:
-            valid_inputs = axis_mode._VALID_INPUTS[current_mode]
-            if valid_inputs is None:
-                self._inputWidget.setEnabled(False)
-            else:
-                self._inputWidget.setEnabled(True)
-                self._inputWidget.setValidInputs(valid_inputs)
+            self._inputWidget.setEnabled(True)
+            self._inputWidget.setValidInputs(valid_inputs)
 
 
 class _CalculationWidget(qt.QWidget):
@@ -1582,45 +1494,46 @@ class _CalculationWidget(qt.QWidget):
         self._modeWidget.layout().addWidget(self.__rotAxisSelLabel)
         self._qcbPosition = qt.QComboBox(self)
 
-        algorithm_tooltips = (
+        algorithm_groups = (
+            # radio group
             (
                 axis_mode.AxisMode.centered,
-                "Dedicated to fullfield. Previously named 'accurate'",
-            ),
-            (
                 axis_mode.AxisMode.global_,
-                "Algorithm which can work for both half acquisition and standard ('full field') acquisition",
-            ),
-            (axis_mode.AxisMode.growing_window_radios, "A auto-Cor method"),
-            (
+                axis_mode.AxisMode.growing_window_radios,
                 axis_mode.AxisMode.sliding_window_radios,
-                "A method for estimating semi-automatically the CoR position. You have to provide a hint on where the CoR is (left, center, right).",
+                axis_mode.AxisMode.octave_accurate_radios,
             ),
-            ("separator", None),
-            (axis_mode.AxisMode.growing_window_sinogram, "A auto-Cor method"),
+            # sino group
             (
+                axis_mode.AxisMode.growing_window_sinogram,
                 axis_mode.AxisMode.sino_coarse_to_fine,
-                "Estimate CoR from sinogram. Only works for 360 degrees scans.",
+                axis_mode.AxisMode.sliding_window_sinogram,
+                axis_mode.AxisMode.sino_fourier_angles,
             ),
+            # composite corase to fine
             (
-                axis_mode.AxisMode.sliding_window_sinogram,
-                "A method for estimating semi-automatically the CoR position. You have to provide a hint on where the CoR is (left, center, right).",
+                axis_mode.AxisMode.composite_coarse_to_fine,
+                axis_mode.AxisMode.near,
             ),
-            ("separator", None),
-            (axis_mode.AxisMode.composite_coarse_to_fine, "A auto-Cor method"),
-            ("separator", None),
-            (axis_mode.AxisMode.manual, "Enter or find manually the COR value"),
-            ("separator", None),
-            (axis_mode.AxisMode.read, "Read COR value from a file"),
+            # manual
+            (axis_mode.AxisMode.manual,),
+            # read
+            (axis_mode.AxisMode.read,),
         )
-
-        for i_elmt, (method, tooltip) in enumerate(algorithm_tooltips):
-            if method == "separator":
-                self._qcbPosition.insertSeparator(i_elmt)
-            else:
-                self._qcbPosition.addItem(method.value)
-                idx = self._qcbPosition.findText(method.value)
-                self._qcbPosition.setItemData(idx, tooltip, qt.Qt.ToolTipRole)
+        current_pos = 0
+        for i_grp, algorithm_group in enumerate(algorithm_groups):
+            if i_grp != 0:
+                self._qcbPosition.insertSeparator(current_pos)
+                current_pos += 1
+            for cor_algorithm in algorithm_group:
+                self._qcbPosition.addItem(cor_algorithm.value)
+                idx = self._qcbPosition.findText(cor_algorithm.value)
+                self._qcbPosition.setItemData(
+                    idx,
+                    axis_mode.AXIS_MODE_METADATAS[cor_algorithm].tooltip,
+                    qt.Qt.ToolTipRole,
+                )
+                current_pos += 1
 
         self._modeWidget.layout().addWidget(self._qcbPosition)
 
@@ -1734,6 +1647,9 @@ class _CalculationWidget(qt.QWidget):
     def setEstimatedCorValue(self, value):
         if value is not None:
             self._qleNearPosQLE.setText(str(value))
+            # note: keep self._axis_params up to date.
+            if self._axis_params:
+                self._axis_params.estimated_cor = value
 
     def getEstimatedCor(self):
         try:
@@ -1760,11 +1676,6 @@ class _CalculationWidget(qt.QWidget):
         mode = self.getMode()
         with block_signals(self._qcbPosition):
             with block_signals(self._axis_params):
-                side = self.getSide()
-                self._nearOptsWidget.setVisible(
-                    mode == axis_mode.AxisMode.composite_coarse_to_fine
-                    and side == "near"
-                )
                 self._corOptsWidget.setVisible(
                     mode
                     not in (
@@ -1774,74 +1685,38 @@ class _CalculationWidget(qt.QWidget):
                 )
 
                 self._padding_widget.setVisible(
-                    mode
-                    in (
-                        axis_mode.AxisMode.centered,
-                        axis_mode.AxisMode.global_,
-                        axis_mode.AxisMode.growing_window_sinogram,
-                        axis_mode.AxisMode.growing_window_radios,
-                        axis_mode.AxisMode.sliding_window_sinogram,
-                        axis_mode.AxisMode.sliding_window_radios,
-                        axis_mode.AxisMode.sino_coarse_to_fine,
-                        axis_mode.AxisMode.composite_coarse_to_fine,
-                    )
+                    axis_mode.AXIS_MODE_METADATAS[mode].allows_padding
                 )
-                if mode in (
-                    axis_mode.AxisMode.centered,
-                    axis_mode.AxisMode.global_,
-                    axis_mode.AxisMode.growing_window_sinogram,
-                    axis_mode.AxisMode.growing_window_radios,
-                    axis_mode.AxisMode.sliding_window_sinogram,
-                    axis_mode.AxisMode.sliding_window_radios,
-                    axis_mode.AxisMode.sino_coarse_to_fine,
-                    axis_mode.AxisMode.composite_coarse_to_fine,
-                ):
+                if axis_mode.AXIS_MODE_METADATAS[mode].is_lockable:
                     self._lockMethodPB.setVisible(True)
                 else:
                     self._lockMethodPB.setVisible(False)
                     self.lockMode(False)
 
-                side_visible = mode in (
-                    axis_mode.AxisMode.growing_window_sinogram,
-                    axis_mode.AxisMode.growing_window_radios,
-                    axis_mode.AxisMode.sliding_window_sinogram,
-                    axis_mode.AxisMode.sliding_window_radios,
-                    axis_mode.AxisMode.composite_coarse_to_fine,
-                )
-                self._sideWidget.setVisible(side_visible)
-                if side_visible is True:
+                sides_visible = len(axis_mode.AXIS_MODE_METADATAS[mode].valid_sides) > 0
+                self._sideWidget.setVisible(sides_visible)
+                if sides_visible is True:
                     self._updateSideVisible(mode)
-
+                self._nearOptsWidget.setVisible(self.getSide() == "near")
                 self._axis_params.mode = mode.value
             self._axis_params.changed()
             self.sigModeChanged.emit(mode.value)
 
     def _updateSideVisible(self, mode: axis_mode.AxisMode):
-        if mode not in (
-            axis_mode.AxisMode.growing_window_sinogram,
-            axis_mode.AxisMode.growing_window_radios,
-            axis_mode.AxisMode.sliding_window_sinogram,
-            axis_mode.AxisMode.sliding_window_radios,
-            axis_mode.AxisMode.composite_coarse_to_fine,
-        ):
+        mode = axis_mode.AxisMode.from_value(mode)
+        if len(axis_mode.AXIS_MODE_METADATAS[mode].valid_sides) == 0:
             return
         else:
             current_value = self._axis_params.side
             with block_signals(self._sideCB):
                 self._sideCB.clear()
-                values = ["left", "right", "center"]
-                if mode in (
-                    axis_mode.AxisMode.growing_window_radios,
-                    axis_mode.AxisMode.growing_window_sinogram,
-                ):
-                    values.append("all")
-
-                if mode in (axis_mode.AxisMode.composite_coarse_to_fine,):
-                    values.append("near")
-
+                values = axis_mode.AXIS_MODE_METADATAS[mode].valid_sides
                 for value in values:
                     self._sideCB.addItem(value)
                 idx = self._sideCB.findText(current_value)
+                if idx == -1:
+                    # if side doesn't exists, propose right as default when possible
+                    idx = self._sideCB.findText("right")
                 if idx >= 0:
                     self._sideCB.setCurrentIndex(idx)
             self._axis_params.side = self.getSide()
@@ -1856,28 +1731,12 @@ class _CalculationWidget(qt.QWidget):
         """
         if mode is not None:
             mode = axis_mode.AxisMode.from_value(mode)
-        if mode is None and self.getMode() not in (
-            axis_mode.AxisMode.centered,
-            axis_mode.AxisMode.global_,
-            axis_mode.AxisMode.growing_window_sinogram,
-            axis_mode.AxisMode.growing_window_radios,
-            axis_mode.AxisMode.sliding_window_sinogram,
-            axis_mode.AxisMode.sliding_window_radios,
-            axis_mode.AxisMode.sino_coarse_to_fine,
-            axis_mode.AxisMode.composite_coarse_to_fine,
-        ):
+        if mode is None and axis_mode.AXIS_MODE_METADATAS[self.getMode()].is_lockable():
             raise ValueError(
                 "Unable to lock the current mode is not an automatic algorithm"
             )
-        elif mode != self.getMode() and mode not in (
-            axis_mode.AxisMode.centered,
-            axis_mode.AxisMode.global_,
-            axis_mode.AxisMode.growing_window_sinogram,
-            axis_mode.AxisMode.growing_window_radios,
-            axis_mode.AxisMode.sliding_window_sinogram,
-            axis_mode.AxisMode.sliding_window_radios,
-            axis_mode.AxisMode.sino_coarse_to_fine,
-            axis_mode.AxisMode.composite_coarse_to_fine,
+        elif (
+            mode != self.getMode() and axis_mode.AXIS_MODE_METADATAS[mode].is_lockable()
         ):
             raise ValueError("Unable to lock %s this is not a lockable mode")
 
@@ -1929,11 +1788,9 @@ class _CalculationWidget(qt.QWidget):
 
     def _sideChanged(self, *args, **kwargs):
         side = self.getSide()
-        self._axis_params.side = side
-        mode = self.getMode()
-        self._nearOptsWidget.setVisible(
-            mode == axis_mode.AxisMode.composite_coarse_to_fine and side == "near"
-        )
+        if side not in ("", None):
+            self._axis_params.side = side
+        self._nearOptsWidget.setVisible(side == "near")
 
     def getCorOptions(self):
         return self._corOpts.text()
@@ -1970,21 +1827,16 @@ class _CalculationWidget(qt.QWidget):
                 self._axis_params.mode = axis_mode.AxisMode.growing_window_radios
             self._axis_params.sigChanged.connect(self._axis_params_changed)
             self._axis_params_changed()
+            self._sideChanged()
 
     def _axis_params_changed(self, *args, **kwargs):
         self.setMode(self._axis_params.mode)
         self.setEstimatedCorValue(self._axis_params.estimated_cor)
         self.setSide(self._axis_params.side)
-        if self._axis_params.mode in (
-            axis_mode.AxisMode.growing_window_sinogram,
-            axis_mode.AxisMode.growing_window_radios,
-            axis_mode.AxisMode.sliding_window_sinogram,
-            axis_mode.AxisMode.sliding_window_radios,
-            axis_mode.AxisMode.composite_coarse_to_fine,
-        ):
-            self._sideWidget.setVisible(True)
-        else:
-            self._sideWidget.setVisible(False)
+        sides_visible = (
+            len(axis_mode.AXIS_MODE_METADATAS[self._axis_params.mode].valid_sides) > 0
+        )
+        self._sideWidget.setVisible(sides_visible)
         self._updateSideVisible(mode=self._axis_params.mode)
         self.setPaddingMode(self._axis_params.padding_mode)
         self.setCorOptions(self._axis_params.extra_cor_options)
@@ -2502,9 +2354,22 @@ class _ManualFramesSelection(qt.QWidget):
             _logger.warning("no angles available, unable to get '+180°' frame")
         else:
             angle = float(self._frame1CB.currentText())
-            closest_180_angle = self._getClosestAssociatedAngle(
+            # 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}")

tomwer/gui/reconstruction/darkref/darkrefcopywidget.py

@@ -36,7 +36,8 @@ from silx.gui import qt
 from silx.gui.dialog.DataFileDialog import DataFileDialog
 from silx.io.url import DataUrl
 
-from tomwer.core import settings, utils
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import is_low_on_memory
 from tomwer.core.process.reconstruction.darkref.darkrefscopy import DarkRefsCopy
 from tomwer.gui.reconstruction.darkref.darkrefwidget import DarkRefWidget
 from tomwer.io.utils import get_default_directory
@@ -117,7 +118,7 @@ class DarkRefAndCopyWidget(DarkRefWidget):
         # Security: if lbs is full, skip requesting fir user ref
         if (
             settings.isOnLbsram(scanID)
-            and utils.isLowOnMemory(settings.get_lbsram_path()) is True
+            and is_low_on_memory(settings.get_lbsram_path()) is True
         ):
             # if computer is running into low memory on lbsram skip it
             mess = (

tomwer/gui/reconstruction/darkref/darkrefwidget.py

@@ -198,7 +198,8 @@ class _TabGeneral(qt.QWidget):
         self._grpOptions = qt.QGroupBox("options", parent=self)
         self._grpOptions.setLayout(qt.QVBoxLayout())
         self._rmOptionCB = qt.QCheckBox(
-            parent=self._grpOptions, text="remove raw files when done"
+            parent=self._grpOptions,
+            text="remove raw EDF files when done (for spec only)",
         )
         self.sigRmToggled = self._rmOptionCB.toggled
         self._skipOptionCB = qt.QCheckBox(

tomwer/gui/reconstruction/nabu/castvolume.py

@@ -39,7 +39,7 @@ from tomwer.core.process.reconstruction.nabu.castvolume import (
     RESCALE_MAX_PERCENTILE,
     RESCALE_MIN_PERCENTILE,
 )
-from tomwer.core.process.reconstruction.nabu.nabucommon import NabuOutputFileFormat
+from tomwer.core.process.reconstruction.output import NabuOutputFileFormat
 from tomwer.gui.qlefilesystem import QLFileSystem
 from tomwer.gui.reconstruction.nabu.nabuconfig.output import QNabuFileFormatComboBox
 from nxtomomill.io.utils import convert_str_to_tuple
@@ -51,6 +51,12 @@ class CastVolumeWidget(qt.QWidget):
     sigConfigChanged = qt.Signal()
     """Signal emit when the configuration changed"""
 
+    DEFAULT_OUTPUT_DATA_TYPE = "uint16"
+
+    AVAILABLE_OUTPUT_DATA_TYPE = ("uint8", "uint16", "float32", "float64")
+
+    assert DEFAULT_OUTPUT_DATA_TYPE in AVAILABLE_OUTPUT_DATA_TYPE
+
     def __init__(self, parent) -> None:
         super().__init__(parent=parent)
 
@@ -61,13 +67,17 @@ class CastVolumeWidget(qt.QWidget):
         self._castToLabel.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum)
         self.layout().addWidget(self._castToLabel, 0, 0, 1, 1)
         self._outputDataTypeCB = qt.QComboBox(self)
-        for data_type in ("uint8", "uint16", "float32", "float64"):
+        for data_type in self.AVAILABLE_OUTPUT_DATA_TYPE:
             self._outputDataTypeCB.addItem(data_type)
         self.layout().addWidget(self._outputDataTypeCB, 0, 1, 1, 3)
         # output file format
         self._outputFileformatLabel = qt.QLabel("output file format", self)
         self.layout().addWidget(self._outputFileformatLabel, 1, 0, 1, 1)
-        self._outputFileformatCB = QNabuFileFormatComboBox(self)
+        # for now cast to vol is not handle to better remove it from the list
+        self._outputFileformatCB = QNabuFileFormatComboBox(
+            self, filter_formats=("vol",)
+        )
+
         self.layout().addWidget(self._outputFileformatCB, 1, 1, 1, 3)
 
         # let the user provide min and max manually
@@ -158,6 +168,7 @@ class CastVolumeWidget(qt.QWidget):
         self.layout().addWidget(self._spacer, 99, 0, 1, 3)
 
         # set up
+        self._outputDataTypeCB.setCurrentText(self.DEFAULT_OUTPUT_DATA_TYPE)
         self._updateCRatiosVis()
 
         # connect signal / slot