implement normalization margin mean widget

zUtil_Python/pydct/orangecontrib/pydct/widgets/load_data.py

 """
 Open 3D _data from h5 files and return numpy array.
 """
+# todo make it terminate if stuff change while processing
 
 import logging
 from typing import Optional

zUtil_Python/pydct/orangecontrib/pydct/widgets/normalize_margin_mean.py

+""""todo """
+import logging
+from typing import List
+
+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 pydct.preprocess.main import normalize_margin_mean
+from silx.gui.qt import QThread
+
+_logger = logging.getLogger("orangecontrib.pydct")
+
+
+class NormalizeMarginMean(QThread):
+    """"todo"""
+
+    def __init__(self, parent, data: ndarray, margin_roi_origin: List[int], margin_roi_size: List[int]):
+
+        super().__init__(parent=parent)
+
+        self.data = data
+        self.margin_roi_origin = margin_roi_origin
+        self.margin_roi_size = margin_roi_size
+
+        self.data_normalized = None
+
+    def run(self):
+
+        # the function bellow has a different interface to describe
+        # rois, with the upper left and bottom right corners
+        roi = (
+            tuple(int(val) for val in self.margin_roi_origin),  # origin is already the upper left corner
+            (
+                int(self.margin_roi_origin[0] + self.margin_roi_size[0]),
+                int(self.margin_roi_origin[1] + self.margin_roi_size[1]),
+            ),
+        )
+
+        self.data_normalized = normalize_margin_mean(self.data, roi)
+
+
+class NormalizeMargin(OWWidget):
+    """
+    todo NormalizeMargin doc, add validations (concentrate on the core function), test
+
+    """
+
+    name = "normalize margin mean"
+    description = "Get the mean value of the ROI of the margin on each frame and use it to normalize the frame."
+    icon = "icons/normalize-margin-mean.svg"
+
+    want_main_area = False
+    resizing_enabled = True
+
+    class Inputs:
+        data = Input("data", ndarray)
+        margin_roi_origin = Input("margin_roi_origin", list)
+        margin_roi_size = Input("margin_roi_size", list)
+
+    class Outputs:
+        data = Output("data", ndarray)
+
+    def __init__(self):
+
+        super().__init__()
+
+        self.data = None
+        self.margin_roi_origin = None
+        self.margin_roi_size = None
+
+        self._computing = False
+        self.information()
+
+        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.margin_roi_origin
+    def set_margin_roi_origin(self, margin_roi_origin):
+        self.margin_roi_origin = margin_roi_origin
+        self._on_input_change()
+
+    @Inputs.margin_roi_size
+    def set_margin_roi_size(self, margin_roi_size):
+        self.margin_roi_size = margin_roi_size
+        self._on_input_change()
+
+    def _on_input_change(self):
+
+        if self._computing:
+            _logger.warning("inputs changed while computing the normalization, terminating...")
+            self._thread.terminate()
+            self._computing = False
+
+        self.Outputs.data.send(None)
+
+        if self.data is None or self.margin_roi_origin is None or self.margin_roi_size 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 allocating, this shouldn't happen")
+            return
+
+        if self.data is None or self.margin_roi_origin is None or self.margin_roi_size is None:
+            _logger.error("trying to run with missing inputs, this shouldn't happen")
+            return
+
+        self.run_button.setDisabled(True)
+
+        self._thread = NormalizeMarginMean(
+            parent=self,
+            data=self.data,
+            margin_roi_origin=self.margin_roi_origin,
+            margin_roi_size=self.margin_roi_size,
+        )
+        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:
+
+            self.Outputs.data.send(self._thread.data_normalized)
+            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/roi_selection.py

@@ -200,6 +200,8 @@ class ROISelectionWidget(qt.QWidget):
 
 class RoiSelectionWidgetOW(OWWidget):
 
+    # todo make it send out put as soon as data arrives when it's already saved
+
     name = "roi selection"
     icon = "icons/one_round.png"
     want_main_area = False
@@ -240,7 +242,7 @@ class RoiSelectionWidgetOW(OWWidget):
     def _sendSignal(self, roi_origin=[], roi_size=[]):
         """Emits the signal with the new data."""
         self.close()
-        self.roi_origin = roi_origin
-        self.roi_size = roi_size
+        self.roi_origin = list(reversed(roi_origin))  # they come as Y X
+        self.roi_size = list(reversed(roi_size))
         self.Outputs.roi_origin.send(self.roi_origin)
         self.Outputs.roi_size.send(self.roi_size)

zUtil_Python/pydct/orangecontrib/pydct/widgets/subtract_dark.py

 """Subtract a dark image from a dataset."""
+# todo make it terminate if stuff change while processing
 
 import logging
 

zUtil_Python/pydct/orangecontrib/pydct/widgets/zwise_median.py

 """Take the median on the z-axis (position 0)."""
+# todo make it terminate if stuff change while processing
 import logging
 
 import numpy as np

zUtil_Python/pydct/pydct/preprocess/main.py

@@ -265,6 +265,7 @@ def main(
 
     elif normalization == NormalizationOptions.margin_mean:
         logger.info("normalizing with the margin's average value")
+        # todo add normalization numerator (check matlab code)
         data = normalize_margin_mean(data, margin_bounding_box)
 
     else:
@@ -489,7 +490,7 @@ class DocstringsAction(DocstringsActionAbstract):
         ]
 
 
-parser.add_argument("--docstrings", action=DocstringsAction)
+preprocess_parser.add_argument("--docstrings", action=DocstringsAction)
 
 
 class ExamplesAction(ExampleCallsActionAbstract):
@@ -512,7 +513,7 @@ class ExamplesAction(ExampleCallsActionAbstract):
         ]
 
 
-parser.add_argument("--examples", action=ExamplesAction)
+preprocess_parser.add_argument("--examples", action=ExamplesAction)
 
 
 parser_main = common.namespace2kwargs(