tomwer 1.4.18__py3-none-any.whl → 1.5.0rc0__py3-none-any.whl

tomwer/gui/stitching/config/tomoobjdetails.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import pint
 from nabu.stitching.config import StitchingType
 from silx.gui import qt
 from silx.gui.utils import blockSignals
@@ -11,6 +12,8 @@ from tomwer.gui.utils.qt_utils import block_signals
 from tomwer.gui.stitching.metadataholder import QStitchingMetadata
 from tomwer.gui.utils.unitsystem import MetricEntry, PixelEntry
 
+_ureg = pint.get_application_registry()
+
 
 class _AxisPositionGroup(qt.QGroupBox):
     sigUpdate = qt.Signal()
@@ -26,13 +29,18 @@ class _AxisPositionGroup(qt.QGroupBox):
 
         # pixel size
         self._pixelSizeRaw = MetricEntry(
-            value="unknown", name="pixel size", parent=self, default_unit="mm"
+            value="unknown",
+            name="pixel size",
+            parent=self,
+            default_unit=_ureg.millimeter,
         )
         self._pixelSizeRaw.setReadOnly(True)
         self.layout().addWidget(self._pixelSizeRaw, 0, 0, 1, 2)
         self._overridePixelSizeCB = qt.QCheckBox("overwrite", self)
         self.layout().addWidget(self._overridePixelSizeCB, 0, 2, 1, 1)
-        self._pixelSizeOverride = MetricEntry(name="", parent=self, default_unit="mm")
+        self._pixelSizeOverride = MetricEntry(
+            name="", parent=self, default_unit=_ureg.millimeter
+        )
         self.layout().addWidget(self._pixelSizeOverride, 0, 3, 1, 2)
 
         # raw position (in meter or millimeter)
@@ -40,14 +48,14 @@ class _AxisPositionGroup(qt.QGroupBox):
             value="unknown",
             name=f"axis {axis} position (metric unit)",
             parent=self,
-            default_unit="mm",
+            default_unit=_ureg.millimeter,
         )
         self._rawPositionMetric.setReadOnly(True)
         self.layout().addWidget(self._rawPositionMetric, 1, 0, 1, 2)
         self._overrideMetricPositionCB = qt.QCheckBox("overwrite", self)
         self.layout().addWidget(self._overrideMetricPositionCB, 1, 2, 1, 1)
         self._metricPositionOverride = MetricEntry(
-            name="", parent=self, default_unit="mm"
+            name="", parent=self, default_unit=_ureg.millimeter
         )
         self.layout().addWidget(self._metricPositionOverride, 1, 3, 1, 2)
 
@@ -110,9 +118,10 @@ class _AxisPositionGroup(qt.QGroupBox):
                 self._stitching_metadata.setPixelOrVoxelSize(
                     value=self.getOverrridePixelSize(), axis=self.axis
                 )
-                self._stitching_metadata.setMetricPos(
-                    self.getOverrrideMetricPosition(), axis=self.axis
-                )
+                metric_quantity = self.getOverrrideMetricPosition()
+                if isinstance(metric_quantity, pint.Quantity):
+                    metric_quantity = metric_quantity.to_base_units().magnitude
+                self._stitching_metadata.setMetricPos(metric_quantity, axis=self.axis)
                 self._stitching_metadata.setPxPos(
                     self.getOverrridePxPosition(), axis=self.axis
                 )
@@ -133,7 +142,6 @@ class _AxisPositionGroup(qt.QGroupBox):
         position_m = self.get_final_metric_position()
         if position_m is None:
             return None
-
         position_px = int(position_m / pixel_size_m)
         self._rawPxPosition.setValue(position_px)
 
@@ -189,9 +197,9 @@ class _AxisPositionGroup(qt.QGroupBox):
             with blockSignals(*self._editingWidgets):
                 # handle pixel size
                 if self.axis == 0:
-                    pixel_size = tomo_obj.y_pixel_size
+                    pixel_size = tomo_obj.sample_y_pixel_size
                 else:
-                    pixel_size = tomo_obj.x_pixel_size
+                    pixel_size = tomo_obj.sample_x_pixel_size
                 if pixel_size is not None:
                     self.setRawPixelSize(pixel_size)
                 override_pixel_size = stitching_metadata._pixel_or_voxel_size[self.axis]
@@ -257,7 +265,7 @@ class _AxisPositionGroup(qt.QGroupBox):
         self._overridePxPosition.setValue(position_px)
         self._overridePxPosition.valueChanged.emit()
 
-    def getOverrrideMetricPosition(self):
+    def getOverrrideMetricPosition(self) -> pint.Quantity:
         if self._overrideMetricPositionCB.isChecked():
             return self._metricPositionOverride.getValue()
         else:
@@ -274,7 +282,7 @@ class _AxisPositionGroup(qt.QGroupBox):
     def getRawMetricPosition(self):
         return self._rawPositionMetric.getValue()
 
-    def setRawMetricPosition(self, position_m, displayed_unit="mm"):
+    def setRawMetricPosition(self, position_m, displayed_unit=_ureg.millimeter):
         self._rawPositionMetric.setValue(
             value_m=position_m, displayed_unit=displayed_unit
         )
@@ -351,7 +359,7 @@ class TomoObjectPositionInfos(qt.QWidget):
         self._axis_2_pos.setStitchingMetadata(metadata)
 
     def updateStitchingType(self, stitching_type: StitchingType):
-        stitching_type = StitchingType.from_value(stitching_type)
+        stitching_type = StitchingType(stitching_type)
         if stitching_type is StitchingType.Z_POSTPROC:
             pixel_or_voxel_label = "voxel size"
         elif stitching_type is StitchingType.Z_PREPROC:

tomwer/gui/stitching/normalization.py

@@ -23,13 +23,13 @@ class NormalizationBySampleGroupBox(qt.QGroupBox):
 
         # method
         self._methodCB = qt.QComboBox(self)
-        self._methodCB.addItems(_SampleNormalizationMethod.values())
+        self._methodCB.addItems([item.value for item in _SampleNormalizationMethod])
         self._methodCB.setCurrentText(_SampleNormalizationMethod.MEDIAN.value)
         self.layout().addRow("method", self._methodCB)
 
         # side
         self._sideCB = qt.QComboBox(self)
-        self._sideCB.addItems(_SampleSide.values())
+        self._sideCB.addItems([item.value for item in _SampleSide])
         self._sideCB.setCurrentText(_SampleSide.LEFT.value)
         self.layout().addRow("sampling side", self._sideCB)
 
@@ -57,17 +57,17 @@ class NormalizationBySampleGroupBox(qt.QGroupBox):
         self.sigConfigChanged.emit()
 
     def getMethod(self) -> _SampleNormalizationMethod:
-        return _SampleNormalizationMethod.from_value(self._methodCB.currentText())
+        return _SampleNormalizationMethod(self._methodCB.currentText())
 
     def setMethod(self, method: _SampleNormalizationMethod | str):
-        method = _SampleNormalizationMethod.from_value(method)
+        method = _SampleNormalizationMethod(method)
         self._methodCB.setCurrentText(method.value)
 
     def getSide(self) -> _SampleSide:
-        return _SampleSide.from_value(self._sideCB.currentText())
+        return _SampleSide(self._sideCB.currentText())
 
     def setSide(self, side: _SampleSide):
-        side = _SampleSide.from_value(side)
+        side = _SampleSide(side)
         self._sideCB.setCurrentText(side.value)
 
     def getMargin(self) -> int:

tomwer/gui/stitching/tests/test_ZStitchingWindow.py

@@ -1,4 +1,8 @@
+from __future__ import annotations
+
+
 import os
+import pint
 import tempfile
 
 from tomoscan.series import Series
@@ -8,6 +12,9 @@ from tomwer.gui.stitching.tests.utils import create_scans_z_series
 from tomwer.tests.conftest import qtapp  # noqa F401
 
 
+_ureg = pint.get_application_registry()
+
+
 def test_ZStitchingWindow(
     qtapp,  # noqa F811
     tmp_path,
@@ -34,7 +41,7 @@ def test_ZStitchingWindow(
         z_positions_m=axis_0_positions,
         x_positions_m=axis_2_positions,
         shifts=((0.0, 0.0), (-90.0, 0.0), (-180.0, 0.0)),
-        pixel_size=pixel_size,
+        sample_pixel_size=pixel_size,
         raw_frame_width=280,
         final_frame_width=100,
     )

tomwer/gui/stitching/tests/test_preview.py

@@ -1,5 +1,7 @@
-import os
+from __future__ import annotations
 
+import os
+import pint
 import numpy
 import pytest
 from nabu.stitching.config import PreProcessedZStitchingConfiguration
@@ -11,13 +13,15 @@ from silx.image.phantomgenerator import PhantomGenerator
 from tomwer.gui.stitching.stitching_preview import PreviewStitchingPlot
 from tomwer.gui.stitching.tests.utils import create_scans_z_series
 
+_ureg = pint.get_application_registry()
+
 
 @pytest.mark.parametrize("flip_lr", (True, False))
 @pytest.mark.parametrize("flip_ud", (True, False))
 def test_preview(tmp_path, flip_lr, flip_ud, qtapp):  # noqa F401
     axis_0_positions = (90, 0.0, -90.0)
     axis_2_positions = (0.0, 0.0, 0.0)
-    pixel_size = 1.0
+    sample_pixel_size = 1.0
 
     output_file_path = os.path.join(str(tmp_path), "output", "stitched.nx")
     input_dir = os.path.join(tmp_path, "input")
@@ -27,7 +31,7 @@ def test_preview(tmp_path, flip_lr, flip_ud, qtapp):  # noqa F401
         z_positions_m=axis_0_positions,
         x_positions_m=axis_2_positions,
         shifts=((0.0, 0.0), (-90.0, 0.0), (-180.0, 0.0)),
-        pixel_size=pixel_size,
+        sample_pixel_size=sample_pixel_size,
         raw_frame_width=280,
         final_frame_width=100,
         flip_lr=flip_lr,
@@ -38,16 +42,15 @@ def test_preview(tmp_path, flip_lr, flip_ud, qtapp):  # noqa F401
         output_data_path="entry_stitched",
         overwrite_results=True,
         slurm_config=None,
-        axis_0_pos_mm=numpy.array(axis_0_positions) / 1000,
-        axis_2_pos_mm=numpy.array(axis_2_positions) / 1000,
+        axis_0_pos_mm=numpy.array(axis_0_positions) * 1000,
+        axis_2_pos_mm=numpy.array(axis_2_positions) * 1000,
         axis_0_pos_px=None,
         axis_1_pos_px=None,
         axis_2_pos_px=None,
         input_scans=scans,
-        pixel_size=pixel_size,
+        pixel_size=sample_pixel_size,
     )
     widget = PreviewStitchingPlot(axis=0)
-
     widget._backGroundAction.toggle()
 
     stitcher = PreProcessZStitcher(configuration=stitching_config)

tomwer/gui/stitching/tests/utils.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import os
+import pint
 
 import numpy
 from nxtomo.application.nxtomo import NXtomo
@@ -9,15 +12,17 @@ from nxtomo.nxobject.nxdetector import ImageKey
 from tomwer.core.scan.nxtomoscan import NXtomoScan
 from nxtomo.utils.transformation import DetYFlipTransformation, DetZFlipTransformation
 
+_ureg = pint.get_application_registry()
+
 
 def create_scans_z_series(
     output_dir,
-    z_positions_m,
-    x_positions_m=None,
-    pixel_size=10e-6,
-    n_proj=20,
-    raw_frame_width=100,
-    final_frame_width=100,
+    z_positions_m: tuple[float | None] | None,
+    x_positions_m: tuple[float | None] | None = None,
+    sample_pixel_size: float | tuple[float, float] = 10.0e6,
+    n_proj: int = 20,
+    raw_frame_width: int = 100,
+    final_frame_width: int = 100,
     shifts=None,
     z_rois=None,
     flip_lr: bool = False,
@@ -44,22 +49,26 @@ def create_scans_z_series(
     ):
         nx_tomo = NXtomo()
         if z_pos is not None:
-            nx_tomo.sample.z_translation = [z_pos] * n_proj
+            nx_tomo.sample.z_translation = ([z_pos] * n_proj) * _ureg.meter
         if x_pos is not None:
-            nx_tomo.sample.x_translation = [x_pos] * n_proj
-        nx_tomo.sample.rotation_angle = numpy.linspace(
-            0, 180, num=n_proj, endpoint=False
+            nx_tomo.sample.x_translation = ([x_pos] * n_proj) * _ureg.meter
+        nx_tomo.sample.rotation_angle = (
+            numpy.linspace(0, 180, num=n_proj, endpoint=False) * _ureg.degree
         )
         nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_proj
-        if pixel_size is not None:
-            if isinstance(pixel_size, (tuple, list)):
-                y_pix_size, x_pix_size = pixel_size
+        # sample pixel size
+        if sample_pixel_size is not None:
+            if isinstance(sample_pixel_size, (tuple, list)):
+                sample_y_pix_size, sample_x_pix_size = sample_pixel_size
             else:
-                y_pix_size, x_pix_size = pixel_size, pixel_size
-            nx_tomo.instrument.detector.x_pixel_size = x_pix_size
-            nx_tomo.instrument.detector.y_pixel_size = y_pix_size
-        nx_tomo.instrument.detector.distance = 2.3
-        nx_tomo.energy = 19.2
+                sample_y_pix_size, sample_x_pix_size = (
+                    sample_pixel_size,
+                    sample_pixel_size,
+                )
+            nx_tomo.sample.x_pixel_size = sample_x_pix_size * _ureg.meter
+            nx_tomo.sample.y_pixel_size = sample_y_pix_size * _ureg.meter
+        nx_tomo.instrument.detector.distance = 2.3 * _ureg.meter
+        nx_tomo.energy = 19.2 * _ureg.keV
         nx_tomo.instrument.detector.transformations.add_transformation(
             DetYFlipTransformation(flip=flip_ud)
         )

tomwer/gui/stitching/z_stitching/fineestimation.py

@@ -25,8 +25,8 @@ class Axis_N_Params(qt.QGroupBox):
 
         # img registration method
         self._imageRegMethodCB = qt.QComboBox(self)
-        for method in _NabuShiftAlgorithm.values():
-            self._imageRegMethodCB.addItem(method)
+        for method in _NabuShiftAlgorithm:
+            self._imageRegMethodCB.addItem(method.value)
         self._imageRegMethodCB.setToolTip(
             "method to use in order to affine positions provided by the user"
         )
@@ -36,12 +36,10 @@ class Axis_N_Params(qt.QGroupBox):
         self._imageRegMethodCB.setCurrentText(_NabuShiftAlgorithm.NONE.value)
 
     def getCurrentMethod(self):
-        return _NabuShiftAlgorithm.from_value(self._imageRegMethodCB.currentText())
+        return _NabuShiftAlgorithm(self._imageRegMethodCB.currentText())
 
     def setCurrentMethod(self, method):
-        self._imageRegMethodCB.setCurrentText(
-            _NabuShiftAlgorithm.from_value(method).value
-        )
+        self._imageRegMethodCB.setCurrentText(_NabuShiftAlgorithm(method).value)
 
     def getOptsLine(self) -> str:
         current_method = self.getCurrentMethod()
@@ -86,8 +84,8 @@ class AutoRefineWidget(qt.QWidget):
 
         # stitching strategy
         self._stitchingStrategyCG = qt.QComboBox(parent=self)
-        for strategy in OverlapStitchingStrategy.values():
-            self._stitchingStrategyCG.addItem(strategy)
+        for strategy in OverlapStitchingStrategy:
+            self._stitchingStrategyCG.addItem(strategy.value)
         self._globalOpts.layout().addRow(
             "stitching strategy", self._stitchingStrategyCG
         )
@@ -135,7 +133,7 @@ class AutoRefineWidget(qt.QWidget):
         raise NotImplementedError
 
     def updateStitchingType(self, mode: StitchingType):
-        mode = StitchingType.from_value(mode)
+        mode = StitchingType(mode)
         self._preProcGroup.setVisible(mode is StitchingType.Z_PREPROC)
         self._postProcGroup.setVisible(mode is StitchingType.Z_POSTPROC)
 

tomwer/gui/stitching/z_stitching/tests/test_raw_estimation.py

@@ -1,6 +1,10 @@
+from __future__ import annotations
+
 import os
 import shutil
 import tempfile
+import pint
+import numpy
 
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
@@ -11,6 +15,8 @@ from tomwer.gui.stitching.tests.utils import create_scans_z_series
 from tomwer.gui.stitching.config.tomoobjdetails import TomoObjectPositionInfos
 from tomwer.gui.stitching.axisorderedlist import AxisOrderedTomoObjsModel
 
+_ureg = pint.get_application_registry()
+
 
 class TestTomoObjectPositionInfos(TestCaseQt):
     """
@@ -26,14 +32,19 @@ class TestTomoObjectPositionInfos(TestCaseQt):
             self._tmp_path,
             z_positions_m=(0.200, 0.205, 0.210),
             x_positions_m=(0.0, 0.0, None),
-            pixel_size=(self._y_pixel_size, self._x_pixel_size),
+            sample_pixel_size=(self._y_pixel_size, self._x_pixel_size),
             raw_frame_width=100,
         )
         self.scan_0_metadata = QStitchingMetadata(tomo_obj=self.scans[0])
-        assert self.scan_0_metadata.get_raw_position_m(axis=0) == 0.20
+        numpy.testing.assert_almost_equal(
+            self.scan_0_metadata.get_raw_position_m(axis=0), 0.20
+        )
+
         assert self.scan_0_metadata.get_raw_position_m(axis=2) == 0.0
         self.scan_2_metadata = QStitchingMetadata(tomo_obj=self.scans[2])
-        assert self.scan_2_metadata.get_raw_position_m(axis=0) == 0.21
+        numpy.testing.assert_almost_equal(
+            self.scan_2_metadata.get_raw_position_m(axis=0), 0.21
+        )
         self._widget = TomoObjectPositionInfos()
 
     def tearDown(self):
@@ -59,7 +70,7 @@ class TestTomoObjectPositionInfos(TestCaseQt):
         # test editing some parameters from the GUI. Make sure GUI is updated as the underlying metadata object
         self._widget._axis_0_pos._overrideMetricPositionCB.setChecked(True)
         self._widget._axis_0_pos.setRawMetricPosition(
-            position_m=0.4, displayed_unit="nm"
+            position_m=0.4, displayed_unit=_ureg.nanometer
         )
         while self.qapp.hasPendingEvents():
             self.qapp.processEvents()
@@ -85,19 +96,19 @@ class TestAxisOrderedTomoObjsModel(TestCaseQt):
         self.scans_with_pos_and_pixel_size = create_scans_z_series(
             os.path.join(self._tmp_path, "case1"),
             z_positions_m=(0.200, 0.205, 0.210),
-            pixel_size=0.001,
+            sample_pixel_size=0.001,
             raw_frame_width=100,
         )
         self.scans_with_pixel_size = create_scans_z_series(
             os.path.join(self._tmp_path, "case2"),
             z_positions_m=(None, None, None),
-            pixel_size=0.001,
+            sample_pixel_size=0.001,
             raw_frame_width=100,
         )
         self.scans_without_metadata = create_scans_z_series(
             os.path.join(self._tmp_path, "case3"),
             z_positions_m=(None, None, None),
-            pixel_size=None,
+            sample_pixel_size=None,
             raw_frame_width=100,
         )
         self._widget = qt.QTableView()

tomwer/gui/stitching/z_stitching/tests/test_stitching_window.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import os
 import shutil
 import tempfile
+import pint
 
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
@@ -9,6 +12,9 @@ from tomwer.gui.stitching.tests.utils import create_scans_z_series
 from tomwer.gui.stitching.StitchingWindow import ZStitchingWindow
 
 
+_ureg = pint.get_application_registry()
+
+
 class TestZStichingWindow(TestCaseQt):
     """
     Test high level z stitching definition
@@ -20,7 +26,7 @@ class TestZStichingWindow(TestCaseQt):
         self.scans = create_scans_z_series(
             os.path.join(self._tmp_path, "case1"),
             z_positions_m=(0.200, 0.205, 0.210),
-            pixel_size=0.001,
+            sample_pixel_size=0.001,
             raw_frame_width=100,
         )
 
@@ -45,7 +51,6 @@ class TestZStichingWindow(TestCaseQt):
         self._widget.show()
         # fill the widget with scans
 
-        scan_0, scan_1, scan_2 = self.scans
         for scan in self.scans:
             self._widget.addTomoObj(scan)
             # note: add the sigChanged to the z ordered list 'update z' slot

tomwer/gui/utils/buttons.py

@@ -4,6 +4,7 @@ Button of general usage.
 
 from __future__ import annotations
 
+import pint
 import numpy
 import logging
 from silx.gui import qt
@@ -12,11 +13,11 @@ from silx.gui.plot.items.roi import LineROI
 from silx.gui.plot.PlotToolButtons import PlotToolButton
 
 from tomwer.gui import icons
-from pyunitsystem.metricsystem import MetricSystem
-
 
 _logger = logging.getLogger(__file__)
 
+_ureg = pint.get_application_registry()
+
 
 class PadlockButton(qt.QPushButton):
     """Simple button to define a button with PadLock icons"""
@@ -87,40 +88,11 @@ class TabBrowsersButtons(qt.QWidget):
 class TapeMeasureToolButton(PlotToolButton):
     """Button to active measurement between two point of the plot"""
 
-    class TapeMeasureROI(LineROI):
-        def __init__(self, parent=None, pixel_size_m=None):
-            super().__init__(parent)
-            self._pixel_size_m = None
-            self.setPixelSize(pixel_size_m)
-
-        def setEndPoints(self, startPoint, endPoint):
-            distance_px = numpy.linalg.norm(endPoint - startPoint)
-            super().setEndPoints(startPoint=startPoint, endPoint=endPoint)
-            if self._pixel_size_m is None:
-                self._updateText(f"{distance_px :.1f}px")
-            else:
-                distance_m = distance_px * self._pixel_size_m
-                value, unit = MetricSystem.cast_metric_to_best_unit(distance_m)
-                self._updateText(f"{distance_px :.1f}px ({value:.2f}{unit})")
-
-        def setPixelSize(self, pixel_size_m: tuple | float | None):
-            if isinstance(pixel_size_m, (tuple, list)):
-                assert (
-                    len(pixel_size_m) == 2
-                ), "expects at most two pixel size values (x and y values)"
-                if not numpy.isclose(pixel_size_m[0], pixel_size_m[1]):
-                    value, unit = MetricSystem.cast_metric_to_best_unit(pixel_size_m[0])
-                    _logger.warning(
-                        f"TapeMeasure is only handling square pixels for now. Will consider the pixel is {value:.2f}{unit}x{value:.2f}{unit}"
-                    )
-                pixel_size_m = pixel_size_m[0]
-            self._pixel_size_m = pixel_size_m
-
     def __init__(self, parent=None, plot=None, pixel_size_mm=None):
         super().__init__(parent=parent, plot=plot)
         self._roiManager = None
         self._lastRoiCreated = None
-        self._pixel_sixel_m = pixel_size_mm
+        self._pixel_size_m = pixel_size_mm
         self.setIcon(icons.getQIcon("ruler"))
         self.setToolTip("measure distance between two pixels")
         self.toggled.connect(self._callback)
@@ -130,7 +102,7 @@ class TapeMeasureToolButton(PlotToolButton):
         return super().setPlot(plot)
 
     def setPixelSize(self, pixel_size_m: tuple | float | None):
-        self._pixel_sixel_m = pixel_size_m
+        self._pixel_size_m = pixel_size_m
 
     def _callback(self, toggled):
         if not self._roiManager:
@@ -179,8 +151,54 @@ class TapeMeasureToolButton(PlotToolButton):
     def _registerCurrentROI(self, currentRoi):
         if self._lastRoiCreated is None:
             self._lastRoiCreated = currentRoi
-            self._lastRoiCreated.setPixelSize(self._pixel_sixel_m)
+            self._lastRoiCreated.setPixelSize(self._pixel_size_m)
         elif currentRoi != self._lastRoiCreated and self._roiManager is not None:
             self._roiManager.removeRoi(self._lastRoiCreated)
             self._lastRoiCreated = currentRoi
-            self._lastRoiCreated.setPixelSize(self._pixel_sixel_m)
+            self._lastRoiCreated.setPixelSize(self._pixel_size_m)
+
+
+class TapeMeasureROI(LineROI):
+    """ROI dedicated to tape measure"""
+
+    def __init__(self, parent=None, pixel_size_m=None):
+        super().__init__(parent)
+        self._pixel_size_m = None
+        self.setPixelSize(pixel_size_m)
+
+    def setEndPoints(self, startPoint, endPoint):
+        distance_px = numpy.linalg.norm(endPoint - startPoint)
+        super().setEndPoints(startPoint=startPoint, endPoint=endPoint)
+        if self._pixel_size_m is None:
+            self._updateText(f"{distance_px :.1f}px")
+        else:
+            distance_m = distance_px * self._pixel_size_m
+            value = self.cast_metric_to_best_unit(distance_m)
+            self._updateText(f"{distance_px :.1f}px ({value:~})")
+
+    def setPixelSize(self, pixel_size_m: tuple | float | None):
+        if isinstance(pixel_size_m, (tuple, list)):
+            assert (
+                len(pixel_size_m) == 2
+            ), "expects at most two pixel size values (x and y values)"
+            if not numpy.isclose(pixel_size_m[0], pixel_size_m[1]):
+                value = self.cast_metric_to_best_unit(pixel_size_m[0])
+                _logger.warning(
+                    f"TapeMeasure is only handling square pixels for now. Will consider the pixel is {value:~}{value:~}"
+                )
+            pixel_size_m = pixel_size_m[0]
+        self._pixel_size_m = pixel_size_m
+
+    @staticmethod
+    def cast_metric_to_best_unit(value: pint.Quantity) -> pint.Quantity:
+        value = value.to_base_units()
+        if value < (1.0 * _ureg.micrometer):
+            return value.to(_ureg.nanometer)
+        elif value < (0.1 * _ureg.millimeter):  # prefer mm to um
+            return value.to(_ureg.micrometer)
+        elif value < (1.0 * _ureg.centimeter):
+            return value.to(_ureg.millimeter)
+        elif value < (1.0 * _ureg.meter):
+            return value.to(_ureg.centimeter)
+        else:
+            return value.to(_ureg.meter)

tomwer/gui/utils/flow.py

@@ -178,7 +178,7 @@ class FlowCanvas(qt.QWidget):
         self, parent, direction: str | FlowDirection, show_lock_state=True
     ) -> None:
         qt.QWidget.__init__(self, parent=parent)
-        self._direction = FlowDirection.from_value(direction)
+        self._direction = FlowDirection(direction)
         if self._direction is FlowDirection.HORIZONTAL:
             layout = qt.QHBoxLayout()
         elif self._direction is FlowDirection.VERTICAL: