tomwer 1.2.0a1__py3-none-any.whl → 1.2.0a3__py3-none-any.whl

tomwer/app/reducedarkflat.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import argparse
+import logging
+import signal
+import sys
+
+from silx.gui import qt
+
+from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefsTask
+from tomwer.core.process.reconstruction.darkref.params import DKRFRP, ReduceMethod
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.resource import increase_max_number_file
+from tomwer.gui import icons
+from tomwer.gui.reconstruction.darkref.darkrefwidget import DarkRefWidget
+from tomwer.gui.utils.splashscreen import getMainSplashScreen
+from tomwer.synctools.darkref import QDKRFRP
+
+logging.basicConfig(level=logging.WARNING)
+_logger = logging.getLogger(__name__)
+
+
+def getinputinfo():
+    return "tomwer darkref [scanDir]"
+
+
+def _exec_without_interaction(scan, dark_method, flat_method, overwrite):
+    recons_params = DKRFRP()
+    recons_params.overwrite_dark = overwrite
+    recons_params.overwrite_ref = overwrite
+    recons_params.dark_calc_method = dark_method
+    recons_params.flat_calc_method = flat_method
+    dark_ref = DarkRefsTask(
+        inputs={
+            "data": scan,
+            "dark_ref_params": recons_params,
+            "serialize_output_data": False,
+        }
+    )
+    _logger.info(f"Start processing of {scan}")
+    dark_ref.run()
+    _logger.info(f"End processing of {scan}")
+    return 0
+
+
+def _exec_with_interaction(scan, dark_method, flat_method, overwrite):
+    class ProcessingThread(qt.QThread):
+        """
+        Thread used to run the processing
+        """
+
+        def __init__(self, inputs: dict) -> None:
+            super().__init__()
+            self._inputs = inputs
+
+        def run(self):
+            process = DarkRefsTask(inputs=self._inputs)
+            process.run()
+
+    class _DarkRefWidgetRunnable(DarkRefWidget):
+        sigScanReady = qt.Signal(str)
+
+        def __init__(self, scan, parent=None):
+            self.__scan = scan
+            self.__darkref_rp = QDKRFRP()
+            DarkRefWidget.__init__(self, parent=parent, reconsparams=self.__darkref_rp)
+            buttonExec = qt.QPushButton("execute", parent=self)
+            buttonExec.setAutoDefault(True)
+            # needed to be used as an application to return end only when the
+            # processing thread is needed
+            self._forceSync = True
+            self.layout().addWidget(buttonExec)
+            buttonExec.pressed.connect(self._process)
+            self.setWindowIcon(icons.getQIcon("tomwer"))
+            self._processingThread = None
+
+        def _notifyEnd(self, *args, **kwargs):
+            self._processingThread.finished.disconnect(self._notifyEnd)
+            print(f"computation of {self.__scan} reduced dark and flat done.")
+            self._processingThread = None
+
+        def _process(self):
+            if self._processingThread is not None:
+                print("processing already on-going...")
+            else:
+                self._processingThread = ProcessingThread(
+                    inputs={
+                        "data": self.__scan,
+                        "dark_ref_params": self.__darkref_rp,
+                        "force_sync": self._forceSync,
+                    }
+                )
+                self._processingThread.finished.connect(self._notifyEnd)
+                print(f"start reducing dark and flat of {self.__scan} ...")
+                self._processingThread.start()
+
+    def sigintHandler(*args):
+        """Handler for the SIGINT signal."""
+        qt.QApplication.quit()
+
+    global app  # QApplication must be global to avoid seg fault on quit
+    app = qt.QApplication.instance() or qt.QApplication(["tomwer"])
+
+    qt.QLocale.setDefault(qt.QLocale(qt.QLocale.English))
+    qt.QLocale.setDefault(qt.QLocale.c())
+    signal.signal(signal.SIGINT, sigintHandler)
+    sys.excepthook = qt.exceptionHandler
+
+    timer = qt.QTimer()
+    timer.start(500)
+    # Application have to wake up Python interpreter, else SIGINT is not
+    # catched
+    timer.timeout.connect(lambda: None)
+
+    splash = getMainSplashScreen()
+
+    widget = _DarkRefWidgetRunnable(scan)
+    # set up
+    widget.recons_params.overwrite_dark = overwrite
+    widget.recons_params.overwrite_flat = overwrite
+    widget.recons_params.dark_calc_method = dark_method
+    widget.recons_params.flat_calc_method = flat_method
+    splash.finish(widget)
+    widget.show()
+    return app.exec_()
+
+
+def main(argv):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "scan_path", help="Data file to show (h5 file, edf files, spec files)"
+    )
+    parser.add_argument(
+        "--entry",
+        help="an entry can be specify in case of hdf5 the master file",
+        default=None,
+    )
+    parser.add_argument(
+        "--dark-method",
+        help="Define the method to be used for computing dark",
+        default=ReduceMethod.MEAN,
+    )
+    parser.add_argument(
+        "--flat-method",
+        help="Define the method to be used for computing flat",
+        default=ReduceMethod.MEDIAN,
+    )
+    parser.add_argument(
+        "--no-gui",
+        help="Will run directly the dark and ref without any interaction",
+        dest="run",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--overwrite",
+        dest="overwrite",
+        action="store_true",
+        default=False,
+        help="Overwrite dark/flats if exists",
+    )
+    parser.add_argument(
+        "--debug",
+        dest="debug",
+        action="store_true",
+        default=False,
+        help="Set logging system in debug mode",
+    )
+
+    options = parser.parse_args(argv[1:])
+
+    if options.debug:
+        logging.root.setLevel(logging.DEBUG)
+
+    increase_max_number_file()
+
+    scan = ScanFactory.create_scan_object(options.scan_path, entry=options.entry)
+    scan.set_process_index_frm_tomwer_process_file()
+
+    dark_method = ReduceMethod.from_value(options.dark_method)
+    flat_method = ReduceMethod.from_value(options.flat_method)
+
+    if options.run:
+        exit(
+            _exec_without_interaction(
+                scan=scan,
+                dark_method=dark_method,
+                flat_method=flat_method,
+                overwrite=options.overwrite,
+            )
+        )
+    else:
+        exit(
+            _exec_with_interaction(
+                scan=scan,
+                dark_method=dark_method,
+                flat_method=flat_method,
+                overwrite=options.overwrite,
+            )
+        )
+
+
+if __name__ == "__main__":
+    main(sys.argv)

tomwer/app/saaxis.py

@@ -12,11 +12,11 @@ from silx.gui import qt
 from silx.io.utils import h5py_read_dataset
 
 from tomwer.core.process import utils as core_utils
-from tomwer.core.process.reconstruction.axis.axis import AxisProcess, NoAxisUrl
+from tomwer.core.process.reconstruction.axis.axis import AxisTask, NoAxisUrl
 from tomwer.core.process.reconstruction.darkref.darkrefs import (
     requires_reduced_dark_and_flat,
 )
-from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
+from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisTask
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.resource import increase_max_number_file
@@ -42,8 +42,14 @@ class SAAxisThread(qt.QThread):
         self._dump_roi = dump_roi
 
     def run(self) -> None:
-        process = SAAxisProcess(process_id=None, inputs={"data": self.scan})
-        process.set_configuration(self._configuration)
+        process = SAAxisTask(
+            process_id=None,
+            inputs={
+                "data": self.scan,
+                "sa_axis_params": self._configuration,
+                "serialize_output_data": False,
+            },
+        )
         process.dump_roi = self._dump_roi
         t0 = time.time()
         process.run()
@@ -51,9 +57,9 @@ class SAAxisThread(qt.QThread):
 
 
 class SAAxisWindow(_SAAxisWindow):
-    def __init__(self, parent=None, dump_roi=False):
+    def __init__(self, parent=None, dump_roi=False, backend=None):
         self._scan = None
-        super().__init__(parent)
+        super().__init__(parent, backend=backend)
         # thread for computing cors
         self._processingThread = SAAxisThread()
         self._processingThread.finished.connect(self._threadedProcessEnded)
@@ -120,10 +126,11 @@ class SAAxisWindow(_SAAxisWindow):
         scan = self.getScan()
         if scan is None:
             return
-        _cor_estimation_process = AxisProcess(
+        _cor_estimation_process = AxisTask(
             inputs={
                 "axis_params": self.getQAxisRP(),
                 "data": scan,
+                "serialize_output_data": False,
             }
         )
 
@@ -187,6 +194,13 @@ def main(argv):
         default=False,
         help="Save roi where the score is computed on the .hdf5",
     )
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
+
     options = parser.parse_args(argv[1:])
 
     if options.debug:
@@ -219,6 +233,11 @@ def main(argv):
     )
     requires_reduced_dark_and_flat(scan=scan, logger_=_logger)
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     window = SAAxisWindow(dump_roi=options.dump_roi)
     window.setWindowTitle("saaxis")
     window.setWindowIcon(icons.getQIcon("tomwer"))
@@ -261,7 +280,7 @@ def _load_latest_scores(scan) -> tuple:
         return scores, selected
 
     with EntryReader(scan.process_file_url) as h5f:
-        latest_saaxis_node = Task.get_most_recent_process(h5f, SAAxisProcess)
+        latest_saaxis_node = Task.get_most_recent_process(h5f, SAAxisTask)
         if latest_saaxis_node and "results" in latest_saaxis_node:
             scores = core_utils.get_scores(latest_saaxis_node)
             if "center_of_rotation" in latest_saaxis_node["results"]:

tomwer/app/sadeltabeta.py

@@ -12,12 +12,12 @@ from silx.gui import qt
 from silx.io.utils import h5py_read_dataset
 
 from tomwer.core.process import utils as core_utils
-from tomwer.core.process.reconstruction.axis.axis import AxisProcess, NoAxisUrl
+from tomwer.core.process.reconstruction.axis.axis import AxisTask, NoAxisUrl
 from tomwer.core.process.reconstruction.darkref.darkrefs import (
     requires_reduced_dark_and_flat,
 )
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
-    SADeltaBetaProcess,
+    SADeltaBetaTask,
 )
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanfactory import ScanFactory
@@ -47,7 +47,13 @@ class SADeltaBetaThread(qt.QThread):
         self._dump_roi = dump_roi
 
     def run(self) -> None:
-        process = SADeltaBetaProcess(process_id=None, inputs={"scan": self.scan})
+        process = SADeltaBetaTask(
+            process_id=None,
+            inputs={
+                "scan": self.scan,
+                "serialize_output_data": False,
+            },
+        )
         process.set_configuration(self._configuration)
         process.dump_roi = self._dump_roi
         t0 = time.time()
@@ -56,9 +62,9 @@ class SADeltaBetaThread(qt.QThread):
 
 
 class SADeltaBetaWindow(_SADeltaBetaWindow):
-    def __init__(self, parent=None, dump_roi=False):
+    def __init__(self, parent=None, dump_roi=False, backend=None):
         self._scan = None
-        super().__init__(parent)
+        super().__init__(parent, backend=backend)
         self._insert_cor_gui()
         # thread for computing cors
         self._processingThread = SADeltaBetaThread()
@@ -198,8 +204,12 @@ class SADeltaBetaWindow(_SADeltaBetaWindow):
         scan = self.getScan()
         if scan is None:
             return
-        _cor_estimation_process = AxisProcess(
-            inputs={"data": scan, "axis_params": self._qaxis_rp}
+        _cor_estimation_process = AxisTask(
+            inputs={
+                "data": scan,
+                "axis_params": self._qaxis_rp,
+                "serialize_output_data": False,
+            }
         )
 
         _logger.info(f"{scan} - start cor estimation for")
@@ -261,11 +271,22 @@ def main(argv):
         default=False,
         help="Save roi where the score is computed on the .hdf5",
     )
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
     options = parser.parse_args(argv[1:])
 
     if options.debug:
         logging.root.setLevel(logging.DEBUG)
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     increase_max_number_file()
     scan = ScanFactory.create_scan_object(
         scan_path=options.scan_path, entry=options.entry
@@ -334,7 +355,7 @@ def _load_latest_scores(scan) -> tuple:
         return scores, selected
 
     with EntryReader(scan.process_file_url) as h5f:
-        latest_sa_db_node = Task.get_most_recent_process(h5f, SADeltaBetaProcess)
+        latest_sa_db_node = Task.get_most_recent_process(h5f, SADeltaBetaTask)
         if latest_sa_db_node and "results" in latest_sa_db_node:
             scores = core_utils.get_scores(latest_sa_db_node)
             if "delta_beta" in latest_sa_db_node["results"]:

tomwer/app/samplemoved.py

@@ -45,8 +45,19 @@ def main(argv):
         help="For Nexus files: entry in the master file",
         default=None,
     )
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
     options = parser.parse_args(argv[1:])
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     increase_max_number_file()
 
     global app  # QApplication must be global to avoid seg fault on quit

tomwer/app/scanviewer.py

@@ -32,12 +32,24 @@ def main(argv):
         default=None,
         nargs="?",
     )
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
 
     options = parser.parse_args(argv[1:])
 
     scan = ScanFactory.create_scan_object(
         scan_path=options.scan_path, entry=options.entry
     )
+
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     increase_max_number_file()
 
     global app  # QApplication must be global to avoid seg fault on quit

tomwer/app/sinogramviewer.py

@@ -62,9 +62,20 @@ def main(argv):
         help="You can define a subsampling to generate the sinogram in order"
         "to speed up creation",
     )
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
 
     options = parser.parse_args(argv[1:])
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     scan = ScanFactory.create_scan_object(options.scan_path, entry=options.entry)
     increase_max_number_file()
 

tomwer/app/slicestack.py

@@ -40,6 +40,12 @@ def main(argv):
     parser.add_argument(
         "root_dir", help="Root dir to browse and to extract all slices files under it."
     )
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
     parser.add_argument(
         "--debug",
         dest="debug",
@@ -50,6 +56,11 @@ def main(argv):
 
     options = parser.parse_args(argv[1:])
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     increase_max_number_file()
 
     global app  # QApplication must be global to avoid seg fault on quit

tomwer/app/zstitching.py

@@ -107,6 +107,7 @@ class _StitcherThread(qt.QThread):
                 "stitching_config": self._stitching_config,
                 "cluster_config": self._cluster_config,
                 "progress": Progress("stitching"),
+                "serialize_output_data": False,
             },
         )
 
@@ -220,9 +221,20 @@ def main(argv):
         default=None,
         help="Provide stitching configuration file to load parameters from it",
     )
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
 
     options = parser.parse_args(argv[1:])
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     if options.debug:
         logging.root.setLevel(logging.DEBUG)
 

tomwer/core/futureobject.py

@@ -32,7 +32,7 @@ import datetime
 import logging
 from typing import Iterable, Optional, Union
 
-from sluurp.job import get_job_status
+from sluurp.job import get_job_status, cancel_slurm_job
 
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.tomwer_object import TomwerObject
@@ -180,4 +180,6 @@ class FutureTomwerObject:
 
     def cancel(self):
         for future in self.futures:
-            future.cancel()
+            if hasattr(future, "job_id"):
+                print("cancel ", future.job_id)
+                cancel_slurm_job(future.job_id)

tomwer/core/process/conditions/filters.py

@@ -41,6 +41,8 @@ from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 
+from silx.utils.deprecation import deprecated_warning
+
 _logger = logging.getLogger(__name__)
 
 
@@ -130,10 +132,16 @@ class UnixFileNamePatternFilter(_PatternBaseFilter):
         return not match
 
 
-class FileNameFilter(
-    _PatternBaseFilter, Task, input_names=("data",), output_names=("data",)
+class FileNameFilterTask(
+    _PatternBaseFilter,
+    Task,
+    input_names=("data", "pattern"),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data",),
 ):
-    """Filter than can call several filter type"""
+    """
+    Task to filter a scan according to his name and a 'unix file name pattern' or a 'regular expression'
+    """
 
     UNIX_PATTERN_FILTER = "unix file name pattern"
 
@@ -195,7 +203,7 @@ class FileNameFilter(
         assert isinstance(scan, TomwerScanBase)
 
         if not self.isFiltered(os.path.basename(scan.path)):
-            if self._return_dict:
+            if self.get_input_value("serialize_output_data", True):
                 self.outputs.data = scan.to_dict()
             else:
                 self.outputs.data = scan
@@ -215,3 +223,17 @@ class FileNameFilter(
     def definition():
         """definition of the process"""
         return "filter a scan according to his name"
+
+
+class FileNameFilter(FileNameFilterTask):
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.conditions.filters.FileNameFilter",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="FileNameFilterTask",
+        )
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)

tomwer/core/process/control/datadiscovery.py

@@ -3,5 +3,9 @@ from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 
 class _DataDiscoveryPlaceHolder(EwoksTask, input_names=["data"], output_names=["data"]):
+    """
+    Task to recursivly search under a root folder for any scan / data.
+    """
+
     def run(self):
         self.outputs.data = data_identifier_to_scan(self.inputs.data)

tomwer/core/process/control/datawatcher/datawatcher.py

@@ -103,6 +103,10 @@ class _DataWatcher(BaseProcessInfo):
         self._setCurrentStatus("not processing")
         self._launchObservation()
         self._checkThread = None
+        self._serialize_output_data = False
+
+    def set_serialize_output_data(self, serialize: bool):
+        self._serialize_output_data = serialize
 
     def _launchObservation(self):
         """Main function of the widget"""
@@ -434,7 +438,7 @@ class DataWatcher(_DataWatcher):
     def _signalScanReady(self, scan):
         assert isinstance(scan, TomwerScanBase)
         super()._signalScanReady(scan)
-        if self._return_dict:
+        if self._serialize_output_data:
             value = scan.to_dict()
         else:
             value = scan