tomwer 1.3.0.dev2__py3-none-any.whl → 1.3.0rc10__py3-none-any.whl

tomwer/gui/reconstruction/axis/CompareImages.py

@@ -33,75 +33,30 @@ import weakref
 import numpy
 from silx.gui import icons as silx_icons
 from silx.gui import qt
-from silx.gui.plot import CompareImages as _CompareImages
+from silx.gui.plot.CompareImages import (
+    CompareImages as _CompareImages,
+    VisualizationMode,
+)
+
+try:
+    # silx 2
+    from silx.gui.plot.tools.compare.toolbar import VisualizationModeToolButton
+except ImportError as e:
+    raise e
+    # silx 1
+    from silx.gui.plot.CompareImages import VisualizationModeToolButton
 from silx.gui.plot import tools
 
-from tomwer.gui import icons as tomwer_icons
 
 _logger = logging.getLogger(__name__)
 
 
-class CompareImagesToolBar(qt.QToolBar):
-    """ToolBar containing specific tools to custom the configuration of a
-    :class:`CompareImages` widget
-
-    Use :meth:`setCompareWidget` to connect this toolbar to a specific
-    :class:`CompareImages` widget.
-
-    :param Union[qt.QWidget,None] parent: Parent of this widget.
-    """
-
-    def __init__(self, parent=None):
-        qt.QToolBar.__init__(self, parent)
-
-        self.__compareWidget = None
-
-        menu = qt.QMenu(self)
-        self.__visualizationAction = qt.QAction(self)
-        self.__visualizationAction.setMenu(menu)
-        self.__visualizationAction.setCheckable(False)
-        self.addAction(self.__visualizationAction)
-        self.__visualizationGroup = qt.QActionGroup(self)
-        self.__visualizationGroup.setExclusive(True)
-        self.__visualizationGroup.triggered.connect(self.__visualizationModeChanged)
-
-        icon = silx_icons.getQIcon("compare-mode-a")
-        action = qt.QAction(icon, "Display frame 1", self)
-        action.setIconVisibleInMenu(True)
-        action.setCheckable(True)
-        action.setShortcut(qt.QKeySequence(qt.Qt.Key_A))
-        action.setProperty("mode", CompareImages.VisualizationMode.ONLY_A)
-        menu.addAction(action)
-        self.__visualizationGroup.addAction(action)
-
-        icon = silx_icons.getQIcon("compare-mode-b")
-        action = qt.QAction(icon, "Display frame 2", self)
-        action.setIconVisibleInMenu(True)
-        action.setCheckable(True)
-        action.setShortcut(qt.QKeySequence(qt.Qt.Key_B))
-        action.setProperty("mode", CompareImages.VisualizationMode.ONLY_B)
-        menu.addAction(action)
-        self.__visualizationGroup.addAction(action)
-
-        icon = silx_icons.getQIcon("compare-mode-rbneg-channel")
-        action = qt.QAction(icon, "Subtract in color mode", self)
-        action.setIconVisibleInMenu(True)
-        action.setCheckable(True)
-        action.setShortcut(qt.QKeySequence(qt.Qt.Key_C))
-        action.setProperty(
-            "mode", _CompareImages.VisualizationMode.COMPOSITE_RED_BLUE_GRAY_NEG
-        )
-        menu.addAction(action)
-        self.__visualizationGroup.addAction(action)
+class CompareImages(_CompareImages):
+    sigCropImagesChanged = qt.Signal()
+    """Emit when cropping of the compared images has changed"""
 
-        icon = tomwer_icons.getQIcon("compare_mode_a_minus_b")
-        action = qt.QAction(icon, "Subtract in BW mode", self)
-        action.setIconVisibleInMenu(True)
-        action.setCheckable(True)
-        action.setShortcut(qt.QKeySequence(qt.Qt.Key_S))
-        action.setProperty("mode", _CompareImages.VisualizationMode.COMPOSITE_A_MINUS_B)
-        menu.addAction(action)
-        self.__visualizationGroup.addAction(action)
+    def __init__(self, parent=None, backend=None):
+        super().__init__(parent, backend)
 
         # create crop images action
         icon = silx_icons.getQIcon("crop")
@@ -110,126 +65,39 @@ class CompareImagesToolBar(qt.QToolBar):
         action.setChecked(True)
         action.triggered.connect(self.__cropComparedImagesChanged)
         self.__cropComparedImages = action
-        self.addAction(action)
-
-    def setCompareWidget(self, widget):
-        """
-        Connect this tool bar to a specific :class:`CompareImages` widget.
-
-        :param Union[None,CompareImages] widget: The widget to connect with.
-        """
-        compareWidget = self.getCompareWidget()
-        if compareWidget is not None:
-            compareWidget.sigConfigurationChanged.disconnect(
-                self.__updateSelectedActions
-            )
-        compareWidget = widget
-        if compareWidget is None:
-            self.__compareWidget = None
-        else:
-            self.__compareWidget = weakref.ref(compareWidget)
-        if compareWidget is not None:
-            widget.sigConfigurationChanged.connect(self.__updateSelectedActions)
-        self.__updateSelectedActions()
-
-    def getCompareWidget(self):
-        """Returns the connected widget.
-
-        :rtype: CompareImages
-        """
-        if self.__compareWidget is None:
-            return None
-        else:
-            return self.__compareWidget()
-
-    def __updateSelectedActions(self):
-        """
-        Update the state of this tool bar according to the state of the
-        connected :class:`CompareImages` widget.
-        """
-        widget = self.getCompareWidget()
-        if widget is None:
-            return
-
-        mode = widget.getVisualizationMode()
-        action = None
-        for a in self.__visualizationGroup.actions():
-            actionMode = a.property("mode")
-            if mode == actionMode:
-                action = a
-                break
-        old = self.__visualizationGroup.blockSignals(True)
-        if action is not None:
-            # Check this action
-            action.setChecked(True)
-        else:
-            action = self.__visualizationGroup.checkedAction()
-            if action is not None:
-                # Uncheck this action
-                action.setChecked(False)
-        self.__updateVisualizationMenu()
-        self.__visualizationGroup.blockSignals(old)
-
-    def __visualizationModeChanged(self, selectedAction):
-        """Called when user requesting changes of the visualization mode."""
-        self.__updateVisualizationMenu()
-        widget = self.getCompareWidget()
-        if widget is not None:
-            mode = selectedAction.property("mode")
-            widget.setVisualizationMode(mode)
+        self._compareToolBar.addAction(action)
+
+        # define visible compare mode
+        self._compareToolBar._visualizationToolButton.setVisibleModes(
+            [
+                VisualizationMode.ONLY_A,
+                VisualizationMode.ONLY_B,
+                VisualizationMode.COMPOSITE_RED_BLUE_GRAY_NEG,
+                VisualizationMode.COMPOSITE_A_MINUS_B,
+            ]
+        )
 
     def __cropComparedImagesChanged(self):
-        widget = self.getCompareWidget()
-        if widget is not None:
-            cropCompositeImage = self.__cropComparedImages.isChecked()
-            widget.setCropComparedImages(cropCompositeImage)
-
-    def __updateVisualizationMenu(self):
-        """Update the state of the action containing visualization menu."""
-        selectedAction = self.__visualizationGroup.checkedAction()
-        if selectedAction is not None:
-            self.__visualizationAction.setText(selectedAction.text())
-            self.__visualizationAction.setIcon(selectedAction.icon())
-            self.__visualizationAction.setToolTip(selectedAction.toolTip())
-        else:
-            self.__visualizationAction.setText("")
-            self.__visualizationAction.setIcon(qt.QIcon())
-            self.__visualizationAction.setToolTip("")
-
-
-class CompareImages(_CompareImages.CompareImages):
-    sigCropImagesChanged = qt.Signal()
-    """Emit when cropping of the compared images has changed"""
-
-    def __init__(self, parent=None, backend=None):
-        super().__init__(parent, backend=backend)
-        self.__cropComparedImages = True
+        cropCompositeImage = self.__cropComparedImages.isChecked()
+        self.setCropComparedImages(cropCompositeImage)
 
     def cropComparedImages(self) -> bool:
-        return self.__cropComparedImages
+        return self.__cropComparedImages.isChecked()
 
     def setCropComparedImages(self, crop):
-        self.__cropComparedImages = crop
+        self.__cropComparedImages.setChecked(crop)
         self.sigCropImagesChanged.emit()
 
     def _createToolBars(self, plot):
         """Create tool bars displayed by the widget"""
-        self._interactiveModeToolBar = tools.InteractiveModeToolBar(
-            parent=self, plot=plot
-        )
-        self._imageToolBar = tools.ImageToolBar(parent=self, plot=plot)
-
+        toolBar = tools.InteractiveModeToolBar(parent=self, plot=plot)
+        self._interactiveModeToolBar = toolBar
+        toolBar = tools.ImageToolBar(parent=self, plot=plot)
+        self._imageToolBar = toolBar
         toolBar = CompareImagesToolBar(self)
         toolBar.setCompareWidget(self)
         self._compareToolBar = toolBar
 
-    def _createStatusBar(self, plot):
-        self._statusBar = CompareImagesStatusBar(self)
-        self._statusBar.setCompareWidget(self)
-
-    def getCompareToolBar(self):
-        return self._compareToolBar
-
 
 class CompareImagesStatusBar(qt.QStatusBar):
     """StatusBar containing specific information contained in a
@@ -407,3 +275,61 @@ class CompareImagesStatusBar(qt.QStatusBar):
                     text2 = self._formatData(data2)
                 self._label1.setText("Frame 1: %s" % text1)
                 self._label2.setText("Frame 2: %s" % text2)
+
+
+class CompareImagesToolBar(qt.QToolBar):
+    def __init__(self, parent=None):
+        qt.QToolBar.__init__(self, parent)
+
+        self.__compareWidget = None
+
+        self._visualizationToolButton = VisualizationModeToolButton(self)
+        self._visualizationToolButton.setPopupMode(qt.QToolButton.InstantPopup)
+        self._visualizationToolButton.sigSelected.connect(self.__visualizationChanged)
+        self.addWidget(self._visualizationToolButton)
+
+    def __visualizationChanged(self, mode: VisualizationMode):
+        widget = self.getCompareWidget()
+        if widget is not None:
+            widget.setVisualizationMode(mode)
+
+    def setCompareWidget(self, widget):
+        """
+        Connect this tool bar to a specific :class:`CompareImages` widget.
+
+        :param Union[None,CompareImages] widget: The widget to connect with.
+        """
+        compareWidget = self.getCompareWidget()
+        if compareWidget is not None:
+            compareWidget.sigConfigurationChanged.disconnect(
+                self.__updateSelectedActions
+            )
+        compareWidget = widget
+        self.setEnabled(compareWidget is not None)
+        if compareWidget is None:
+            self.__compareWidget = None
+        else:
+            self.__compareWidget = weakref.ref(compareWidget)
+        if compareWidget is not None:
+            widget.sigConfigurationChanged.connect(self.__updateSelectedActions)
+        self.__updateSelectedActions()
+
+    def getCompareWidget(self):
+        """Returns the connected widget.
+
+        :rtype: CompareImages
+        """
+        if self.__compareWidget is None:
+            return None
+        else:
+            return self.__compareWidget()
+
+    def __updateSelectedActions(self):
+        """
+        Update the state of this tool bar according to the state of the
+        connected :class:`CompareImages` widget.
+        """
+        widget = self.getCompareWidget()
+        if widget is None:
+            return
+        self._visualizationToolButton.setSelected(widget.getVisualizationMode())

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
@@ -490,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 "
@@ -1501,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):
@@ -1537,46 +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"),
-            (axis_mode.AxisMode.near, "Alias to composite_coarse_to_fine"),
-            ("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)
 
@@ -1716,14 +1673,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 is axis_mode.AxisMode.composite_coarse_to_fine
-                        and side == "near"
-                    )
-                    or (mode is axis_mode.AxisMode.near)
-                )
                 self._corOptsWidget.setVisible(
                     mode
                     not in (
@@ -1733,82 +1682,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.AxisMode.near,
-                    )
+                    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,
-                    axis_mode.AxisMode.near,
-                ):
+                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,
-                    axis_mode.AxisMode.near,
-                )
-                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,
-            axis_mode.AxisMode.near,
-        ):
+        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 is axis_mode.AxisMode.composite_coarse_to_fine:
-                    values.append("near")
-                elif mode is axis_mode.AxisMode.near:
-                    values = [
-                        "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()
@@ -1823,30 +1728,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,
-            axis_mode.AxisMode.near,
-        ):
+        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,
-            axis_mode.AxisMode.near,
+        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")
 
@@ -1900,11 +1787,7 @@ class _CalculationWidget(qt.QWidget):
         side = self.getSide()
         if side not in ("", None):
             self._axis_params.side = side
-        mode = self.getMode()
-        self._nearOptsWidget.setVisible(
-            (mode is axis_mode.AxisMode.composite_coarse_to_fine and side == "near")
-            or mode is axis_mode.AxisMode.near
-        )
+        self._nearOptsWidget.setVisible(side == "near")
 
     def getCorOptions(self):
         return self._corOpts.text()
@@ -1947,17 +1830,10 @@ class _CalculationWidget(qt.QWidget):
         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,
-            axis_mode.AxisMode.near,
-        ):
-            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)

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

@@ -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,7 +67,7 @@ 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
@@ -158,6 +164,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