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

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)
@@ -210,7 +215,7 @@ class VariableSelection(qt.QWidget):
         colormap = None
         if self.parent() and hasattr(self.parent(), "getPlotWidget"):
             master_plot = self.parent().getPlotWidget()
-            colormap = master_plot.getColorBarWidget().getColormap()
+            colormap = master_plot.getPlotWidget().getColorBarWidget().getColormap()
         dialog = VignettesQDialog(
             value_name=f"{self._variable_name} position",
             score_name="score",
@@ -571,7 +576,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 +593,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__()
@@ -603,12 +613,7 @@ class ScorePlot(qt.QWidget):
         self.sigConfigurationChanged.emit()
 
     def getPlotWidget(self):
-        return self._plot.getPlotWidget()
-
-    def _stopAnimationThread(self):
-        self._plot._freeLoadingThreads()
-        if self._plot._plot.updateThread.is_alive():
-            self._plot._plot.updateThread.stop()
+        return self._plot
 
     def close(self):
         self._plot.close()
@@ -657,9 +662,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,33 +52,55 @@ 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()
 
     def testSetImagesNumpyArray(self):
         """Test the setImages function"""
         radio_axis = self._window._axisWidget._radioAxis
-        self.assertEqual(radio_axis.getPlot().getPlot().getActiveImage(), None)
+        radio_axis_plot = self._window._axisWidget._radioAxis.getPlot()
+        numpy.testing.assert_array_equal(
+            radio_axis_plot.getPlot().getActiveImage().getData(), numpy.empty((0, 0, 4))
+        )
         imgA = numpy.random.random((100, 100))
         imgB = numpy.random.random((100, 100))
         radio_axis.setImages(imgA=imgA, imgB=imgB, flipB=True)
         self.qapp.processEvents()
-        self.assertNotEqual(radio_axis.getPlot().getPlot().getActiveImage(), None)
+        # make sur the image has been set
+        assert radio_axis_plot.getPlot().getImage(legend="image1").getData().shape == (
+            100,
+            100,
+        )
 
     def testSetScan(self):
         """Test the setScan function"""
         radio_axis_plot = self._window._axisWidget._radioAxis.getPlot()
-        self.assertEqual(radio_axis_plot.getPlot().getActiveImage(), None)
+        numpy.testing.assert_array_equal(
+            radio_axis_plot.getPlot().getActiveImage().getData(), numpy.empty((0, 0, 4))
+        )
         self._window.setScan(self.scan)
-        self.assertNotEqual(radio_axis_plot.getPlot().getActiveImage(), None)
+        self.qapp.processEvents()
+        # make sur the image has been set
+        assert radio_axis_plot.getPlot().getImage(legend="image1").getData().shape == (
+            20,
+            20,
+        )
 
     def testShiftButtons(self):
         """Test that the 'left', 'right', ... buttons and the shift steps are
@@ -89,7 +112,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 +124,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 +157,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 +171,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)

tomwer/gui/reconstruction/test/test_nabu.py

@@ -37,7 +37,7 @@ from tomwer.gui.reconstruction.nabu.nabuconfig.output import _NabuOutputConfig
 from tomwer.gui.reconstruction.nabu.nabuconfig.phase import _NabuPhaseConfig
 from tomwer.gui.reconstruction.nabu.nabuconfig.preprocessing import (
     _NabuPreProcessingConfig,
-    _RingCorrectionMethod,
+    RingCorrectionMethod,
 )
 from tomwer.gui.reconstruction.nabu.nabuconfig.reconstruction import (
     _NabuReconstructionConfig,
@@ -45,6 +45,7 @@ from tomwer.gui.reconstruction.nabu.nabuconfig.reconstruction import (
 from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowControl
 from tomwer.gui.reconstruction.nabu.volume import NabuVolumeWidget
 from tomwer.tests.utils import skip_gui_test
+from tomwer.core.process.output import ProcessDataOutputDirMode
 
 
 class ProcessClass:
@@ -119,8 +120,8 @@ class TestNabuPreProcConfig(TestCaseQt):
             "log_max_clip": 10.0,
             "take_logarithm": True,
             "normalize_srcurrent": 0,
-            "sino_rings_correction": _RingCorrectionMethod.NONE.value,
-            "sino_rings_options": "sigma=1.0 ; levels=10",
+            "sino_rings_correction": RingCorrectionMethod.NONE.value,
+            "sino_rings_options": "sigma=1.0 ; levels=10 ; padding=False",
             "tilt_correction": "",
             "autotilt_options": "",
         }
@@ -138,8 +139,8 @@ class TestNabuPreProcConfig(TestCaseQt):
             "log_max_clip": 250.0,
             "take_logarithm": False,
             "normalize_srcurrent": 1,
-            "sino_rings_correction": _RingCorrectionMethod.MUNCH.value,
-            "sino_rings_options": "sigma=1.4 ; levels=11",
+            "sino_rings_correction": RingCorrectionMethod.MUNCH.value,
+            "sino_rings_options": "sigma=1.4 ; levels=11 ; padding=True",
             "tilt_correction": "1d-correlation",
             "autotilt_options": "low_pass=1; high_pass=20",
         }
@@ -218,6 +219,7 @@ class TestNabuReconstructionConfig(TestCaseQt):
         """Test that the get configuration is working"""
         ini_conf = {
             "method": "FBP",
+            "slice_plane": "XY",
             "angles_file": "",
             "axis_correction_file": "",
             "angle_offset": 0.0,
@@ -245,6 +247,7 @@ class TestNabuReconstructionConfig(TestCaseQt):
         """Test that the set configuration is working"""
         ini_conf = {
             "method": "FBP",
+            "slice_plane": "XZ",
             "angles_file": "",
             "axis_correction_file": "",
             "angle_offset": 12.5,
@@ -283,6 +286,7 @@ class TestNabuReconstructionConfig(TestCaseQt):
         self.assertFalse(self.nabuWidget._preconditioningFilter.isChecked())
         self.assertTrue(self.nabuWidget._clipOuterCircleCB.isChecked())
         self.assertTrue(self.nabuWidget._centeredAxisCB.isChecked())
+        assert self.nabuWidget._axisQCB.currentText() == ini_conf["slice_plane"]
 
         # check the generated configuration
         self.assertEqual(self.nabuWidget.getConfiguration(), ini_conf)
@@ -303,17 +307,25 @@ class TestNabuOutputConfig(TestCaseQt):
         self.qapp.processEvents()
 
     def testGetConfiguration(self):
-        ini_conf = {"file_format": "hdf5", "location": ""}
+        ini_conf = {
+            "file_format": "hdf5",
+            "location": "",
+            "output_dir_mode": "same folder as scan",
+        }
         self.assertEqual(self.nabuWidget.getConfiguration(), ini_conf)
 
     def testSetConfiguration(self):
-        conf = {"file_format": "tiff", "location": os.sep.join(("tmp", "my_output"))}
+        conf = {
+            "file_format": "tiff",
+            "location": os.sep.join(("tmp", "my_output")),
+            "output_dir_mode": "other",
+        }
         self.nabuWidget.setConfiguration(conf)
         self.nabuWidget.show()
         self.qapp.processEvents()
         # check some widget visibility
         self.assertTrue(self.nabuWidget._output_dir_widget._outputDirQLE.isVisible())
-        self.assertFalse(self.nabuWidget._output_dir_widget._defaultOutput.isChecked())
+        self.assertTrue(self.nabuWidget._output_dir_widget._otherDirRB.isChecked())
 
         self.assertEqual(self.nabuWidget.getConfiguration(), conf)
 
@@ -323,6 +335,7 @@ class TestNabuVolumeWidget(TestCaseQt):
     def setUp(self):
         TestCaseQt.setUp(self)
         self.nabuWidget = NabuVolumeWidget(parent=None)
+        self.nabuWidget.setConfigurationLevel("advanced")
 
     def tearDown(self):
         self.nabuWidget.setAttribute(qt.Qt.WA_DeleteOnClose)
@@ -334,6 +347,8 @@ class TestNabuVolumeWidget(TestCaseQt):
             "start_z": 0,
             "end_z": -1,
             "gpu_mem_fraction": 0.9,
+            "output_dir_mode": ProcessDataOutputDirMode.IN_SCAN_FOLDER.value,
+            "overwrite_output_location": False,
             "postproc": {"output_histogram": 1},
             "cpu_mem_fraction": 0.9,
             "use_phase_margin": True,
@@ -354,6 +369,13 @@ class TestNabuVolumeWidget(TestCaseQt):
             "new_output_location": "/new/location",
         }
         self.nabuWidget.setConfiguration(conf)
-        self.nabuWidget.show()
         self.qapp.processEvents()
+
+        # update the config dict has setting an other custom output directory update some items
+        conf.update(
+            {
+                "overwrite_output_location": True,
+                "output_dir_mode": ProcessDataOutputDirMode.OTHER.value,
+            }
+        )
         self.assertEqual(self.nabuWidget.getConfiguration(), conf)

tomwer/gui/reconstruction/test/test_saaxis.py

@@ -37,7 +37,7 @@ import pytest
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 from silx.io.url import DataUrl
-from tomoscan.unitsystem import metricsystem
+from pyunitsystem import metricsystem
 
 from tomwer.core.process.reconstruction.saaxis.params import (
     ReconstructionMode,
@@ -45,7 +45,7 @@ from tomwer.core.process.reconstruction.saaxis.params import (
 )
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
 from tomwer.gui.reconstruction.saaxis.saaxis import SAAxisWindow
 from tomwer.tests.utils import skip_gui_test
@@ -144,7 +144,7 @@ class TestSAAxisWindow(TestCaseQt):
         # create a scan
         self.folder = tempfile.mkdtemp()
         dim = 10
-        mock = MockHDF5(
+        mock = MockNXtomo(
             scan_path=self.folder, n_proj=10, n_ini_proj=10, scan_range=180, dim=dim
         )
         mock.add_alignment_radio(index=10, angle=90)

tomwer/gui/reconstruction/test/test_sadeltabeta.py

@@ -41,7 +41,7 @@ from silx.io.url import DataUrl
 from tomwer.core.process.reconstruction.sadeltabeta.params import SADeltaBetaParams
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.reconstruction.sadeltabeta import SADeltaBetaWindow
 from tomwer.tests.utils import skip_gui_test
 
@@ -75,7 +75,7 @@ class TestSADeltaBetaWindow(TestCaseQt):
         # create a scan
         self.folder = tempfile.mkdtemp()
         dim = 10
-        mock = MockHDF5(
+        mock = MockNXtomo(
             scan_path=self.folder, n_proj=10, n_ini_proj=10, scan_range=180, dim=dim
         )
         mock.add_alignment_radio(index=10, angle=90)
@@ -115,11 +115,19 @@ class TestSADeltaBetaWindow(TestCaseQt):
 
     def testSetConfiguration(self):
         """Insure configuration setter works"""
+        nabu_specific_params = {
+            "phase": {
+                "padding_type": "zeros",
+                "unsharp_coeff": 5.36,
+                "unsharp_sigma": 4.1,
+            },
+        }
         self._window.setSlicesRange(0, 20)
         configuration = {
             "slice_index": {"Slice": 2},
             "delta_beta_values": (50, 100, 200),
             "score_method": "standard deviation",
+            "nabu_params": nabu_specific_params,
         }
         self._window.setConfiguration(configuration)
         res_conf = self._window.getConfiguration()
@@ -129,6 +137,8 @@ class TestSADeltaBetaWindow(TestCaseQt):
             "score_method",
         ):
             self.assertEqual(configuration[key], res_conf[key])
+        for key, value in nabu_specific_params["phase"].items():
+            assert value == res_conf["nabu_params"]["phase"][key]
 
     def testSetResults(self):
         """Test setting results"""

tomwer/gui/settings.py

@@ -1,31 +1,8 @@
-# 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.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "05/11/2018"
+from silx.gui import qt
 
 
 Y_AXIS_DOWNWARD = True
+"""Default axis direction Y"""
+
+EDITING_BACKGROUND_COLOR = qt.QColor("#c3d0d6")
+"""Background color used to notify the user that application waits end of edition before taking it into account"""

tomwer/gui/stackplot.py

@@ -555,7 +555,7 @@ class _StackImageToLoad(_StackImage, qt.QObject):
 
     def clear(self):
         for img in self._images.values():
-            img.sigLoaded.disconnect(self._loaded)
+            img.sigLoaded.disconnect(self.sigImageLoaded)
         _StackImage.clear(self)
         self._url_to_index.clear()
 
@@ -568,7 +568,7 @@ class _StackImageToLoad(_StackImage, qt.QObject):
             raise TypeError(f"Unmanaged type: {type(image)}")
         self._url_to_index[image_.url.path()] = self.nextIndex
         _StackImage.addImage(self, image_)
-        image_.sigLoaded.connect(self._loaded)
+        image_.sigLoaded.connect(self.sigImageLoaded)
         if self._mode == ASAP_LOADING:
             image_.load(self._force_sync)
 
@@ -615,9 +615,6 @@ class _StackImageToLoad(_StackImage, qt.QObject):
             except Exception as e:
                 logger.error(e)
 
-    def _loaded(self, url_path):
-        self.sigImageLoaded.emit(url_path)
-
     def setForceSync(self, value):
         self._force_sync = value
 

tomwer/gui/stitching/action.py

@@ -0,0 +1,49 @@
+from silx.gui import qt
+from silx.gui import icons as silx_icons
+from tomwer.gui import icons as tomwer_icons
+
+
+class LoadConfigurationAction(qt.QAction):
+    """Action to trigger load of a stitching configuration"""
+
+    def __init__(self, parent=None, text=None):
+        super().__init__(parent)
+        if text is not None:
+            self.setText(text)
+        self.setToolTip("load nabu-stitching configuration")
+        load_icon = silx_icons.getQIcon("document-open")
+        self.setIcon(load_icon)
+
+
+class SaveConfigurationAction(qt.QAction):
+    """Action to trigger save of a stitching configuration"""
+
+    def __init__(self, parent=None, text=None):
+        super().__init__(parent)
+        if text is not None:
+            self.setText(text)
+        self.setToolTip("save nabu-stitching configuration")
+        save_icon = silx_icons.getQIcon("document-save")
+        self.setIcon(save_icon)
+
+
+class AddTomoObjectAction(qt.QAction):
+    """Action to trigger add a volume to a stitching configuration"""
+
+    def __init__(self, parent=None, text=None):
+        super().__init__(parent)
+        if text is not None:
+            self.setText(text)
+        self.setToolTip(
+            "Add a NXtomo or a (nabu) reconstructed volume to the stitching"
+        )
+        add_icon = tomwer_icons.getQIcon("add")
+        self.setIcon(add_icon)
+
+
+class PreviewAction(qt.QAction):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setToolTip("Compute preview with current settings (shortcut: F5)")
+        update_preview_icon = tomwer_icons.getQIcon("update_stitching_preview")
+        self.setIcon(update_preview_icon)

tomwer/gui/stitching/config/axisparams.py

@@ -2,11 +2,11 @@ import logging
 from typing import Union
 
 from nabu.stitching import config as stitching_config
-from nabu.stitching.utils import ScoreMethod
 from nabu.stitching.utils import ShiftAlgorithm as StitchShiftAlgorithm
 from silx.gui import qt
 
 from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.gui.configuration.level import ConfigurationLevel
 
 _logger = logging.getLogger(__name__)
 
@@ -34,7 +34,6 @@ class StitcherAxisParams(qt.QWidget):
         axis_0_shift_search_method = [
             StitchShiftAlgorithm.NABU_FFT,
             StitchShiftAlgorithm.SKIMAGE,
-            StitchShiftAlgorithm.SHIFT_GRID,
             StitchShiftAlgorithm.ITK_IMG_REG_V4,
             StitchShiftAlgorithm.NONE,
         ]
@@ -54,13 +53,6 @@ class StitcherAxisParams(qt.QWidget):
         tooltip = "size of the window to try to refine shift"
         self._windowSizeLabel.setToolTip(tooltip)
         self._windowSizeSB.setToolTip(tooltip)
-        # score method
-        self._scoreMethodLabel = qt.QLabel("score method", self)
-        self.layout().addWidget(self._scoreMethodLabel, 2, 0, 1, 1)
-        self._scoreMethodCB = qt.QComboBox(self)
-        for method in ScoreMethod:
-            self._scoreMethodCB.addItem(method.value)
-        self.layout().addWidget(self._scoreMethodCB, 2, 1, 1, 1)
 
         # filter options
         self._filteringGroup = _FilteringGroupBox("filter for shift search", self)
@@ -68,7 +60,7 @@ class StitcherAxisParams(qt.QWidget):
         self._filteringGroup.setChecked(False)
         self._filteringGroup.setLowPassValue(1)
         self._filteringGroup.setHighPassValue(20)
-        self.layout().addWidget(self._filteringGroup, 3, 0, 2, 3)
+        self.layout().addWidget(self._filteringGroup, 2, 0, 2, 3)
 
         # set up
         self._methodChanged()
@@ -76,7 +68,6 @@ class StitcherAxisParams(qt.QWidget):
         # connect signal / slot
         self._shiftSearchMethodCB.currentIndexChanged.connect(self._methodChanged)
         self._windowSizeSB.valueChanged.connect(self._notifyConfigChanged)
-        self._scoreMethodCB.currentIndexChanged.connect(self._notifyConfigChanged)
         self._filteringGroup.sigValueChanged.connect(self._notifyConfigChanged)
 
     @property
@@ -91,21 +82,12 @@ class StitcherAxisParams(qt.QWidget):
         idx = self._shiftSearchMethodCB.findText(method.value)
         self._shiftSearchMethodCB.setCurrentIndex(idx)
 
-    def setScoreMethod(self, method: Union[ScoreMethod, str]) -> None:
-        method = ScoreMethod.from_value(method)
-        idx = self._scoreMethodCB.findText(method.value)
-        self._scoreMethodCB.setCurrentIndex(idx)
-
     def getConfiguration(self) -> dict:
         method = self.getShiftSearchMethod()
         param_opts = [
             f"{stitching_config.KEY_IMG_REG_METHOD}={method.value}",
             f"{stitching_config.KEY_WINDOW_SIZE}={self._windowSizeSB.value()}",
         ]
-        if method is StitchShiftAlgorithm.SHIFT_GRID:
-            param_opts.append(
-                f"{stitching_config.KEY_SCORE_METHOD}='{self._scoreMethodCB.currentText()}'"
-            )
         if self._filteringGroup.isChecked():
             param_opts.append(
                 f"{stitching_config.KEY_LOW_PASS_FILTER}='{self._filteringGroup.getLowPassValue()}'"
@@ -136,8 +118,6 @@ class StitcherAxisParams(qt.QWidget):
                     self.setShiftSearchMethod(opt_value)
                 elif opt_name == stitching_config.KEY_WINDOW_SIZE:
                     self._windowSizeSB.setValue(int(opt_value))
-                elif opt_name == stitching_config.KEY_SCORE_METHOD:
-                    self.setScoreMethod(opt_value)
                 elif opt_name == stitching_config.KEY_LOW_PASS_FILTER:
                     self._filteringGroup.setLowPassValue(int(opt_value))
                     self._filteringGroup.setEnabled(True)
@@ -153,8 +133,6 @@ class StitcherAxisParams(qt.QWidget):
     def _methodChanged(self) -> None:
         method = self.getShiftSearchMethod()
         with block_signals(self):
-            self._scoreMethodCB.setVisible(method is StitchShiftAlgorithm.SHIFT_GRID)
-            self._scoreMethodLabel.setVisible(method is StitchShiftAlgorithm.SHIFT_GRID)
             self._windowSizeSB.setVisible(method is not StitchShiftAlgorithm.NONE)
             self._windowSizeLabel.setVisible(method is not StitchShiftAlgorithm.NONE)
         self._notifyConfigChanged()
@@ -162,6 +140,11 @@ class StitcherAxisParams(qt.QWidget):
     def _notifyConfigChanged(self, *args, **kwargs) -> None:
         self.sigConfigChanged.emit()
 
+    def setConfigurationLevel(self, level: ConfigurationLevel):
+        self._windowSizeLabel.setVisible(level >= ConfigurationLevel.OPTIONAL)
+        self._windowSizeSB.setVisible(level >= ConfigurationLevel.OPTIONAL)
+        self._filteringGroup.setVisible(level >= ConfigurationLevel.ADVANCED)
+
 
 class _FilteringGroupBox(qt.QGroupBox):
     sigValueChanged = qt.Signal()

tomwer/gui/stitching/config/output.py

@@ -5,9 +5,10 @@ from nabu.stitching.config import StitchingType
 from nxtomomill.io.utils import convert_str_to_bool
 from silx.gui import qt
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan, HDF5TomoScanIdentifier
+from tomwer.core.scan.nxtomoscan import NXtomoScan, NXtomoScanIdentifier
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.gui.utils.inputwidget import OutputVolumeDefinition
+from tomwer.gui.qlefilesystem import QLFileSystem
 
 _logger = logging.getLogger(__name__)
 
@@ -21,21 +22,21 @@ class _PreProcessingOutput(qt.QWidget):
         super().__init__(parent)
         self.setLayout(qt.QFormLayout())
         # TODO: check if the widget with output .nx file exists somewhere
-        self._outputFile = qt.QLineEdit("stitching/stitched.nx", self)
+        self._outputFile = QLFileSystem("stitching/stitched.nx", self)
         self.layout().addRow("output nexus file", self._outputFile)
         self._outputDataPath = qt.QLineEdit("entry0000", self)
         self.layout().addRow("output data path", self._outputDataPath)
 
     def getUrl(self) -> str:
-        return HDF5TomoScanIdentifier(
-            object=HDF5TomoScan,
+        return NXtomoScanIdentifier(
+            object=NXtomoScan,
             hdf5_file=self._outputFile.text(),
             entry=self._outputDataPath.text(),
         )
 
     def setUrl(self, url: str):
         try:
-            identifier = HDF5TomoScanIdentifier.from_str(url)
+            identifier = NXtomoScanIdentifier.from_str(url)
         except Exception as e:
             _logger.warning(f"Fail to create an identifier from {url}. Error is {e}")
         else:
@@ -71,6 +72,7 @@ class StitchingOutput(qt.QWidget):
         self._postProcOutput = _PostProcessingOutput(parent=self)
         self.layout().addWidget(self._postProcOutput)
         self._overwritePB = qt.QCheckBox("overwrite", self)
+        self._overwritePB.setChecked(True)
         self.layout().addWidget(self._overwritePB)
 
         # add a vertical spacer for display
@@ -110,7 +112,7 @@ class StitchingOutput(qt.QWidget):
             except Exception:
                 scan = None
 
-            if not isinstance(scan, HDF5TomoScan):
+            if not isinstance(scan, NXtomoScan):
                 _logger.info("Failed to create an HDFTomoscan from url")
                 return None
             else:
@@ -146,8 +148,8 @@ class StitchingOutput(qt.QWidget):
             stitching_config.DATA_PATH_FIELD, None
         )
         if location is not None:
-            identifier = HDF5TomoScanIdentifier(
-                object=HDF5TomoScan, hdf5_file=location, entry=data_path
+            identifier = NXtomoScanIdentifier(
+                object=NXtomoScan, hdf5_file=location, entry=data_path
             )
             self._preProcOutput.setUrl(identifier.to_str())