tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/gui/stitching/config/positionoveraxis.py

@@ -3,6 +3,7 @@ import numpy
 from silx.gui import qt
 
 from tomwer.gui.stitching.axisorderedlist import AxisOrderedTomoObjsModel
+from tomwer.gui.utils.step import StepSizeSelectorWidget
 
 
 class PosEditorOverOneAxis(qt.QWidget):
@@ -15,7 +16,6 @@ class PosEditorOverOneAxis(qt.QWidget):
     ) -> None:
         assert axis_edited in (0, 1, 2)
         super().__init__(parent, *args, **kwargs)
-        self._stepSize = 1
         self._axisEdited = axis_edited
         # the axis the spin boxes are editing
         self._axisOrder = axis_order if axis_order is not None else axis_edited
@@ -25,7 +25,13 @@ class PosEditorOverOneAxis(qt.QWidget):
         self.__spinBoxescallback = {}
         self.setLayout(qt.QVBoxLayout())
         # widget to define step size
-        self._stepSizeWidget = StepSizeWidget(self)
+        self._stepSizeWidget = StepSizeSelectorWidget(
+            self,
+            fine_value=1,
+            medium_value=5,
+            rough_value=25,
+            dtype=int,
+        )
         self.layout().addWidget(self._stepSizeWidget)
 
         # table with the different Tomo objects
@@ -35,22 +41,28 @@ class PosEditorOverOneAxis(qt.QWidget):
 
         self.layout().addWidget(self._tomoObjsTableView)
 
+        # connect signal / slot
+        self._stepSizeWidget.valueChanged.connect(self._updateStepSize)
+
         # tune table view
         self._tomoObjsTableView.setColumnWidth(0, 15)
         self._tomoObjsTableView.setColumnWidth(2, 120)
         self._tomoObjsTableView.horizontalHeader().setSectionResizeMode(
             1, qt.QHeaderView.Stretch
         )
+        self.setStepSize(1)
 
-        # connect signal / slot
-        self._stepSizeWidget.stepSB.valueChanged.connect(self.setStepSize)
-        self._stepSize = 1
+    def _updateStepSize(self):
+        step_size = self.getStepSize()
+        for sb in self._tomoObjtoSpinBoxes.values():
+            sb.setSingleStep(step_size)
 
     def setStepSize(self, step_size: int):
-        self._stepSize = step_size
-        # update SB step size
-        for sb in self._tomoObjtoSpinBoxes.values():
-            sb.setSingleStep(self._stepSize)
+        self._stepSizeWidget.setStepSize(step_size)
+        self._updateStepSize()
+
+    def getStepSize(self) -> int:
+        return self._stepSizeWidget.getStepSize()
 
     def addTomoObj(self, tomo_obj):
         if tomo_obj is None:
@@ -68,7 +80,7 @@ class PosEditorOverOneAxis(qt.QWidget):
         spinBox = qt.QSpinBox(parent=self)
         spinBox.setRange(numpy.iinfo(numpy.int32).min, numpy.iinfo(numpy.int32).max)
         spinBox.setSuffix("px")
-        spinBox.setSingleStep(self._stepSize)
+        spinBox.setSingleStep(self.getStepSize())
         spinBox.setValue(
             tomo_obj.stitching_metadata.get_abs_position_px(axis=self._axisEdited)
             or self.DEFAULT_VALUE_WHEM_MISSING
@@ -154,16 +166,3 @@ class EditableAxisOrderedTomoObjsModel(AxisOrderedTomoObjsModel):
     def __init__(self, axis: int, parent=None) -> None:
         super().__init__(axis, parent)
         self._headers = ["index", "tomo obj", f"axis {axis} pos (px)"]
-
-
-class StepSizeWidget(qt.QWidget):
-    def __init__(self, parent=None) -> None:
-        super().__init__(parent)
-        self.setLayout(qt.QFormLayout())
-        self._stepSB = qt.QSpinBox(self)
-        self._stepSB.setRange(1, 9999)
-        self.layout().addRow("step size", self._stepSB)
-
-    @property
-    def stepSB(self):
-        return self._stepSB

tomwer/gui/stitching/normalization.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+from silx.gui import qt
+from nabu.stitching.sample_normalization import (
+    SampleSide as _SampleSide,
+    Method as _SampleNormalizationMethod,
+)
+from nabu.stitching import config as _config_stitching
+from tomwer.gui.utils.qt_utils import block_signals
+
+
+class NormalizationBySampleGroupBox(qt.QGroupBox):
+    """
+    Widget to define the normalization to apply to frames"""
+
+    sigConfigChanged = qt.Signal()
+    """Emit when the configuration is changed"""
+
+    def __init__(self, title: str = "normalization by sample", parent=None):
+        # FIXME: add a way to the user for requesting a view of the region picked ???
+        super().__init__(title, parent)
+        self.setCheckable(True)
+        self.setLayout(qt.QFormLayout())
+
+        # method
+        self._methodCB = qt.QComboBox(self)
+        self._methodCB.addItems(_SampleNormalizationMethod.values())
+        self._methodCB.setCurrentText(_SampleNormalizationMethod.MEDIAN.value)
+        self.layout().addRow("method", self._methodCB)
+
+        # side
+        self._sideCB = qt.QComboBox(self)
+        self._sideCB.addItems(_SampleSide.values())
+        self._sideCB.setCurrentText(_SampleSide.LEFT.value)
+        self.layout().addRow("sampling side", self._sideCB)
+
+        # width
+        self._widthSB = qt.QSpinBox(self)
+        self._widthSB.setRange(1, 9999999)
+        self._widthSB.setValue(30)
+        self._widthSB.setSingleStep(10)
+        self.layout().addRow("sampling width", self._widthSB)
+
+        # margin
+        self._marginSB = qt.QSpinBox(self)
+        self._marginSB.setRange(0, 999999)
+        self._marginSB.setValue(0)
+        self.layout().addRow("sampling margin", self._marginSB)
+
+        # connect signal / slot
+        self._methodCB.currentIndexChanged.connect(self._configChanged)
+        self._sideCB.currentIndexChanged.connect(self._configChanged)
+        self._widthSB.valueChanged.connect(self._configChanged)
+        self._marginSB.valueChanged.connect(self._configChanged)
+
+    def _configChanged(self, *args, **kwargs):
+        self.sigConfigChanged.emit()
+
+    def getMethod(self) -> _SampleNormalizationMethod:
+        return _SampleNormalizationMethod.from_value(self._methodCB.currentText())
+
+    def setMethod(self, method: _SampleNormalizationMethod | str):
+        method = _SampleNormalizationMethod.from_value(method)
+        self._methodCB.setCurrentText(method.value)
+
+    def getSide(self) -> _SampleSide:
+        return _SampleSide.from_value(self._sideCB.currentText())
+
+    def setSide(self, side: _SampleSide):
+        side = _SampleSide.from_value(side)
+        self._sideCB.setCurrentText(side.value)
+
+    def getMargin(self) -> int:
+        return self._marginSB.value()
+
+    def setMargin(self, margin: int):
+        self._marginSB.setValue(int(margin))
+
+    def getWidth(self) -> int:
+        return self._widthSB.value()
+
+    def setWidth(self, width: int):
+        self._widthSB.setValue(int(width))
+
+    def getConfiguration(self) -> dict:
+        return {
+            _config_stitching.NORMALIZATION_BY_SAMPLE_ACTIVE_FIELD: self.isChecked(),
+            _config_stitching.NORMALIZATION_BY_SAMPLE_METHOD: self.getMethod().value,
+            _config_stitching.NORMALIZATION_BY_SAMPLE_SIDE: self.getSide().value,
+            _config_stitching.NORMALIZATION_BY_SAMPLE_MARGIN: self.getMargin(),
+            _config_stitching.NORMALIZATION_BY_SAMPLE_WIDTH: self.getWidth(),
+        }
+
+    def setConfiguration(self, config: dict) -> None:
+        with block_signals(self):
+            method = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_METHOD, None)
+            if method is not None:
+                self.setMethod(method=method)
+
+            side = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_SIDE, None)
+            if side is not None:
+                self.setSide(side=side)
+
+            margin = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_MARGIN, None)
+            if margin is not None:
+                self.setMargin(margin=margin)
+
+            width = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_WIDTH, None)
+            if width is not None:
+                self.setWidth(width=width)
+
+            active = config.get(
+                _config_stitching.NORMALIZATION_BY_SAMPLE_ACTIVE_FIELD, None
+            )
+            if active is not None:
+                self.setChecked(active in (True, 1, "1", "True"))
+
+        self._configChanged()

tomwer/gui/stitching/stitchandbackground.py

@@ -21,11 +21,11 @@ class AlphaChannelWidget(qt.QWidget):
         self._alphaImgSlider = qt.QSlider(qt.Qt.Horizontal, self)
         self._alphaImgSlider.setMinimumWidth(40)
         self._alphaImgSlider.setRange(0, 100)
-        self.layout().addRow(f"{ALPHA_CHAR} stitching", self._alphaImgSlider)
+        self.layout().addRow(f"{ALPHA_CHAR} image", self._alphaImgSlider)
         self._alphaBackgroundSlider = qt.QSlider(qt.Qt.Horizontal, self)
         self._alphaBackgroundSlider.setMinimumWidth(40)
         self._alphaBackgroundSlider.setRange(0, 100)
-        self.layout().addRow(f"{ALPHA_CHAR} background", self._alphaBackgroundSlider)
+        self.layout().addRow(f"{ALPHA_CHAR} overlay", self._alphaBackgroundSlider)
 
         # connect signal / slot
         self._alphaImgSlider.valueChanged.connect(self._alphaImgchanged)
@@ -62,8 +62,8 @@ class StitchAndBackgroundAlphaMixIn:
         self._stitched_image = None
         self._composition_background = None
         # background action to show / hide the backgrounds
-        self._backGroundAction = qt.QAction("background", self)
-        self._backGroundAction.setToolTip("show / hide colored background")
+        self._backGroundAction = qt.QAction("overlay", self)
+        self._backGroundAction.setToolTip("show / hide overlay on top of image")
         self._backGroundAction.setCheckable(True)
         save_icon = tomwer_icons.getQIcon("background")
         self._backGroundAction.setIcon(save_icon)
@@ -128,8 +128,6 @@ class StitchAndBackgroundAlphaMixIn:
             )
             background_data = self.getImage(legend=self.LEGEND_BACKGROUND)
             background_data.setAlpha(self.getBackgroundImgAlpha())
-            # TODO: active image is always the image data
-
         else:
             if self.getImage(self.LEGEND_BACKGROUND) is not None:
                 self.removeImage(self.LEGEND_BACKGROUND)