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

tomwer/gui/visualization/reconstructionparameters.py

@@ -28,10 +28,13 @@ __license__ = "MIT"
 __date__ = "31/03/2021"
 
 
+import logging
 from typing import Optional
 from silx.gui import qt
 from tomwer.core.utils.char import BETA_CHAR, DELTA_CHAR
 
+_logger = logging.getLogger(__name__)
+
 
 class ReconstructionParameters(qt.QWidget):
     """
@@ -114,7 +117,10 @@ class ReconstructionParameters(qt.QWidget):
             self._setSinoNormalization,
             self._setSoftwareVersion,
         ):
-            func(metadata)
+            try:
+                func(metadata)
+            except Exception as e:
+                _logger.warning(f"Fail update when call {func}. Error is", e)
 
     def _setMethod(self, metadata: dict):
         method = (
@@ -140,8 +146,10 @@ class ReconstructionParameters(qt.QWidget):
             metadata.get("processing_options", {})
             .get("phase", {})
             .get("distance_cm", None)
+        ) or metadata.get("processing_options", {}).get("reconstruction", {}).get(
+            "sample_detector_dist", None
         )
-        if distance_cm not in (None, ""):
+        if distance_cm not in (None, "", "None"):
             distance_cm = float(distance_cm)
             distance_cm = f"{distance_cm:.2}"
         else:
@@ -151,12 +159,24 @@ class ReconstructionParameters(qt.QWidget):
     def _setPixelSize(self, metadata: dict):
         # voxel size can be stored as pixel size (old version) or voxel size (new version)
         recons_params = metadata.get("processing_options", {}).get("reconstruction", {})
-        voxel_size_cm = recons_params.get("voxel_size_cm", None) or recons_params.get(
-            "pixel_size_cm", None
-        )
+        voxel_size_cm = recons_params.get("voxel_size_cm", None)
+
+        # now voxel size is expected to be a tuple of three elements
+        if voxel_size_cm is not None:
+            voxel_size_cm = voxel_size_cm[0]
+            # FIXME: load_ini seems to fail to remove some char like '(' or ')'... to be fixed or investigate
+            # simplest might be to filter those when dumping it to text file... ??? or to handle those at silx level
+            if isinstance(voxel_size_cm, str):
+                for char_to_ignore in (" ", "(", ")", "[", "]"):
+                    voxel_size_cm = voxel_size_cm.replace(char_to_ignore, "")
+        else:
+            # backward compatibility with old volume
+            voxel_size_cm = recons_params.get("pixel_size_cm", None)
         if voxel_size_cm is not None:
             voxel_size_cm = f"{float(voxel_size_cm):.8}"
-        self._pixelSizeQLE.setText(voxel_size_cm if voxel_size_cm is not None else "")
+        self._pixelSizeQLE.setText(
+            str(voxel_size_cm) if voxel_size_cm is not None else ""
+        )
 
     def _setCor(self, metadata: dict):
         cor = (

tomwer/gui/visualization/sinogramviewer.py

@@ -59,7 +59,13 @@ class SinogramViewer(qt.QMainWindow):
     sigSinoLoadEnded = qt.Signal()
     """Signal emitted when a computation is ended"""
 
-    def __init__(self, parent=None, scan=None, opts_orientation=qt.Qt.Vertical):
+    def __init__(
+        self,
+        parent=None,
+        scan=None,
+        opts_orientation=qt.Qt.Vertical,
+        backend=None,
+    ):
         qt.QMainWindow.__init__(self, parent)
         self._scan = None
         self._sinoInfoCache = None

tomwer/gui/visualization/test/test_reconstruction_parameters.py

@@ -53,14 +53,12 @@ def test_ReconstructionParameters(qtapp, phase_method):  # noqa F401
                 },
             },
             "processing_options": {
-                "phase": {
-                    "distance_cm": 0.4,
-                },
                 "reconstruction": {
-                    "voxel_size_cm": 0.2,
+                    "voxel_size_cm": (0.2, 0.2, 0.2),
                     "rotation_axis_position": 104,
                     "enable_halftomo": True,
                     "fbp_filter_type": "Hilbert",
+                    "sample_detector_dist": 0.4,
                 },
                 "take_log": {
                     "log_min_clip": 1.0,

tomwer/gui/visualization/volumeviewer.py

@@ -357,6 +357,8 @@ class VolumeViewer(qt.QMainWindow):
                 self._set_volume(data)
             # set reconstruction parameters
             try:
+                # warning: limitation expected for .vol as it gets two configuration file. The default one is vol.info and does not contains
+                # any of the metadata 'distance', 'pixel size'... but it is here for backward compatiblity
                 self._reconsWidget.setVolumeMetadata(
                     volume.metadata or volume.load_metadata()
                 )

tomwer/resources/__init__.py

@@ -24,17 +24,17 @@
 # ###########################################################################*/
 
 
-import importlib
+from __future__ import annotations
 import os
 import sys
+import contextlib
+import atexit
+from typing import NamedTuple, Optional
+import importlib
+import functools
 
-# pkg_resources is useful when this package is stored in a zip
-# When pkg_resources is not available, the resources dir defaults to the
-# directory containing this module.
-try:
+if sys.version_info < (3, 9):
     import pkg_resources
-except ImportError:
-    pkg_resources = None
 
 # For packaging purpose, patch this variable to use an alternative directory
 # E.g., replace with _RESOURCES_DIR = '/usr/share/silx/data'
@@ -56,25 +56,20 @@ if getattr(sys, "frozen", False):
         _RESOURCES_DIR = _dir
 
 
-class _ResourceDirectory(object):
+# Manage resource files life-cycle
+_file_manager = contextlib.ExitStack()
+atexit.register(_file_manager.close)
+
+
+class _ResourceDirectory(NamedTuple):
     """Store a source of resources"""
 
-    def __init__(self, package_name, package_path=None, forced_path=None):
-        if forced_path is None:
-            if package_path is None:
-                if pkg_resources is None:
-                    # In this case we have to compute the package path
-                    # Else it will not be used
-                    module = importlib.import_module(package_name)
-                    package_path = os.path.abspath(os.path.dirname(module.__file__))
-        self.package_name = package_name
-        self.package_path = package_path
-        self.forced_path = forced_path
+    package_name: str
+    forced_path: Optional[str] = None
 
 
 _TOMWER_DIRECTORY = _ResourceDirectory(
     package_name=__name__,
-    package_path=os.path.abspath(os.path.dirname(__file__)),
     forced_path=_RESOURCES_DIR,
 )
 
@@ -100,45 +95,62 @@ def _get_package_and_resource(resource, default_directory=None):
     else:
         prefix = "tomwer"
         if default_directory is not None:
-            resource = os.path.join(default_directory, resource)
+            resource = f"{default_directory}/{resource}"
     if prefix not in _RESOURCE_DIRECTORIES:
         raise ValueError("Resource '%s' uses an unregistred prefix", resource)
     resource_directory = _RESOURCE_DIRECTORIES[prefix]
     return resource_directory, resource
 
 
-def _resource_filename(resource, default_directory=None):
+# Manage resource files life-cycle
+_file_manager = contextlib.ExitStack()
+atexit.register(_file_manager.close)
+
+
+@functools.lru_cache(maxsize=None)
+def _get_resource_filename(package: str, resource: str) -> str:
+    """Returns path to requested resource in package
+
+    :param package: Name of the package in which to look for the resource
+    :param resource: Resource path relative to package using '/' path separator
+    :return: Abolute resource path in the file system
+    """
+    if sys.version_info < (3, 9):
+        return pkg_resources.resource_filename(package, resource)
+
+    # Caching prevents extracting the resource twice
+    file_context = importlib.resources.as_file(
+        importlib.resources.files(package) / resource
+    )
+    path = _file_manager.enter_context(file_context)
+    return str(path.absolute())
+
+
+def _resource_filename(resource: str, default_directory: Optional[str] = None) -> str:
     """Return filename corresponding to resource.
 
-     The existence of the resource is not checked.
+    The existence of the resource is not checked.
 
-     The resource name can be prefixed by the name of a resource directory. For
+    The resource name can be prefixed by the name of a resource directory. For
     example "silx:foo.png" identify the resource "foo.png" from the resource
-     directory "silx". See also :func:`register_resource_directory`.
-
-     :param str resource: Resource path relative to resource directory
-                         using '/' path separator. It can be either a file or
-                          a directory.
-     :param str default_directory: If the resource is not prefixed, the resource
-         will be searched on this default directory of the silx resource
-         directory. It should only be used internally by silx.
-     :return: Absolute resource path in the file system
-     :rtype: str
+    directory "silx". See also :func:`register_resource_directory`.
+
+    :param resource: Resource path relative to resource directory
+                     using '/' path separator. It can be either a file or
+                     a directory.
+    :param default_directory: If the resource is not prefixed, the resource
+        will be searched on this default directory of the silx resource
+        directory. It should only be used internally by silx.
+    :return: Absolute resource path in the file system
     """
     resource_directory, resource_name = _get_package_and_resource(
         resource, default_directory=default_directory
     )
+
     if resource_directory.forced_path is not None:
         # if set, use this directory
         base_dir = resource_directory.forced_path
         resource_path = os.path.join(base_dir, *resource_name.split("/"))
         return resource_path
-    elif pkg_resources is None:
-        # Fallback if pkg_resources is not available
-        base_dir = resource_directory.package_path
-        resource_path = os.path.join(base_dir, *resource_name.split("/"))
-        return resource_path
-    else:
-        # Preferred way to get resources as it supports zipfile package
-        package_name = resource_directory.package_name
-        return pkg_resources.resource_filename(package_name, resource_name)
+
+    return _get_resource_filename(resource_directory.package_name, resource_name)

tomwer/resources/gui/icons/compose.svg

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="48"
+   height="48"
+   viewBox="0 0 12.7 12.7"
+   version="1.1"
+   id="svg286"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   sodipodi:docname="compose.svg"
+   inkscape:export-filename="compose.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview288"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     showgrid="false"
+     inkscape:zoom="4.7572176"
+     inkscape:cx="23.858484"
+     inkscape:cy="53.182348"
+     inkscape:window-width="1920"
+     inkscape:window-height="1131"
+     inkscape:window-x="0"
+     inkscape:window-y="32"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="g872" />
+  <defs
+     id="defs283" />
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <g
+       id="g872"
+       transform="matrix(2.7603153,0,0,2.1174268,-0.61582227,-584.86385)">
+      <g
+         id="g877"
+         transform="matrix(0.69394884,-0.91617956,0.56586616,0.69394884,-154.75708,81.317197)"
+         inkscape:transform-center-x="6.3041843"
+         inkscape:transform-center-y="-5.6562159"
+         style="fill:none">
+        <rect
+           style="fill:none;fill-opacity:1;stroke:#000000;stroke-width:0.233763;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:stroke fill markers"
+           id="rect825"
+           width="3.7308216"
+           height="0.62381279"
+           x="-4.3877668"
+           y="281.05283" />
+        <path
+           style="fill:none;stroke:#000000;stroke-width:0.168986;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           d="m -4.3877668,281.67664 c -0.2793163,0.009 -0.5577288,-0.0435 -0.8324456,-0.35142 0.2750181,-0.18258 0.5523208,-0.28005 0.8324456,-0.27239"
+           id="path827"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccc" />
+        <path
+           style="fill:none;stroke:#000000;stroke-width:0.2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           d="m -1.110839,281.0557 0.00835,0.60971"
+           id="path848"
+           inkscape:connector-curvature="0" />
+      </g>
+    </g>
+  </g>
+</svg>

tomwer/synctools/datatransfert.py

@@ -30,7 +30,9 @@ __date__ = "28/01/2019"
 
 from silx.gui import qt
 
-from tomwer.core.process.control.scantransfer import ScanTransfer as FolderTransfertP
+from tomwer.core.process.control.scantransfer import (
+    ScanTransferTask as FolderTransfertP,
+)
 from tomwer.core.scan.scanbase import TomwerScanBase
 
 

tomwer/synctools/stacks/edit/darkflatpatch.py

@@ -109,12 +109,18 @@ class _DarkFlatPatchProcessingThread(ProcessingThread, SuperviseProcess):
         self._configuration = configuration
 
     def run(self):
+        # TODO: must be replace by calling the 'DarkFlatPatch' task directly
         self.sigComputationStarted.emit()
         _logger.processStarted(f"{self._scan} Start dark-flat patch")
+        process = darkflatpatch.DarkFlatPatchTask(
+            inputs={
+                "data": self._scan,
+                "configuration": self._configuration,
+                "serialize_output_data": False,
+            }
+        )
         try:
-            darkflatpatch.apply_dark_flat_patch(
-                config=self._configuration, scan=self._scan
-            )
+            process.run()
         except Exception as e:
             info = f"Fail to patch dark-flat for {self._scan}. Reason is {e}"
             _logger.processFailed(info)
@@ -124,36 +130,35 @@ class _DarkFlatPatchProcessingThread(ProcessingThread, SuperviseProcess):
                 state=DatasetState.FAILED,
                 details=info,
             )
+            return
+
+        index = self._scan.pop_process_index()
+        if isinstance(self._scan, EDFTomoScan):
+            entry = None
         else:
-            index = self._scan.pop_process_index()
-            if isinstance(self._scan, EDFTomoScan):
-                entry = None
-            else:
-                entry = self._scan.entry
-            configuration_to_dump = self._configuration
-            keys = list(configuration_to_dump.keys())
-            for key in keys:
-                if isinstance(configuration_to_dump[key], DataUrl):
-                    configuration_to_dump[key] = configuration_to_dump[key].path()
-            try:
-                darkflatpatch.DarkFlatPatch._register_process(
-                    process_file=self._scan.process_file,
-                    entry=entry,
-                    configuration=configuration_to_dump,
-                    results={},
-                    process=darkflatpatch.DarkFlatPatch,
-                    process_index=index,
-                    overwrite=True,
-                )
-            except Exception as e:
-                _logger.warning(
-                    f"Fail to register DarkFlatPatch process. Reason is {e}"
-                )
-            info = f"Dark-flat patched for {self._scan}."
-            _logger.processSucceed(info)
-            ProcessManager().notify_dataset_state(
-                dataset=self._scan,
-                process=self,
-                state=DatasetState.SUCCEED,
-                details=info,
+            entry = self._scan.entry
+        configuration_to_dump = self._configuration
+        keys = list(configuration_to_dump.keys())
+        for key in keys:
+            if isinstance(configuration_to_dump[key], DataUrl):
+                configuration_to_dump[key] = configuration_to_dump[key].path()
+        try:
+            darkflatpatch.DarkFlatPatchTask._register_process(
+                process_file=self._scan.process_file,
+                entry=entry,
+                configuration=configuration_to_dump,
+                results={},
+                process=darkflatpatch.DarkFlatPatchTask,
+                process_index=index,
+                overwrite=True,
             )
+        except Exception as e:
+            _logger.warning(f"Fail to register DarkFlatPatch process. Reason is {e}")
+        info = f"Dark-flat patched for {self._scan}."
+        _logger.processSucceed(info)
+        ProcessManager().notify_dataset_state(
+            dataset=self._scan,
+            process=self,
+            state=DatasetState.SUCCEED,
+            details=info,
+        )

tomwer/synctools/stacks/edit/imagekeyeditor.py

@@ -32,7 +32,6 @@ import logging
 from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
 
 from tomwer.core.process.edit import imagekeyeditor
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -107,10 +106,15 @@ class _ImageKeyEditorProcessingThread(ProcessingThread, SuperviseProcess):
     def run(self):
         self.sigComputationStarted.emit()
         _logger.processStarted(f"Start image key edition of {self._scan}")
+        task = imagekeyeditor.ImageKeyEditorTask(
+            inputs={
+                "data": self._scan,
+                "serialize_output_data": False,
+                "configuration": self._configuration,
+            },
+        )
         try:
-            imagekeyeditor.change_image_key_control(
-                config=self._configuration, scan=self._scan
-            )
+            task.run()
         except Exception as e:
             info = f"Fail to edit image keys for {self._scan}. Reason is {e}"
             _logger.processFailed(info)
@@ -121,29 +125,6 @@ class _ImageKeyEditorProcessingThread(ProcessingThread, SuperviseProcess):
                 details=info,
             )
         else:
-            conf_to_dump = {}
-            if "modifications" in self._configuration:
-                for frame_index, new_frame_type in self._configuration[
-                    "modifications"
-                ].items():
-                    conf_to_dump[str(frame_index)] = ImageKey.from_value(
-                        new_frame_type
-                    ).value
-            index = self._scan.pop_process_index()
-            try:
-                imagekeyeditor.ImageKeyEditor._register_process(
-                    process_file=self._scan.process_file,
-                    entry=self._scan.entry,
-                    configuration=conf_to_dump,
-                    results={},
-                    process=imagekeyeditor.ImageKeyEditor,
-                    process_index=index,
-                    overwrite=True,
-                )
-            except Exception as e:
-                _logger.warning(
-                    f"Fail to register ImageKeyEditor process. Reason is {e}"
-                )
             info = f"Image key edited for {self._scan.get_identifier()}."
             _logger.processSucceed(info)
             ProcessManager().notify_dataset_state(

tomwer/synctools/stacks/processingstack.py

@@ -28,7 +28,10 @@ __license__ = "MIT"
 __date__ = "08/01/2020"
 
 
-from queue import Queue
+from collections import deque
+from typing import Optional
+from tomwer.core.tomwer_object import TomwerObject
+from silx.gui.utils import blockSignals
 
 from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
@@ -42,7 +45,7 @@ class ProcessingThread(qt.QThread):
     """Signal emitted when a computation is started"""
 
 
-class FIFO(Queue, SuperviseProcess):
+class FIFO(SuperviseProcess):
     """Processing Queue with a First In, First Out behavior"""
 
     sigComputationStarted = qt.Signal(object)
@@ -53,7 +56,7 @@ class FIFO(Queue, SuperviseProcess):
 
     def __init__(self, process_id=None):
         SuperviseProcess.__init__(self, process_id=process_id)
-        Queue.__init__(self)
+        self._deque = deque()
         self._computationThread = self._create_processing_thread(process_id=process_id)
         assert isinstance(self._computationThread, ProcessingThread)
         self._computationThread.sigComputationStarted.connect(
@@ -64,6 +67,10 @@ class FIFO(Queue, SuperviseProcess):
         """Scan computed currently"""
         self._processing = False
 
+    @property
+    def data_currently_computed(self) -> Optional[TomwerObject]:
+        return self._data_currently_computed
+
     def add(self, data, configuration=None, callback=None):
         """
         add a scan to process
@@ -82,7 +89,7 @@ class FIFO(Queue, SuperviseProcess):
         except Exception:
             pass
 
-        Queue.put(self, (data, configuration, callback))
+        self.append((data, configuration, callback))
         if self.can_process_next():
             self._process_next()
 
@@ -90,11 +97,11 @@ class FIFO(Queue, SuperviseProcess):
         raise NotImplementedError("Virtual class")
 
     def _process_next(self):
-        if Queue.empty(self):
+        if len(self) == 0:
             return
 
         self._processing = True
-        data, configuration, callback = Queue.get(self)
+        data, configuration, callback = self.pop()
         self._process(data=data, configuration=configuration or {}, callback=callback)
 
     def can_process_next(self):
@@ -154,8 +161,37 @@ class FIFO(Queue, SuperviseProcess):
             future_tomo_obj=future_tomo_obj,
         )
 
+    def cancel(self):
+        if self._computationThread.isRunning():
+            with blockSignals(self._computationThread):
+                self._computationThread.cancel()
+                # stop stack
+                self.stop()
+                # emit next
+                self.sigComputationEnded.emit(None, None)
+
     def stop(self):
-        while not self.empty():
-            self.get()
-        self._computationThread.blockSignals(True)
         self._computationThread.wait()
+        self._processing = False
+        self._data_currently_computed = None
+
+    # expose deque API
+    def append(self, value):
+        self._deque.append(value)
+
+    def clear(self):
+        self._deque.clear()
+
+    def pop(self):
+        return self._deque.pop()
+
+    def remove(self, value):
+        return self._deque.remove(value)
+
+    def __len__(self):
+        return len(self._deque)
+
+    def __contains__(self, value):
+        return value.get_identifier().to_str() in [
+            scan.get_identifier().to_str() for scan in self._deque
+        ]

tomwer/synctools/stacks/reconstruction/axis.py

@@ -34,7 +34,7 @@ from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
 from silx.gui import qt
 
-from tomwer.core.process.reconstruction.axis import AxisProcess
+from tomwer.core.process.reconstruction.axis import AxisTask
 from tomwer.core.process.reconstruction.axis.axis import NoAxisUrl
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
@@ -98,10 +98,10 @@ class AxisProcessStack(FIFO, qt.QObject):
                 entry = "entry"
             try:
                 with data.acquire_process_file_lock():
-                    AxisProcess._register_process(
+                    AxisTask._register_process(
                         process_file=data.process_file,
                         entry=entry,
-                        process=AxisProcess,
+                        process=AxisTask,
                         results={"center_of_rotation": cor if cor is not None else "-"},
                         configuration=self._axis_params.to_dict(),
                         process_index=data.pop_process_index(),
@@ -115,7 +115,7 @@ class AxisProcessStack(FIFO, qt.QObject):
 
         elif (
             not self._axis_params.use_sinogram
-            and mode not in AxisProcess._CALCULATIONS_METHODS
+            and mode not in AxisTask._CALCULATIONS_METHODS
         ):
             _logger.warning(f"no method defined to compute {mode}")
             if callback is not None:
@@ -188,10 +188,11 @@ class _ProcessingThread(ProcessingThread, SuperviseProcess):
 
     def run(self):
         self.sigComputationStarted.emit()
-        axis = AxisProcess(
+        axis = AxisTask(
             inputs={
                 "data": self._scan,
                 "axis_params": self._axis_params,
+                "serialize_output_data": False,
             },
             process_id=self.process_id,
         )

tomwer/synctools/stacks/reconstruction/dkrefcopy.py

@@ -152,6 +152,7 @@ class _ProcessingThread(ProcessingThread, SuperviseProcess):
         inputs = self._inputs
         inputs["data"] = self._data
         inputs["save_dir"] = self._save_dir
+        inputs["serialize_output_data"] = False
         process = DarkRefsCopyWithSig(
             parent=self.parent(), inputs=inputs, process_id=self.process_id
         )