tomwer 0.7.2__tar.gz → 0.8.0a0__tar.gz

home/payno/.local/share/virtualenvs/tomwer_venv/bin/tomwer

@@ -1,10 +1,10 @@
 #!/home/payno/.local/share/virtualenvs/tomwer_venv/bin/python
-# EASY-INSTALL-ENTRY-SCRIPT: 'tomwer==0.7.2','console_scripts','tomwer'
+# EASY-INSTALL-ENTRY-SCRIPT: 'tomwer==0.8.0a0','console_scripts','tomwer'
 import re
 import sys
 
 # for compatibility with easy_install; see #2198
-__requires__ = 'tomwer==0.7.2'
+__requires__ = 'tomwer==0.8.0a0'
 
 try:
     from importlib.metadata import distribution
@@ -30,4 +30,4 @@ globals().setdefault('load_entry_point', importlib_load_entry_point)
 
 if __name__ == '__main__':
     sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(load_entry_point('tomwer==0.7.2', 'console_scripts', 'tomwer')())
+    sys.exit(load_entry_point('tomwer==0.8.0a0', 'console_scripts', 'tomwer')())

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/__init__.py

@@ -56,18 +56,5 @@ WIDGET_HELP_PATH = (
     # Correct DATA_FILES entry is needed in setup.py and documentation has to be built
     # # before the wheel is created.
     ("{}/help/tomwer/index.html".format(sysconfig.get_path("data")), None),
-    ("http://www.silx.org/pub/doc/tomwer/htmlhelp/0.7.0/", None),
+    ("http://www.silx.org/pub/doc/tomwer/htmlhelp/0.8/", None),
 )
-
-
-import unittest
-
-
-def suite():
-
-    test_suite = unittest.TestSuite()
-
-    from .test import suite as widgets_suite
-
-    test_suite.addTest(widgets_suite())
-    return test_suite

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/DataListOW.py

@@ -1,7 +1,7 @@
 # coding: utf-8
 # /*##########################################################################
 #
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
+# Copyright (c) 2016-2021 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -134,14 +134,3 @@ class DataListOW(widget.OWWidget, OWClient):
         self._scanIDs = []
         for scan in self.widget.datalist.items:
             self._scanIDs.append(scan)
-
-
-def main():
-    app = qt.QApplication([])
-    s = DataListOW()
-    s.show()
-    app.exec_()
-
-
-if __name__ == "__main__":
-    main()

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/DataSelectorOW.py

@@ -117,12 +117,3 @@ class DataSelectorOW(widget.OWWidget, OWClient):
         self._scanIDs = []
         for scan in self.widget.dataList.items:
             self._scanIDs.append(scan)
-
-
-if __name__ == "__main__":
-    from silx.gui import qt
-
-    qapp = qt.QApplication([])
-    widget = DataSelectorOW(parent=None)
-    widget.show()
-    qapp.exec_()

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/DataValidatorOW.py

@@ -119,9 +119,10 @@ class DataValidatorOW(SuperviseOW):
         self._widget._centralWidget.sigConfigChanged.connect(self._updateSettings)
 
     def close(self):
-        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self._widget.close()
-        self._widget = None
+        if self._widget is not None:
+            self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+            self._widget.close()
+            self._widget = None
         widget.OWWidget.close(self)
 
     @Inputs.data_in

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/OldDataValidatorOW.py

@@ -118,6 +118,7 @@ class OldDataValidatorOW(widget.OWWidget, ScanValidator):
         """
         widget.OWWidget.__init__(self, parent)
         ScanValidator.__init__(self, memoryReleaser=QWaiterThread(memReleaserWaitLoop))
+        self.destroyed.connect(self._clearMemoryReleaser)
         OWClient.__init__(self)
 
         self._buildGUI(ftserie)
@@ -332,7 +333,7 @@ class OldDataValidatorOW(widget.OWWidget, ScanValidator):
         if new_active_scan is not None:
             self.setActiveScan(new_active_scan)
 
-    def _validateStack(self):
+    def _validateStack(self, filter_=None):
         ScanValidator._validateStack(self)
         self.updateStackView()
 

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/control/VolumeSymLinkOW.py

@@ -34,7 +34,10 @@ from tomwer.web.client import OWClient
 from Orange.widgets.settings import Setting
 from Orange.widgets.widget import Output, Input
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.process.control.volumesymlink import OutputType, VolumeSymbolicLink
+from tomwer.core.process.control.volumesymlink import (
+    OutputType,
+    VolumeSymbolicLinkProcess,
+)
 from orangecontrib.tomwer.orange.managedprocess import SuperviseOW
 from processview.core.manager import ProcessManager, DatasetState
 from tomwer.utils import docstring
@@ -93,7 +96,7 @@ class VolumeSymLinkOW(SuperviseOW, OWClient):
     def process(self, scan):
         if scan is None:
             return
-        symlink_process = VolumeSymbolicLink()
+        symlink_process = VolumeSymbolicLinkProcess()
         symlink_process.set_properties(
             {
                 "output_type": self._mainWidget.getOutputType(),

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/debugtools/DatasetGeneratorOW.py

@@ -118,6 +118,7 @@ class DatasetGeneratorOW(widget.OWWidget):
             dims=self.generatorGUI.getFrameDims(),
         )
         thread.start()
+        return thread
 
     def _loadSettings(self):
         self.generatorGUI.setConfiguration(self._settings)

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/reconstruction/AxisOW.py

@@ -181,6 +181,8 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
                         self._setValueLockFrmSettings(
                             bool(self._rpSetting["gui"]["value_is_lock"])
                         )
+        # expose API
+        self._applyBut = self._widget._axisWidget._controlWidget._applyBut
         # connect Signal / Slot
         self._widget.sigComputationRequested.connect(self.__compute)
         self._widget.sigApply.connect(self.__validate)
@@ -255,7 +257,7 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
                     self.__scan._axis_params.frame_width is None
                     and self.__scan.dim_1 is not None
                 ):
-                    self.__scan._axis_params.frame_width = self.__scan.dim_1 // 2
+                    self.__scan._axis_params.frame_width = self.__scan.dim_1
 
                 self.__scan._axis_params.set_relative_value(
                     self._axis_params.value_ref_tomwer
@@ -366,22 +368,31 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
         elif self.__skip_exec:
             self._n_skip += 1
             if self.isValueLock():
-                scan._axis_params.set_relative_value(self._axis_params.value)
-                cor = scan._axis_params.value_ref_tomwer
+                scan._axis_params.set_relative_value(
+                    self._axis_params.relative_cor_value
+                )
+                cor = scan._axis_params.relative_cor_value
                 if isinstance(scan, HDF5TomoScan):
                     entry = scan.entry
                 else:
                     entry = "entry"
                 with scan.acquire_process_file_lock():
+                    ap = AxisProcess(process_id=self.process_id)
                     AxisProcess._register_process(
                         process_file=scan.process_file,
                         entry=entry,
-                        process=AxisProcess,
+                        process=ap,
                         results={"center_of_rotation": cor if cor is not None else "-"},
                         configuration=self._axis_params.to_dict(),
                         process_index=scan.pop_process_index(),
                         overwrite=True,
                     )
+                    ProcessManager().notify_dataset_state(
+                        dataset=scan,
+                        process=ap,
+                        state=DatasetState.SUCCEED,
+                    )
+
             else:
                 processing_class = AxisProcess(axis_params=self._axis_params)
                 for patch in self._patches:

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/reconstruction/DarkRefAndCopyOW.py

@@ -60,7 +60,7 @@ class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
     id = "orange.widgets.tomwer.darkrefs"
     description = "This widget will generate dark refs for a received scan "
     icon = "icons/darkref.svg"
-    priority = 25
+    priority = 15
     category = "esrfWidgets"
     keywords = ["tomography", "dark", "darks", "ref", "refs"]
 

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/reconstruction/NabuVolumeOW.py

@@ -182,9 +182,13 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
 
         config = scan.nabu_recons_params
         if "phase" in config and "delta_beta" in config["phase"]:
-            pag_dbs = nabu_utils.retrieve_lst_of_value_from_str(
-                config["phase"]["delta_beta"], type_=float
-            )
+            pag_dbs = config["phase"]["delta_beta"]
+            try:
+                pag_dbs = nabu_utils.retrieve_lst_of_value_from_str(
+                    config["phase"]["delta_beta"], type_=float
+                )
+            except Exception:
+                pass
             if len(pag_dbs) > 1:
                 _logger.warning(
                     "Several value found for {} / {}. Volume"
@@ -356,19 +360,3 @@ class _DeltaBetaSelector(qt.QTableWidget):
         for item in self.selectedItems():
             sel = item.text()
         return sel
-
-
-if __name__ == "__main__":
-    from tomwer.core.scan.scanbase import TomwerScanBase
-    from silx.gui import qt
-
-    app = qt.QApplication([])
-    widget = NabuVolumeOW(None)
-    scan = TomwerScanBase()
-    scan.projections = {}
-    scan.nabu_recons_params = {"phase": {"delta_beta": "12, 15"}}
-    widget.process(scan)
-
-    widget.show()
-    print(widget.getConfiguration())
-    app.exec_()

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/reconstruction/SAAxisOW.py

@@ -231,7 +231,7 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
     id = "orange.widgets.tomwer.sa_axis"
     description = "use to compute the center of rotation semi automatic way"
     icon = "icons/saaxis.png"
-    priority = 15
+    priority = 21
     category = "esrfWidgets"
     keywords = [
         "tomography",
@@ -265,7 +265,7 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
             type=AxisProcess.inputs[0].type,
             doc=AxisProcess.inputs[0].doc,
         )
-        data_recompute_axis = Input(
+        data_recompute = Input(
             name=AxisProcess.inputs[1].name,
             type=AxisProcess.inputs[1].type,
             doc=AxisProcess.inputs[1].doc,
@@ -375,7 +375,7 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
             self.notify_skip(scan=scan, details=details)
             self.Outputs.data_out.send(scan)
 
-    @Inputs.data_recompute_axis
+    @Inputs.data_recompute
     def reprocess(self, dataset):
         self.lockAutofocus(False)
         self.process(scan=dataset)
@@ -394,3 +394,11 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
             self.raise_()
             self.show()
             self._widget.showResults()
+
+    def stop(self):
+        self._widget.stop()
+
+    def close(self):
+        self.stop()
+        self._widget = None
+        super().close()

home/payno/.local/share/virtualenvs/tomwer_venv/lib/python3.7/site-packages/orangecontrib/tomwer/widgets/reconstruction/SADeltaBetaOW.py

@@ -0,0 +1,324 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "04/05/2021"
+
+
+from ..utils import WidgetLongProcessing
+from Orange.widgets import gui
+from orangecontrib.tomwer.orange.managedprocess import SuperviseOW
+from Orange.widgets.settings import Setting
+from orangecontrib.tomwer.orange.settings import CallbackSettingsHandler
+from Orange.widgets.widget import Input, Output
+from tomwer.core.process.reconstruction.sadeltabeta import SADeltaBetaProcess
+from tomwer.synctools.stacks.reconstruction.sadeltabeta import SADeltaBetaProcessStack
+from tomwer.synctools.sadeltabeta import QSADeltaBetaParams
+from tomwer.synctools.axis import QAxisRP
+from silx.gui import qt
+from tomwer.gui.reconstruction.sadeltabeta import (
+    SADeltaBetaWindow as _SADeltaBetaWindow,
+)
+from tomwer.core.scan.scanbase import TomwerScanBase, _TomwerBaseDock
+from processview.core.manager import ProcessManager, DatasetState
+from tomwer.core import settings
+from tomwer.core import utils
+from processview.core import helpers as pv_helpers
+import functools
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+class SADeltaBetaWindow(_SADeltaBetaWindow):
+    def __init__(self, Outputs, parent=None, process_id=None):
+        _SADeltaBetaWindow.__init__(self, parent=parent)
+        self.Outputs = Outputs
+        self._sa_delta_beta_params = QSADeltaBetaParams()
+        self._processing_stack = SADeltaBetaProcessStack(
+            sa_delta_beta_params=self._sa_delta_beta_params, process_id=process_id
+        )
+
+    def _launchReconstructions(self):
+        """callback when we want to launch the reconstruction of the
+        slice for n cor value"""
+        scan = self.getScan()
+        if scan is None:
+            return
+        # step1: if isAutoFocus: validate automatically the scan
+        # step2: update the interface if the current scan is the one displayed
+        # else skip it
+        callback = functools.partial(
+            self._mightUpdateResult, scan, self.isAutoFocusLock()
+        )
+        self._processing_stack.add(
+            scan=scan, configuration=self.getConfiguration(), callback=callback
+        )
+
+    def _validate(self):
+        self.validateCurrentScan()
+
+    def _mightUpdateResult(self, scan: TomwerScanBase, validate: bool):
+        if not isinstance(scan, TomwerScanBase):
+            raise TypeError("scan is expected to be an instance of TomwerScanBase")
+        if not isinstance(validate, bool):
+            raise TypeError("validate is expected to be a boolean")
+        if scan == self.getScan():
+            self.setDBScores(
+                scan.sa_delta_beta_params.scores,
+                score_method=scan.sa_delta_beta_params.score_method,
+            )
+            if scan.sa_delta_beta_params.autofocus is not None:
+                self.setCurrentDeltaBetaValue(scan.sa_delta_beta_params.autofocus)
+            ProcessManager().notify_dataset_state(
+                dataset=scan,
+                process=self._processing_stack,
+                details="processing done. Wait for user validation",
+                state=DatasetState.WAIT_USER_VALIDATION,
+            )
+        if validate:
+            self.validateScan(scan)
+
+    def wait_processing(self, wait_time):
+        self._processing_stack._computationThread.wait(wait_time)
+
+    def validateCurrentScan(self):
+        return self.validateScan(self.getScan())
+
+    def validateScan(self, scan):
+        if scan is None:
+            return
+        assert isinstance(scan, TomwerScanBase)
+        selected_db_value = self.getCurrentDeltaBetaValue()
+        if selected_db_value is None:
+            infos = "no selected delta / beta value. {} skip SADeltaBetaParams".format(
+                scan
+            )
+            _logger.warning(infos)
+            scan.sa_delta_beta_params.set_db_selected_value(None)
+            pv_helpers.notify_skip(
+                process=self._processing_stack, dataset=scan, details=infos
+            )
+        else:
+            scan.sa_delta_beta_params.set_db_selected_value(selected_db_value)
+            infos = "delta / beta selected for {}: {},".format(
+                scan, scan.sa_delta_beta_params.value
+            )
+            pv_helpers.notify_succeed(
+                process=self._processing_stack, dataset=scan, details=infos
+            )
+        SADeltaBetaProcess.process_to_tomwer_processes(
+            scan=scan,
+        )
+        self.Outputs.data_out.send(scan)
+
+
+class SADeltaBetaOW(SuperviseOW, WidgetLongProcessing):
+    """
+    Widget for semi-automatic delta / beta calculation
+
+    behavior within a workflow:
+    * no delta / beta value will be loaded even if an "axis" window exists on
+    the upper stream.
+    * if autofocus option is lock:
+       * launch the series of reconstruction (with research width defined)
+         and the estimated center of rotation if defined. Once the
+         reconstruction is ended and if the autofocus button is still lock
+         it will select the cor with the highest
+         value and mode to workflow downstream.
+    * hint: you can define a "multi-step" half-automatic center of rotation
+       research by creating several "sa_delta_beta" widget and reducing the research
+       width.
+
+    Details about :ref:`sadeltabeta score calculation`
+    """
+
+    name = "semi automatic delta/beta calculation"
+    id = "orange.widgets.tomwer.sa_delta_beta"
+    description = (
+        "compute several delta / beta value to get the optimal "
+        "delta / beta value (before reconstructing a volume for "
+        "example."
+    )
+    icon = "icons/delta_beta_range.png"
+    priority = 22
+    category = "esrfWidgets"
+    keywords = [
+        "tomography",
+        "semi automatic",
+        "half automatic",
+        "axis",
+        "delta-beta",
+        "delta/beta",
+        "delta",
+        "beta",
+        "tomwer",
+        "reconstruction",
+        "position",
+        "center of rotation",
+        "sadeltabetaaxis",
+        "sa_delta_beta_axis",
+        "sa_delta_beta",
+        "sadeltabeta",
+    ]
+
+    want_main_area = True
+    resizing_enabled = True
+    allows_cycle = True
+    compress_signal = False
+
+    settingsHandler = CallbackSettingsHandler()
+
+    sigScanReady = qt.Signal(TomwerScanBase)
+    """Signal emitted when a scan is ready"""
+
+    _rpSetting = Setting(dict())
+    "settings store as dict"
+
+    class Inputs:
+        data_in = Input(name="data", type=TomwerScanBase)
+        data_recompute = Input(
+            name="change recons params",
+            type=_TomwerBaseDock,
+            doc="recompute delta / beta",
+        )
+
+    class Outputs:
+        data_out = Output(name="data", type=TomwerScanBase)
+
+    def __init__(self, parent=None):
+        """
+
+        :param parent: QWidget parent or None
+        """
+        SuperviseOW.__init__(self, parent)
+        WidgetLongProcessing.__init__(self)
+        self._layout = gui.vBox(self.mainArea, self.name).layout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._widget = SADeltaBetaWindow(
+            Outputs=self.Outputs, parent=self, process_id=self.process_id
+        )
+        self._layout.addWidget(self._widget)
+        self.setConfiguration(self._rpSetting)
+
+        # connect signal / slot
+        self._widget.sigConfigurationChanged.connect(self._updateSettings)
+        self.destroyed.connect(self._widget.stop)
+        self._widget._processing_stack.sigComputationStarted.connect(
+            self._startProcessing
+        )
+        self._widget._processing_stack.sigComputationEnded.connect(self._endProcessing)
+        # expose API
+        self.wait_processing = self._widget.wait_processing
+
+    def setConfiguration(self, configuration):
+        if "workflow" in configuration:
+            autofocus_lock = configuration["workflow"].get("autofocus_lock", None)
+            if autofocus_lock is not None:
+                self._widget.lockAutofocus(autofocus_lock)
+            del configuration["workflow"]
+        self._widget.setConfiguration(configuration)
+
+    def getCurrentCorValue(self):
+        return self._widget.getCurrentCorValue()
+
+    def load_sinogram(self):
+        self._widget.loadSinogram()
+
+    def compute(self):
+        self._widget.compute()
+
+    def lockAutofocus(self, lock):
+        self._widget.lockAutofocus(lock=lock)
+
+    def isAutoFocusLock(self):
+        return self._widget.isAutoFocusLock()
+
+    @Inputs.data_in
+    def process(self, scan):
+        if scan is None:
+            return
+        if scan.axis_params is None:
+            scan.axis_params = QAxisRP()
+        if scan.sa_delta_beta_params is None:
+            scan.sa_delta_beta_params = QSADeltaBetaParams()
+        self._skipCurrentScan(new_scan=scan)
+        if settings.isOnLbsram(scan) and utils.isLowOnMemory(
+            settings.get_lbsram_path()
+        ):
+            self.notify_skip(
+                scan=scan,
+                details="sa-delta-beta has been skiped for {} because "
+                "of low space in lbsram".format(scan),
+            )
+            self.Outputs.data_out.send(scan)
+        else:
+            self._widget.setScan(scan=scan)
+            self.notify_pending(scan)
+            self.activateWindow()
+            if self.isAutoFocusLock():
+                self.compute()
+            else:
+                self.raise_()
+                self.show()
+
+    def _skipCurrentScan(self, new_scan):
+        scan = self._widget.getScan()
+        # if the same scan has been run several scan
+        if scan is None or str(scan) == str(new_scan):
+            return
+        current_scan_state = ProcessManager().get_dataset_state(
+            dataset_id=scan.get_dataset_identifier(), process=self
+        )
+        if current_scan_state in (
+            DatasetState.PENDING,
+            DatasetState.WAIT_USER_VALIDATION,
+        ):
+            details = "Was pending and has been replaced by another scan."
+            self.notify_skip(scan=scan, details=details)
+            self.Outputs.data_out.send(scan)
+
+    @Inputs.data_recompute
+    def reprocess(self, dataset):
+        self.lockAutofocus(False)
+        self.process(scan=dataset)
+
+    def validateCurrentScan(self):
+        self._widget.validateCurrentScan()
+
+    def _updateSettings(self):
+        self._rpSetting = self._widget.getConfiguration()
+        self._rpSetting["workflow"] = {
+            "autofocus_lock": self._widget.isAutoFocusLock(),
+        }
+
+    def close(self):
+        self.stop()
+        self._widget = None
+        super().close()
+
+    def stop(self):
+        self._widget.stop()