tomwer 1.5.0rc0__py3-none-any.whl → 1.5.0rc3__py3-none-any.whl

tomwer/gui/reconstruction/nabu/slices.py

@@ -10,7 +10,7 @@ from nabu.pipeline.fullfield.nabu_config import (
 )
 from silx.gui import icons as silx_icons
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from nxtomo.nxobject.nxdetector import FOV
 
 from tomwer.core.utils.dictutils import concatenate_dict
@@ -113,8 +113,8 @@ class _NabuProcess(qt.QWidget):
         qt.QWidget.__init__(self, parent=parent)
         self.setLayout(qt.QGridLayout())
         self._stageCB = qt.QComboBox(parent=self)
-        for stage in _NabuStages.values():
-            self._stageCB.addItem(stage)
+        for stage in _NabuStages:
+            self._stageCB.addItem(stage.value)
 
         self.layout().addWidget(qt.QLabel("stage:", self), 0, 0, 1, 1)
         self.layout().addWidget(self._stageCB, 0, 1, 1, 1)
@@ -377,7 +377,7 @@ class NabuWindow(qt.QMainWindow):
         return self._filterAction.isChecked()
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         if level == ConfigurationLevel.REQUIRED:
             self._minimalisticAction.setChecked(True)
         elif level == ConfigurationLevel.ADVANCED:
@@ -601,7 +601,7 @@ class NabuWidget(qt.QWidget):
         self._configurationScrollArea.updateGeometry()
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         self._configuration_level = level
         self.updateConfigurationFilter()
 

tomwer/gui/reconstruction/nabu/volume.py

@@ -330,7 +330,7 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
             self.setHistogramRequested(requested=bool(config["output_histogram"]))
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         _NabuStageConfigBase.setConfigurationLevel(self, level)
 
     def getConfigurationLevel(self):

tomwer/gui/reconstruction/normalization/intensity.py

@@ -502,12 +502,12 @@ class _NormIntensityOptions(qt.QWidget):
 
     def getCurrentSource(self):
         if self.getCurrentMethod() in (Method.DIVISION, Method.SUBTRACTION):
-            return _ValueSource.from_value(self._sourceCB.currentText())
+            return _ValueSource(self._sourceCB.currentText())
         else:
             return _ValueSource.NONE
 
     def setCurrentSource(self, source):
-        source = _ValueSource.from_value(source)
+        source = _ValueSource(source)
         idx = self._sourceCB.findText(source.value)
         self._sourceCB.setCurrentIndex(idx)
 
@@ -601,8 +601,8 @@ class _NormIntensityCalcOpts(qt.QWidget):
         self.setLayout(qt.QFormLayout())
         # calculation function
         self._calculationModeCB = qt.QComboBox(self)
-        for fct in _normParams._ValueCalculationFct.values():
-            self._calculationModeCB.addItem(fct)
+        for fct in _normParams._ValueCalculationFct:
+            self._calculationModeCB.addItem(fct.value)
         self._calculationModeLabel = qt.QLabel("calculation fct", self)
         self.layout().addRow(self._calculationModeLabel, self._calculationModeCB)
 
@@ -616,14 +616,10 @@ class _NormIntensityCalcOpts(qt.QWidget):
         self._calculationModeCB.setVisible(visible)
 
     def getCalculationFct(self):
-        return _normParams._ValueCalculationFct.from_value(
-            self._calculationModeCB.currentText()
-        )
+        return _normParams._ValueCalculationFct(self._calculationModeCB.currentText())
 
     def setCalculationFct(self, fct):
-        idx = self._calculationModeCB.findText(
-            _normParams._ValueCalculationFct.from_value(fct)
-        )
+        idx = self._calculationModeCB.findText(_normParams._ValueCalculationFct(fct))
         self._calculationModeCB.setCurrentIndex(idx)
 
 

tomwer/gui/reconstruction/saaxis/corrangeselector.py

@@ -13,7 +13,7 @@ from silx.gui import icons as silxicons
 from silx.gui import qt
 from silx.gui.dialog.ImageFileDialog import ImageFileDialog
 from silx.gui.plot import items
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from tomoscan.esrf.scan.utils import get_data
 
 from tomwer.core.process.reconstruction.utils.cor import (
@@ -308,7 +308,7 @@ class _ReconstructionModeGB(qt.QGroupBox):
             raise ValueError("No reconstruction mode selected")
 
     def setReconstructionMode(self, mode: ReconstructionMode | str) -> None:
-        mode = ReconstructionMode.from_value(mode)
+        mode = ReconstructionMode(mode)
         if mode is ReconstructionMode.TILT_CORRECTION:
             self._tiltCorrectionRB.setChecked(True)
         elif mode is ReconstructionMode.VERTICAL:

tomwer/gui/reconstruction/sacommon.py

@@ -107,7 +107,7 @@ class NabuWidgetWithToolbar(qt.QMainWindow):
             self._nabuSettings.setConfiguration(config)
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         if level == ConfigurationLevel.REQUIRED:
             self._minimalisticAction.setChecked(True)
         elif level == ConfigurationLevel.ADVANCED:

tomwer/gui/reconstruction/scores/scoreplot.py

@@ -248,10 +248,10 @@ class VariableSelection(qt.QWidget):
         self._img_width = width
 
     def getScoreMethod(self):
-        return ScoreMethod.from_value(self._scoreMethodCB.currentText())
+        return ScoreMethod(self._scoreMethodCB.currentText())
 
     def setScoreMethod(self, method):
-        method_value = ScoreMethod.from_value(method).value
+        method_value = ScoreMethod(method).value
         index = self._scoreMethodCB.findText(method_value)
         self._scoreMethodCB.setCurrentIndex(index)
 
@@ -671,7 +671,7 @@ class ScorePlot(qt.QWidget):
         :param scores: cor value (float) as key and
                             tuple(url: DataUrl, score: float) as value
         """
-        score_method = ScoreMethod.from_value(score_method)
+        score_method = ScoreMethod(score_method)
         if not update_only_scores:
             self.clear()
             self._scores = scores

tomwer/gui/stitching/config/positionoveraxis.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import functools
 import numpy
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.gui import icons

tomwer/gui/utils/flow.py

@@ -4,7 +4,7 @@ import functools
 from typing import Iterable
 
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.gui import icons
 from tomwer.utils import docstring

tomwer/gui/utils/loadingmode.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import functools
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from silx.gui import qt
 from tomwer.gui import icons
 

tomwer/gui/utils/vignettes.py

@@ -302,7 +302,7 @@ class VignettesWidget(qt.QWidget):
                     f"score is expected to be a dict with values as (v1: numpy.ndarray, v2: ComputedScore). v2 type Found: {type(score_cls)}"
                 )
             scores_values.append(score_cls.get(score_method))
-        self.__score_method = ScoreMethod.from_value(score_method)
+        self.__score_method = ScoreMethod(score_method)
         highest_score_indices = numpy.nanargmax(scores_values)
         self._vignettesGroup = qt.QButtonGroup(self)
         self._vignettesGroup.setExclusive(True)

tomwer/gui/visualization/dataviewer.py

@@ -1,7 +1,7 @@
 import weakref
 
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.volume.volumebase import TomwerVolumeBase
@@ -318,26 +318,26 @@ class DisplayControl(qt.QWidget):
 
         :return: selected mode: display slices or radios
         """
-        return _DisplayMode.from_value(self._displayMode.currentText())
+        return _DisplayMode(self._displayMode.currentText())
 
     def setDisplayMode(self, mode):
-        mode = _DisplayMode.from_value(mode)
+        mode = _DisplayMode(mode)
         idx = self._displayMode.findText(mode.value)
         self._displayMode.setCurrentIndex(idx)
 
     def getRadioOption(self) -> _RadioMode:
-        return _RadioMode.from_value(self._radioMode.currentText())
+        return _RadioMode(self._radioMode.currentText())
 
     def setRadioOption(self, opt):
-        opt = _RadioMode.from_value(opt)
+        opt = _RadioMode(opt)
         idx = self._radioMode.findText(opt.value)
         self._radioMode.setCurrentIndex(idx)
 
     def getSliceOption(self) -> _SliceMode:
-        return _SliceMode.from_value(self._sliceMode.currentText())
+        return _SliceMode(self._sliceMode.currentText())
 
     def setSliceOption(self, opt):
-        opt = _SliceMode.from_value(opt)
+        opt = _SliceMode(opt)
         idx = self._sliceMode.findText(opt.value)
         self._sliceMode.setCurrentIndex(idx)
 

tomwer/gui/visualization/reconstructionparameters.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import numpy
 import logging
 from silx.gui import qt
 from tomwer.core.utils.char import BETA_CHAR, DELTA_CHAR
@@ -28,14 +29,16 @@ class ReconstructionParameters(qt.QWidget):
         self._deltaBetaQLE = qt.QLineEdit("", self)
         self._deltaBetaQLE.setReadOnly(True)
         self.layout().addRow(self._deltaBetaLabel, self._deltaBetaQLE)
-        # distance
-        self._distanceQLE = qt.QLineEdit("", self)
-        self._distanceQLE.setReadOnly(True)
-        self.layout().addRow("distance (cm)", self._distanceQLE)
+        # sample_detector distance
+        self._sampleDetectorDistanceQLE = qt.QLineEdit("", self)
+        self._sampleDetectorDistanceQLE.setReadOnly(True)
+        self.layout().addRow(
+            "sample-detector distance (cm)", self._sampleDetectorDistanceQLE
+        )
         # pixel size
-        self._pixelSizeQLE = qt.QLineEdit("", self)
-        self._pixelSizeQLE.setReadOnly(True)
-        self.layout().addRow("pixel size (cm)", self._pixelSizeQLE)
+        self._voxelSizeQLE = qt.QLineEdit("", self)
+        self._voxelSizeQLE.setReadOnly(True)
+        self.layout().addRow("voxel size (cm)", self._voxelSizeQLE)
         # cor
         self._corQLE = qt.QLineEdit("", self)
         self._corQLE.setReadOnly(True)
@@ -89,7 +92,7 @@ class ReconstructionParameters(qt.QWidget):
             self._setPhaseMethod,
             self._setDeltaBeta,
             self._setDistance,
-            self._setPixelSize,
+            self._setVoxelSize,
             self._setCor,
             self._setPaddingType,
             self._setHalfTomo,
@@ -136,29 +139,38 @@ class ReconstructionParameters(qt.QWidget):
             distance_cm = f"{distance_cm:.2}"
         else:
             distance_cm = ""
-        self._distanceQLE.setText(distance_cm)
+        self._sampleDetectorDistanceQLE.setText(distance_cm)
 
-    def _setPixelSize(self, metadata: dict):
+    def _setVoxelSize(self, metadata: dict):
         # voxel size can be stored as pixel size (old version) or voxel size (new version)
         recons_params = metadata.get("processing_options", {}).get("reconstruction", {})
-        voxel_size_cm = recons_params.get("voxel_size_cm", None)
+        voxel_size_cm = recons_params.get("voxel_size_cm", [None] * 3)
+        # back compatibility when voxel was a scalar ( ~ nabu 2023 ?)
+        if numpy.isscalar(voxel_size_cm):
+            voxel_size_cm = [voxel_size_cm] * 3
 
         # now voxel size is expected to be a tuple of three elements
         if voxel_size_cm is not None:
-            voxel_size_cm = voxel_size_cm[0]
-            # FIXME: load_ini seems to fail to remove some char like '(' or ')'... to be fixed or investigate
-            # simplest might be to filter those when dumping it to text file... ??? or to handle those at silx level
-            if isinstance(voxel_size_cm, str):
-                for char_to_ignore in (" ", "(", ")", "[", "]"):
-                    voxel_size_cm = voxel_size_cm.replace(char_to_ignore, "")
+
+            def clean_voxel_value(value):
+                if isinstance(value, str):
+                    for char_to_ignore in (" ", "(", ")", "[", "]"):
+                        value = value.replace(char_to_ignore, "")
+                return value
+
+            voxel_size_cm = [clean_voxel_value(value) for value in voxel_size_cm]
+
         else:
             # backward compatibility with old volume
-            voxel_size_cm = recons_params.get("pixel_size_cm", None)
-        if voxel_size_cm is not None:
-            voxel_size_cm = f"{float(voxel_size_cm):.8}"
-        self._pixelSizeQLE.setText(
-            str(voxel_size_cm) if voxel_size_cm is not None else ""
-        )
+            voxel_size_cm = recons_params.get("pixel_size_cm", [None] * 3)
+
+        voxel_size_cm = filter(None, voxel_size_cm)
+
+        def cast_voxel_value(value: float | None):
+            return f"{float(value):.8}"
+
+        voxel_size_cm = [cast_voxel_value(value) for value in voxel_size_cm]
+        self._voxelSizeQLE.setText("x".join(voxel_size_cm))
 
     def _setCor(self, metadata: dict):
         cor = (

tomwer/gui/visualization/scanoverview.py

@@ -47,10 +47,10 @@ class ScanOverviewWidget(qt.QWidget):
         self._estimatedCOR = qt.QTreeWidgetItem(self._frames)
         self._estimatedCOR.setText(0, "estimated cor")
 
-        self._x_pixel_size = qt.QTreeWidgetItem(self._instrument)
-        self._x_pixel_size.setText(0, "x pixel size")
-        self._y_pixel_size = qt.QTreeWidgetItem(self._instrument)
-        self._y_pixel_size.setText(0, "y pixel size")
+        self._detector_x_pixel_size = qt.QTreeWidgetItem(self._instrument)
+        self._detector_x_pixel_size.setText(0, "x pixel size")
+        self._detector_y_pixel_size = qt.QTreeWidgetItem(self._instrument)
+        self._detector_y_pixel_size.setText(0, "y pixel size")
 
         # 2: define sample
         self._sample = qt.QTreeWidgetItem(self._tree)
@@ -58,6 +58,11 @@ class ScanOverviewWidget(qt.QWidget):
         self._sample_name = qt.QTreeWidgetItem(self._sample)
         self._sample_name.setText(0, "name")
 
+        self._sample_x_pixel_size = qt.QTreeWidgetItem(self._sample)
+        self._sample_x_pixel_size.setText(0, "x pixel size")
+        self._sample_y_pixel_size = qt.QTreeWidgetItem(self._sample)
+        self._sample_y_pixel_size.setText(0, "y pixel size")
+
         # 3: other hight level items
         self._startTime = qt.QTreeWidgetItem(self._tree)
         self._startTime.setText(0, "start_time")
@@ -96,6 +101,7 @@ class ScanOverviewWidget(qt.QWidget):
             "times": self._updateTimes,
             "names": self._updateNames,
             "scan-range": self._updateScanRange,
+            "sample": self._updateSample,
         }
         for part_name, fct in parts.items():
             try:
@@ -107,7 +113,7 @@ class ScanOverviewWidget(qt.QWidget):
     def _updateInstrument(self, scan: TomwerScanBase):
         self._updateFrames(scan=scan)
         self._updateEnergy(scan=scan)
-        self._updatePixelSize(scan=scan)
+        self._updateDetectorPixelSize(scan=scan)
 
     def _setColoredTxt(
         self, item, text, column=1, hightlight_red=False, hightlight_orange=False
@@ -125,7 +131,18 @@ class ScanOverviewWidget(qt.QWidget):
         item.setBackground(0, qt.QBrush(bkg_color))
 
     def _updateSample(self, scan: TomwerScanBase):
-        pass
+        x_pixel_size = scan.sample_x_pixel_size
+        y_pixel_size = scan.sample_y_pixel_size
+        self._setColoredTxt(
+            item=self._sample_x_pixel_size,
+            text=f"{x_pixel_size} (m)",
+            hightlight_red=x_pixel_size in (None, 0.0, 1.0),
+        )
+        self._setColoredTxt(
+            item=self._sample_y_pixel_size,
+            text=f"{y_pixel_size} (m)",
+            hightlight_red=y_pixel_size in (None, 0.0, 1.0),
+        )
 
     def _updateTimes(self, scan: TomwerScanBase):
         self._startTime.setText(1, str(scan.start_time))
@@ -213,20 +230,20 @@ class ScanOverviewWidget(qt.QWidget):
             text=str(scan_range),
         )
 
-    def _updatePixelSize(self, scan: TomwerScanBase):
+    def _updateDetectorPixelSize(self, scan: TomwerScanBase):
         assert isinstance(scan, TomwerScanBase)
         if isinstance(scan, EDFTomoScan):
             x_pixel_size = y_pixel_size = scan.pixel_size
         else:
-            x_pixel_size = scan.x_pixel_size
-            y_pixel_size = scan.y_pixel_size
+            x_pixel_size = scan.detector_x_pixel_size
+            y_pixel_size = scan.detector_y_pixel_size
         self._setColoredTxt(
-            item=self._x_pixel_size,
+            item=self._detector_x_pixel_size,
             text=f"{x_pixel_size} (m)",
             hightlight_red=x_pixel_size in (None, 0.0, 1.0),
         )
         self._setColoredTxt(
-            item=self._y_pixel_size,
+            item=self._detector_y_pixel_size,
             text=f"{y_pixel_size} (m)",
             hightlight_red=y_pixel_size in (None, 0.0, 1.0),
         )

tomwer/gui/visualization/test/test_reconstruction_parameters.py

@@ -46,8 +46,8 @@ def test_ReconstructionParameters(qtapp, phase_method):  # noqa F401
     assert window._methodQLE.text() == "FBP"
     assert window._paganinQLE.text() == phase_method
     assert window._deltaBetaQLE.text() == "110.0"
-    assert window._distanceQLE.text() == "0.4"
-    assert window._pixelSizeQLE.text() == "0.2"
+    assert window._sampleDetectorDistanceQLE.text() == "0.4"
+    assert window._voxelSizeQLE.text() == "0.2x0.2x0.2"
     assert window._corQLE.text() == "104.00"
     assert window._halfTomoCB.isChecked()
     assert window._fbpFilterQLE.text() == "Hilbert"

tomwer/synctools/utils/scanstages.py

@@ -10,7 +10,7 @@ import os
 import shutil
 
 from silx.io.url import DataUrl
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.nxtomoscan import NXtomoScan
@@ -59,7 +59,7 @@ class ScanStages:
         :param stage:
         :param dest_dir:
         """
-        stage = ScanStages.AcquisitionStage.from_value(stage)
+        stage = ScanStages.AcquisitionStage(stage)
         if not dest_dir.endswith(os.path.basename(self.scan.path)):
             dest_dir = os.path.join(dest_dir, os.path.basename(self.scan.path))
         for t_stage in ScanStages.AcquisitionStage:
@@ -75,7 +75,7 @@ class ScanStages:
         """
         if not dest_dir.endswith(os.path.basename(self.scan.path)):
             dest_dir = os.path.join(dest_dir, os.path.basename(self.scan.path))
-        stage = ScanStages.AcquisitionStage.from_value(stage)
+        stage = ScanStages.AcquisitionStage(stage)
         if stage is ScanStages.AcquisitionStage.ACQUI_NOT_STARTED:
             return
         elif stage is ScanStages.AcquisitionStage.ACQUI_STARTED:

tomwer/version.py

@@ -79,7 +79,7 @@ MAJOR = 1
 MINOR = 5
 MICRO = 0
 RELEV = "rc"  # <16
-SERIAL = 0  # <16
+SERIAL = 3  # <16
 
 date = __date__
 

{tomwer-1.5.0rc0.dist-info → tomwer-1.5.0rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tomwer
-Version: 1.5.0rc0
+Version: 1.5.0rc3
 Summary: "tomography workflow tools"
 Home-page: https://gitlab.esrf.fr/tomotools/tomwer
 Author: Henri Payno, Pierre Paleo, Pierre-Olivier Autran, Jérôme Lesaint, Alessandro Mirone