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

tomwer/gui/reconstruction/nabu/slices.py

@@ -36,21 +36,22 @@ from nabu.pipeline.fullfield.nabu_config import (
 from silx.gui import icons as silx_icons
 from silx.gui import qt
 from silx.utils.enum import Enum as _Enum
-from tomoscan.scanbase import FOV
+from nxtomo.nxobject.nxdetector import FOV
 
-from tomwer.core.process.reconstruction.nabu.utils import ConfigurationLevel, _NabuMode
+from tomwer.core.process.reconstruction.nabu.utils import _NabuMode
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui import icons as tomwer_icons
 from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowArea
 from tomwer.gui.utils.buttons import PadlockButton
 
 from ...utils.flow import FlowDirection
-from .action import (
+from tomwer.gui.configuration.action import (
     BasicConfigurationAction,
     ExpertConfigurationAction,
     FilterAction,
     MinimalisticConfigurationAction,
 )
+from tomwer.gui.configuration.level import ConfigurationLevel
 from .nabuconfig import NabuConfiguration
 
 _logger = logging.getLogger(__name__)
@@ -250,7 +251,7 @@ class NabuWindow(qt.QMainWindow):
 
         # add load option
         self.__loadAction = qt.QAction(self)
-        self.__loadAction.setToolTip("load nabu configuration from a .cfg file")
+        self.__loadAction.setToolTip("load nabu configuration from a text file")
         # load_icon = style.standardIcon(qt.QStyle.SP_)
         load_icon = silx_icons.getQIcon("document-open")
         self.__loadAction.setIcon(load_icon)
@@ -259,7 +260,7 @@ class NabuWindow(qt.QMainWindow):
 
         # add save option
         self.__saveAction = qt.QAction(self)
-        self.__saveAction.setToolTip("save nabu configuration to a .cfg file")
+        self.__saveAction.setToolTip("save nabu configuration to a text file")
         save_icon = silx_icons.getQIcon("document-save")
         self.__saveAction.setIcon(save_icon)
         toolbar.addAction(self.__saveAction)
@@ -287,7 +288,7 @@ class NabuWindow(qt.QMainWindow):
         self.hidePaganinInterface = self._mainWidget.hidePaganinInterface
 
         # connect signal / slot
-        self._mainWidget.sigConfigChanged.connect(self._triggerConfigChanged)
+        self._mainWidget.sigConfigChanged.connect(self.sigConfigChanged)
 
         # set up
         self._resetParameters()
@@ -348,6 +349,7 @@ class NabuWindow(qt.QMainWindow):
 
     def _resetParameters(self):
         default_config = get_default_nabu_config(nabu_fullfield_default_config)
+        self._mainWidget._configuration._preProcessingWidget._sinoRingsOpts.resetConfiguration()
         default_config["tomwer_slices"] = "middle"
         default_config["preproc"]["ccd_filter_enabled"] = False
         default_config["preproc"]["double_flatfield_enabled"] = False
@@ -386,8 +388,8 @@ class NabuWindow(qt.QMainWindow):
         filesSelected = dialog.selectedFiles()
         if filesSelected is not None and len(filesSelected) > 0:
             output = filesSelected[0]
-            if not output.endswith(".cfg"):
-                output = ".".join((output, "cfg"))
+            if not output.endswith((".cfg", ".conf", ".config")):
+                output = f"{output}.conf"
             return output
 
     def _userModeChanged(self, *args, **kwargs):
@@ -431,9 +433,6 @@ class NabuWindow(qt.QMainWindow):
     def isModeLocked(self):
         return self._mainWidget.isModeLocked()
 
-    def _triggerConfigChanged(self):
-        self.sigConfigChanged.emit()
-
 
 class NabuWidget(qt.QWidget):
     """

tomwer/gui/reconstruction/nabu/volume.py

@@ -34,15 +34,15 @@ from asyncio.log import logger
 from silx.gui import qt
 
 from tomwer.core.process.reconstruction.nabu.utils import (
-    ConfigurationLevel,
     _NabuStages,
 )
 from tomwer.gui import icons
-from tomwer.gui.reconstruction.nabu.action import (
+from tomwer.gui.configuration.action import (
     BasicConfigurationAction,
     ExpertConfigurationAction,
     MinimalisticConfigurationAction,
 )
+from tomwer.gui.configuration.level import ConfigurationLevel
 from tomwer.gui.reconstruction.nabu.nabuconfig.base import _NabuStageConfigBase
 from tomwer.gui.reconstruction.nabu.nabuconfig.output import (
     NabuOutputLocationWidget,
@@ -196,7 +196,7 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         )
         self._redefineNabuOutputLocation.setCheckable(True)
         self._redefineNabuOutputLocation.setLayout(qt.QVBoxLayout())
-        self._outputLocationWidget = NabuOutputLocationWidget(self)
+        self._outputLocationWidget = NabuOutputLocationWidget(parent=self)
         self._redefineNabuOutputLocation.layout().addWidget(self._outputLocationWidget)
         self.layout().addWidget(self._redefineNabuOutputLocation, 5, 0, 1, 2)
         self.registerWidget(self._redefineNabuOutputLocation, "advanced")
@@ -259,13 +259,15 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         self._outputLocationWidget._outputDirQLE.editingFinished.connect(
             self._triggerSigConfChanged
         )
-        self._outputLocationWidget._defaultOutput.toggled.connect(
-            self._triggerSigConfChanged
-        )
+        self._outputLocationWidget.sigOutputChanged.connect(self._triggerSigConfChanged)
+        self._redefineNabuOutputLocation.toggled.connect(self._triggerSigConfChanged)
 
     def redefineOutputLocation(self):
         return self._redefineNabuOutputLocation.isChecked()
 
+    def setRedefineOutputLocation(self, redefine: bool):
+        self._redefineNabuOutputLocation.setChecked(redefine)
+
     def getNabuOutputLocation(self):
         if self.redefineOutputLocation():
             return self._outputLocationWidget.getOutputDir()
@@ -277,6 +279,7 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
             self._redefineNabuOutputLocation.setChecked(False)
         else:
             self._redefineNabuOutputLocation.setChecked(True)
+            self._outputLocationWidget.setOutputDirMode("other")
             self._outputLocationWidget.setOutputDir(location)
 
     def redefineNabuFileFormat(self):
@@ -307,13 +310,13 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
         return self._spbCPUFract.value() / 100.0
 
     def setCPUFract(self, value):
-        return self._spbCPUFract.setValue(value * 100.0)
+        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(value * 100.0)
+        return self._spbGPUFract.setValue(int(value * 100.0))
 
     def getStartZ(self):
         return self._fromSlice.value()
@@ -357,6 +360,8 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
             },
             "new_output_file_format": self.getNabuFileFormat() or "",
             "new_output_location": self.getNabuOutputLocation() or "",
+            "output_dir_mode": self._outputLocationWidget.getOutputDirMode().value,
+            "overwrite_output_location": self.redefineOutputLocation(),
         }
 
     def setConfiguration(self, config):
@@ -382,6 +387,12 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
             if new_output_location == "":
                 new_output_location = None
             self.setNabuOutputLocation(new_output_location)
+        output_dir_mode = config.get("output_dir_mode", None)
+        if output_dir_mode is not None:
+            self._outputLocationWidget.setOutputDirMode(output_dir_mode)
+        overwrite_output_location = config.get("overwrite_output_location", None)
+        if overwrite_output_location is not None:
+            self.setRedefineOutputLocation(overwrite_output_location)
 
     def setPostProcConfiguration(self, config):
         if "output_histogram" in config:
@@ -430,6 +441,7 @@ class NabuVolumeWindow(qt.QMainWindow):
 
         self._minimalisticAction = MinimalisticConfigurationAction(toolbar)
         menu.addAction(self._minimalisticAction)
+        self.__configurationModesGroup.addAction(self._minimalisticAction)
         self._basicConfigAction = BasicConfigurationAction(toolbar)
         menu.addAction(self._basicConfigAction)
         self.__configurationModesGroup.addAction(self._basicConfigAction)
@@ -438,8 +450,8 @@ class NabuVolumeWindow(qt.QMainWindow):
         self.__configurationModesGroup.addAction(self._expertConfiguration)
 
         # set up
-        self._basicConfigAction.setChecked(True)
         self._userModeChanged(action=self._basicConfigAction)
+        self._basicConfigAction.setChecked(True)
 
         # connect signal / slot
         self._mainWidget.sigConfigChanged.connect(self._triggerSigConfigChanged)
@@ -455,7 +467,7 @@ class NabuVolumeWindow(qt.QMainWindow):
         elif action is self._expertConfiguration:
             level = ConfigurationLevel.ADVANCED
         else:
-            raise ValueError("unknow configuration level")
+            level = ConfigurationLevel.REQUIRED
         self._mainWidget.setConfigurationLevel(level)
 
     # expose API

tomwer/gui/reconstruction/normalization/intensity.py

@@ -46,7 +46,7 @@ from tomoscan.normalization import Method
 
 from tomwer.core.process.reconstruction.normalization import params as _normParams
 from tomwer.core.process.reconstruction.normalization.params import _ValueSource
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.reconstruction.scores.control import ControlWidget
 from tomwer.gui.utils.buttons import PadlockButton
@@ -88,7 +88,7 @@ class SinoNormWindow(qt.QMainWindow):
         # connect signal / slot
         # self._optsWidget.sigModeChanged.connect(self._modeChanged)
         self._optsWidget.sigValueUpdated.connect(self.setResult)
-        self._optsWidget.sigConfigurationChanged.connect(self._configurationChanged)
+        self._optsWidget.sigConfigurationChanged.connect(self.sigConfigurationChanged)
         self._optsWidget.sigSourceChanged.connect(self._sourceChanged)
         self._crtWidget.sigValidateRequest.connect(self._validated)
 
@@ -96,14 +96,6 @@ class SinoNormWindow(qt.QMainWindow):
         self._centralWidget._updateSinogramROI()
         self._modeChanged()
 
-    def close(self):
-        self._centralWidget.stop()
-        self._centralWidget = None
-        super().close()
-
-    def _configurationChanged(self):
-        self.sigConfigurationChanged.emit()
-
     def _hideLockButton(self):
         self._optsWidget._hideLockButton()
 
@@ -168,11 +160,6 @@ class SinoNormWindow(qt.QMainWindow):
         self._centralWidget.setScan(scan=scan)
         self._optsWidget.setScan(scan=scan)
 
-    def stop(self):
-        if self._centralWidget is not None:
-            self._centralWidget.stop()
-            self._centralWidget = None
-
     def getExtraArgs(self) -> dict:
         return self._optsWidget.getExtraInfos()
 
@@ -249,12 +236,6 @@ class _Viewer(qt.QTabWidget):
         self._projView.setManualROIVisible(visible=visible)
         self._sinoView.setROIVisible(visible=visible)
 
-    def stop(self):
-        self._projView.stop()
-        self._projView = None
-        self._sinoView.stop()
-        self._sinoView = None
-
     def getROI(self):
         return self._projView.getROI()
 
@@ -344,9 +325,6 @@ class _ProjPlotWithROI(DataViewer):
         super().clear()
         self.getPlotWidget().removeMarker("sinogram_line")
 
-    def stop(self):
-        self._viewer._plot.stopUpdateThread()
-
 
 class SinogramViewer(_SinogramViewer):
     """ "Sinogram viewer but adapated for Intensity normalization"""
@@ -400,14 +378,11 @@ class SinogramViewer(_SinogramViewer):
                     self.getPlotWidget().addItem(item)
 
     def getPlotWidget(self):
-        return self._plot.getPlotWidget()
+        return self._plot
 
     def _updatePlot(self, sinogram):
-        self._plot.getPlotWidget().addImage(data=sinogram)
-        self._plot.getPlotWidget().replot()
-
-    def stop(self):
-        self._plot.stopUpdateThread()
+        self.getPlotWidget().addImage(data=sinogram)
+        self.getPlotWidget().replot()
 
 
 class _NormIntensityOptions(qt.QWidget):
@@ -489,21 +464,20 @@ class _NormIntensityOptions(qt.QWidget):
 
         # connect signal / slot
         self._modeCB.currentIndexChanged.connect(self._modeChanged)
-        self._modeCB.currentIndexChanged.connect(self._configurationChanged)
+        self._modeCB.currentIndexChanged.connect(self.sigConfigurationChanged)
         self._sourceCB.currentIndexChanged.connect(self._sourceChanged)
-        self._sourceCB.currentIndexChanged.connect(self._configurationChanged)
-        self._computeButton.released.connect(self._computationRequested)
+        self._sourceCB.currentIndexChanged.connect(self.sigConfigurationChanged)
+        self._computeButton.released.connect(self.sigProcessingRequested)
         self._scalarValueWidget.sigValueChanged.connect(self._valueUpdated)
-        self._scalarValueWidget.sigValueChanged.connect(self._configurationChanged)
-        self._datasetWidget.sigConfigurationChanged.connect(self._configurationChanged)
+        self._scalarValueWidget.sigValueChanged.connect(self.sigConfigurationChanged)
+        self._datasetWidget.sigConfigurationChanged.connect(
+            self.sigConfigurationChanged
+        )
         self._intensityCalcOpts.sigConfigurationChanged.connect(
-            self._configurationChanged
+            self.sigConfigurationChanged
         )
         self._lockButton.toggled.connect(self._lockChanged)
-        self._lockButton.toggled.connect(self._configurationChanged)
-
-    def _configurationChanged(self):
-        self.sigConfigurationChanged.emit()
+        self._lockButton.toggled.connect(self.sigConfigurationChanged)
 
     def _sourceChanged(self):
         source = self.getCurrentSource()
@@ -644,9 +618,6 @@ class _NormIntensityOptions(qt.QWidget):
             else:
                 raise ValueError(f"unhandled source: {source} for method {method}")
 
-    def _computationRequested(self):
-        self.sigProcessingRequested.emit()
-
 
 class _NormIntensityCalcOpts(qt.QWidget):
     """Options to compute the norm intensity"""
@@ -665,15 +636,14 @@ class _NormIntensityCalcOpts(qt.QWidget):
         self.layout().addRow(self._calculationModeLabel, self._calculationModeCB)
 
         # connect signal / slot
-        self._calculationModeCB.currentIndexChanged.connect(self._configurationChanged)
+        self._calculationModeCB.currentIndexChanged.connect(
+            self.sigConfigurationChanged
+        )
 
     def setCalculationFctVisible(self, visible):
         self._calculationModeLabel.setVisible(visible)
         self._calculationModeCB.setVisible(visible)
 
-    def _configurationChanged(self):
-        self.sigConfigurationChanged.emit()
-
     def getCalculationFct(self):
         return _normParams._ValueCalculationFct.from_value(
             self._calculationModeCB.currentText()
@@ -885,7 +855,7 @@ class _NormIntensityDatasetWidget(qt.QWidget):
         if self.getMode() is _normParams._DatasetScope.LOCAL:
             if self.getScan() is not None:
                 scan = self.getScan()
-                if not isinstance(scan, HDF5TomoScan):
+                if not isinstance(scan, NXtomoScan):
                     mess = qt.QMessageBox(
                         parent=self,
                         icon=qt.QMessageBox.Warning,

tomwer/gui/reconstruction/saaxis/corrangeselector.py

@@ -148,7 +148,7 @@ class SinogramViewer(_SinogramViewer):
         self._estimated_cor = estimated_cor
         self._other_cors = other_cors if other_cors is not None else tuple()
 
-        plot = self._plot.getPlotWidget()
+        plot = self._plot
 
         if self._corMarker is not None:
             self._corMarker.sigDragFinished.disconnect(self._middleMarkerMoved)
@@ -259,9 +259,7 @@ class _ReconstructionModeGB(qt.QGroupBox):
         # connect signal / slot
         self._verticalRB.toggled.connect(self._reconstructionModeChanged)
         self._tiltCorrectionRB.toggled.connect(self._reconstructionModeChanged)
-        self._sliceVerticalQSB.sigSlicesChanged.connect(
-            self._reconstructionSliceChanged
-        )
+        self._sliceVerticalQSB.sigSlicesChanged.connect(self.reconstructionSliceChanged)
         self._onRadioButton.released.connect(self._onRadioActivated)
         self._defaultSlicesCB.currentIndexChanged.connect(self._updateVerticalSelection)
 
@@ -295,7 +293,7 @@ class _ReconstructionModeGB(qt.QGroupBox):
         mode_is_middle = current_mode == "middle"
         self._sliceVerticalQSB.setVisible(not mode_is_middle)
         self._onRadioButton.setVisible(not mode_is_middle)
-        self._reconstructionSliceChanged()
+        self.reconstructionSliceChanged.emit()
 
     def _onRadioActivated(self):
         lineSelection = QSliceSelectorDialog(parent=self, n_required_slice=1)
@@ -327,11 +325,6 @@ class _ReconstructionModeGB(qt.QGroupBox):
     def setScan(self, scan):
         self.__scan = weakref.ref(scan)
 
-    def _reconstructionSliceChanged(self):
-        # for now we only synchronize sliceQSB from vertical with the sinogram
-        # viewer
-        self.reconstructionSliceChanged.emit()
-
     def getReconstructionMode(self) -> ReconstructionMode:
         if self._tiltCorrectionRB.isChecked():
             return ReconstructionMode.TILT_CORRECTION
@@ -516,10 +509,10 @@ class _EstimatedCorWidget(qt.QGroupBox):
         self._middlePositionRB.toggled.connect(self._modeChanged)
         self._manualCORRel.editingFinished.connect(self._relativePositionChanged)
         self._manualCORAbs.editingFinished.connect(self._absolutePositionChanged)
-        self._autoCorPB.released.connect(self._autoCorReqested)
-        self._middlePositionRB.toggled.connect(self._autoCorValueChanged)
-        self._manualCORRel.editingFinished.connect(self._autoCorValueChanged)
-        self._manualCORAbs.editingFinished.connect(self._autoCorValueChanged)
+        self._autoCorPB.released.connect(self.sigAutoCorRequested)
+        self._middlePositionRB.toggled.connect(self.sigAutoCorChanged)
+        self._manualCORRel.editingFinished.connect(self.sigAutoCorChanged)
+        self._manualCORAbs.editingFinished.connect(self.sigAutoCorChanged)
         # set up
         self._middlePositionRB.setChecked(True)
         self._modeChanged()
@@ -607,12 +600,6 @@ class _EstimatedCorWidget(qt.QGroupBox):
             self._manualCORAbs.setValue(float(value))
             self._manualCORAbs.editingFinished.emit()
 
-    def _autoCorReqested(self):
-        self.sigAutoCorRequested.emit()
-
-    def _autoCorValueChanged(self):
-        self.sigAutoCorChanged.emit()
-
 
 class SAAxisOptions(qt.QWidget):
     """
@@ -673,7 +660,7 @@ class SAAxisOptions(qt.QWidget):
 
         # connect signal / slot
         self._reconstructionMode.reconstructionSliceChanged.connect(
-            self._reconstructionSliceChanged
+            self.sigReconstructionSliceChanged
         )
         self._nReconsSB.valueChanged.connect(self._reconstructionRangeChanged)
         self._estimatedCorWidget.sigAutoCorChanged.connect(
@@ -722,9 +709,6 @@ class SAAxisOptions(qt.QWidget):
         self._reconstructionMode.setSlicesRange(min_index, max_index)
         self.sigConfigurationChanged.emit()
 
-    def _reconstructionSliceChanged(self):
-        self.sigReconstructionSliceChanged.emit()
-
     def _reconstructionRangeChanged(self):
         self.sigReconstructionRangeChanged.emit()
         self.sigConfigurationChanged.emit()

tomwer/gui/reconstruction/saaxis/dimensionwidget.py

@@ -37,7 +37,7 @@ __date__ = "05/02/2021"
 from collections.abc import Iterable
 
 from silx.gui import qt
-from tomoscan.unitsystem import metricsystem
+from pyunitsystem import metricsystem
 
 
 class DimensionWidget(qt.QGroupBox):

tomwer/gui/reconstruction/saaxis/saaxis.py

@@ -41,7 +41,7 @@ import numpy
 from silx.gui import qt
 
 from tomwer.core.process.reconstruction.axis import mode as axis_mode
-from tomwer.core.process.reconstruction.nabu.utils import _NabuMode
+from tomwer.core.process.reconstruction.nabu.utils import _NabuMode, slice_index_to_int
 from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
 from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisTask
 from tomwer.gui import icons
@@ -66,14 +66,14 @@ class ScorePlot(_ScorePlot, constructor=CorSelection):
 
     def _updateScores(self):
         scan = self.__scan() if self.__scan else None
+        img_width = None
         if scan is not None:
             if scan.saaxis_params:
                 scan.saaxis_params.score_method = self.getScoreMethod()
                 img_width = scan.dim_1
                 # update autofocus
                 SAAxisTask.autofocus(scan)
-        else:
-            img_width = None
+
         self.setVarScores(
             scores=self._scores,
             score_method=self.getScoreMethod(),
@@ -131,13 +131,10 @@ class NabuAutoCorDiag(qt.QDialog):
         self.layout().addWidget(self._buttons)
 
         self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(
-            self._requestAutomaticCor
+            self.sigRequestAutoCor
         )
         self._buttons.button(qt.QDialogButtonBox.Ok).setText("compute")
 
-    def _requestAutomaticCor(self, *args, **kwargs):
-        self.sigRequestAutoCor.emit()
-
 
 class _SAAxisTabWidget(qt.QTabWidget):
     sigConfigurationChanged = qt.Signal()
@@ -258,6 +255,10 @@ class _SAAxisTabWidget(qt.QTabWidget):
             "mode": self.getReconstructionMode().value,
             "score_method": self.getScoreMethod().value,
             "estimated_cor": self.getEstimatedCorPosition(),
+            "output_dir": self.getNabuReconsParams()
+            .get("output", {})
+            .get("location", None)
+            or None,
         }
 
     def setConfiguration(self, config):
@@ -302,10 +303,6 @@ class _SAAxisTabWidget(qt.QTabWidget):
         self._nabuSettings = None
         super().close()
 
-    def _stopAnimationThread(self):
-        self._resultsViewer._stopAnimationThread()
-        self._sliceAndCorWidget._sinogramViewer._stopAnimationThread()
-
 
 class SAAxisWindow(qt.QMainWindow):
     """
@@ -380,9 +377,6 @@ class SAAxisWindow(qt.QMainWindow):
         self._saaxisControl.sigComputationRequest.connect(self._launchReconstructions)
         self._saaxisControl.sigValidateRequest.connect(self._validate)
 
-    def stop(self):
-        self._stopAnimationThread()
-
     def showResults(self):
         self._tabWidget.showResults()
 
@@ -450,10 +444,7 @@ class SAAxisWindow(qt.QMainWindow):
     def _updateSinogramLine(self):
         r_slice = self.getReconstructionSlices()
         if r_slice == "middle":
-            if self._scan is not None and self._scan.dim_2 is not None:
-                line = self._scan.dim_2 // 2
-            else:
-                line = 1024
+            line = slice_index_to_int(slice_index="middle", scan=self._scan, axis="XY")
         else:
             line = list(r_slice.values())[0]
         self._tabWidget.getSinogramViewer().setLine(line)
@@ -509,9 +500,6 @@ class SAAxisWindow(qt.QMainWindow):
         if idx >= 0:
             self._tabWidget.setCurrentIndex(idx)
 
-    def _stopAnimationThread(self):
-        self._tabWidget._stopAnimationThread()
-
     def close(self):
         self._tabWidget.close()
         self._tabWidget = None

tomwer/gui/reconstruction/sadeltabeta/saadeltabeta.py

@@ -41,10 +41,10 @@ import numpy
 from silx.gui import qt
 
 from tomwer.core.process.reconstruction.nabu.utils import (
-    ConfigurationLevel,
     _NabuMode,
     retrieve_lst_of_value_from_str,
 )
+from tomwer.gui.configuration.level import ConfigurationLevel
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
     SADeltaBetaTask,
 )
@@ -175,11 +175,22 @@ class _SADeltaBetaTabWidget(qt.QTabWidget):
         nabu_config = self.getNabuReconsParams()
         enable_ht = int(self._nabuSettings.getMode() is _NabuMode.HALF_ACQ)
         nabu_config["reconstruction"]["enable_halftomo"] = enable_ht
+        # update phase option
+        nabu_config["phase"][
+            "padding_type"
+        ] = self._deltaBetaSelectionWidget.getPaddingType().value
+        nabu_config["phase"][
+            "unsharp_coeff"
+        ] = self._deltaBetaSelectionWidget.getUnsharpCoeff()
+        nabu_config["phase"][
+            "unsharp_sigma"
+        ] = self._deltaBetaSelectionWidget.getUnsharpSigma()
         return {
             "slice_index": self.getReconstructionSlice(),
             "nabu_params": nabu_config,
             "score_method": self.getScoreMethod().value,
             "delta_beta_values": self.getDeltaBetaValues(),
+            "output_dir": nabu_config.get("output", {}).get("location", None) or None,
         }
 
     def getReconstructionSlice(self):
@@ -203,7 +214,21 @@ class _SADeltaBetaTabWidget(qt.QTabWidget):
         if slice_index is not None:
             self.setReconstructionSlice(slice_index)
         if "nabu_params" in config:
-            self.setNabuReconsParams(config["nabu_params"])
+            nabu_params = config["nabu_params"]
+            self.setNabuReconsParams(nabu_params)
+            # special handling of unsharp coeff, sigma and padding type
+            padding_type = nabu_params.get("phase", {}).get("padding_type", None)
+            if padding_type is not None:
+                self._deltaBetaSelectionWidget.setPaddingType(padding_type=padding_type)
+
+            unsharp_coeff = nabu_params.get("phase", {}).get("unsharp_coeff", None)
+            if unsharp_coeff is not None:
+                self._deltaBetaSelectionWidget.setUnsharpCoeff(coeff=unsharp_coeff)
+
+            unsharp_sigma = nabu_params.get("phase", {}).get("unsharp_sigma", None)
+            if unsharp_sigma is not None:
+                self._deltaBetaSelectionWidget.setUnsharpSigma(sigma=unsharp_sigma)
+
         if "score_method" in config:
             self.setScoreMethod(config["score_method"])
 
@@ -214,7 +239,6 @@ class _SADeltaBetaTabWidget(qt.QTabWidget):
         self._resultsViewer.setScoreMethod(method)
 
     def close(self):
-        self._stopAnimationThread()
         self._resultsViewer.close()
         self._resultsViewer = None
         self._deltaBetaSelectionWidget.close()
@@ -223,9 +247,6 @@ class _SADeltaBetaTabWidget(qt.QTabWidget):
         self._nabuSettings = None
         super().close()
 
-    def _stopAnimationThread(self):
-        self._resultsViewer._stopAnimationThread()
-
     def setSliceRange(self, min_, max_):
         self._deltaBetaSelectionWidget.setSliceRange(min_, max_)
 
@@ -332,12 +353,6 @@ class SADeltaBetaWindow(qt.QMainWindow):
         self._tabWidget = None
         super().close()
 
-    def stop(self):
-        self._stopAnimationThread()
-
-    def _stopAnimationThread(self):
-        self._tabWidget._stopAnimationThread()
-
     def setDBScores(
         self,
         scores: dict,
@@ -498,3 +513,21 @@ class DeltaBetaSelectionWidget(qt.QWidget):
                     from_=values.min(), to_=values.max(), step_=step
                 )
             )
+
+    def getPaddingType(self):
+        return self._mainWindow.getPaddingType()
+
+    def setPaddingType(self, padding_type: str):
+        self._mainWindow.setPaddingType(padding_type=padding_type)
+
+    def getUnsharpCoeff(self) -> float:
+        return self._mainWindow.getUnsharpCoeff()
+
+    def setUnsharpCoeff(self, coeff) -> float:
+        return self._mainWindow.setUnsharpCoeff(coeff=coeff)
+
+    def getUnsharpSigma(self) -> float:
+        return self._mainWindow.getUnsharpSigma()
+
+    def setUnsharpSigma(self, sigma):
+        self._mainWindow.setUnsharpSigma(sigma=sigma)

tomwer/gui/reconstruction/scores/control.py

@@ -71,12 +71,5 @@ class ControlWidget(qt.QWidget):
         self.layout().addWidget(self._buttons)
 
         # make connection
-        self._computeBut.pressed.connect(self._needComputation)
-        self._applyBut.pressed.connect(self._validate)
-
-    def _needComputation(self, *arg, **kwargs):
-        """callback when the radio line changed"""
-        self.sigComputationRequest.emit()
-
-    def _validate(self):
-        self.sigValidateRequest.emit()
+        self._computeBut.pressed.connect(self.sigComputationRequest)
+        self._applyBut.pressed.connect(self.sigValidateRequest)