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

tomwer/app/darkref.py

@@ -1,181 +1,10 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import argparse
-import logging
-import signal
-import sys
-
-from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefs
-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
-
-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 = DarkRefs(
-        inputs={
-            "data": scan,
-            "dark_ref_params": recons_params,
-        }
-    )
-    _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):
-    from silx.gui import qt
-
-    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
-
-    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"))
-
-        def _process(self):
-            process = DarkRefs(
-                inputs={
-                    "data": self.__scan,
-                    "dark_ref_params": self.__darkref_rp,
-                    "force_sync": self._forceSync,
-                }
-            )
-            process.run()
-
-    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)
+from silx.utils.deprecation import deprecated_warning
+
+deprecated_warning(
+    "module",
+    name="tomwer.app.darkref",
+    reason="Has been moved",
+    replacement="tomwer.app.reducedarkflat",
+    only_once=True,
+)
+from tomwer.app.reducedarkflat import *  # noqa F401

tomwer/app/darkrefpatch.py

@@ -1,131 +1,10 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import argparse
-import logging
-import signal
-import sys
-
-from nxtomomill.utils import add_dark_flat_nx_file
-from silx.gui import qt
-
-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.edit.dkrfpatch import DarkRefPatchWidget
-from tomwer.gui.utils.splashscreen import getMainSplashScreen
-
-logging.basicConfig(level=logging.WARNING)
-_logger = logging.getLogger(__name__)
-
-
-class _DarkRefPatchDialog(qt.QDialog):
-    def __init__(self, parent):
-        qt.QDialog.__init__(self, parent)
-        self._scan = None
-        self.setLayout(qt.QVBoxLayout())
-        self._mainWidget = DarkRefPatchWidget(self)
-        self.layout().addWidget(self._mainWidget)
-
-        # buttons
-        types = qt.QDialogButtonBox.Ok
-        self._buttons = qt.QDialogButtonBox(parent=self)
-        self._buttons.setStandardButtons(types)
-        self._buttons.button(qt.QDialogButtonBox.Ok).setText("Apply")
-        self.layout().addWidget(self._buttons)
-
-        # connect signal slot
-        self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(self._apply)
-
-    def _apply(self):
-        if self._scan is None:
-            raise ValueError("Scan should be set before applying patch")
-        url_sd = self._mainWidget.getStartDarkUrl()
-        url_sf = self._mainWidget.getStartFlatUrl()
-        url_ed = self._mainWidget.getEndDarkUrl()
-        url_ef = self._mainWidget.getEndFlatUrl()
-        add_dark_flat_nx_file(
-            file_path=self._scan.master_file,
-            entry=self._scan.entry,
-            darks_start=url_sd,
-            flats_start=url_sf,
-            darks_end=url_ed,
-            flats_end=url_ef,
-        )
-
-    def setScan(self, scan):
-        self._scan = scan
-
-
-def main(argv):
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "scan_path",
-        help="HDF5 - Nexus file path",
-        default=None,
-    )
-    parser.add_argument("entry", help="NXTomo entry to load", default=None)
-    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()
-
-    global app  # QApplication must be global to avoid seg fault on quit
-    app = qt.QApplication.instance() or qt.QApplication(["tomwer"])
-    splash = getMainSplashScreen()
-    qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
-    qt.QApplication.processEvents()
-
-    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
-    # catch
-    timer.timeout.connect(lambda: None)
-
-    scan = ScanFactory.create_scan_object(
-        scan_path=options.scan_path, entry=options.entry
-    )
-
-    # define the process_index is any tomwer_processes_existing
-    scan.set_process_index_frm_tomwer_process_file()
-
-    if options.debug:
-        _logger.setLevel(logging.DEBUG)
-
-    window = _DarkRefPatchDialog(parent=None)
-    window.setScan(scan=scan)
-    window.setWindowTitle("patch dark & flat")
-    window.setWindowIcon(icons.getQIcon("tomwer"))
-
-    splash.finish(window)
-    window.show()
-    qt.QApplication.restoreOverrideCursor()
-    app.exec_()
-
-
-def getinputinfo():
-    return "tomwer darkref-patch [scanDir]"
-
-
-def sigintHandler(*args):
-    """Handler for the SIGINT signal."""
-    qt.QApplication.quit()
-
-
-if __name__ == "__main__":
-    main(sys.argv)
+from silx.utils.deprecation import deprecated_warning
+
+deprecated_warning(
+    "module",
+    name="tomwer.app.darkrefpatch",
+    reason="Has been moved",
+    replacement="tomwer.app.patchrawdarkflat",
+    only_once=True,
+)
+from tomwer.app.patchrawdarkflat import *  # noqa F401

tomwer/app/diffframe.py

@@ -40,6 +40,12 @@ def main(argv):
     )
     parser.add_argument("--second-scan", default=None, help="Second data files")
     parser.add_argument("--second-entry", default=None, help="Second entry")
+    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:])
     options.scan_path = options.scan_path.rstrip(os.path.sep)
 
@@ -75,6 +81,11 @@ def main(argv):
     else:
         scan_2 = None
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     # handle gui
     widget = DiffFrameViewer(parent=None)
     widget.addScan(scan_1)

tomwer/app/imagekeyeditor.py

@@ -6,12 +6,11 @@ import logging
 import signal
 import sys
 
-from nxtomomill.utils import change_image_key_control
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
 
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.utils.resource import increase_max_number_file
+from tomwer.core.process.edit.imagekeyeditor import ImageKeyEditorTask
 from tomwer.gui import icons
 from tomwer.gui.edit.imagekeyeditor import ImageKeyDialog as _ImageKeyDialog
 from tomwer.gui.utils.splashscreen import getMainSplashScreen
@@ -35,24 +34,18 @@ class ImageKeyDialog(_ImageKeyDialog):
         if not self._scan:
             raise ValueError("Scan should be set first")
 
-        modifications = self.getModifications()
-        image_keys_set = set(self.getModifications().values())
-        image_keys_set = set(
-            [ImageKey.from_value(image_key) for image_key in image_keys_set]
+        task = ImageKeyEditorTask(
+            inputs={
+                "data": self._scan,
+                "configuration": {"modifications": self.getModifications()},
+            }
         )
-        for image_key_type in image_keys_set:
-            frame_indexes_dict = dict(
-                filter(lambda item: item[1] is image_key_type, modifications.items())
-            )
-            frame_indexes = tuple(frame_indexes_dict.keys())
-            _logger.warning(f"will modify {frame_indexes} to {image_key_type}")
-            change_image_key_control(
-                file_path=self._scan.master_file,
-                entry=self._scan.entry,
-                frames_indexes=frame_indexes,
-                image_key_control_value=image_key_type.value,
-                logger=_logger,
-            )
+        try:
+            task.run()
+        except Exception as e:
+            _logger.error(e)
+        else:
+            print("edition succeed")
 
 
 def getinputinfo():

tomwer/app/intensitynormalization.py

@@ -51,6 +51,7 @@ class IntensityNormalizationThread(qt.QThread):
             inputs={
                 "data": self.scan,
                 "configuration": self._configuration,
+                "serialize_output_data": False,
             },
             varinfo=None,
         )

tomwer/app/lamino.py

@@ -9,7 +9,7 @@ import sys
 
 from silx.gui import qt
 
-from tomwer.core.process.reconstruction.lamino.tofu import LaminoReconstruction
+from tomwer.core.process.reconstruction.lamino.tofu import LaminoReconstructionTask
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.resource import increase_max_number_file
@@ -115,7 +115,12 @@ class ToFuDialog(qt.QDialog):
         self.tofuWidget.setEnabled(False)
         qt.QApplication.processEvents()
         qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
-        self._reconsProcess = LaminoReconstruction(inputs={"scan": self._scan})
+        self._reconsProcess = LaminoReconstructionTask(
+            inputs={
+                "scan": self._scan,
+                "serialize_output_data": False,
+            }
+        )
         self._reconsProcess.set_configuration(
             (preprocess_add_options, reco_add_options)
         )

tomwer/app/patchrawdarkflat.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import argparse
+import logging
+import signal
+import sys
+
+from nxtomomill.utils import add_dark_flat_nx_file
+from silx.gui import qt
+
+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.edit.dkrfpatch import DarkRefPatchWidget
+from tomwer.gui.utils.splashscreen import getMainSplashScreen
+
+logging.basicConfig(level=logging.WARNING)
+_logger = logging.getLogger(__name__)
+
+
+class _DarkRefPatchDialog(qt.QDialog):
+    def __init__(self, parent):
+        qt.QDialog.__init__(self, parent)
+        self._scan = None
+        self.setLayout(qt.QVBoxLayout())
+        self._mainWidget = DarkRefPatchWidget(self)
+        self.layout().addWidget(self._mainWidget)
+
+        # buttons
+        types = qt.QDialogButtonBox.Ok
+        self._buttons = qt.QDialogButtonBox(parent=self)
+        self._buttons.setStandardButtons(types)
+        self._buttons.button(qt.QDialogButtonBox.Ok).setText("Apply")
+        self.layout().addWidget(self._buttons)
+
+        # connect signal slot
+        self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(self._apply)
+
+    def _apply(self):
+        if self._scan is None:
+            raise ValueError("Scan should be set before applying patch")
+        url_sd = self._mainWidget.getStartDarkUrl()
+        url_sf = self._mainWidget.getStartFlatUrl()
+        url_ed = self._mainWidget.getEndDarkUrl()
+        url_ef = self._mainWidget.getEndFlatUrl()
+        add_dark_flat_nx_file(
+            file_path=self._scan.master_file,
+            entry=self._scan.entry,
+            darks_start=url_sd,
+            flats_start=url_sf,
+            darks_end=url_ed,
+            flats_end=url_ef,
+        )
+
+    def setScan(self, scan):
+        self._scan = scan
+
+
+def main(argv):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "scan_path",
+        help="HDF5 - Nexus file path",
+        default=None,
+    )
+    parser.add_argument("entry", help="NXTomo entry to load", default=None)
+    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()
+
+    global app  # QApplication must be global to avoid seg fault on quit
+    app = qt.QApplication.instance() or qt.QApplication(["tomwer"])
+    splash = getMainSplashScreen()
+    qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
+    qt.QApplication.processEvents()
+
+    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
+    # catch
+    timer.timeout.connect(lambda: None)
+
+    scan = ScanFactory.create_scan_object(
+        scan_path=options.scan_path, entry=options.entry
+    )
+
+    # define the process_index is any tomwer_processes_existing
+    scan.set_process_index_frm_tomwer_process_file()
+
+    if options.debug:
+        _logger.setLevel(logging.DEBUG)
+
+    window = _DarkRefPatchDialog(parent=None)
+    window.setScan(scan=scan)
+    window.setWindowTitle("patch dark & flat")
+    window.setWindowIcon(icons.getQIcon("tomwer"))
+
+    splash.finish(window)
+    window.show()
+    qt.QApplication.restoreOverrideCursor()
+    app.exec_()
+
+
+def getinputinfo():
+    return "tomwer darkref-patch [scanDir]"
+
+
+def sigintHandler(*args):
+    """Handler for the SIGINT signal."""
+    qt.QApplication.quit()
+
+
+if __name__ == "__main__":
+    main(sys.argv)

tomwer/app/radiostack.py

@@ -43,6 +43,12 @@ def main(argv):
     parser.add_argument(
         "root_dir", help="Root dir to browse and to extract all radio 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",
@@ -54,6 +60,10 @@ def main(argv):
     increase_max_number_file()
 
     options = parser.parse_args(argv[1:])
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
 
     global app  # QApplication must be global to avoid seg fault on quit
     app = qt.QApplication.instance() or qt.QApplication(["tomwer"])