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

tomwer/gui/stitching/stitching_preview.py

@@ -4,6 +4,7 @@ from typing import Union
 import numpy
 from nabu.stitching.frame_composition import ZFrameComposition
 from silx.gui import qt
+from tomwer.gui.utils.buttons import TapeMeasureToolButton
 from tomoscan.esrf.scan.utils import get_data
 from tomoscan.identifier import BaseIdentifier
 from tomoscan.scanbase import TomoScanBase
@@ -14,27 +15,61 @@ from tomwer.gui import icons as tomwer_icons
 from tomwer.gui import settings
 from tomwer.gui.stitching.stitchandbackground import StitchAndBackgroundAlphaMixIn
 
-try:
-    from silx.gui.plot.ImageStack import (  # noqa F401
-        PlotWithWaitingLabel as _PlotWithWaitingLabel,
-    )
-except ImportError:
-    from silx.gui.plot.ImageStack import _PlotWithWaitingLabel  # noqa F401
+from silx.gui.plot import Plot2D, items
+from silx.gui.widgets.WaitingOverlay import WaitingOverlay
 
 _logger = logging.getLogger(__name__)
 
 
-class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn):
+class _PreviewPlot2D(Plot2D):
+    """simple inheritance to get data from the 'stitched image' instead of the 'background / overlay' image"""
+
+    def _getImageValue(self, x, y):
+        pickedMask = None
+        for picked in self.pickItems(
+            *self.dataToPixel(x, y, check=False),
+            lambda item: isinstance(item, items.ImageBase),
+        ):
+            if isinstance(picked.getItem(), items.MaskImageData):
+                if pickedMask is None:  # Use top-most if many masks
+                    pickedMask = picked
+            else:
+                # we want to avoid displaying the value of the background image. So just ignore it.
+                # TODO: see with Thomas if there is a better way to do this.
+                # like starting by the active image ?
+                image = picked.getItem()
+                if image.getLegend() == StitchAndBackgroundAlphaMixIn.LEGEND_BACKGROUND:
+                    continue
+
+                indices = picked.getIndices(copy=False)
+                if indices is not None:
+                    row, col = indices[0][0], indices[1][0]
+                    value = image.getData(copy=False)[row, col]
+
+                    if pickedMask is not None:  # Check if masked
+                        maskItem = pickedMask.getItem()
+                        indices = pickedMask.getIndices()
+                        row, col = indices[0][0], indices[1][0]
+                        if maskItem.getData(copy=False)[row, col] != 0:
+                            return value, "Masked"
+                    return value
+
+        return "-"  # No image picked
+
+
+class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
     DEFAULT_STITCHED_IMG_ALPHA = 0.95
-    DEFAULT_BACKGROUND_IMG_ALPHA = 0.15
+    DEFAULT_BACKGROUND_IMG_ALPHA = 0.20
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent=parent)  # pylint: disable=E1123
+        self._waitingOverlay = WaitingOverlay(self)
+        self._waitingOverlay.setIconSize(qt.QSize(30, 30))
         self._stitched_image = None
         self._composition_background = None
 
         # tune plot
-        self.getPlotWidget().setYAxisInverted(settings.Y_AXIS_DOWNWARD)
+        self.setYAxisInverted(settings.Y_AXIS_DOWNWARD)
         # by default we want to have a full screen display
         self.setAxesDisplayed(False)
 
@@ -47,6 +82,11 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
         self.setKeepDataAspectRatio(True)
         self.getColorBarWidget().hide()
 
+        # tape mesure action
+        self._tapeMeasureButton = TapeMeasureToolButton(parent=self, plot=self)
+        self._tapeMeasureButton.setCheckable(True)
+        self.toolBar().addWidget(self._tapeMeasureButton)
+
         # removing some plot action to clear toolbar
         self.getMaskAction().setVisible(False)
         self.getCopyAction().setVisible(False)
@@ -62,7 +102,7 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
         # set up
         self.setAlphaBackgroundImg(value=self.DEFAULT_BACKGROUND_IMG_ALPHA)
         self.setAlphaStitchedImg(value=self.DEFAULT_STITCHED_IMG_ALPHA)
-        self.setWaiting(False)
+        self._waitingOverlay.hide()
 
         # connect signal / slot
         self._backGroundAction.toggled.connect(self._update)
@@ -111,15 +151,19 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
             shape=(
                 (raw_compositon.global_end_y[-1] - raw_compositon.global_start_y[0]),
                 frame_width,
+                4,
             ),
         )
-        assert background.ndim == 2
+        assert background.ndim == 3
 
         def get_next_color():
+            yellow = qt.QColor(qt.Qt.yellow)
+            magenta = qt.QColor(qt.Qt.magenta)
+            blue = qt.QColor(qt.Qt.blue)
             while True:
-                yield qt.QColor(qt.Qt.yellow).hue()
-                yield qt.QColor(qt.Qt.magenta).hue()
-                yield qt.QColor(qt.Qt.blue).hue()
+                yield yellow.red(), yellow.green(), yellow.blue(), 255
+                yield magenta.red(), magenta.green(), magenta.blue(), 255
+                yield blue.red(), blue.green(), blue.blue(), 255
 
         colors_raw_frames = []
         for _, color in zip(raw_compositon.local_end_y, get_next_color()):
@@ -127,6 +171,7 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
                 shape=(
                     raw_compositon.global_end_y[-1] - raw_compositon.global_start_y[0],
                     frame_width,
+                    4,
                 ),
                 fill_value=color,
             )
@@ -196,44 +241,6 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
     def stitched_image(self):
         return self._stitched_image
 
-    # expose API
-    def getImage(self, *args, **kwargs):
-        return self.getPlotWidget().getImage(*args, **kwargs)
-
-    def addImage(self, *args, **kwargs):
-        self.getPlotWidget().addImage(*args, **kwargs)
-
-    def removeImage(self, *args, **kwargs):
-        self.getPlotWidget().removeImage(*args, **kwargs)
-
-    def toolBar(self, *args, **kwargs):
-        return self.getPlotWidget().toolBar(*args, **kwargs)
-
-    def setKeepDataAspectRatio(self, *args, **kwargs):
-        return self.getPlotWidget().setKeepDataAspectRatio(*args, **kwargs)
-
-    def getColorBarWidget(self, *args, **kwargs):
-        return self.getPlotWidget().getColorBarWidget(*args, **kwargs)
-
-    def getMaskAction(self, *args, **kwargs):
-        return self.getPlotWidget().getMaskAction(*args, **kwargs)
-
-    def getCopyAction(self, *args, **kwargs):
-        return self.getPlotWidget().getCopyAction(*args, **kwargs)
-
-    def addToolBar(self, *args, **kwargs):
-        return self.getPlotWidget().addToolBar(*args, **kwargs)
-
-    def setActiveImage(self, *args, **kwargs):
-        return self.getPlotWidget().setActiveImage(*args, **kwargs)
-
-    def setAxesDisplayed(self, *args, **kwargs):
-        plotWidget = self.getPlotWidget()
-        if hasattr(plotWidget, "setAxesDisplayed"):
-            plotWidget.setAxesDisplayed(*args, **kwargs)
-
-    def getDefaultColormap(self, *args, **kwargs):
-        return self.getPlotWidget().getDefaultColormap()
-
-    def setDefaultColormap(self, *args, **kwargs):
-        return self.getPlotWidget().setDefaultColormap(*args, **kwargs)
+    def setPixelSize(self, pixel_size: Union[tuple, float]):
+        """set the pixel size to be used by the ruler"""
+        self._tapeMeasureButton.setPixelSize(pixel_size_m=pixel_size)

tomwer/gui/stitching/stitching_raw.py

@@ -6,7 +6,7 @@ from contextlib import AbstractContextManager
 
 from silx.gui import qt
 from silx.gui.plot import PlotWindow
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 from tomwer.core.volume.volumebase import TomwerVolumeBase
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.tomwer_object import TomwerObject
@@ -189,9 +189,9 @@ class RawStitchingPlot(PlotWindow):
 
         self._alphaValuesWidget.addTomoObj(tomo_obj)
         if isinstance(tomo_obj, TomwerScanBase):
-            self._scan_reading_order[
-                tomo_obj.get_identifier().to_str()
-            ] = self.getRotationAngleDirection(tomo_obj)
+            self._scan_reading_order[tomo_obj.get_identifier().to_str()] = (
+                self.getRotationAngleDirection(tomo_obj)
+            )
             if first_tomo_obj_id != tuple(self._tomo_objs.keys())[0]:
                 # if the order of scans might have change we need to update the full stack (to handle reading order)
                 self._updateImages()
@@ -322,22 +322,26 @@ class RawStitchingPlot(PlotWindow):
             # compute flat field
             # TODO: this must be done in another thread... but sync with update might be difficult...
             try:
-                reduced_darks = scan.load_reduced_darks()
+                reduced_darks, reduced_darks_infos = scan.load_reduced_darks(
+                    return_info=True
+                )
             except Exception:
                 _logger.warning(
                     f"no reduced dark found for {scan}. Please compute them to get a better display."
                 )
             else:
-                scan.set_reduced_darks(reduced_darks)
+                scan.set_reduced_darks(reduced_darks, darks_infos=reduced_darks_infos)
 
             try:
-                reduced_flats = scan.load_reduced_flats()
+                reduced_flats, reduced_flats_info = scan.load_reduced_flats(
+                    return_info=True
+                )
             except Exception:
                 _logger.warning(
                     f"no reduced flat(s) found for {scan}. Please compute them to get a better display."
                 )
             else:
-                scan.set_reduced_flats(reduced_flats)
+                scan.set_reduced_flats(reduced_flats, flats_infos=reduced_flats_info)
 
             reading_order_ref = self._getReadingOrderRef()
             reading_order = self._scan_reading_order[scan.get_identifier().to_str()]
@@ -557,10 +561,7 @@ class AlphaValueSlider(qt.QTableWidget):
         self._visibleButton.released.connect(self._setVisible)
 
         # expose API
-        self._slider.valueChanged.connect(self._changed)
-
-    def _changed(self, value: int):
-        self.valueChanged.emit(value)
+        self._slider.valueChanged.connect(self.valueChanged)
 
     def _setInvisible(self, *args, **kwargs):
         self._slider.setValue(0)

tomwer/gui/stitching/z_stitching/fineestimation.py

@@ -10,7 +10,6 @@ from typing import Union
 from nabu.stitching import config as _nabu_stitching_config
 from nabu.stitching.config import StitchingType
 from nabu.stitching.overlap import OverlapStitchingStrategy
-from nabu.stitching.utils import ScoreMethod as _NabuScoreMethod
 from nabu.stitching.utils import ShiftAlgorithm as _NabuShiftAlgorithm
 from silx.gui import qt
 from tomoscan.serie import Serie
@@ -39,44 +38,8 @@ class Axis_N_Params(qt.QGroupBox):
         )
         self.layout().addRow("image registration method", self._imageRegMethodCB)
 
-        # window size
-        self._windowSize = qt.QSpinBox(self)
-        self._windowSizeLabel = qt.QLabel(
-            _nabu_stitching_config.KEY_WINDOW_SIZE.replace("_", " "), self
-        )
-        self.layout().addRow(self._windowSizeLabel, self._windowSize)
-        self._windowSize.setToolTip("research window width to find shifts")
-
-        # score method
-        self._scoreCB = qt.QComboBox(self)
-        for score_method in _NabuScoreMethod.values():
-            self._scoreCB.addItem(score_method)
-        self._scoreCBLabel = qt.QLabel(
-            _nabu_stitching_config.KEY_SCORE_METHOD.replace("_", " "), self
-        )
-        self.layout().addRow(self._scoreCBLabel, self._scoreCB)
-        self._windowSize.setToolTip(
-            "method to use in order to compute score and determine the best shift"
-        )
-
-        # connect signal / slot
-        self._imageRegMethodCB.currentTextChanged.connect(self._updatePossibleOpts)
-
         # set up
         self._imageRegMethodCB.setCurrentText(_NabuShiftAlgorithm.NONE.value)
-        self._updatePossibleOpts()
-
-    def getWindowSize(self):
-        return self._windowSize.value()
-
-    def setWindowSize(self, window_size):
-        return self._windowSize.setValue(int(window_size))
-
-    def getScoreMethod(self):
-        return _NabuScoreMethod.from_value(self._scoreCB.currentText())
-
-    def setScoreMethod(self, method):
-        self._scoreCB.setCurrentText(_NabuScoreMethod.from_value(method).value)
 
     def getCurrentMethod(self):
         return _NabuShiftAlgorithm.from_value(self._imageRegMethodCB.currentText())
@@ -89,13 +52,6 @@ class Axis_N_Params(qt.QGroupBox):
     def getOptsLine(self) -> str:
         current_method = self.getCurrentMethod()
         line_ = f"{_nabu_stitching_config.KEY_IMG_REG_METHOD}={current_method.value}"
-        if current_method is _NabuShiftAlgorithm.SHIFT_GRID:
-            line_ = ",".join(
-                (
-                    line_,
-                    f"{_nabu_stitching_config.KEY_WINDOW_SIZE}={self.getWindowSize()},{_nabu_stitching_config.KEY_SCORE_METHOD}={self.getScoreMethod().value}",
-                )
-            )
         return line_
 
     def setOptsLine(self, opt_line: str) -> None:
@@ -113,13 +69,6 @@ class Axis_N_Params(qt.QGroupBox):
             except Exception as e:
                 _logger.error(e)
 
-        score_method = opts.get(_nabu_stitching_config.KEY_SCORE_METHOD, None)
-        if score_method is not None:
-            try:
-                self.setScoreMethod(score_method)
-            except Exception as e:
-                _logger.error(e)
-
         img_reg_exp_method = opts.get(_nabu_stitching_config.KEY_IMG_REG_METHOD, None)
         if img_reg_exp_method is not None:
             try:
@@ -127,15 +76,6 @@ class Axis_N_Params(qt.QGroupBox):
             except Exception as e:
                 _logger.error(e)
 
-    def _updatePossibleOpts(self, *args, **kwargs):
-        current_method = self.getCurrentMethod()
-        self._windowSizeLabel.setVisible(
-            current_method is _NabuShiftAlgorithm.SHIFT_GRID
-        )
-        self._windowSize.setVisible(current_method is _NabuShiftAlgorithm.SHIFT_GRID)
-        self._scoreCBLabel.setVisible(current_method is _NabuShiftAlgorithm.SHIFT_GRID)
-        self._scoreCB.setVisible(current_method is _NabuShiftAlgorithm.SHIFT_GRID)
-
 
 class AutoRefineWidget(qt.QWidget):
     """

tomwer/gui/utils/buttons.py

@@ -1,39 +1,20 @@
-# coding: utf-8
-# /*##########################################################################
-# Copyright (C) 2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################*/
-
 """
 Button of general usage.
 """
 
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "03/10/2018"
-
-
+import numpy
+import logging
+from typing import Optional, Union
 from silx.gui import qt
+from silx.gui.plot.tools.roi import RegionOfInterestManager
+from silx.gui.plot.items.roi import LineROI
+from silx.gui.plot.PlotToolButtons import PlotToolButton
 
 from tomwer.gui import icons
+from pyunitsystem.metricsystem import MetricSystem
+
+
+_logger = logging.getLogger(__file__)
 
 
 class PadlockButton(qt.QPushButton):
@@ -100,3 +81,105 @@ class TabBrowsersButtons(qt.QWidget):
 
     def _nextReleased(self, *args, **kwargs):
         self.sigNextReleased.emit()
+
+
+class TapeMeasureToolButton(PlotToolButton):
+    """Button to active measurement between two point of the plot"""
+
+    class TapeMeasureROI(LineROI):
+        def __init__(self, parent=None, pixel_size_m=None):
+            super().__init__(parent)
+            self._pixel_size_m = None
+            self.setPixelSize(pixel_size_m)
+
+        def setEndPoints(self, startPoint, endPoint):
+            distance_px = numpy.linalg.norm(endPoint - startPoint)
+            super().setEndPoints(startPoint=startPoint, endPoint=endPoint)
+            if self._pixel_size_m is None:
+                self._updateText(f"{distance_px :.1f}px")
+            else:
+                distance_m = distance_px * self._pixel_size_m
+                value, unit = MetricSystem.cast_metric_to_best_unit(distance_m)
+                self._updateText(f"{distance_px :.1f}px ({value:.2f}{unit})")
+
+        def setPixelSize(self, pixel_size_m: Optional[Union[tuple, float]]):
+            if isinstance(pixel_size_m, (tuple, list)):
+                assert (
+                    len(pixel_size_m) == 2
+                ), "expects at most two pixel size values (x and y values)"
+                if not numpy.isclose(pixel_size_m[0], pixel_size_m[1]):
+                    value, unit = MetricSystem.cast_metric_to_best_unit(pixel_size_m[0])
+                    _logger.warning(
+                        f"TapeMeasure is only handling square pixels for now. Will consider the pixel is {value:.2f}{unit}x{value:.2f}{unit}"
+                    )
+                pixel_size_m = pixel_size_m[0]
+            self._pixel_size_m = pixel_size_m
+
+    def __init__(self, parent=None, plot=None, pixel_size_mm=None):
+        super().__init__(parent=parent, plot=plot)
+        self._roiManager = None
+        self._lastRoiCreated = None
+        self._pixel_sixel_m = pixel_size_mm
+        self.setIcon(icons.getQIcon("ruler"))
+        self.setToolTip("measure distance between two pixels")
+        self.toggled.connect(self._callback)
+        self._connectPlot(plot)
+
+    def setPlot(self, plot):
+        return super().setPlot(plot)
+
+    def setPixelSize(self, pixel_size_m: Optional[Union[tuple, float]]):
+        self._pixel_sixel_m = pixel_size_m
+
+    def _callback(self, toggled):
+        if not self._roiManager:
+            return
+        if self._lastRoiCreated is not None:
+            self._lastRoiCreated.setVisible(self.isChecked())
+        if self.isChecked():
+            self._roiManager.start(
+                self.TapeMeasureROI,
+                self,
+            )
+            self.__interactiveModeStarted(self._roiManager)
+        else:
+            source = self._roiManager.getInteractionSource()
+            if source is self:
+                self._roiManager.stop()
+
+    def __interactiveModeStarted(self, roiManager):
+        roiManager.sigInteractiveModeFinished.connect(self.__interactiveModeFinished)
+
+    def __interactiveModeFinished(self):
+        roiManager = self._roiManager
+        if roiManager is not None:
+            roiManager.sigInteractiveModeFinished.disconnect(
+                self.__interactiveModeFinished
+            )
+        self.setChecked(False)
+
+    def _connectPlot(self, plot):
+        """
+        Called when the plot is connected to the widget
+        :param plot: :class:`.PlotWidget` instance
+        """
+        if plot is None:
+            return
+        self._roiManager = RegionOfInterestManager(plot)
+        self._roiManager.setColor("yellow")  # Set the color of ROI
+        self._roiManager.sigRoiAdded.connect(self._registerCurrentROI)
+
+    def _disconnectPlot(self, plot):
+        if plot and self._lastRoiCreated is not None:
+            self._roiManager.removeRoi(self._lastRoiCreated)
+            self._lastRoiCreated = None
+        return super()._disconnectPlot(plot)
+
+    def _registerCurrentROI(self, currentRoi):
+        if self._lastRoiCreated is None:
+            self._lastRoiCreated = currentRoi
+            self._lastRoiCreated.setPixelSize(self._pixel_sixel_m)
+        elif currentRoi != self._lastRoiCreated and self._roiManager is not None:
+            self._roiManager.removeRoi(self._lastRoiCreated)
+            self._lastRoiCreated = currentRoi
+            self._lastRoiCreated.setPixelSize(self._pixel_sixel_m)

tomwer/gui/utils/inputwidget.py

@@ -28,7 +28,7 @@ __date__ = "16/08/2018"
 
 import logging
 import os
-from typing import Optional
+from typing import Optional, Union
 
 import numpy
 from nxtomomill.io.config import TomoEDFConfig as EDFConfig
@@ -41,7 +41,7 @@ from tomwer.gui import icons
 from tomwer.gui.qlefilesystem import QLFileSystem
 from tomwer.io.utils import get_default_directory
 from tomwer.core.volume.volumefactory import VolumeFactory
-from tomwer.core.process.control.nxtomomill import NXtomomillNXDefaultOutput
+from tomwer.core.process.output import ProcessDataOutputDirMode
 
 from tomwer.core.volume import (
     EDFVolume,
@@ -271,42 +271,49 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         self.__buttonGroup.setExclusive(True)
 
         tooltip = """Define the output directory of the nexus (.nx) file. Options are:
-        \n - next to bliss file: create the NXtomos at the same level as the bliss input file
+        \n - same folder as scan: create the NXtomos at the same level as the bliss input file or spec folder
+        \n - 'RAW_DATA' folder: create NXtomos on the default 'RAW_DATA' folder (bliss default folder, nearby the 'raw' folder).
         \n - 'PROCESSED_DATA' folder: create NXtomos on the default 'PROCESSED_DATA' folder (bliss default folder, nearby the 'raw' folder).
         \n - user defined folder: users can provide their own folders using keywords for string formatting such as 'scan_dir_name', 'scan_basename' or 'scan_parent_dir_basename'
         """
 
         # output dir is the folder containing the .nx file
-        self._closeToBlissFileRB = qt.QRadioButton("near input file", self)
-        self._closeToBlissFileRB.setToolTip(tooltip)
-        self.layout().addWidget(self._closeToBlissFileRB, 0, 0, 1, 1)
-        self.__buttonGroup.addButton(self._closeToBlissFileRB)
+        self._inScanFolder = qt.QRadioButton("same folder as scan", self)
+        self._inScanFolder.setToolTip(tooltip)
+        self.layout().addWidget(self._inScanFolder, 0, 0, 1, 1)
+        self.__buttonGroup.addButton(self._inScanFolder)
         # output dir is the default 'reduced'folder
         self._processedDataFolderRB = qt.QRadioButton("'PROCESSED_DATA' folder", self)
         self._processedDataFolderRB.setToolTip(tooltip)
         self.layout().addWidget(self._processedDataFolderRB, 1, 0, 1, 1)
         self.__buttonGroup.addButton(self._processedDataFolderRB)
+        # output dir is the default 'reduced'folder
+        self._rawDataFolderRB = qt.QRadioButton("'RAW_DATA' folder", self)
+        self._rawDataFolderRB.setToolTip(tooltip)
+        self.layout().addWidget(self._rawDataFolderRB, 2, 0, 1, 1)
+        self.__buttonGroup.addButton(self._rawDataFolderRB)
         # manual
         self._manualRB = qt.QRadioButton("custom output directory", self)
         self._manualRB.setToolTip(tooltip)
-        self.layout().addWidget(self._manualRB, 2, 0, 1, 1)
+        self.layout().addWidget(self._manualRB, 3, 0, 1, 1)
         self._outputFolderQLE = QLFileSystem("", self)
-        self.layout().addWidget(self._outputFolderQLE, 2, 1, 1, 1)
+        self.layout().addWidget(self._outputFolderQLE, 3, 1, 1, 1)
         self._selectButton = qt.QPushButton("", self)
         style = qt.QApplication.style()
         icon_opendir = style.standardIcon(qt.QStyle.SP_DirOpenIcon)
         self._selectButton.setIcon(icon_opendir)
         self._selectButton.setToolTip("select output directory")
-        self.layout().addWidget(self._selectButton, 2, 2, 1, 1)
+        self.layout().addWidget(self._selectButton, 3, 2, 1, 1)
         self.__buttonGroup.addButton(self._manualRB)
 
         # connect signal / slot
         self._selectButton.released.connect(self._selectOutpuFolder)
         self.__buttonGroup.buttonReleased.connect(self._updateVisiblity)
-        self._closeToBlissFileRB.toggled.connect(self._outputDirChanged)
-        self._processedDataFolderRB.toggled.connect(self._outputDirChanged)
-        self._manualRB.toggled.connect(self._outputDirChanged)
-        self._outputFolderQLE.editingFinished.connect(self._outputDirChanged)
+        self._inScanFolder.toggled.connect(self.sigChanged)
+        self._processedDataFolderRB.toggled.connect(self.sigChanged)
+        self._rawDataFolderRB.toggled.connect(self.sigChanged)
+        self._manualRB.toggled.connect(self.sigChanged)
+        self._outputFolderQLE.editingFinished.connect(self.sigChanged)
 
         # set up
         self._processedDataFolderRB.setChecked(True)
@@ -316,9 +323,6 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         self._selectButton.setVisible(self._manualRB.isChecked())
         self._outputFolderQLE.setVisible(self._manualRB.isChecked())
 
-    def _outputDirChanged(self):
-        self.sigChanged.emit()
-
     def _selectOutpuFolder(self):  # pragma: no cover
         defaultDirectory = self._outputFolderQLE.text()
         if os.path.isdir(defaultDirectory):
@@ -334,13 +338,15 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         self._outputFolderQLE.setText(dialog.selectedFiles()[0])
         self.sigChanged.emit()
 
-    def getOutputFolder(self) -> str:
+    def getOutputFolder(self) -> Union[str, ProcessDataOutputDirMode]:
         if self._manualRB.isChecked():
             return self._outputFolderQLE.text()
         elif self._processedDataFolderRB.isChecked():
-            return NXtomomillNXDefaultOutput.PROCESSED_DATA.value
-        elif self._closeToBlissFileRB.isChecked():
-            return NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value
+            return ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER
+        elif self._inScanFolder.isChecked():
+            return ProcessDataOutputDirMode.IN_SCAN_FOLDER
+        elif self._rawDataFolderRB.isChecked():
+            return ProcessDataOutputDirMode.RAW_DATA_FOLDER
         else:
             raise RuntimeError("Use case - h52nx output dir - not handled")
 
@@ -348,15 +354,17 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         old = self.blockSignals(True)
         self._manualRB.setChecked(output_folder is not None)
         try:
-            default_output = NXtomomillNXDefaultOutput.from_value(output_folder)
+            default_output = ProcessDataOutputDirMode.from_value(output_folder)
         except ValueError:
             self._outputFolderQLE.setText(output_folder)
             self._manualRB.setChecked(True)
         else:
-            if default_output is NXtomomillNXDefaultOutput.NEAR_INPUT_FILE:
+            if default_output is ProcessDataOutputDirMode.IN_SCAN_FOLDER:
+                self._inScanFolder.setChecked(True)
+            elif default_output is ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER:
                 self._processedDataFolderRB.setChecked(True)
-            elif default_output is NXtomomillNXDefaultOutput.PROCESSED_DATA:
-                self._closeToBlissFileRB.setChecked(True)
+            elif default_output is ProcessDataOutputDirMode.RAW_DATA_FOLDER:
+                self._rawDataFolderRB.setChecked(True)
             else:
                 raise ValueError(f"default output not handled ({default_output})")
         finally:
@@ -516,6 +524,11 @@ class OutputVolumeDefinition(qt.QWidget):
             os.environ["TOMWER_DEFAULT_INPUT_DIR"]
         ):
             dialog.setDirectory(os.environ["TOMWER_DEFAULT_INPUT_DIR"])
+        elif dialog.directory() != os.getcwd() or str(dialog.directory()).startswith(
+            "/data"
+        ):
+            # if the directory as already been set by the user. Avoid redefining it
+            pass
         elif os.path.isdir("/data"):
             dialog.setDirectory("/data")
 
@@ -532,6 +545,11 @@ class OutputVolumeDefinition(qt.QWidget):
             os.environ["TOMWER_DEFAULT_INPUT_DIR"]
         ):
             dialog.setDirectory(os.environ["TOMWER_DEFAULT_INPUT_DIR"])
+        elif dialog.directory() != os.getcwd() or str(dialog.directory()).startswith(
+            "/data"
+        ):
+            # if the directory as already been set by the user. Avoid redefining it
+            pass
         elif os.path.isdir("/data"):
             dialog.setDirectory("/data")
 

tomwer/gui/utils/lineselector/lineselector.py

@@ -219,7 +219,7 @@ class QLineSelector(qt.QWidget):
         """
         legend = self._getLegend(row_n=row)
         if legend in self.__selection:
-            self._plot.removeItem(legend)
+            self._plot.remove(legend=legend, kind="item")
             del self.__selection[legend]
 
     def _plotDrawEvent(self, event):

tomwer/gui/utils/scandescription.py

@@ -64,6 +64,10 @@ class ScanNameLabelAndShape(qt.QWidget):
     def setScan(self, scan: Optional[TomwerScanBase]):
         if scan is None or scan.path is None:
             self.clear()
+        elif not isinstance(scan, TomwerScanBase):
+            raise TypeError(
+                f"Scan is expected to be an  instance of {TomwerScanBase}. Get {type(scan)} instead"
+            )
         else:
             assert isinstance(scan, TomwerScanBase)
             self._scanNameLabel.setText(scan.get_identifier().short_description())