tomwer 1.2.8__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

tomwer/gui/reconstruction/axis/radioaxis.py

@@ -56,6 +56,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
@@ -671,12 +673,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 +698,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 +839,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 +858,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 +894,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 +918,6 @@ class _ROIControl(qt.QGroupBox):
         else:
             self._roiButton.setChecked(True)
 
-    def _requestZoomReset(self):
-        self.sigResetZoomRequested.emit()
-
 
 class _ROIDefinition(qt.QWidget):
     """
@@ -1165,12 +1161,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 +1236,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 +1461,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 +1484,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()
@@ -1608,6 +1563,7 @@ class _CalculationWidget(qt.QWidget):
             ),
             ("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),
@@ -1762,8 +1718,11 @@ class _CalculationWidget(qt.QWidget):
             with block_signals(self._axis_params):
                 side = self.getSide()
                 self._nearOptsWidget.setVisible(
-                    mode == axis_mode.AxisMode.composite_coarse_to_fine
-                    and side == "near"
+                    (
+                        mode is axis_mode.AxisMode.composite_coarse_to_fine
+                        and side == "near"
+                    )
+                    or (mode is axis_mode.AxisMode.near)
                 )
                 self._corOptsWidget.setVisible(
                     mode
@@ -1784,6 +1743,7 @@ class _CalculationWidget(qt.QWidget):
                         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 in (
@@ -1795,6 +1755,7 @@ class _CalculationWidget(qt.QWidget):
                     axis_mode.AxisMode.sliding_window_radios,
                     axis_mode.AxisMode.sino_coarse_to_fine,
                     axis_mode.AxisMode.composite_coarse_to_fine,
+                    axis_mode.AxisMode.near,
                 ):
                     self._lockMethodPB.setVisible(True)
                 else:
@@ -1807,6 +1768,7 @@ class _CalculationWidget(qt.QWidget):
                     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:
@@ -1823,6 +1785,7 @@ class _CalculationWidget(qt.QWidget):
             axis_mode.AxisMode.sliding_window_sinogram,
             axis_mode.AxisMode.sliding_window_radios,
             axis_mode.AxisMode.composite_coarse_to_fine,
+            axis_mode.AxisMode.near,
         ):
             return
         else:
@@ -1836,8 +1799,12 @@ class _CalculationWidget(qt.QWidget):
                 ):
                     values.append("all")
 
-                if mode in (axis_mode.AxisMode.composite_coarse_to_fine,):
+                if mode is axis_mode.AxisMode.composite_coarse_to_fine:
                     values.append("near")
+                elif mode is axis_mode.AxisMode.near:
+                    values = [
+                        "near",
+                    ]
 
                 for value in values:
                     self._sideCB.addItem(value)
@@ -1865,6 +1832,7 @@ class _CalculationWidget(qt.QWidget):
             axis_mode.AxisMode.sliding_window_radios,
             axis_mode.AxisMode.sino_coarse_to_fine,
             axis_mode.AxisMode.composite_coarse_to_fine,
+            axis_mode.AxisMode.near,
         ):
             raise ValueError(
                 "Unable to lock the current mode is not an automatic algorithm"
@@ -1878,6 +1846,7 @@ class _CalculationWidget(qt.QWidget):
             axis_mode.AxisMode.sliding_window_radios,
             axis_mode.AxisMode.sino_coarse_to_fine,
             axis_mode.AxisMode.composite_coarse_to_fine,
+            axis_mode.AxisMode.near,
         ):
             raise ValueError("Unable to lock %s this is not a lockable mode")
 
@@ -1929,10 +1898,12 @@ class _CalculationWidget(qt.QWidget):
 
     def _sideChanged(self, *args, **kwargs):
         side = self.getSide()
-        self._axis_params.side = side
+        if side not in ("", None):
+            self._axis_params.side = side
         mode = self.getMode()
         self._nearOptsWidget.setVisible(
-            mode == axis_mode.AxisMode.composite_coarse_to_fine and side == "near"
+            (mode is axis_mode.AxisMode.composite_coarse_to_fine and side == "near")
+            or mode is axis_mode.AxisMode.near
         )
 
     def getCorOptions(self):
@@ -1982,6 +1953,7 @@ class _CalculationWidget(qt.QWidget):
             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:
@@ -2503,9 +2475,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/lamino/tofu/projections.py

@@ -34,7 +34,7 @@ import os
 from silx.gui import qt
 
 from tomwer.core.process.reconstruction.lamino.tofu import FFCWhen, getDark, getFlats
-from tomwer.core.utils import (
+from tomwer.core.utils.spec import (
     getClosestEnergy,
     getDARK_N,
     getDim1Dim2,

tomwer/gui/reconstruction/lamino/tofu/tofuoutput.py

@@ -325,9 +325,9 @@ class _AnglesWidget(qt.QWidget):
         self._spacerBot.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
         self.layout().addWidget(self._spacerBot)
 
-        self._volAngleX.sigEdited.connect(self._haveBeenEdited)
-        self._volAngleY.sigEdited.connect(self._haveBeenEdited)
-        self._volAngleZ.sigEdited.connect(self._haveBeenEdited)
+        self._volAngleX.sigEdited.connect(self.sigAnglesEdited)
+        self._volAngleY.sigEdited.connect(self.sigAnglesEdited)
+        self._volAngleZ.sigEdited.connect(self.sigAnglesEdited)
 
         # aliases
         self.setVolumeAngleX = self._volAngleX.setAngle
@@ -337,9 +337,6 @@ class _AnglesWidget(qt.QWidget):
         self.getVolumeAngleY = self._volAngleY.getAngle
         self.getVolumeAngleZ = self._volAngleZ.getAngle
 
-    def _haveBeenEdited(self):
-        self.sigAnglesEdited.emit()
-
     def set(self, xAngle, yAngle, zAngle):
         self.blockSignals(True)
         self.setVolumeAngleX(xAngle)

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

tomwer/gui/reconstruction/nabu/check.py

@@ -29,13 +29,13 @@ __date__ = "02/12/2021"
 
 
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.utils.nxtomoutils import get_n_series
 
 
-def check_dark_series(scan: HDF5TomoScan, logger=None, user_input: bool = True) -> bool:
+def check_dark_series(scan: NXtomoScan, logger=None, user_input: bool = True) -> bool:
     """
     check:
         - if scan has computed_dark attached. If there is more than one then ask confirmation to the user to process the dataset
@@ -43,15 +43,15 @@ def check_dark_series(scan: HDF5TomoScan, logger=None, user_input: bool = True)
 
     ask confirmation for processing is done by a pop up dialog.
 
-    :param HDF5TomoScan scan: scan to check
+    :param NXtomoScan scan: scan to check
     :param bool user_input: if True and if n series of flat is invalid then ask the user to confirm the processing. Else print a warning and refuse processing
 
     :return: True if processing can be done else False
     :note: user can 'force' the processing to be done
     """
-    if not isinstance(scan, HDF5TomoScan):
+    if not isinstance(scan, NXtomoScan):
         raise TypeError(
-            f"scan is expected to be an instance of {HDF5TomoScan} not a {type(scan)}"
+            f"scan is expected to be an instance of {NXtomoScan} not a {type(scan)}"
         )
     try:
         image_keys = scan.image_keys
@@ -82,13 +82,13 @@ def check_dark_series(scan: HDF5TomoScan, logger=None, user_input: bool = True)
         return True
 
 
-def check_flat_series(scan: HDF5TomoScan, logger, user_input: bool = True) -> bool:
+def check_flat_series(scan: NXtomoScan, logger, user_input: bool = True) -> bool:
     """
     Insure the scan contains at least one serie of flat. Otherwise warn the user nabu will not be able to process
     """
-    if not isinstance(scan, HDF5TomoScan):
+    if not isinstance(scan, NXtomoScan):
         raise TypeError(
-            f"scan is expected to be an instance of {HDF5TomoScan} not a {type(scan)}"
+            f"scan is expected to be an instance of {NXtomoScan} not a {type(scan)}"
         )
     try:
         image_keys = scan.image_keys

tomwer/gui/reconstruction/nabu/helical.py

@@ -22,17 +22,28 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
         )
         self.layout().addWidget(self._outputFilePathQLE, 0, 2, 1, 1)
 
-        # transition_width
-        self._transitionWidthQDSP = qt.QLabel("transition width", self)
-        self.layout().addWidget(self._transitionWidthQDSP, 1, 0, 1, 1)
-        self._transitionWidthQDSP = qt.QDoubleSpinBox(self)
-        self._transitionWidthQDSP.setRange(0.0, 99999999)
-        self._transitionWidthQDSP.setValue(50.0)
-        self._transitionWidthQDSP.setToolTip(
+        # transition_width_vertical
+        self._verticalTransitionWidthQDSP = qt.QLabel("transition width", self)
+        self.layout().addWidget(self._verticalTransitionWidthQDSP, 1, 0, 1, 1)
+        self._verticalTransitionWidthQDSP = qt.QDoubleSpinBox(self)
+        self._verticalTransitionWidthQDSP.setRange(0.0, 99999999)
+        self._verticalTransitionWidthQDSP.setValue(50.0)
+        self._verticalTransitionWidthQDSP.setToolTip(
             "the transition width is used to determine how the weights are apodised near the upper and lower border"
         )
         # TODO: improve tooltip of this
-        self.layout().addWidget(self._transitionWidthQDSP, 1, 1, 1, 2)
+        self.layout().addWidget(self._verticalTransitionWidthQDSP, 1, 1, 1, 2)
+
+        # transition_width_vertical
+        self._horizontalTransitionWidthQDSP = qt.QLabel("transition width", self)
+        self.layout().addWidget(self._horizontalTransitionWidthQDSP, 1, 0, 1, 1)
+        self._horizontalTransitionWidthQDSP = qt.QDoubleSpinBox(self)
+        self._horizontalTransitionWidthQDSP.setRange(0.0, 99999999)
+        self._horizontalTransitionWidthQDSP.setValue(50.0)
+        self._horizontalTransitionWidthQDSP.setToolTip(
+            "the transition width is used to determine how the weights are apodised near the upper and lower border"
+        )
+        self.layout().addWidget(self._horizontalTransitionWidthQDSP, 1, 1, 1, 2)
 
         spacer = qt.QWidget(parent=self)
         spacer.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
@@ -40,7 +51,8 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
 
         # connect signal / slot
         self._outputFilePathQLE.editingFinished.connect(self._changed)
-        self._transitionWidthQDSP.valueChanged.connect(self._changed)
+        self._verticalTransitionWidthQDSP.valueChanged.connect(self._changed)
+        self._horizontalTransitionWidthQDSP.valueChanged.connect(self._changed)
 
     def _changed(self, *args, **kwargs):
         self.sigConfigChanged.emit()
@@ -48,7 +60,8 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
     def getConfiguration(self) -> dict:
         return {
             "processes_file": self._outputFilePathQLE.text(),
-            "transition_width": self._transitionWidthQDSP.value(),
+            "transition_width_vertical": self._verticalTransitionWidthQDSP.value(),
+            "transition_width_horizontal": self._horizontalTransitionWidthQDSP.value(),
         }
 
     def setConfiguration(self, config: dict):
@@ -56,6 +69,10 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
         if processes_file is not None:
             self._outputFilePathQLE.setText(processes_file)
 
-        transition_width = config.get("transition_width", None)
+        transition_width = config.get("transition_width_vertical", None)
+        if transition_width is not None:
+            self._verticalTransitionWidthQDSP.setValue(float(transition_width))
+
+        transition_width = config.get("transition_width_horizontal", None)
         if transition_width is not None:
-            self._transitionWidthQDSP.setValue(float(transition_width))
+            self._horizontalTransitionWidthQDSP.setValue(float(transition_width))

tomwer/gui/reconstruction/nabu/nabuconfig/base.py

@@ -30,10 +30,8 @@ __date__ = "11/02/2020"
 
 from typing import Union
 
-from tomwer.core.process.reconstruction.nabu.utils import (
-    ConfigurationLevel,
-    _NabuStages,
-)
+from tomwer.core.process.reconstruction.nabu.utils import _NabuStages
+from tomwer.gui.configuration.level import ConfigurationLevel
 
 
 class _FilteringObject: