implement first attempt with shared memory

zUtil_Python/pydct/orangecontrib/pydct/widgets/remove_zmoving_medians.py

+""""todo """
+import logging
+from enum import Enum
+from multiprocessing.sharedctypes import RawArray
+from typing import List
+
+import _ctypes
+import numpy as np
+from numpy import ndarray
+from Orange.widgets import gui, settings, widget
+from Orange.widgets.utils.signals import Input, Output
+from Orange.widgets.widget import OWWidget
+from orangewidget.settings import Setting
+from pydct.preprocess.main import normalize_margin_mean
+from pydct.preprocess.moving_median_removal import remove_moving_medians
+from silx.gui.qt import QThread
+
+_logger = logging.getLogger("orangecontrib.pydct")
+
+
+class RemoveZmovingMediansThread(QThread):
+    """todo"""
+
+    def __init__(self, parent, data: ndarray, multiprocessing_array: RawArray, median_window: int, median_validity: int):
+
+        super().__init__(parent=parent)
+
+        self.data = data
+        self.multiprocessing_array = multiprocessing_array
+        self.median_window = median_window
+        self.median_validity = median_validity
+
+        self.data_processed = None
+        self.backgrounds = None
+
+    def run(self):
+
+        data_processed, self.backgrounds = remove_moving_medians(
+            data=self.data,
+            multiprocessing_rawarray=self.multiprocessing_array,
+            median_window=self.median_window,
+            median_validity=self.median_validity,
+        )
+
+        self.data_processed = data_processed.copy()
+
+
+class RemoveZmovingMedian(OWWidget):
+    """todo"""
+
+    name = "remove z-moving medians"
+    description = "todo "  # todo
+    icon = "icons/remove-zmoving-median.svg"
+
+    want_main_area = False
+    resizing_enabled = True
+
+    class Inputs:
+        data = Input("data", ndarray)
+        multiprocessing_array = Input("multiprocessing_array", _ctypes.Array)
+
+    class Outputs:
+        data = Output("data", ndarray)
+        multiprocessing_array = Output("multiprocessing_array", _ctypes.Array)
+        backgrounds = Output("backgrounds", ndarray)
+
+    median_window = Setting(500, schema_only=True)
+    median_validity = Setting(50, schema_only=True)
+
+    def __init__(self):
+
+        super().__init__()
+
+        self.data = None
+        self.multiprocessing_array = None
+
+        self.median_validity_spin = gui.spin(
+            self.controlArea,
+            self,
+            "median_window",
+            minv=1,
+            maxv=28000,
+            step=1,
+            label="median_window",
+            disabled=False,
+            spinType=int,
+        )
+
+        self.median_validity_spin = gui.spin(
+            self.controlArea,
+            self,
+            "median_validity",
+            minv=1,
+            maxv=28000,
+            step=1,
+            label="median_validity",
+            disabled=False,
+            spinType=int,
+        )
+
+        self._computing = False
+
+        self.run_button = gui.button(widget=self.controlArea, master=self, label="go", callback=self._run)
+        self.run_button.setDisabled(True)
+
+    @Inputs.data
+    def set_data(self, data):
+        self.data = data
+        self._on_input_change()
+
+    @Inputs.multiprocessing_array
+    def set_data(self, multiprocessing_array):
+        self.multiprocessing_array = multiprocessing_array
+        self._on_input_change()
+
+    def _on_input_change(self):
+
+        if self._computing:
+            _logger.warning("inputs changed while computing the normalization, terminating...")
+            self._thread.quit()  # todo check if this works
+            self._computing = False
+
+        self.Outputs.data.send(None)
+        self.Outputs.multiprocessing_array.send(None)
+
+        if self.data is None or self.multiprocessing_array is None:
+            self.run_button.setDisabled(True)
+            self.information()
+            return
+
+        else:
+            self.run_button.setDisabled(False)
+            self.information("data ready, waiting to run")
+
+    def _run(self):
+
+        if self._computing:
+            _logger.error("already running")
+            return
+
+        if self.data is None or self.multiprocessing_array is None:
+            _logger.error("trying to run with missing inputs, this shouldn't happen")
+            return
+
+        self.run_button.setDisabled(True)
+
+        self._thread = RemoveZmovingMediansThread(
+            parent=self,
+            data=self.data,
+            multiprocessing_array=self.multiprocessing_array,
+            median_window=self.median_window,
+            median_validity=self.median_validity,
+        )
+        self._thread.finished.connect(self._send_signal)
+
+        self._computing = True
+        self.information("computing...")
+
+        self._thread.start()
+
+    def _send_signal(self):
+
+        self._thread.finished.disconnect(self._send_signal)
+
+        _logger.info("done normalizing")
+        self._computing = False
+
+        if self._thread.data_normalized is not None and self._thread.backgrounds is not None:
+
+            self.Outputs.data.send(self._thread.data_normalized)
+            self.Outputs.multiprocessing_array.send(self.multiprocessing_array)
+            self.Outputs.backgrounds.send(self._thread.backgrounds)
+            self.information("done")
+
+        else:
+            self.run_button.setDisabled(False)
+            self.error("something went wrong and the worker thread did not return the result properly")

zUtil_Python/pydct/orangecontrib/pydct/widgets/shared_memory_ndarray.py

@@ -77,7 +77,7 @@ class AllocateSharedMemory(OWWidget):
     def _run(self):
 
         if self._computing:
-            _logger.warning("already allocating")
+            _logger.error("already allocating")
             return
 
         if self.data is None:
@@ -107,6 +107,7 @@ class AllocateSharedMemory(OWWidget):
 
         if self._thread.data_shared is not None and self._thread.multiprocessing_array is not None:
 
+            # todo move this to vefore the condition everywhere
             self.data_shared = self._thread.data_shared
             self.multiprocessing_array = self._thread.multiprocessing_array