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

tomwer/gui/reconstruction/nabu/nabuflow.py

@@ -108,23 +108,27 @@ class NabuFlowControl(qt.QWidget):
         self._iniProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.INI)
         )
-        self._iniProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._iniProcessWidgets.sigWidgetDeactivated.connect(self.sigResetConfiguration)
         self._preProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.PRE)
         )
-        self._preProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._preProcessWidgets.sigWidgetDeactivated.connect(self.sigResetConfiguration)
         self._phaseProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.PHASE)
         )
-        self._phaseProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._phaseProcessWidgets.sigWidgetDeactivated.connect(
+            self.sigResetConfiguration
+        )
         self._processWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.PROC)
         )
-        self._processWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._processWidgets.sigWidgetDeactivated.connect(self.sigResetConfiguration)
         self._postProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.POST)
         )
-        self._postProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._postProcessWidgets.sigWidgetDeactivated.connect(
+            self.sigResetConfiguration
+        )
 
         # set up
         self.setIniprocVisible(False)
@@ -133,9 +137,6 @@ class NabuFlowControl(qt.QWidget):
         self.setProcVisible(True)
         self.setPostVisible(True)
 
-    def _activeProcessUnset(self):
-        self.sigResetConfiguration.emit()
-
     def _updateActiveProcess(self, stage):
         stage = _NabuStages.from_value(stage)
 
@@ -396,14 +397,8 @@ class NabuFlowArea(qt.QWidget):
 
         # connect signal / slot
         self._addRmWidget.sigRmProcess.connect(self._control._removeActiveProcess)
-        self._control.sigConfigurationChanged.connect(self._repeatConfigSignal)
-        self._control.sigResetConfiguration.connect(self._repeatResetConfigSignal)
-
-    def _repeatConfigSignal(self, *args):
-        self.sigConfigurationChanged.emit(*args)
-
-    def _repeatResetConfigSignal(self):
-        self.sigResetConfiguration.emit()
+        self._control.sigConfigurationChanged.connect(self.sigConfigurationChanged)
+        self._control.sigResetConfiguration.connect(self.sigResetConfiguration)
 
     @docstring(NabuFlowControl)
     def setIniProcessing(self, processes, icons):
@@ -464,12 +459,9 @@ class _AddRemoveProcessWidget(qt.QWidget):
 
         # connect signal / slot
         self._addButton.pressed.connect(self._addProcess)
-        self._rmButton.pressed.connect(self._rmProcess)
+        self._rmButton.pressed.connect(self.sigRmProcess)
 
     def _addProcess(self):
         # should be able to add a process from ini, post, processing and pre
 
         raise NotImplementedError(" not implemented, to be defined")
-
-    def _rmProcess(self):
-        self.sigRmProcess.emit()

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__)
@@ -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
@@ -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)
 
@@ -101,9 +101,6 @@ class SinoNormWindow(qt.QMainWindow):
         self._centralWidget = None
         super().close()
 
-    def _configurationChanged(self):
-        self.sigConfigurationChanged.emit()
-
     def _hideLockButton(self):
         self._optsWidget._hideLockButton()
 
@@ -489,21 +486,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 +640,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 +658,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 +877,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

@@ -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
@@ -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):
@@ -450,10 +451,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)
         else:
             line = list(r_slice.values())[0]
         self._tabWidget.getSinogramViewer().setLine(line)

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,
 )
@@ -190,6 +190,7 @@ class _SADeltaBetaTabWidget(qt.QTabWidget):
             "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):

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)

tomwer/gui/reconstruction/scores/scoreplot.py

@@ -137,6 +137,11 @@ class VariableSelection(qt.QWidget):
         self._scoreMethodCB = qt.QComboBox(self)
         self.layout().addWidget(self._scoreMethodCB, 0, 1, 1, 1)
         for method in ScoreMethod:
+            if method is ScoreMethod.TOMO_CONSISTENCY:
+                # for now we avoid this method. Does not provide great results and is very time consuming
+                # I guess when we will add it we will need to first display slices
+                # and then only compute the score. It might be an "on demand" score but not computed by default.
+                continue
             self._scoreMethodCB.addItem(method.value)
         # default score method is 1 / tv
         idx = self._scoreMethodCB.findText(ScoreMethod.TV_INVERSE.value)
@@ -193,7 +198,6 @@ class VariableSelection(qt.QWidget):
         self._autofocusRB.toggled.connect(self._selectionModeChanged)
         self._lockAutofocusButton.toggled.connect(self._lockButtonActive)
         self._vignetteButton.released.connect(self._openVignetteMode)
-        self._scoreMethodCB.currentIndexChanged.connect(self._scoreMethodChanged)
 
         # update widget to fit set up
         self._selectionModeChanged()
@@ -571,7 +575,7 @@ class ScorePlot(qt.QWidget):
         self._varSlider.valueChanged.connect(self._plot.setCurrentUrlIndex)
         self._varSlider.valueChanged.connect(self._sliderReleased)
         self._varSlider.valueChanged.connect(self._updateVarValue)
-        self._varScore.sigMouseWheelActive.connect(self._propagateSPWheelEvent)
+        self._varScore.sigMouseWheelActive.connect(self._varSlider.wheelEvent)
         self._varValueWidget.sigAutoFocusLocked.connect(self._autoFocusLockChanged)
         self._varValueWidget.sigAutoFocusUnLocked.connect(self._autoFocusLockChanged)
         self._varValueWidget.sigSelectionModeChanged.connect(
@@ -588,6 +592,11 @@ class ScorePlot(qt.QWidget):
         self._volumeSizeW.hide()
         self._voxelSizeW.hide()
         self._axisLabel.hide()
+        # use mean mean+/-3std for the cor
+        plotWidget = self._plot.getPlotWidget()
+        colormap = plotWidget.getDefaultColormap()
+        colormap.setAutoscaleMode(colormap.STDDEV3)
+        plotWidget.setDefaultColormap(colormap=colormap)
 
     def __init_subclass__(cls, constructor, **kwargs):  # pylint: disable=E0302
         super().__init_subclass__()
@@ -657,9 +666,6 @@ class ScorePlot(qt.QWidget):
     def _varSelectedFromVignettes(self, value):
         self._varSlider.setVarValue(value)
 
-    def _propagateSPWheelEvent(self, event):
-        self._varSlider.wheelEvent(event)
-
     def _get_closest_var(self, value):
         """return the closest cor value to value or None if no cor value
         defined"""

tomwer/gui/reconstruction/test/test_axis.py

@@ -38,12 +38,13 @@ from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.reconstruction.axis import AxisWindow
 from tomwer.gui.reconstruction.axis.radioaxis import _ManualFramesSelection
 from tomwer.synctools.axis import QAxisRP
-from tomwer.tests.utils import UtilsTest, skip_gui_test
+from tomwer.tests.datasets import TomwerCIDatasets
+from tomwer.tests.utils import skip_gui_test
+from tomwer.core.utils.scanutils import MockNXtomo
 
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
@@ -51,14 +52,22 @@ class TestWindowAxis(TestCaseQt):
     """Test that the axis widget work correctly"""
 
     def setUp(self):
+        self.tempdir = tempfile.mkdtemp()
         self.recons_params = QAxisRP()
         self._window = AxisWindow(axis_params=self.recons_params)
-        self.scan_path = UtilsTest.getEDFDataset("D2_H2_T2_h_")
-        self.scan = EDFTomoScan(self.scan_path)
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tempdir, "nx_tomo.nx"),
+            n_proj=10,
+            n_ini_proj=10,
+            scan_range=180,
+            dim=20,
+            energy=12.3,
+        ).scan
         self._window.show()
         self.qWaitForWindowExposed(self._window)
 
     def tearDown(self):
+        shutil.rmtree(self.tempdir)
         self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
         self._window.close()
 
@@ -89,7 +98,10 @@ class TestWindowAxis(TestCaseQt):
         self.qapp.processEvents()
         self.assertTrue(radio_axis.getXShift() == 0)
         self.assertTrue(radio_axis.getYShift() == 0)
-        self.assertTrue(radio_axis.getShiftStep() == 1.0)
+        self.assertTrue(
+            radio_axis.getShiftStep() == 1.0,
+            f"shift is {radio_axis.getShiftStep()} when 1.0 expected",
+        )
         radio_axis._controlWidget._shiftControl._leftButton.click()
         self.qapp.processEvents()
         self.assertTrue(radio_axis.getXShift() == -1)
@@ -98,7 +110,7 @@ class TestWindowAxis(TestCaseQt):
         self.qapp.processEvents()
         self.assertTrue(radio_axis.getXShift() == 0)
         self.assertTrue(radio_axis.getYShift() == 0)
-        radio_axis._controlWidget._displacementSelector._fineButton.toggle()
+        radio_axis._controlWidget._displacementSelector._fineButton.click()
         self.qapp.processEvents()
         self.assertTrue(radio_axis.getShiftStep() == 0.1)
         radio_axis._controlWidget._shiftControl._topButton.click()
@@ -131,9 +143,6 @@ class TestWindowAxis(TestCaseQt):
         self.assertEqual(radio_axis.getXShift(), -6.0)
         self.assertEqual(radio_axis.getYShift(), 0.0)
 
-    def testAxisCalculationSaveLoad(self):
-        pass
-
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
 class TestWindowsAxisSetScan(TestCaseQt):
@@ -148,10 +157,12 @@ class TestWindowsAxisSetScan(TestCaseQt):
         # create dataset
         self.master_file = os.path.join(self.scan_dir, "frm_edftomomill_twoentries.nx")
         shutil.copyfile(
-            UtilsTest.getH5Dataset(folderID="frm_edftomomill_twoentries.nx"),
+            TomwerCIDatasets.get_dataset(
+                "h5_datasets/frm_edftomomill_twoentries.nx",
+            ),
             self.master_file,
         )
-        self.scan = HDF5TomoScan(scan=self.master_file, entry="entry0000")
+        self.scan = NXtomoScan(scan=self.master_file, entry="entry0000")
 
     def tearDown(self):
         self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)