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

tomwer/gui/control/serie/seriecreator.py

@@ -107,10 +107,10 @@ class SerieWidget(qt.QTabWidget):
 
         # conenct signal / slot
         self._historyWidget.sigEditSerie.connect(self._serieEditionRequested)
-        self._historyWidget.sigSerieSend.connect(self._repeatSerieSend)
+        self._historyWidget.sigSerieSend.connect(self.sigSerieSend)
         self._historyWidget.sigHistoryUpdated.connect(self._repeatHistoryUpdated)
         self._serieDefinitionWidget.sigSerieChanged.connect(self._repeatSerieChanged)
-        self._serieDefinitionWidget.sigSerieSend.connect(self._repeatSerieSend)
+        self._serieDefinitionWidget.sigSerieSend.connect(self.sigSerieSend)
         self._serieDefinitionWidget.sigSerieSend.connect(self._historyWidget.addSerie)
 
     def getHistoryWidget(self):
@@ -143,9 +143,6 @@ class SerieWidget(qt.QTabWidget):
     def _repeatSerieChanged(self, *args, **kwargs):
         self.sigCurrentSerieChanged.emit()
 
-    def _repeatSerieSend(self, serie: Serie):
-        self.sigSerieSend.emit(serie)
-
     def _repeatHistoryUpdated(self, *args, **kwargs):
         self.sigHistoryChanged.emit()
 
@@ -186,9 +183,7 @@ class SerieDefinition(qt.QWidget):
 
         # connect signal / slot
         self._modeCB.currentIndexChanged.connect(self._updateVisibility)
-        self._manualDefWidget._newSerieWidget.sigUpdated.connect(
-            self._repeatSerieChanged
-        )
+        self._manualDefWidget._newSerieWidget.sigUpdated.connect(self.sigSerieChanged)
 
         # set up
         self._updateVisibility()
@@ -217,12 +212,6 @@ class SerieDefinition(qt.QWidget):
     def getAutoDefinitionWidget(self):
         return self._automaticDefWidget
 
-    def _repeatSerieChanged(self, *args, **kwargs):
-        self.sigSerieChanged.emit()
-
-    def _repeatSerieSend(self, serie: Serie):
-        self.sigSerieSend.emit(serie)
-
     def createManualSerie(self):
         self._manualDefWidget.createSerie()
 
@@ -651,7 +640,7 @@ class NewSerieWidget(qt.QWidget):
 
         # Signal / slot connection
         self._serieTree.itemChanged.connect(self._handleItemUpdate)
-        self._serieTree.sigUpdated.connect(self._repeatUpdateSignal)
+        self._serieTree.sigUpdated.connect(self.sigUpdated)
         self._nameQLE.textChanged.connect(self._nameChangedOnQLE)
 
     def setSerie(self, serie: Serie) -> None:
@@ -674,9 +663,6 @@ class NewSerieWidget(qt.QWidget):
             self.blockSignals(old)
         self.sigUpdated.emit()
 
-    def _repeatUpdateSignal(self):
-        self.sigUpdated.emit()
-
     def addTomoObjToCurrentSerie(self, tomo_obj: TomwerObject):
         assert isinstance(
             tomo_obj, TomwerObject
@@ -726,7 +712,7 @@ class SerieManualDefinitionDialog(qt.QDialog):
 
         # connect signal / slot
         self._newSerieWidget.sigNameChanged.connect(self._nameChanged)
-        self._newSerieWidget.sigUpdated.connect(self._repeatUpdateSignal)
+        self._newSerieWidget.sigUpdated.connect(self.sigUpdated)
         self._addScanButton.clicked.connect(self.addScanFromFileDialog)
         self._removeSelectedButton.clicked.connect(self.removeSelectedTomoObjs)
         self._clearButton.clicked.connect(self.clearSerie)
@@ -742,9 +728,6 @@ class SerieManualDefinitionDialog(qt.QDialog):
             serieTree.setSerieName(name=new_name)
         self.sigUpdated.emit()
 
-    def _repeatUpdateSignal(self):
-        self.sigUpdated.emit()
-
     def setSerieName(self, name: str):
         self._newSerieWidget.setSerieName(name=name)
 

tomwer/gui/control/test/test_email.py

@@ -1,5 +1,5 @@
 from tomwer.tests.conftest import qtapp  # noqa F401
-from tomwer.gui.control.email import Emailwidget
+from tomwer.gui.control.emailnotifier import Emailwidget
 
 
 def test_Emailwidget(qtapp):  # noqa F811

tomwer/gui/control/test/test_scanvalidator.py

@@ -37,7 +37,8 @@ import time
 import pytest
 from silx.gui.utils.testutils import TestCaseQt
 
-from tomwer.core import settings, utils
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import mock_low_memory, is_low_on_memory
 from tomwer.core.process.control.scanvalidator import ScanValidatorP
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.utils.scanutils import MockEDF
@@ -57,7 +58,7 @@ class TestScanValidator(TestCaseQt):
     NB_SCANS = 2
 
     def tearDown(self):
-        utils.mockLowMemory(False)
+        mock_low_memory(False)
 
     @classmethod
     def setUpClass(cls):
@@ -81,7 +82,7 @@ class TestScanValidator(TestCaseQt):
                 shutil.rmtree(f)
 
     @pytest.mark.skipif(
-        (settings.isOnLbsram() and utils.isLowOnMemory(settings.get_lbsram_path())),
+        (settings.isOnLbsram() and is_low_on_memory(settings.get_lbsram_path())),
         reason="Lbsram already overloaded",
     )
     def testMemoryReleaseLoop(self):
@@ -102,11 +103,11 @@ class TestScanValidator(TestCaseQt):
                 time.sleep(self.LOOP_MEM_RELEASER_DURATION * 2)
 
         add_all_scans()
-        utils.mockLowMemory(True)
+        mock_low_memory(True)
         my_wait()
         self.assertEqual(len(self.scanValidator._scans), 0)
 
-        utils.mockLowMemory(False)
+        mock_low_memory(False)
         add_all_scans()
         my_wait()
         self.assertEqual(len(self.scanValidator._scans), self.NB_SCANS)

tomwer/gui/control/test/test_single_tomo_obj.py

@@ -5,7 +5,7 @@ import numpy
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.core.volume.hdf5volume import HDF5Volume
 from tomwer.gui.control.singletomoobj import SingleTomoObj
 
@@ -29,12 +29,12 @@ class TestSingletomoObj(TestCaseQt):
         self.volume.save()
 
         self._scan_file_path = os.path.join(self._tempdir, "scan.nx")
-        self.scan_hdf5 = MockHDF5(
+        self.scan_hdf5 = MockNXtomo(
             scan_path=self._scan_file_path,
             n_proj=10,
             n_ini_proj=10,
             create_ini_dark=False,
-            create_ini_ref=False,
+            create_ini_flat=False,
             dim=10,
         ).scan
 

tomwer/gui/control/tomoobjdisplaymode.py

@@ -0,0 +1,8 @@
+from silx.utils.enum import Enum as _Enum
+
+
+class DisplayMode(_Enum):
+    """possible display mode for the tomo object"""
+
+    URL = "url"
+    SHORT = "short"

tomwer/gui/debugtools/datasetgenerator.py

@@ -34,7 +34,7 @@ from silx.gui import qt
 
 from tomwer.core.scan.blissscan import BlissScan
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 
 
 class DatasetGeneratorDialog(qt.QDialog):
@@ -116,13 +116,13 @@ class DatasetGeneratorConfig(qt.QWidget):
         self._typeCB = qt.QComboBox(self)
         for _typeClass in (
             EDFTomoScan,
-            HDF5TomoScan,
+            NXtomoScan,
             BlissScan,
         ):
             self._typeCB.addItem(_typeClass.__name__)
         self.layout().addWidget(qt.QLabel("type", self), 0, 0, 1, 1)
         self.layout().addWidget(self._typeCB, 0, 1, 1, 2)
-        txt_index = self._typeCB.findText(HDF5TomoScan.__name__)
+        txt_index = self._typeCB.findText(NXtomoScan.__name__)
         self._typeCB.setCurrentIndex(txt_index)
 
         # generation timeout

tomwer/gui/edit/dkrfpatch.py

@@ -36,11 +36,11 @@ from silx.gui import qt
 from silx.gui.dialog.DataFileDialog import DataFileDialog
 from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from tomoscan.io import HDF5File
+from silx.io.utils import open as open_hdf5
+from nxtomo.nxobject.nxdetector import ImageKey
 
 import tomwer.core.utils.nxtomoutils as nxtomo_utils
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.io.utils import get_default_directory
 
 _logger = logging.getLogger(__name__)
@@ -67,11 +67,8 @@ class _DarkOrFlatUrl(qt.QWidget):
 
         # connect signal / slot
         self._qle.editingFinished.connect(self._tryUpdateOptions)
-        self._qle.editingFinished.connect(self._editingFinished)
-        self._optionsCB.currentIndexChanged.connect(self._editingFinished)
-
-    def _editingFinished(self):
-        self.editingFinished.emit()
+        self._qle.editingFinished.connect(self.editingFinished)
+        self._optionsCB.currentIndexChanged.connect(self.editingFinished)
 
     def setUrl(self, url):
         """
@@ -86,7 +83,7 @@ class _DarkOrFlatUrl(qt.QWidget):
         url = self._redirectDataPath(url, logger=_logger)
 
         def dataset_invalid(url):
-            with HDF5File(url.file_path(), mode="r") as h5s:
+            with open_hdf5(url.file_path()) as h5s:
                 if not isinstance(h5s[url.data_path()], h5py.Dataset):
                     return True
             return False
@@ -102,7 +99,7 @@ class _DarkOrFlatUrl(qt.QWidget):
         self._qle.setText(url.path())
         self._updateOptions(url)
         self.blockSignals(old)
-        self._editingFinished()
+        self.editingFinished.emit()
 
     def setSerie(self, serie):
         type_name = self._type.name.lower().replace("_", " ")
@@ -116,10 +113,10 @@ class _DarkOrFlatUrl(qt.QWidget):
 
     def _redirectDataPath(self, url, logger=None):
         try:
-            with HDF5File(url.file_path(), mode="r") as h5s:
+            with open_hdf5(url.file_path()) as h5s:
                 node = h5s[url.data_path()]
 
-                if HDF5TomoScan.entry_is_nx_tomo(node):
+                if NXtomoScan.entry_is_nx_tomo(node):
                     if (
                         "detector" in node["instrument"]
                         and "data" in node["instrument"]["detector"]
@@ -133,7 +130,7 @@ class _DarkOrFlatUrl(qt.QWidget):
                             (url.data_path(), "instrument", "detector", "data")
                         )
                         url = DataUrl(file_path=url.file_path(), data_path=data_path)
-                elif HDF5TomoScan.is_nxdetector(node):
+                elif NXtomoScan.is_nxdetector(node):
                     if "data" in node:
                         if logger:
                             _logger.info(
@@ -191,10 +188,10 @@ class _DarkOrFlatUrl(qt.QWidget):
     def _getImageKey(self, url):
         # if we are on a 'detector / data dataset' then we can try to reach
         # image_key information
-        with HDF5File(url.file_path(), mode="r") as h5s:
+        with open_hdf5(url.file_path()) as h5s:
             dataset = h5s[url.data_path()]
             grp_parent = dataset.parent
-            if grp_parent is not None and HDF5TomoScan.is_nxdetector(grp_parent):
+            if grp_parent is not None and NXtomoScan.is_nxdetector(grp_parent):
                 if "image_key" in grp_parent:
                     return h5py_read_dataset(grp_parent["image_key"])
         return None
@@ -319,17 +316,14 @@ class DarkRefPatchWidget(qt.QWidget):
         self._efCB.toggled.connect(self._toggleEF)
 
         # connect QLE modifications
-        self._sdQLE.editingFinished.connect(self._configurationChanged)
-        self._sdCB.toggled.connect(self._configurationChanged)
-        self._sfQLE.editingFinished.connect(self._configurationChanged)
-        self._sfCB.toggled.connect(self._configurationChanged)
-        self._efQLE.editingFinished.connect(self._configurationChanged)
-        self._efCB.toggled.connect(self._configurationChanged)
-        self._edQLE.editingFinished.connect(self._configurationChanged)
-        self._edCB.toggled.connect(self._configurationChanged)
-
-    def _configurationChanged(self):
-        self.sigConfigurationChanged.emit()
+        self._sdQLE.editingFinished.connect(self.sigConfigurationChanged)
+        self._sdCB.toggled.connect(self.sigConfigurationChanged)
+        self._sfQLE.editingFinished.connect(self.sigConfigurationChanged)
+        self._sfCB.toggled.connect(self.sigConfigurationChanged)
+        self._efQLE.editingFinished.connect(self.sigConfigurationChanged)
+        self._efCB.toggled.connect(self.sigConfigurationChanged)
+        self._edQLE.editingFinished.connect(self.sigConfigurationChanged)
+        self._edCB.toggled.connect(self.sigConfigurationChanged)
 
     def _selectSDDataset(self):
         self._selectDataset("start dark", self._sdQLE)

tomwer/gui/edit/imagekeyeditor.py

@@ -35,10 +35,10 @@ from collections.abc import Iterable
 from typing import Union
 
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey as _ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey as _ImageKey
 
 from tomwer.core.process.edit.imagekeyeditor import IMAGE_KEYS
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 
 _logger = logging.getLogger(__name__)
 
@@ -93,7 +93,7 @@ class ImageKeyDialog(qt.QDialog):
     def setScan(self, scan):
         """
 
-        :param HDF5TomoScan scan: scan to be edited
+        :param NXtomoScan scan: scan to be edited
         """
         self._widget.setScan(scan)
 
@@ -120,7 +120,7 @@ class ImageKeyWindow(qt.QMainWindow):
     def setScan(self, scan) -> None:
         """
 
-        :param HDF5TomoScan scan: scan to be edited
+        :param NXtomoScan scan: scan to be edited
         """
         self._mainWindow.setScan(scan=scan)
         self._editorControl.setScan(scan=scan)
@@ -213,7 +213,7 @@ class _ImageKeyEditor(qt.QDialog):
         self._selectionModeCB.currentTextChanged.connect(
             self._selectionWidget.setSelectionMode
         )
-        self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(self._apply)
+        self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(self.sigApply)
 
     def getUpgradeToImagKey(self) -> str:
         """
@@ -243,9 +243,6 @@ class _ImageKeyEditor(qt.QDialog):
         else:
             raise NotImplementedError("Not implemented")
 
-    def _apply(self):
-        self.sigApply.emit()
-
     def setScan(self, scan):
         self._selectionWidget.setScan(scan=scan)
         if scan is not None:
@@ -450,7 +447,7 @@ class _ImageKeyList(qt.QTableWidget):
         """
         Update the QTableWidget for the provided frames
 
-        :param Iterable frames: Iterable of tomoscan.esrf.scan.HDF5TomoScan.Frame
+        :param Iterable frames: Iterable of tomoscan.esrf.scan.NXtomoScan.Frame
         :param dict frames_new_keys: dictionary with frame edited. key is frame
                                      index. Value is the new `image_key` value
         """
@@ -522,6 +519,7 @@ class _ImageKeyList(qt.QTableWidget):
             my_list = modifications
         to_apply = {}
         for frame_index in my_list:
+            assert isinstance(frame_index, int), "frame_index should be an int"
             to_apply[frame_index] = new_image_key
             if frame_index in self._imageKeyComboboxes:
                 self._imageKeyComboboxes[frame_index].setImageKey(new_image_key)
@@ -551,12 +549,13 @@ class _ImageKeyList(qt.QTableWidget):
             else:
                 self.hideRow(i)
 
-    def notify_modified(self, frame_index) -> None:
+    def notify_modified(self, frame_index: int) -> None:
         """
         Update list of modification and emit sigKeyUpdated
 
         :param int frame_index:
         """
+        assert isinstance(frame_index, int), "frame index should be an int"
         frame_row = self._getFrameRowIndex(frame_index)
         if frame_row is not None:
             new_image_key = self._imageKeyComboboxes[frame_index].currentText()
@@ -627,9 +626,9 @@ class _ImageKeyListFiltered(qt.QWidget):
         return self._filterCB.currentText()
 
     def setScan(self, scan):
-        if not isinstance(scan, HDF5TomoScan):
+        if not isinstance(scan, NXtomoScan):
             raise TypeError(
-                f"scan should be an instance of {HDF5TomoScan}. {type(scan)} provided"
+                f"scan should be an instance of {NXtomoScan}. {type(scan)} provided"
             )
         self.__frames_modifications = {}
         self._scan = weakref.ref(scan)

tomwer/gui/edit/nxtomoeditor.py

@@ -1,17 +1,26 @@
 import logging
 import weakref
 from typing import Optional
+from functools import lru_cache as cache
 
 import h5py
 import numpy
 from silx.gui import qt
 from silx.io.utils import h5py_read_dataset
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from tomoscan.io import HDF5File
-from tomoscan.nexus.paths.nxtomo import get_paths as get_nexus_paths
-from tomoscan.scanbase import _FOV
+from silx.io.dictdump import dicttonx
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomoscan.io import HDF5File
+from nxtomo.paths.nxtomo import get_paths as get_nexus_paths
+from nxtomo.nxobject.nxdetector import ImageKey
+from nxtomo.nxobject.nxdetector import FOV
+from nxtomo.nxobject.nxtransformations import NXtransformations
+from nxtomo.utils.transformation import (
+    build_matrix,
+    UDDetTransformation,
+    LRDetTransformation,
+)
+
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.utils.buttons import PadlockButton
 from tomwer.gui.utils.scandescription import ScanNameLabelAndShape
 from tomwer.gui.utils.unitsystem import MetricEntry
@@ -149,7 +158,7 @@ class NXtomoEditor(qt.QWidget):
         self._fieldOfViewQTWI = qt.QTreeWidgetItem(self._detectorQTWI)
         self._fieldOfViewQTWI.setText(0, "field of view")
         self._fieldOfViewCB = qt.QComboBox(self)
-        for value in _FOV.values():
+        for value in FOV.values():
             self._fieldOfViewCB.addItem(value)
         self._tree.setItemWidget(self._fieldOfViewQTWI, 1, self._fieldOfViewCB)
         self._editableWidgets.append(self._fieldOfViewCB)
@@ -235,9 +244,9 @@ class NXtomoEditor(qt.QWidget):
     def setScan(self, scan):
         if scan is None:
             self._scan = scan
-        elif not isinstance(scan, HDF5TomoScan):
+        elif not isinstance(scan, NXtomoScan):
             raise TypeError(
-                f"{scan} is expected to be an instance of {HDF5TomoScan}. Not {type(scan)}"
+                f"{scan} is expected to be an instance of {NXtomoScan}. Not {type(scan)}"
             )
         else:
             self._scan = weakref.ref(scan)
@@ -281,8 +290,8 @@ class NXtomoEditor(qt.QWidget):
         else:
             self._updateTranslations(scan=scan)
 
-    def _updateTranslations(self, scan: HDF5TomoScan):
-        assert isinstance(scan, HDF5TomoScan)
+    def _updateTranslations(self, scan: NXtomoScan):
+        assert isinstance(scan, NXtomoScan)
 
         # note: for now and in order to allow edition we expect to have at most a unique value. Will fail for helicoidal
         def reduce(values):
@@ -307,17 +316,61 @@ class NXtomoEditor(qt.QWidget):
     def _updateFieldOfView(self, scan):
         if not self._fieldOfViewLB.isLocked():
             # if in ''auto mode: we want to overwrite the NXtomo existing value by the one of the GUI
-            idx = self._fieldOfViewCB.findText(
-                _FOV.from_value(scan.field_of_view).value
-            )
+            idx = self._fieldOfViewCB.findText(FOV.from_value(scan.field_of_view).value)
             if idx > 0:
                 self._fieldOfViewCB.setCurrentIndex(idx)
 
+    @staticmethod
+    @cache(maxsize=None)
+    def _get_UD_flip_matrix():
+        return UDDetTransformation().as_matrix()
+
+    @staticmethod
+    @cache(maxsize=None)
+    def _get_LR_flip_matrix():
+        return LRDetTransformation().as_matrix()
+
+    @staticmethod
+    @cache(maxsize=None)
+    def _get_UD_AND_LR_flip_matrix():
+        return numpy.matmul(
+            NXtomoEditor._get_UD_flip_matrix(),
+            NXtomoEditor._get_LR_flip_matrix(),
+        )
+
     def _updateFlipped(self, scan):
-        if (not self._xFlippedLB.isLocked()) and scan.x_flipped is not None:
-            self._xFlippedCB.setChecked(scan.x_flipped)
-        if (not self._yFlippedLB.isLocked()) and scan.y_flipped is not None:
-            self._yFlippedCB.setChecked(scan.y_flipped)
+        transformations = list(scan.get_detector_transformations(tuple()))
+        transformation_matrix_det_space = build_matrix(transformations)
+        if transformation_matrix_det_space is None or numpy.allclose(
+            transformation_matrix_det_space, numpy.identity(3)
+        ):
+            flip_ud = False
+            flip_lr = False
+        elif numpy.array_equal(
+            transformation_matrix_det_space, NXtomoEditor._get_UD_flip_matrix()
+        ):
+            flip_ud = True
+            flip_lr = False
+        elif numpy.allclose(
+            transformation_matrix_det_space, NXtomoEditor._get_LR_flip_matrix()
+        ):
+            flip_ud = False
+            flip_lr = True
+        elif numpy.allclose(
+            transformation_matrix_det_space, NXtomoEditor._get_UD_AND_LR_flip_matrix()
+        ):
+            flip_ud = True
+            flip_lr = True
+        else:
+            flip_ud = None
+            flip_lr = None
+            _logger.warning(
+                "detector transformations provided not handled... For now only handle up-down flip as left-right flip"
+            )
+        if (not self._xFlippedLB.isLocked()) and flip_lr is not None:
+            self._xFlippedCB.setChecked(flip_lr)
+        if (not self._yFlippedLB.isLocked()) and flip_ud is not None:
+            self._yFlippedCB.setChecked(flip_ud)
 
     def _updateDistance(self, scan):
         if not self._distanceLB.isLocked():
@@ -325,14 +378,14 @@ class NXtomoEditor(qt.QWidget):
             self._distanceMetricEntry.setValue(scan.distance)
 
     def _updateEnergy(self, scan):
-        assert isinstance(scan, HDF5TomoScan)
+        assert isinstance(scan, NXtomoScan)
         if not self._energyLockerLB.isLocked():
             # if in ''auto mode: we want to overwrite the NXtomo existing value by the one of the GUI
             energy = scan.energy
             self._energyEntry.setValue(energy)
 
     def _updatePixelSize(self, scan):
-        assert isinstance(scan, HDF5TomoScan)
+        assert isinstance(scan, NXtomoScan)
         if not self._xPixelSizeLB.isLocked():
             x_pixel_size = scan.x_pixel_size
             self._xPixelSizeMetricEntry.setValue(x_pixel_size)
@@ -433,7 +486,7 @@ class NXtomoEditor(qt.QWidget):
             _logger.warning("no scan found to be saved")
             return
         nexus_paths = get_nexus_paths(scan.nexus_version)
-        assert isinstance(scan, HDF5TomoScan)
+        assert isinstance(scan, NXtomoScan)
         with HDF5File(scan.master_file, mode="a") as h5f:
             entry = h5f[scan.entry]
             # overwrite energy
@@ -503,37 +556,49 @@ class NXtomoEditor(qt.QWidget):
                 name="field of view",
                 expected_type=str,
             )
-            # overwrite x flipped
-            self.__write_to_file(
-                entry=entry,
-                path="/".join(
+
+            # solve NXtranformations
+            nx_transformations = NXtransformations()
+            if self._xFlippedCB.isChecked():
+                nx_transformations.add_transformation(LRDetTransformation())
+            if self._yFlippedCB.isChecked():
+                nx_transformations.add_transformation(UDDetTransformation())
+
+            nx_dict = nx_transformations.to_nx_dict(
+                nexus_path_version=scan.nexus_version,
+                data_path="/".join(
                     (
                         nexus_paths.INSTRUMENT_PATH,
                         nexus_paths.nx_instrument_paths.DETECTOR_PATH,
-                        nexus_paths.nx_detector_paths.X_FLIPPED,
                     )
                 ),
-                value=self._xFlippedCB.isChecked(),
-                name="x flipped",
-                expected_type=bool,
+                solve_empty_dependency=True,
             )
-            # overwrite y flipped
-            self.__write_to_file(
-                entry=entry,
-                path="/".join(
-                    (
-                        nexus_paths.INSTRUMENT_PATH,
-                        nexus_paths.nx_instrument_paths.DETECTOR_PATH,
-                        nexus_paths.nx_detector_paths.Y_FLIPPED,
-                    )
+            detector_transformation_path = "/".join(
+                (
+                    nexus_paths.INSTRUMENT_PATH,
+                    nexus_paths.nx_instrument_paths.DETECTOR_PATH,
+                    nexus_paths.nx_detector_paths.NX_TRANSFORMATIONS,
                 ),
-                value=self._yFlippedCB.isChecked(),
-                name="y flipped",
-                expected_type=bool,
             )
-            # clear caches to make sure all modifications will be considered
-            scan.clear_caches()
-            scan.clear_frames_caches()
+            if detector_transformation_path in entry:
+                del entry[detector_transformation_path]
+
+            detector_transformation_path = "/".join(
+                (scan.entry, detector_transformation_path)
+            )
+
+        dicttonx(
+            nx_dict,
+            h5file=scan.master_file,
+            h5path=detector_transformation_path,
+            update_mode="replace",
+            mode="a",
+        )
+
+        # clear caches to make sure all modifications will be considered
+        scan.clear_caches()
+        scan.clear_frames_caches()
 
     @staticmethod
     def _newValueIsExistingValue(dataset: h5py.Dataset, new_value, units):
@@ -557,7 +622,9 @@ class NXtomoEditor(qt.QWidget):
                 return False
 
     @staticmethod
-    def __write_to_file(entry, path, value, name, expected_type, n_value=1, units=None):
+    def __write_to_file(
+        entry: h5py.Group, path: str, value, name, expected_type, n_value=1, units=None
+    ):
         if path is None:
             # if the path does not exists (no handled by this version of nexus for example)
             return

tomwer/gui/edit/nxtomowarmer.py

@@ -1,9 +1,10 @@
 from typing import Optional
 import h5py
 from silx.gui import qt
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from silx.io.utils import open as open_hdf5
+
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui import icons
-from tomoscan.io import HDF5File
 
 
 class NXtomoProxyWarmer(qt.QWidget):
@@ -40,17 +41,17 @@ class NXtomoProxyWarmer(qt.QWidget):
         # set up
         self.setScan(None)
 
-    def setScan(self, scan: Optional[HDF5TomoScan]):
+    def setScan(self, scan: Optional[NXtomoScan]):
         if scan is None:
             self._activateWarning(False)
-        elif isinstance(scan, HDF5TomoScan):
-            with HDF5File(scan.master_file, mode="r") as h5f:
+        elif isinstance(scan, NXtomoScan):
+            with open_hdf5(scan.master_file) as h5f:
                 entry = h5f.get(
                     name=scan.entry, getclass=True, getlink=True, default=None
                 )
                 self._activateWarning(entry in (h5py.ExternalLink, h5py.SoftLink))
         else:
-            raise TypeError(f"{scan} is expected to be an instance of {HDF5TomoScan}")
+            raise TypeError(f"{scan} is expected to be an instance of {NXtomoScan}")
 
     def _activateWarning(self, activate: bool):
         self._warningIcon.setVisible(activate)