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

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 nxtomo.nxobject.nxdetector import ImageKey
 from tomoscan.io import HDF5File
 
 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):
         """
@@ -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("_", " ")
@@ -119,7 +116,7 @@ class _DarkOrFlatUrl(qt.QWidget):
             with HDF5File(url.file_path(), mode="r") 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(
@@ -194,7 +191,7 @@ class _DarkOrFlatUrl(qt.QWidget):
         with HDF5File(url.file_path(), mode="r") 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
         """
@@ -627,9 +624,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,7 +1,7 @@
 from typing import Optional
 import h5py
 from silx.gui import qt
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui import icons
 from tomoscan.io import HDF5File
 
@@ -40,17 +40,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):
+        elif isinstance(scan, NXtomoScan):
             with HDF5File(scan.master_file, mode="r") 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)

tomwer/gui/edit/test/test_dkrf_patch.py

@@ -37,11 +37,11 @@ from nxtomomill.utils import add_dark_flat_nx_file
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 from silx.io.url import DataUrl
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 from tomoscan.esrf.scan.utils import get_data
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.edit.dkrfpatch import DarkRefPatchWidget, _DarkOrFlatUrl
 from tomwer.tests.utils import skip_gui_test
 
@@ -62,7 +62,7 @@ class TestDarkOrFlatUrl(TestCaseQt):
         )
         self.output_folder = tempfile.mkdtemp()
         #
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder,
             n_ini_proj=20,
             n_proj=20,
@@ -130,7 +130,7 @@ class TestDarkRefPatchWidget(TestCaseQt):
         self.output_folder1 = tempfile.mkdtemp()
         self.output_folder2 = tempfile.mkdtemp()
 
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder1,
             n_ini_proj=20,
             n_proj=20,
@@ -140,7 +140,7 @@ class TestDarkRefPatchWidget(TestCaseQt):
         )
         self._scanWithDarkAndRef = hdf5_mock.scan
 
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder2,
             n_ini_proj=20,
             n_proj=20,
@@ -176,7 +176,7 @@ class TestDarkRefPatchWidget(TestCaseQt):
         self.assertTrue(self._widget.getEndDarkUrl() is None)
         self.assertTrue(self._widget.getEndFlatUrl() is None)
         self.process()
-        new_scan = HDF5TomoScan(scan=self._scan.master_file, entry=self._scan.entry)
+        new_scan = NXtomoScan(scan=self._scan.master_file, entry=self._scan.entry)
         self.assertEqual(len(new_scan.darks), 1)
         self.assertTrue(0 in new_scan.darks)
         numpy.testing.assert_array_equal(

tomwer/gui/edit/test/test_image_key_editor.py

@@ -33,9 +33,9 @@ import tempfile
 import pytest
 from silx.gui import qt
 from silx.gui.utils.testutils import SignalListener, TestCaseQt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.edit.imagekeyeditor import (
     ImageKeyDialog,
     ImageKeyUpgraderWidget,
@@ -55,7 +55,7 @@ class TestImageKeyEditorGUI(TestCaseQt):
         self._widget = ImageKeyDialog(parent=None)
         self.output_folder = tempfile.mkdtemp()
 
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder,
             n_ini_proj=20,
             n_proj=20,

tomwer/gui/edit/test/test_nx_editor.py

@@ -2,21 +2,28 @@ import os
 
 import numpy
 import pytest
-from nxtomomill.nexus.nxtomo import NXtomo
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from tomoscan.scanbase import _FOV
-from tomoscan.unitsystem.energysystem import EnergySI
-from tomoscan.unitsystem.metricsystem import MetricSystem
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from pyunitsystem.energysystem import EnergySI
+from pyunitsystem.metricsystem import MetricSystem
+
+from nxtomo.application.nxtomo import NXtomo
+from nxtomo.nxobject.nxdetector import ImageKey, FOV
+from nxtomo.utils.transformation import (
+    build_matrix,
+    UDDetTransformation,
+    LRDetTransformation,
+)
+from nxtomo.nxobject.nxtransformations import NXtransformations
+
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.edit.nxtomoeditor import NXtomoEditor, _TranslationMetricEntry
 from tomwer.tests.conftest import qtapp  # noqa F401
 
 
 @pytest.mark.parametrize("x_pixel_size", (None, 0.12))
 @pytest.mark.parametrize("y_pixel_size", (None, 0.0065))
-@pytest.mark.parametrize("field_of_view", _FOV.values())
+@pytest.mark.parametrize("field_of_view", FOV.values())
 @pytest.mark.parametrize("distance", (None, 1.2))
 @pytest.mark.parametrize("energy", (None, 23.5))
 @pytest.mark.parametrize("x_flipped", (True, False))
@@ -42,14 +49,20 @@ def test_nx_editor(
     nx_tomo.instrument.detector.y_pixel_size = y_pixel_size
     nx_tomo.instrument.detector.field_of_view = field_of_view
     nx_tomo.instrument.detector.distance = distance
-    nx_tomo.instrument.detector.x_flipped = x_flipped
-    nx_tomo.instrument.detector.y_flipped = y_flipped
     nx_tomo.energy = energy
     nx_tomo.sample.x_translation = x_translation
     nx_tomo.sample.z_translation = z_translation
     nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
     nx_tomo.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
     nx_tomo.sample.rotation_angle = numpy.linspace(0, 20, num=12)
+    if x_flipped:
+        nx_tomo.instrument.detector.transformations.add_transformation(
+            LRDetTransformation()
+        )
+    if y_flipped:
+        nx_tomo.instrument.detector.transformations.add_transformation(
+            UDDetTransformation()
+        )
 
     file_path = os.path.join(tmp_path, "nxtomo.nx")
     entry = "entry0000"
@@ -58,7 +71,7 @@ def test_nx_editor(
         data_path=entry,
     )
 
-    scan = HDF5TomoScan(file_path, entry)
+    scan = NXtomoScan(file_path, entry)
 
     # 2.0 create the widget and do the edition
     widget = NXtomoEditor()
@@ -107,7 +120,7 @@ def test_nx_editor(
     widget._xPixelSizeMetricEntry.setUnit("nm")
     widget._yPixelSizeMetricEntry.setValue(2.1e-7)
     widget._distanceMetricEntry.setValue("unknown")
-    widget._fieldOfViewCB.setCurrentText(_FOV.HALF.value)
+    widget._fieldOfViewCB.setCurrentText(FOV.HALF.value)
     widget._xFlippedCB.setChecked(not x_flipped)
     widget._xTranslationQLE.setValue(1.8)
     widget._xTranslationQLE.setUnit("mm")
@@ -135,10 +148,21 @@ def test_nx_editor(
     assert overwrite_nx_tomo.instrument.detector.y_pixel_size.value == 2.1e-7
 
     assert overwrite_nx_tomo.instrument.detector.distance.value is None
-    assert overwrite_nx_tomo.instrument.detector.field_of_view is _FOV.HALF
+    assert overwrite_nx_tomo.instrument.detector.field_of_view is FOV.HALF
 
-    assert overwrite_nx_tomo.instrument.detector.x_flipped is not x_flipped
-    assert overwrite_nx_tomo.instrument.detector.y_flipped is y_flipped
+    final_transformation = NXtransformations()
+
+    if y_flipped:
+        final_transformation.add_transformation(UDDetTransformation())
+    if not x_flipped:  # as we invert _xFlippedCB combobox
+        final_transformation.add_transformation(LRDetTransformation())
+
+    numpy.testing.assert_allclose(
+        build_matrix(
+            overwrite_nx_tomo.instrument.detector.transformations.transformations
+        ),
+        build_matrix(final_transformation.transformations),
+    )
 
     numpy.testing.assert_array_almost_equal(
         overwrite_nx_tomo.sample.x_translation.value,
@@ -181,7 +205,7 @@ def test_nx_editor_lock(
         data_path=entry,
     )
 
-    scan_1 = HDF5TomoScan(file_path, entry)
+    scan_1 = NXtomoScan(file_path, entry)
 
     nx_tomo_2 = NXtomo()
     nx_tomo_2.instrument.detector.x_pixel_size = 4.023
@@ -206,7 +230,7 @@ def test_nx_editor_lock(
         data_path=entry,
     )
 
-    scan_2 = HDF5TomoScan(file_path, entry)
+    scan_2 = NXtomoScan(file_path, entry)
 
     # 2.0 create the widget and do the edition
     widget = NXtomoEditor()