dcscope 2.22.1__py3-none-any.whl

dcscope/gui/widgets/rangecontrol.py

@@ -0,0 +1,308 @@
+import importlib.resources
+
+import numpy as np
+from PyQt6 import uic, QtCore, QtWidgets
+
+
+#: Precision for these features (``data``) should not go below this value.
+#: (Precision is set automatically based on data range)
+SPIN_CONTROL_PRECISION = {
+    "area_ratio": 3,
+    "aspect": 3,
+    "bright_avg": 1,
+    "bright_sd": 3,
+}
+
+
+class RangeControl(QtWidgets.QWidget):
+    #: Emitted when the range changed
+    range_changed = QtCore.pyqtSignal(float, float)
+
+    def __init__(self, parent, label="feature", checkbox=True, integer=False,
+                 data=None, *args, **kwargs):
+        super(RangeControl, self).__init__(parent=parent, *args, **kwargs)
+        ref = importlib.resources.files(
+            "dcscope.gui.widgets") / "rangecontrol.ui"
+        with importlib.resources.as_file(ref) as path_ui:
+            uic.loadUi(path_ui, self)
+
+        for spinbox in (self.doubleSpinBox_min, self.doubleSpinBox_max):
+            spinbox.setOpts(
+                format="{scaledValue:.{decimals}f}{suffixGap}{suffix}",
+                compactHeight=False,
+            )
+
+        # arbitrary data
+        self.data = data
+
+        # default values for limits
+        self.minimum = -100
+        self.maximum = +100
+
+        # label on top of control
+        self.setLabel(label)
+
+        # enable/disable checkbox
+        if not checkbox:
+            self.checkBox.hide()
+
+        # integer-valued control
+        if integer:
+            self.doubleSpinBox_min.setDecimals(1)
+            self.doubleSpinBox_max.setDecimals(1)
+        self.is_integer = integer
+
+        # reduce font size of name
+        font = self.label.font()
+        font.setPointSize(font.pointSize()-1)
+        self.label.setFont(font)
+
+        # signals
+        self.range_slider.rangeChanged.connect(self.on_range)
+        self.doubleSpinBox_min.valueChanged.connect(self.on_spinbox)
+        self.doubleSpinBox_max.valueChanged.connect(self.on_spinbox)
+
+        # call show to make sure slider is updated
+        self.show()
+
+    def read_pipeline_state(self):
+        state = {
+            "active": self.checkBox.isChecked(),
+            "start": self.doubleSpinBox_min.value(),
+            "end": self.doubleSpinBox_max.value(),
+        }
+        return state
+
+    def write_pipeline_state(self, state):
+        self.checkBox.setChecked(state["active"])
+        self.setSpinRange(state["start"], state["end"])
+
+    def check_boundary(self, old_value):
+        """Make sure boundaries are properly set in the UI
+
+        The main purpose of this function is to fix #123. For integer
+        features we would like to have 0.5 step sizes to properly
+        filter out e.g. ML classes.
+        """
+        if self.is_integer:
+            # force an increment of 0.5
+            new_value = round(old_value * 2) / 2
+        else:
+            new_value = old_value
+        return new_value
+
+    @QtCore.pyqtSlot(float, float)
+    def map_spin_values_to_range_slider(self):
+        """Read values from spin controls and update the slider UI"""
+        # spin values
+        smin = self.doubleSpinBox_min.value()
+        smax = self.doubleSpinBox_max.value()
+        # limits
+        lmin = self.minimum
+        lmax = self.maximum
+
+        # current range slider limits [a.u.]
+        rmin = self.range_slider.min()
+        rmax = self.range_slider.max()
+        # ranges for translating to handle widths
+        dr = rmax - rmin  # handle range
+        dl = lmax - lmin  # value range
+        # range slider handles (not the limits)
+        if dl == 0:
+            hmin = hmax = 0
+        else:
+            hmin = rmin + (smin - lmin) * dr / dl
+            hmax = rmax - (lmax - smax) * dr / dl
+        if hmin < rmin:
+            hmin = 0
+        if hmax > rmax:
+            hmax = self.range_slider._INT_NUM
+
+        # make range selection stick tight to edges
+        if hmin < 10:
+            hmin = 0
+        if hmin > self.range_slider._INT_NUM - 10:
+            hmax = self.range_slider._INT_NUM
+
+        self.range_slider.update()
+        self.range_slider.blockSignals(True)
+        self.range_slider.setRange(hmin, hmax)
+        self.range_slider.blockSignals(False)
+        return hmin, hmax
+
+    @QtCore.pyqtSlot(int, int)
+    def map_range_slider_to_spin_values(self):
+        """Return the respective value of the current range
+
+        Range limits are defined by
+        - self.doubleSpinBox_min.minimum()
+        - self.doubleSpinBox_min.maximum()
+        """
+        # limits
+        lmin = self.minimum
+        lmax = self.maximum
+        # range slider limits
+        rmin = self.range_slider.min()
+        rmax = self.range_slider.max()
+        # range slider handles
+        hmin = self.range_slider.start()
+        hmax = self.range_slider.end()
+        # compute values
+        dr = rmax - rmin
+        dl = lmax - lmin
+        vmin = lmin + (hmin - rmin) * dl / dr
+        vmax = lmax - (rmax - hmax) * dl / dr
+
+        vmin = self.check_boundary(vmin)
+        vmax = self.check_boundary(vmax)
+
+        self.setSpinRange(vmin, vmax)
+        return vmin, vmax
+
+    def is_active(self):
+        return self.checkBox.isChecked()
+
+    @QtCore.pyqtSlot()
+    def on_range(self):
+        self.map_range_slider_to_spin_values()
+        self.range_changed.emit(self.doubleSpinBox_min.value(),
+                                self.doubleSpinBox_max.value())
+
+    @QtCore.pyqtSlot()
+    def on_spinbox(self):
+        self.doubleSpinBox_min.setValue(
+            self.check_boundary(self.doubleSpinBox_min.value()))
+        self.doubleSpinBox_max.setValue(
+            self.check_boundary(self.doubleSpinBox_max.value()))
+
+        self.map_spin_values_to_range_slider()
+        self.range_changed.emit(self.doubleSpinBox_min.value(),
+                                self.doubleSpinBox_max.value())
+
+    def reset_range(self):
+        self.doubleSpinBox_min.setValue(self.minimum)
+        self.doubleSpinBox_max.setValue(self.maximum)
+
+    def setActive(self, b=True):
+        self.checkBox.setChecked(b)
+
+    def setCheckable(self, b=True):
+        self.checkBox.setVisible(b)
+
+    def setInteger(self, b=True):
+        self.is_integer = b
+
+    def setLabel(self, label):
+        if label:
+            self.label.setText(label)
+            self.label.show()
+        else:
+            self.label.hide()
+
+    def setLimits(self, vmin, vmax, hard_limit=False):
+        """Set the limits of the range control
+
+        Parameters
+        ----------
+        vmin, vmax: float
+            Minimum and maximum values
+        hard_limit: bool
+            If set to True, the spin controls will have a hard limit
+            that matches vmin and vmax. If False (default), the
+            limit of the spin controls is larger, giving the user
+            a broader range.
+        """
+        if vmin == vmax:
+            return
+
+        self.minimum = vmin
+        self.maximum = vmax
+
+        if hard_limit:
+            vminh = vmin
+            vmaxh = vmax
+        else:
+            # estimate based on number of digits
+            if vmin >= 0:
+                vminh = 0
+            else:
+                lmin = int(np.ceil(np.log10(np.abs(vmin)))) + 1
+                vminh = -10**lmin
+            if vmax > 0:
+                lmax = int(np.ceil(np.log10(vmax))) + 1
+                vmaxh = 10**lmax
+            else:
+                vmaxh = 0
+
+        self.setSpinLimits(vmin=vminh, vmax=vmaxh)
+        # slider values
+        self.map_spin_values_to_range_slider()
+
+    def setSpinLimits(self, vmin, vmax):
+        """Sets spin control limits and precision
+
+        Notes
+        -----
+        The precision is set automatically from the min/max
+        peak-to-peak size. If this precision is not high
+        enough for a specific application, you can set the
+        ``data`` attribute upon initialization and add the
+        precision (in decimals) to :const:`SPIN_CONTROL_PRECISION`
+        via ``SPIN_CONTROL_PRECISION[data] = precision``.
+        """
+        # min/max
+        self.doubleSpinBox_min.setMinimum(vmin)
+        self.doubleSpinBox_max.setMinimum(vmin)
+        self.doubleSpinBox_min.setMaximum(vmax)
+        self.doubleSpinBox_max.setMaximum(vmax)
+
+        # decimals
+        if not self.is_integer:
+            if vmax == vmin:
+                dec = 1
+            else:
+                # two significant digits
+                dec = int(np.ceil(np.log10(1/np.abs(vmax-vmin)))) + 5
+                if dec <= 0:
+                    dec = 1
+            if self.data in SPIN_CONTROL_PRECISION:
+                dec = max(dec, SPIN_CONTROL_PRECISION[self.data])
+            self.doubleSpinBox_min.setDecimals(dec)
+            self.doubleSpinBox_max.setDecimals(dec)
+            self.doubleSpinBox_min.setSingleStep(10**-dec)
+            self.doubleSpinBox_max.setSingleStep(10**-dec)
+
+    def setSpinRange(self, vmin, vmax):
+        """Set values of left and right spin controls (not the limits)
+
+        Extends the range if necessary
+        """
+        limits_changed = False
+
+        if vmin < self.minimum:
+            limit_min = np.floor(vmin)
+            limits_changed = True
+        else:
+            limit_min = self.minimum
+
+        if vmax > self.maximum:
+            limit_max = np.ceil(vmax)
+            limits_changed = True
+        else:
+            limit_max = self.maximum
+
+        if limits_changed:
+            self.setLimits(limit_min, limit_max)
+
+        self.doubleSpinBox_min.blockSignals(True)
+        self.doubleSpinBox_max.blockSignals(True)
+        self.doubleSpinBox_min.setValue(vmin)
+        self.doubleSpinBox_max.setValue(vmax)
+        self.doubleSpinBox_min.blockSignals(False)
+        self.doubleSpinBox_max.blockSignals(False)
+
+        self.range_slider.blockSignals(True)
+        self.map_spin_values_to_range_slider()
+        self.range_slider.blockSignals(False)
+
+        self.range_changed.emit(vmin, vmax)

dcscope/gui/widgets/rangecontrol.ui

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>481</width>
+    <height>45</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <property name="spacing">
+    <number>0</number>
+   </property>
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Feature description</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <property name="spacing">
+      <number>6</number>
+     </property>
+     <item>
+      <widget class="QCheckBox" name="checkBox">
+       <property name="text">
+        <string/>
+       </property>
+       <property name="checked">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="SpinBox" name="doubleSpinBox_min">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>90</width>
+         <height>16777215</height>
+        </size>
+       </property>
+       <property name="decimals">
+        <number>2</number>
+       </property>
+       <property name="maximum">
+        <double>100.000000000000000</double>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QRangeSlider" name="range_slider" native="true">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="SpinBox" name="doubleSpinBox_max">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>90</width>
+         <height>16777215</height>
+        </size>
+       </property>
+       <property name="maximum">
+        <double>100.000000000000000</double>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QRangeSlider</class>
+   <extends>QWidget</extends>
+   <header>dcscope.gui.widgets</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>SpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>pyqtgraph</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

dcscope/gui/widgets/simple_image_view.py

@@ -0,0 +1,55 @@
+import numpy as np
+from PyQt6 import QtCore, QtGui, QtWidgets
+import pyqtgraph as pg
+
+from .simple_plot_widget import SimpleViewBox
+
+
+class SimpleImageView(pg.ImageView):
+    """Custom class for data visualization in DCscope"""
+
+    def __init__(self, *args, **kwargs):
+        super(SimpleImageView, self).__init__(view=SimpleImageViewBox(),
+                                              *args, **kwargs)
+        self.view.export.connect(self.on_export)
+
+        # disable pyqtgraph controls we don't need
+        self.ui.histogram.hide()
+        self.ui.roiBtn.hide()
+        self.ui.menuBtn.hide()
+        # disable keyboard shortcuts
+        self.keyPressEvent = lambda _: None
+        self.keyReleaseEvent = lambda _: None
+
+    def on_export(self, suffix):
+        assert suffix == "png"
+        path, _ = QtWidgets.QFileDialog.getSaveFileName(
+            self, '', '', 'PNG image (*.png)', '')
+        if not path.endswith(".png"):
+            path += ".png"
+
+        img = np.require(self.image, np.uint8, 'C')
+        height, width, _ = self.image.shape
+
+        qImg = QtGui.QImage(img, width, height, width *
+                            3, QtGui.QImage.Format.Format_RGB888)
+        qImg.save(path)
+
+
+class SimpleImageViewBox(SimpleViewBox):
+    export = QtCore.pyqtSignal(str)
+
+    def autoRange(self, padding=0, *args, **kwargs):
+        super(SimpleImageViewBox, self).autoRange(padding=padding,
+                                                  *args,
+                                                  **kwargs)
+
+    def raiseContextMenu(self, ev):
+        menu = self.menu
+        menu.clear()
+        menu.addAction("Save event image as PNG",
+                       lambda: self.export.emit("png"))
+
+        pos = ev.screenPos()
+        menu.popup(QtCore.QPoint(int(pos.x()), int(pos.y())))
+        return True

dcscope/gui/widgets/simple_plot_widget.py

@@ -0,0 +1,113 @@
+from PyQt6 import QtCore, QtWidgets
+import pyqtgraph as pg
+from pyqtgraph import exporters
+
+
+class SimplePlotItem(pg.PlotItem):
+    """Custom class for data visualization in DCscope
+
+    Modifications include:
+    - right click menu only with "Export..."
+    - top and right axes
+    """
+
+    def __init__(self, parent=None, *args, **kwargs):
+        if "viewBox" not in kwargs:
+            kwargs["viewBox"] = SimpleViewBox()
+        super(SimplePlotItem, self).__init__(parent, *args, **kwargs)
+        self.vb.export.connect(self.on_export)
+        # show top and right axes, but not ticklabels
+        for kax in ["top", "right"]:
+            self.showAxis(kax)
+            ax = self.axes[kax]["item"]
+            ax.setTicks([])
+            ax.setLabel(None)
+            ax.setStyle(tickTextOffset=0,
+                        tickTextWidth=0,
+                        tickTextHeight=0,
+                        autoExpandTextSpace=False,
+                        showValues=False,
+                        )
+        # show grid
+        # https://github.com/DC-analysis/DCscope/issues/75
+        # self.showGrid(x=True, y=True, alpha=.1)
+        # visualization
+        self.hideButtons()
+
+    def axes_to_front(self):
+        """Give the axes a high zValue"""
+        # bring axes to front
+        # (This screws up event selection in QuickView)
+        for kax in self.axes:
+            self.axes[kax]["item"].setZValue(900)
+
+    def on_export(self, suffix):
+        """Export subplots as original figures (with axes labels, etc)"""
+        file, _ = QtWidgets.QFileDialog.getSaveFileName(
+            None,
+            'Save {} file'.format(suffix.upper()),
+            '',
+            '{} file (*.{})'.format(suffix.upper(), suffix))
+        if not file.endswith("." + suffix):
+            file += "." + suffix
+        self.perform_export(file)
+
+    def perform_export(self, file):
+        suffix = file[-3:]
+        if suffix == "png":
+            exp = exporters.ImageExporter(self)
+            # translate from screen resolution (80dpi) to 300dpi
+            exp.params["width"] = int(exp.params["width"] / 72 * 300)
+        elif suffix == "svg":
+            exp = exporters.SVGExporter(self)
+        exp.export(file)
+
+
+class SimplePlotWidget(pg.PlotWidget):
+    """Custom class for data visualization in DCscope
+
+    Modifications include:
+    - white background
+    - those of SimplePlotItem
+    """
+
+    def __init__(self, parent=None, background='w', **item_kwargs):
+        plot_item = SimplePlotItem(**item_kwargs)
+        super(SimplePlotWidget, self).__init__(parent,
+                                               background=background,
+                                               plotItem=plot_item)
+
+
+class SimpleViewBox(pg.ViewBox):
+    export = QtCore.pyqtSignal(str)
+
+    def __init__(self, *args, **kwargs):
+        super(SimpleViewBox, self).__init__(*args, **kwargs)
+        #: allowed right-click menu options with new name
+        self.right_click_actions = {}
+        settings = QtCore.QSettings()
+        if int(settings.value("advanced/developer mode", 0)):
+            # Enable advanced export in developer mode
+            self.right_click_actions["Export..."] = "Advanced Export"
+
+    def raiseContextMenu(self, ev):
+        # Let the scene add on to the end of our context menu
+        menu = self.scene().addParentContextMenus(self, self.menu, ev)
+
+        # Only keep list of actions defined in `self.right_click_actions`
+        for action in self.menu.actions():
+            if action.text() in self.right_click_actions.values():
+                pass
+            elif action.text() not in self.right_click_actions:
+                self.menu.removeAction(action)
+            else:
+                action.setText(self.right_click_actions[action.text()])
+
+        menu.addAction("Export subplot as PNG",
+                       lambda: self.export.emit("png"))
+        menu.addAction("Export subplot as SVG",
+                       lambda: self.export.emit("svg"))
+
+        pos = ev.screenPos()
+        menu.popup(QtCore.QPoint(int(pos.x()), int(pos.y())))
+        return True

dcscope/gui/widgets/so_colorbaritem.py

@@ -0,0 +1,29 @@
+import pyqtgraph as pg
+
+
+class DCscopeColorBarItem(pg.ColorBarItem):
+    def __init__(self, yoffset, height, label, colorMap, *args, **kwargs):
+        """pg.ColorBarItem modified for DCscope
+
+        - Added option to define height
+        - translate the colorbar so that it is aligned with the plot
+        - show the label on the right-hand axis
+        - increase the contents margins
+        """
+        super(DCscopeColorBarItem, self).__init__(
+            colorMap=colorMap,
+            # TODO: Removing `cmap=colorMap` results in grayscale colormaps.
+            *args, **kwargs)
+
+        # show label on right side
+        self.axis.setLabel(label)
+
+        # increase contents margins
+        self.layout.setContentsMargins(7, 0, 7, 0)
+
+        # set correct size and position
+        self.setFixedHeight(height)
+
+        tr = self.transform()
+        tr.translate(0, yoffset)
+        self.setTransform(tr)

dcscope/gui/widgets/wait_cursor.py

@@ -0,0 +1,33 @@
+import functools
+
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtGui import QCursor
+from PyQt6.QtCore import Qt, QEventLoop
+
+
+class ShowWaitCursor(object):
+    def __enter__(self):
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        # This overloaded function call makes sure that all events,
+        # even those triggered during the function call, are processed.
+        QApplication.processEvents(QEventLoop.ProcessEventsFlag.AllEvents, 50)
+        return self
+
+    def __exit__(self, type, value, traceback):
+        QApplication.restoreOverrideCursor()
+
+
+def show_wait_cursor(func):
+    """A decorator that starts and stops a wait cursor for a function call
+
+    https://doc.qt.io/qt-5/qguiapplication.html#setOverrideCursor
+    Every setOverrideCursor() must eventually be followed by a
+    corresponding restoreOverrideCursor(), otherwise the stack
+    will never be emptied.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with ShowWaitCursor():
+            ret = func(*args, **kwargs)
+        return ret
+    return wrapper

dcscope/idiom.py

@@ -0,0 +1,26 @@
+from dclab.rtdc_dataset import feat_anc_core
+
+#: integer-valued features
+INTEGER_FEATURES = [
+    "fl1_max",
+    "fl1_npeaks",
+    "fl2_max",
+    "fl2_npeaks",
+    "fl3_max",
+    "fl3_npeaks",
+    "frame",
+    "index",
+    "ml_class",
+    "nevents",
+]
+
+#: features that by definition trend over the course of a measurement
+SLOPING_FEATURES = [
+    "frame",
+    "index",
+    "index_online",
+    "time",
+]
+
+#: ancillary features that are easily computed
+QUICK_FEATURES = feat_anc_core.FEATURES_RAPID