tomwer 1.4.0rc0__py3-none-any.whl → 1.4.0rc1__py3-none-any.whl

tomwer/gui/reconstruction/axis/InputWidget.py

@@ -6,17 +6,10 @@ from silx.gui import qt
 
 from tomwer.core.process.reconstruction.axis import mode as axis_mode
 from tomwer.core.process.reconstruction.axis.anglemode import CorAngleMode
-from tomwer.core.process.reconstruction.axis.params import (
-    DEFAULT_CMP_N_SUBSAMPLING_Y,
-    DEFAULT_CMP_OVERSAMPLING,
-    DEFAULT_CMP_TAKE_LOG,
-    DEFAULT_CMP_THETA,
-)
 from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.utils.qt_utils import block_signals
 from tomwer.synctools.axis import QAxisRP
-from .CalculationWidget import CalculationWidget
 from .ManualFramesSelection import ManualFramesSelection
 
 _logger = logging.getLogger(__name__)
@@ -55,74 +48,24 @@ class InputWidget(qt.QWidget):
 
         # sinogram input
         self._sinogramGB = qt.QGroupBox(self)
-        self._sinogramGB.setLayout(qt.QVBoxLayout())
-        self._standardSinogramOpts = qt.QGroupBox(self)
-        self._sinogramGB.layout().addWidget(self._standardSinogramOpts)
-        self._standardSinogramOpts.setLayout(qt.QFormLayout())
-        self._standardSinogramOpts.layout().setContentsMargins(0, 0, 0, 0)
-        self._standardSinogramOpts.setTitle("standard options")
+        self._sinogramGB.setLayout(qt.QFormLayout())
 
         self._sinogramGB.setTitle("sinogram")
         self._sinogramGB.setCheckable(True)
         self.layout().addWidget(self._sinogramGB)
         ##  sinogram line
         self._sinogramLineSB = _SliceSelector(self)
-        self._standardSinogramOpts.layout().addRow("line", self._sinogramLineSB)
+        self._sinogramGB.layout().addRow("line", self._sinogramLineSB)
         ##  sinogram subsampling
         self._sinogramSubsampling = qt.QSpinBox(self)
         self._sinogramSubsampling.setRange(1, 1000)
         self._sinogramSubsampling.setValue(10)
-        self._standardSinogramOpts.layout().addRow(
-            "subsampling", self._sinogramSubsampling
-        )
+        self._sinogramGB.layout().addRow("subsampling", self._sinogramSubsampling)
 
         self._spacer = qt.QWidget(self)
         self._spacer.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
         self.layout().addWidget(self._spacer)
 
-        ## options for the composite mode
-        self._compositeOpts = qt.QGroupBox(self)
-        self._compositeOpts.setTitle("composite options")
-        self._sinogramGB.layout().addWidget(self._compositeOpts)
-        self._compositeOpts.setLayout(qt.QFormLayout())
-        self._compositeOpts.layout().setContentsMargins(0, 0, 0, 0)
-        self._thetaSB = qt.QSpinBox(self)
-        self._thetaSB.setRange(0, 360)
-        self._thetaSB.setValue(DEFAULT_CMP_THETA)
-        self._thetaSB.setToolTip("a radio will be picked each theta degres")
-        self._thetaLabel = qt.QLabel("angle interval (in degree)", self)
-        self._thetaLabel.setToolTip(
-            "algorithm will take one projection each 'angle interval'. Also know as 'theta'"
-        )
-        self._compositeOpts.layout().addRow(self._thetaLabel, self._thetaSB)
-
-        self._oversamplingSB = qt.QSpinBox(self)
-        self._oversamplingSB.setValue(DEFAULT_CMP_OVERSAMPLING)
-        self._oversamplingSB.setToolTip("sinogram oversampling")
-        self._compositeOpts.layout().addRow("oversampling", self._oversamplingSB)
-
-        self._nearwidthSB = qt.QSpinBox(self)
-        self._nearwidthSB.setRange(-40000, 40000)
-        self._nearwidthSB.setValue(0)
-        self._nearwidthSB.setToolTip("position to be used with near option")
-        self._nearwidthLabel = qt.QLabel("near width", self)
-        self._nearwidthLabel.setToolTip("position to be used with near option")
-        self._compositeOpts.layout().addRow(self._nearwidthLabel, self._nearwidthSB)
-
-        self._subsamplingYSB = qt.QSpinBox(self)
-        self._subsamplingYSB.setValue(DEFAULT_CMP_N_SUBSAMPLING_Y)
-        self._subsamplingYSB.setToolTip("sinogram number of subsampling along y")
-        self._compositeOpts.layout().addRow("n_subsampling_y", self._subsamplingYSB)
-
-        self._takeLogCB = qt.QCheckBox(self)
-        self._takeLogCB.setToolTip("Take logarithm")
-        self._takeLogCB.setChecked(DEFAULT_CMP_TAKE_LOG)
-        self._takeTheLogLabel = qt.QLabel("linearisation (-log(I/I0))")
-        self._takeTheLogLabel.setToolTip(
-            "take (-log(I/I0)) as input. Also know as 'take_log' option"
-        )
-        self._compositeOpts.layout().addRow(self._takeTheLogLabel, self._takeLogCB)
-
         # set up
         self._sinogramGB.setChecked(False)
 
@@ -131,11 +74,6 @@ class InputWidget(qt.QWidget):
         self._radioGB.toggled.connect(self._radiosChecked)
         self._sinogramSubsampling.valueChanged.connect(self._changed)
         self._sinogramLineSB.sigChanged.connect(self._changed)
-        self._thetaSB.valueChanged.connect(self._changed)
-        self._oversamplingSB.valueChanged.connect(self._changed)
-        self._subsamplingYSB.valueChanged.connect(self._changed)
-        self._nearwidthSB.valueChanged.connect(self._changed)
-        self._takeLogCB.toggled.connect(self._changed)
         self._angleModeWidget.sigChanged.connect(self._sigUrlChanged)
 
     def setScan(self, scan: TomwerScanBase):
@@ -151,10 +89,11 @@ class InputWidget(qt.QWidget):
                 if axis_params is not None:
                     assert isinstance(axis_params, QAxisRP)
                     with block_signals(self._sinogramGB):
-                        self._sinogramChecked(axis_params.use_sinogram, on_load=True)
+                        self._sinogramChecked(
+                            axis_params.mode.requires_sinogram_index(), on_load=True
+                        )
                     self._sinogramLineSB.setSlice(axis_params.sinogram_line)
                     self._sinogramSubsampling.setValue(axis_params.sinogram_subsampling)
-                    self.setCompositeOptions(axis_params.composite_options)
                 self._angleModeWidget.setAxisParams(axis_params)
                 self._axis_params = axis_params
 
@@ -202,10 +141,8 @@ class InputWidget(qt.QWidget):
 
     def _updateAxisParams(self):
         if not self._blockUpdateAxisParams:
-            self._axis_params.use_sinogram = self._sinogramGB.isChecked()
             self._axis_params.sinogram_line = self.getSinogramLine()
             self._axis_params.sinogram_subsampling = self.getSinogramSubsampling()
-            self._axis_params.composite_options = self.getCompositeOptions()
 
     def setValidInputs(self, modes: list | tuple):
         """
@@ -230,102 +167,21 @@ class InputWidget(qt.QWidget):
             raise ValueError("modes is empty")
         else:
             mode = axis_mode._InputType.from_value(modes.pop())
-            if mode in (axis_mode._InputType.SINOGRAM, axis_mode._InputType.COMPOSITE):
+            if mode is axis_mode._InputType.SINOGRAM:
                 self._sinogramGB.setEnabled(True)
                 self._radioGB.setEnabled(False)
                 self._sinogramGB.setChecked(True)
-                self._compositeOpts.setEnabled(mode is axis_mode._InputType.COMPOSITE)
-                self._standardSinogramOpts.setEnabled(
-                    mode is not axis_mode._InputType.COMPOSITE
-                )
             elif mode is axis_mode._InputType.RADIOS_X2:
                 self._radioGB.setEnabled(True)
                 self._sinogramGB.setEnabled(False)
                 self._radioGB.setChecked(True)
+            elif mode is axis_mode._InputType.COMPOSITE:
+                # those mode are neither sinogram neither radio. Now one of the two will be checked but without any much meaning
+                self._radioGB.setEnabled(False)
+                self._sinogramGB.setEnabled(False)
             else:
                 raise ValueError(f"Nothing implemented for {mode.value}")
 
-    def getCompositeOptions(self) -> dict:
-        return {
-            "theta": self.getTheta(),
-            "oversampling": self.getOversampling(),
-            "n_subsampling_y": self.getSubsamplingY(),
-            "take_log": self.getTakeLog(),
-            "near_pos": self.getNearpos(),
-            "near_width": self.getNearwidth(),
-        }
-
-    def setCompositeOptions(self, opts: dict) -> None:
-        if not isinstance(opts, dict):
-            raise TypeError("opts should be an instance of dict")
-        for key in opts.keys():
-            if key not in (
-                "theta",
-                "oversampling",
-                "n_subsampling_y",
-                "take_log",
-                "near_pos",
-                "near_width",
-            ):
-                raise KeyError(f"{key} is not recogized")
-            theta = opts.get("theta", None)
-            if theta is not None:
-                self.setTheta(theta=theta)
-            oversampling = opts.get("oversampling", None)
-            if oversampling is not None:
-                self.setOversampling(oversampling)
-            n_subsampling_y = opts.get("n_subsampling_y", None)
-            if n_subsampling_y is not None:
-                self.setSubsamplingY(n_subsampling_y)
-
-            near_width = opts.get("near_width", None)
-            if near_width is not None:
-                self.setNearwidth(near_width)
-
-            take_log = opts.get("take_log", None)
-            if take_log is not None:
-                self.setTakeLog(take_log)
-
-    def getTheta(self) -> int:
-        return self._thetaSB.value()
-
-    def setTheta(self, theta: int) -> None:
-        self._thetaSB.setValue(theta)
-
-    def getOversampling(self) -> int:
-        return self._oversamplingSB.value()
-
-    def setOversampling(self, oversampling: int) -> None:
-        self._oversamplingSB.setValue(oversampling)
-
-    def getNearpos(self) -> int:
-        cal_widget = self.parentWidget().widget(0)
-        assert isinstance(cal_widget, CalculationWidget)
-        return cal_widget.getEstimatedCor()
-
-    def setNearpos(self, value) -> int:
-        cal_widget = self.parentWidget().widget(0)
-        assert isinstance(cal_widget, CalculationWidget)
-        cal_widget.setNearPosition(value)
-
-    def getNearwidth(self) -> int:
-        return self._nearwidthSB.value()
-
-    def setNearwidth(self, value) -> int:
-        return self._nearwidthSB.setValue(value)
-
-    def getSubsamplingY(self) -> int:
-        return self._subsamplingYSB.value()
-
-    def setSubsamplingY(self, subsampling: int) -> None:
-        self._subsamplingYSB.setValue(subsampling)
-
-    def getTakeLog(self) -> bool:
-        return self._takeLogCB.isChecked()
-
-    def setTakeLog(self, log: bool) -> None:
-        self._takeLogCB.setChecked(log)
-
 
 class _AngleSelectionWidget(qt.QWidget):
     """Group box to select the angle to used for cor calculation

tomwer/gui/reconstruction/saaxis/corrangeselector.py

@@ -16,6 +16,10 @@ from silx.gui.plot import items
 from silx.utils.enum import Enum as _Enum
 from tomoscan.esrf.scan.utils import get_data
 
+from tomwer.core.process.reconstruction.utils.cor import (
+    absolute_pos_to_relative,
+    relative_pos_to_absolute,
+)
 from tomwer.core.process.reconstruction.saaxis.saaxis import ReconstructionMode
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui import icons
@@ -23,6 +27,7 @@ from tomwer.gui.reconstruction.saaxis.sliceselector import SliceSelector
 from tomwer.gui.utils.lineselector import QSliceSelectorDialog
 from tomwer.gui.utils.slider import LogSlider
 from tomwer.gui.visualization.sinogramviewer import SinogramViewer as _SinogramViewer
+from tomwer.gui.fonts import FONT_MEDIUM, FONT_IMPORTANT
 
 _logger = logging.getLogger(__name__)
 
@@ -493,7 +498,9 @@ class _EstimatedCorWidget(qt.QGroupBox):
                 return 0.0
             elif mode in ("abs", "absolute"):
                 if self._frameWidth is not None:
-                    return (self._frameWidth - 1) / 2.0
+                    return relative_pos_to_absolute(
+                        relative_pos=0.0, det_width=self._frameWidth
+                    )
                 else:
                     return self._MIDDLE_COR_TXT
             else:
@@ -519,7 +526,9 @@ class _EstimatedCorWidget(qt.QGroupBox):
             old = self.blockSignals(True)
             old_mcor = self._manualCORAbs.blockSignals(True)
             self._manualCORAbs.setValue(
-                self._manualCORRel.value() + (self._frameWidth - 1) / 2.0
+                relative_pos_to_absolute(
+                    relative_pos=self._manualCORRel.value(), det_width=self._frameWidth
+                )
             )
             self._manualCORAbs.blockSignals(old_mcor)
             self.blockSignals(old)
@@ -529,7 +538,10 @@ class _EstimatedCorWidget(qt.QGroupBox):
             old = self.blockSignals(True)
             old_mcor = self._manualCORRel.blockSignals(True)
             self._manualCORRel.setValue(
-                self._manualCORAbs.value() - (self._frameWidth - 1) / 2.0
+                absolute_pos_to_relative(
+                    absolute_pos=self._manualCORAbs.value(),
+                    det_width=self._frameWidth,
+                )
             )
             self._manualCORRel.blockSignals(old_mcor)
             self.blockSignals(old)
@@ -582,15 +594,12 @@ class SAAxisOptions(qt.QWidget):
     sigConfigurationChanged = qt.Signal()
     """signal emitted when the configuration change"""
 
-    _FONT_IMPORTANT = qt.QFont("Arial", 12)
-    _FONT_MEDIUM = qt.QFont("Arial", 10)
-
     def __init__(self, parent=None):
         qt.QWidget.__init__(self, parent)
         self.setLayout(qt.QVBoxLayout())
         # reconstruction mode
         self._reconstructionMode = _ReconstructionModeGB(parent=self)
-        self._reconstructionMode.setFont(self._FONT_MEDIUM)
+        self._reconstructionMode.setFont(FONT_MEDIUM)
         self.layout().addWidget(self._reconstructionMode)
 
         # estimated cor
@@ -598,12 +607,12 @@ class SAAxisOptions(qt.QWidget):
             self,
             title="Estimated cor position (x axis)",
         )
-        self._estimatedCorWidget.setFont(self._FONT_IMPORTANT)
+        self._estimatedCorWidget.setFont(FONT_IMPORTANT)
         self.layout().addWidget(self._estimatedCorWidget)
 
         # detection accuracy
         self._detectionAccuracy = _DetectionAccuracyGB(parent=self)
-        self._detectionAccuracy.setFont(self._FONT_MEDIUM)
+        self._detectionAccuracy.setFont(FONT_MEDIUM)
         self.layout().addWidget(self._detectionAccuracy)
 
         # number of reconstructions eq volume size
@@ -613,7 +622,7 @@ class SAAxisOptions(qt.QWidget):
         self._nReconsSB = qt.QSpinBox(self._nReconsWidget)
         self._nReconsSB.setRange(0, 2000)
         self._nReconsSB.setValue(30)
-        self._nReconsWidget.setFont(self._FONT_IMPORTANT)
+        self._nReconsWidget.setFont(FONT_IMPORTANT)
         self._nReconsWidget.layout().addRow("Number of reconstruction", self._nReconsSB)
         self.layout().addWidget(self._nReconsWidget)
 

tomwer/gui/reconstruction/scores/scoreplot.py

@@ -14,6 +14,7 @@ from matplotlib import image as _matplotlib_image
 from silx.gui import qt
 from silx.gui.plot import PlotWidget
 
+from tomwer.core.process.reconstruction.utils.cor import relative_pos_to_absolute
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
 from tomwer.gui import icons, settings
 from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
@@ -307,7 +308,9 @@ class CorSelection(VariableSelection):
         if relative_value is None or self._img_width is None:
             self._absoluteVarValueLE.clear()
         else:
-            absolute_value = relative_value + (self._img_width - 1) / 2.0
+            absolute_value = relative_pos_to_absolute(
+                relative_pos=relative_value, det_width=self._img_width
+            )
             self._absoluteVarValueLE.setText(f"{absolute_value:.3f}")
 
     def getWindowTitle(self):
@@ -422,7 +425,7 @@ class _VariableValueLabels(qt.QWidget):
             # paint oblique text
             with PainterRotationCM(
                 painter=painter,
-                x=var_px_pos + self._slider_ticks_margin / 2.0,
+                x=var_px_pos + (self._slider_ticks_margin / 2.0),
                 y=0,
                 angle=self.rotation_angle_degree,
             ) as l_painter:

tomwer/gui/reconstruction/tests/test_nabu.py

@@ -19,8 +19,11 @@ from tomwer.gui.reconstruction.nabu.nabuconfig.reconstruction import (
 )
 from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowControl
 from tomwer.gui.reconstruction.nabu.volume import NabuVolumeTabWidget
+from tomwer.gui.reconstruction.axis.EstimatedCORWidget import EstimatedCORWidget
 from tomwer.tests.utils import skip_gui_test
 from tomwer.core.process.output import ProcessDataOutputDirMode
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.synctools.axis import QAxisRP
 
 
 class ProcessClass:
@@ -356,3 +359,8 @@ class TestNabuVolumeWidget(TestCaseQt):
             }
         )
         self.assertEqual(self.nabuWidget.getConfiguration(), conf)
+
+
+def test_EstimatedCorWidget(qtapp):  # noqa F811
+    """test of EstimatedCorWidget"""
+    EstimatedCORWidget(parent=None, axis_params=QAxisRP())

tomwer/gui/stitching/z_stitching/fineestimation.py

@@ -73,7 +73,7 @@ class Axis_N_Params(qt.QGroupBox):
 
 class AutoRefineWidget(qt.QWidget):
     """
-    widget grouping information not specific to objects (output file, stithcing strategy...)
+    widget grouping information not specific to objects (output file, stitching strategy...)
     """
 
     def __init__(self, parent=None):

tomwer/gui/tests/test_axis_gui.py

@@ -1,4 +1,5 @@
 import pytest
+import numpy
 
 from tomwer.gui.reconstruction.axis.AxisSettingsWidget import AxisSettingsTabWidget
 from tomwer.synctools.axis import QAxisRP
@@ -10,18 +11,33 @@ from tomwer.tests.conftest import qtapp  # noqa F401
 def test_get_nabu_cor_opts(qtapp):  # noqa F811
     axis_params = QAxisRP()
     widget = AxisSettingsTabWidget(recons_params=axis_params)
-    assert axis_params.get_nabu_cor_options_as_str() == "side='right'"
-    widget._calculationWidget._corOpts.setText("low_pass=2")
-    widget._calculationWidget._corOpts.editingFinished.emit()
-    assert axis_params.get_nabu_cor_options_as_str() == "side='right' ; low_pass=2"
-    widget._calculationWidget._corOpts.setText("low_pass=2 ; high_pass=10")
-    widget._calculationWidget._corOpts.editingFinished.emit()
-    assert axis_params.get_nabu_cor_options_as_str() == (
-        "side='right' ; low_pass=2 ; high_pass=10"
-    )
-    widget._calculationWidget._sideCB.setCurrentText("left")
-    widget._calculationWidget._corOpts.editingFinished.emit()
-    assert (
-        axis_params.get_nabu_cor_options_as_str()
-        == "side='left' ; low_pass=2 ; high_pass=10"
-    )
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "right",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+    }
+    widget._optionsWidget._corOpts.setText("low_pass=2.0")
+    widget._optionsWidget._corOpts.editingFinished.emit()
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "right",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+        "low_pass": 2.0,
+    }
+    widget._optionsWidget._corOpts.setText("low_pass=2 ; high_pass=10")
+    widget._optionsWidget._corOpts.editingFinished.emit()
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "right",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+        "low_pass": 2.0,
+        "high_pass": 10.0,
+    }
+    widget._calculationWidget.setEstimatedCorValue("left")
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "left",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+        "low_pass": 2.0,
+        "high_pass": 10.0,
+    }

tomwer/synctools/stacks/reconstruction/axis.py

@@ -23,7 +23,7 @@ _logger = logging.getLogger(__name__)
 
 
 class AxisProcessStack(FIFO, qt.QObject):
-    """Implementation of the `.AxisProcess` but having a stack for treating
+    """Implementation of the `.AxisTask` but having a stack for treating
     scans and making computation in threads"""
 
     def __init__(self, axis_params, process_id=None):
@@ -55,7 +55,7 @@ class AxisProcessStack(FIFO, qt.QObject):
             if callback is not None:
                 callback()
             self.scan_ready(scan=data)
-        elif not self._axis_params.use_sinogram and mode in (AxisMode.manual,):
+        elif mode is (AxisMode.manual,):
             # if cor is not set then set it to 0 (can be the case if no)
             # interaction has been dne
             cor = self._axis_params.relative_cor_value
@@ -84,14 +84,6 @@ class AxisProcessStack(FIFO, qt.QObject):
             # we will keep the actual one (should have been defined previously)
             self._end_computation(data=data, future_tomo_obj=None, callback=callback)
 
-        elif (
-            not self._axis_params.use_sinogram
-            and mode not in AxisTask._CALCULATIONS_METHODS
-        ):
-            _logger.warning(f"no method defined to compute {mode}")
-            if callback is not None:
-                callback()
-            self._process_next()
         else:
             _logger.processStarted(
                 f"Start cor calculation on {data} ({self._axis_params.get_simple_str()})"
@@ -113,7 +105,7 @@ class AxisProcessStack(FIFO, qt.QObject):
         """
         assert isinstance(data, TomwerScanBase)
         assert self._axis_params is not None
-        # copy result computed on scan on the AxisProcess reconsparams
+        # copy result computed on scan on the AxisTask reconsparams
         self._axis_params.set_relative_value(
             data.axis_params.relative_cor_value
         )  # noqa
@@ -167,23 +159,13 @@ class _ProcessingThread(ProcessingThread, SuperviseProcess):
             },
             process_id=self.process_id,
         )
-        axis = self.apply_patch(axis=axis)
         try:
             axis.run()
         except NoAxisUrl as e:
             self.center_of_rotation = None
-            _logger.error(str(e))
+            _logger.error(f"CoR calculation failed. Issue with input ({e})")
         except Exception as e:
-            _logger.error(str(e))
+            _logger.error(f"CoR calculation failed ({e})", stack_info=True)
             self.center_of_rotation = None
         else:
             self.center_of_rotation = self._scan.axis_params.relative_cor_value
-
-    def patch_calc_method(self, mode, function):
-        self.__patch[mode] = function
-
-    def apply_patch(self, axis):
-        for mode, patch_fct in self.__patch.items():
-            if mode in AxisMode:
-                axis._CALCULATIONS_METHODS[mode] = patch_fct
-        return axis

tomwer/synctools/stacks/reconstruction/dkrefcopy.py

@@ -23,7 +23,7 @@ _logger = logging.getLogger(__name__)
 
 
 class DarkRefCopyProcessStack(FIFO, qt.QObject):
-    """Implementation of the `.AxisProcess` but having a stack for treating
+    """Implementation of the `.AxisTask` but having a stack for treating
     scans and making computation in threads"""
 
     sigRefSetted = qt.Signal(str)

tomwer/synctools/stacks/reconstruction/nabu.py

@@ -21,7 +21,7 @@ _logger = logging.getLogger(__name__)
 
 
 class NabuSliceProcessStack(FIFO, qt.QObject):
-    """Implementation of the `.AxisProcess` but having a stack for treating
+    """Implementation of the `.AxisTask` but having a stack for treating
     scans and making computation in threads"""
 
     def __init__(self, parent=None, process_id=None):
@@ -78,7 +78,7 @@ class NabuSliceProcessStack(FIFO, qt.QObject):
 
 
 class NabuVolumeProcessStack(NabuSliceProcessStack):
-    """Implementation of the `.AxisProcess` but having a stack for treating
+    """Implementation of the `.AxisTask` but having a stack for treating
     scans and making computation in threads"""
 
     def _create_processing_thread(self, process_id=None) -> qt.QThread:

tomwer/synctools/stacks/reconstruction/normalization.py

@@ -20,7 +20,7 @@ _logger = logging.getLogger(__name__)
 
 
 class INormalizationProcessStack(FIFO, qt.QObject):
-    """Implementation of the `.AxisProcess` but having a stack for treating
+    """Implementation of the `.AxisTask` but having a stack for treating
     scans and making computation in threads"""
 
     def __init__(self, process_id=None):

tomwer/synctools/stacks/reconstruction/saaxis.py

@@ -22,7 +22,7 @@ _logger = logging.getLogger(__name__)
 
 
 class SAAxisProcessStack(FIFO, qt.QObject):
-    """Implementation of the `.AxisProcess` but having a stack for treating
+    """Implementation of the `.AxisTask` but having a stack for treating
     scans and making computation in threads"""
 
     def __init__(self, saaxis_params, process_id=None):

tomwer/synctools/stacks/reconstruction/sadeltabeta.py

@@ -24,7 +24,7 @@ _logger = logging.getLogger(__name__)
 
 
 class SADeltaBetaProcessStack(FIFO, qt.QObject):
-    """Implementation of the `.AxisProcess` but having a stack for treating
+    """Implementation of the `.AxisTask` but having a stack for treating
     scans and making computation in threads"""
 
     def __init__(self, sa_delta_beta_params, process_id=None):

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_axis.py

@@ -179,22 +179,6 @@ class TestAxisStack(TestCaseQt):
         self.assertEqual(self._scan2.axis_params, None)
         self.assertEqual(self._scan3.axis_params, None)
 
-    def testUnlockStack(self):
-        """Check that all axis position will be computed properly if we set a
-        stack of scan"""
-        self._mainWindow.recons_params.set_relative_value(1.0)
-        for scan in (self._scan1, self._scan2, self._scan3):
-            self._mainWindow.process(scan)
-
-        for i in range(5):
-            self.qapp.processEvents()
-            time.sleep(0.2)
-            self.qapp.processEvents()
-
-        self.assertNotEqual(self._scan1.axis_params, None)
-        self.assertNotEqual(self._scan2.axis_params, None)
-        self.assertNotEqual(self._scan3.axis_params, None)
-
     def testLockStack(self):
         """Check that axis position will be simply copy if we are in a lock
         stack"""

tomwer/tests/test_ewoks/test_single_node_execution.py

@@ -37,7 +37,7 @@ pytest.mark.skipif(condition=not has_nabu, reason="nabu not installed")
 
 classes_to_test = {
     "darkref": "tomwer.core.process.reconstruction.darkref.darkrefs.DarkRefs",
-    "axis": "tomwer.core.process.reconstruction.axis.axis.AxisProcess",
+    "axis": "tomwer.core.process.reconstruction.axis.axis.AxisTask",
     "nabu slices": "tomwer.core.process.reconstruction.nabu.nabuslices.NabuSlices",
 }
 

tomwer/tests/test_ewoks/test_workflows.py

@@ -55,7 +55,7 @@ def test_simple_workflow_nabu():
                     {
                         "id": "axis",
                         "task_type": "class",
-                        "task_identifier": "tomwer.core.process.reconstruction.axis.axis.AxisProcess",
+                        "task_identifier": "tomwer.core.process.reconstruction.axis.axis.AxisTask",
                         "default_inputs": [
                             {
                                 "name": "axis_params",

tomwer/version.py

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

{tomwer-1.4.0rc0.dist-info → tomwer-1.4.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tomwer
-Version: 1.4.0rc0
+Version: 1.4.0rc1
 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
@@ -28,7 +28,7 @@ Requires-Dist: silx[full]>=2.0
 Requires-Dist: tomoscan>=2.1.0a18
 Requires-Dist: nxtomo>=1.3.0dev4
 Requires-Dist: nxtomomill>=1.1.0a0
-Requires-Dist: processview>=1.3
+Requires-Dist: processview>=1.4.3
 Requires-Dist: ewoks>=0.1.1
 Requires-Dist: sluurp>=0.4.0
 Requires-Dist: packaging