dcscope 2.22.1__py3-none-any.whl

dcscope/gui/quick_view/qv_scatter.py

@@ -0,0 +1,284 @@
+import numpy as np
+from PyQt6 import QtCore
+import pyqtgraph as pg
+from pyqtgraph.graphicsItems.GradientEditorItem import Gradients
+
+from ... import plot_cache
+
+from .. import pipeline_plot
+from ..widgets import SimplePlotWidget, SimpleViewBox
+
+
+class QuickViewScatterWidget(SimplePlotWidget):
+    update_hover_pos = QtCore.pyqtSignal(QtCore.QPointF)
+
+    def __init__(self, *args, **kwargs):
+        self._view_box = QuickViewViewBox()
+        super(QuickViewScatterWidget, self).__init__(viewBox=self._view_box,
+                                                     *args, **kwargs)
+        self._view_box.update_hover_pos.connect(self.update_hover_pos)
+        self.scatter = RTDCScatterPlot()
+        self.select = pg.PlotDataItem(x=[1], y=[2], symbol="o")
+        #: List of isoelasticity line plots
+        self.isoelastics = []
+        self.addItem(self.scatter)
+        self.addItem(self.select)
+        self.select.hide()
+        self.xscale = "linear"
+        self.yscale = "linear"
+        self.kde_type = "none",
+        self.kde_kwargs = {}
+        self.hue_type = "none"
+        self.hue_kwargs = {}
+        #: Boolean array identifying the plotted events w.r.t. the full
+        #: dataset
+        self.events_plotted = None
+        #: Unfiltered and not-downsampled x component of current scatter plot
+        self.data_x = None
+        #: Unfiltered and not-downsampled y component of current scatter plot
+        self.data_y = None
+
+        # polygon editing ROI
+        self.poly_line_roi = None
+
+        # Signals for mouse click
+        # let view box update the selected event in the scatter plot
+        self._view_box.set_scatter_point.connect(self.scatter.set_point)
+        # let view box update self.poly_line_roi
+        self._view_box.add_poly_vertex.connect(self.add_poly_vertex)
+
+    def activate_poly_mode(self, points=None):
+        if points is None:
+            points = []
+        if self.poly_line_roi is None:
+            self.poly_line_roi = pg.PolyLineROI([], closed=True)
+            self.poly_line_roi.setPen("k")
+        self.addItem(self.poly_line_roi)
+        if len(points):
+            mode = "poly-modify"
+            self.set_poly_points(points)
+        else:
+            mode = "poly-create"
+        self.set_mouse_click_mode(mode)
+        return self.poly_line_roi
+
+    def activate_scatter_mode(self):
+        if self.poly_line_roi is not None:
+            self.removeItem(self.poly_line_roi)
+            self.poly_line_roi = None
+        self.set_mouse_click_mode("scatter")
+
+    def add_poly_vertex(self, pos):
+        state = self.poly_line_roi.getState()
+        state["points"].append([pos.x(), pos.y()])
+        self.poly_line_roi.setState(state)
+
+    def get_poly_points(self):
+        if self.poly_line_roi is None:
+            raise ValueError("No polygon selection active!")
+        state = self.poly_line_roi.getState()
+        points = np.array([[p.x(), p.y()] for p in state["points"]])
+        # Take into account manual movements of the entire ROI (issue #115)
+        points[:, 0] += state["pos"][0]
+        points[:, 1] += state["pos"][1]
+        if self.xscale == "log":
+            points[:, 0] = 10**points[:, 0]
+        if self.yscale == "log":
+            points[:, 1] = 10**points[:, 1]
+        return points
+
+    def plot_data(self, rtdc_ds, slot, xax="area_um", yax="deform",
+                  xscale="linear", yscale="linear",  downsample=False,
+                  hue_type="none", hue_kwargs=None, isoelastics=False,
+                  lut_identifier=None):
+        self.rtdc_ds = rtdc_ds
+        self.slot = slot
+        self.xax = xax
+        self.yax = yax
+        self.xscale = xscale
+        self.yscale = yscale
+        self.hue_type = hue_type
+        self.hue_kwargs = hue_kwargs if hue_kwargs else {}
+        if hue_type != "kde":
+            self.kde_type = "none"
+            self.kde_kwargs = {}
+        else:
+            self.kde_type = hue_kwargs["kde_type"]
+            self.kde_kwargs = hue_kwargs.get("kde_kwargs")
+        x, y, kde, idx = plot_cache.get_scatter_data(
+            rtdc_ds=self.rtdc_ds,
+            downsample=downsample,
+            xax=self.xax,
+            yax=self.yax,
+            xscale=self.xscale,
+            yscale=self.yscale,
+            kde_type=self.kde_type,
+            kde_kwargs=self.kde_kwargs)
+        self.events_plotted = idx
+        #: unfiltered x data
+        self.data_x = self.rtdc_ds[self.xax]
+        #: unfiltered y data
+        self.data_y = self.rtdc_ds[self.yax]
+        if self.hue_type == "none":
+            brush = "k"
+        else:
+            # define colormap
+            brush = []
+            cmap = pg.ColorMap(*zip(*Gradients["viridis"]["ticks"]))
+            if self.hue_type == "kde":
+                for k in kde:
+                    brush.append(cmap.mapToQColor(k))
+            elif self.hue_type == "feature":
+                fdata = self.rtdc_ds[self.hue_kwargs["feat"]][idx]
+                fdata -= fdata.min()
+                fdata = np.array(fdata, dtype=float)  # cast int to float
+                fdata /= fdata.max()
+                for f in fdata:
+                    brush.append(cmap.mapToQColor(f))
+
+        if x.size:  # test for empty x/y (#37)
+            # set viewbox
+            pipeline_plot.set_viewbox(plot=self,
+                                      range_x=(x.min(), x.max()),
+                                      range_y=(y.min(), y.max()),
+                                      scale_x=self.xscale,
+                                      scale_y=self.yscale,
+                                      padding=0.05)
+        # set data
+        self.setData(x, y, brush=brush)
+        # set axes labels (replace with user-defined flourescence names)
+        left = pipeline_plot.get_axis_label_from_feature(
+            self.yax, slot_state=self.slot.__getstate__())
+        bottom = pipeline_plot.get_axis_label_from_feature(
+            self.xax, slot_state=self.slot.__getstate__())
+        self.plotItem.setLabels(left=left, bottom=bottom)
+
+        # Force updating the plot item size, otherwise axes labels
+        # may have an offset.
+        s = self.plotItem.size()
+        self.plotItem.resize(s.width()+1, s.height())
+        self.plotItem.resize(s)
+
+        # Isoelastics
+        # remove old isoelastics
+        for lp in self.isoelastics:
+            self.removeItem(lp)
+        if isoelastics:
+            cfg = self.rtdc_ds.config
+            self.isoelastics = pipeline_plot.add_isoelastics(
+                plot_item=self.plotItem,
+                axis_x=self.xax,
+                axis_y=self.yax,
+                channel_width=cfg["setup"]["channel width"],
+                pixel_size=cfg["imaging"]["pixel size"],
+                lut_identifier=lut_identifier)
+
+    def set_mouse_click_mode(self, mode):
+        allowed = ["scatter", "poly-create", "poly-modify"]
+        if mode not in allowed:
+            raise ValueError("Invalid mouse mode: {}, ".format(mode)
+                             + "expected one of {}".format(allowed))
+        if mode in ["poly-create", "poly-modify"]:
+            if self.poly_line_roi is None:
+                raise ValueError("Please set self.poly_line_roi before "
+                                 + "setting the click mode!")
+        self._view_box.mode = mode
+
+    def set_poly_points(self, points):
+        if self.poly_line_roi is None:
+            raise ValueError("No polygon selection active!")
+        points = np.array(points, copy=True)
+        if points.size:
+            if self.xscale == "log":
+                points[:, 0] = np.log10(points[:, 0])
+            if self.yscale == "log":
+                points[:, 1] = np.log10(points[:, 1])
+            state = self.poly_line_roi.getState()
+            state["points"] = points.tolist()
+            self.poly_line_roi.setState(state)
+
+    def setData(self, x, y, **kwargs):
+        # convert to log-scale if applicable
+        if self.xscale == "log":
+            x = np.log10(x)
+        if self.yscale == "log":
+            y = np.log10(y)
+        # set data
+        self.scatter.setData(x=x, y=y, **kwargs)
+
+    def setSelection(self, event_index):
+        x = self.data_x[event_index]
+        y = self.data_y[event_index]
+        self.select.setData([x], [y])
+
+
+class QuickViewViewBox(SimpleViewBox):
+    set_scatter_point = QtCore.pyqtSignal(QtCore.QPointF)
+    add_poly_vertex = QtCore.pyqtSignal(QtCore.QPointF)
+    update_hover_pos = QtCore.pyqtSignal(QtCore.QPointF)
+
+    def __init__(self, *args, **kwargs):
+        super(QuickViewViewBox, self).__init__(*args, **kwargs)
+        self.mode = "scatter"
+
+        #: allowed right-click menu options with new name
+        self.right_click_actions["View All"] = "View All Content"
+        self.right_click_actions["Mouse Mode"] = "Change Mouse mode"
+
+    def mouseClickEvent(self, ev):
+        if ev.button() == QtCore.Qt.MouseButton.LeftButton:
+            pos = self.mapToView(ev.pos())
+            if self.mode == "scatter":
+                self.set_scatter_point.emit(pos)
+            elif self.mode == "poly-create":
+                self.add_poly_vertex.emit(pos)
+            ev.accept()
+        else:
+            # right mouse button shows menu
+            super(QuickViewViewBox, self).mouseClickEvent(ev)
+
+    def hoverEvent(self, ev):
+        if hasattr(ev, "_scenePos"):
+            pos = self.mapToView(ev.pos())
+            self.update_hover_pos.emit(pos)
+
+
+class RTDCScatterPlot(pg.ScatterPlotItem):
+    def __init__(self, size=3, pen=None, brush=None, *args, **kwargs):
+        if pen is None:
+            pen = pg.mkPen(color=(0, 0, 0, 0))
+        if brush is None:
+            brush = pg.mkBrush("k")
+        super(RTDCScatterPlot, self).__init__(size=size,
+                                              pen=pen,
+                                              brush=brush,
+                                              symbol="s",
+                                              *args,
+                                              **kwargs)
+        self.setData(x=range(10), y=range(10), brush=brush)
+
+    def pointAt(self, pos):
+        """Unlike `ScatterPlotItem.pointsAt`, return the closest point"""
+        x = pos.x()
+        y = pos.y()
+
+        pw = self.pixelWidth()
+        ph = self.pixelHeight()
+
+        # compute the distances of all points to x and y
+        dists = np.abs((self.data["x"] - x)/pw) \
+            + np.abs((self.data["y"] - y)/ph)
+        ide = np.argmin(dists)
+
+        # calling `self.points` populates the data["item"] column.
+        return self.points()[ide]
+
+    def set_point(self, view_pos):
+        pos = self.mapFromView(view_pos)
+        pt = self.pointAt(pos)
+        self.ptClicked = pt
+        self.sigClicked.emit(self, self.ptClicked, None)
+
+    def mouseClickEvent(self, ev):
+        """Override that does not handle events"""
+        ev.ignore()  # clicks are handles by CustomViewBox

dcscope/gui/quick_view/qv_style.css

@@ -0,0 +1,10 @@
+QGroupBox {
+  border: 1px solid #E0E0E0;
+  border-radius: 0px;
+  margin-top: 1em;
+}
+
+QGroupBox::title {
+  padding-top: -1.5em;
+  padding-left: 0px;
+}

dcscope/gui/update.py

@@ -0,0 +1,90 @@
+import json
+import os
+import struct
+import sys
+import traceback
+import urllib.request
+
+from dclab.external.packaging import parse as parse_version
+from PyQt6 import QtCore
+
+
+class UpdateWorker(QtCore.QObject):
+    finished = QtCore.pyqtSignal()
+    data_ready = QtCore.pyqtSignal(dict)
+
+    @QtCore.pyqtSlot(str, str)
+    def processUpdate(self, version, ghrepo):
+        mdict = check_release(ghrepo, version)
+        if mdict["update available"]:
+            self.data_ready.emit(mdict)
+        self.finished.emit()
+
+
+def check_for_update(version, ghrepo):
+    thread = QtCore.QThread()
+    obj = UpdateWorker()
+    obj.moveToThread(thread)
+    obj.finished.connect(thread.quit)
+    thread.start()
+
+    QtCore.QMetaObject.invokeMethod(obj, 'processUpdate',
+                                    QtCore.Qt.ConnectionType.QueuedConnection,
+                                    QtCore.Q_ARG(str, version),
+                                    QtCore.Q_ARG(str, ghrepo),
+                                    )
+
+
+def check_release(ghrepo="user/repo", version=None, timeout=20):
+    """Check GitHub repository for latest release"""
+    url = "https://api.github.com/repos/{}/releases/latest".format(ghrepo)
+    if "GITHUB_TOKEN" in os.environ:
+        hdr = {'authorization': os.environ["GITHUB_TOKEN"]}
+    else:
+        hdr = {}
+    web = "https://github.com/{}/releases".format(ghrepo)
+    errors = None  # error messages (str)
+    update = False  # whether an update is available
+    binary = None  # download link to binary file
+    new_version = None  # string identifying new version
+    try:
+        req = urllib.request.Request(url, headers=hdr)
+        data = urllib.request.urlopen(req, timeout=timeout).read()
+    except BaseException:
+        errors = traceback.format_exc()
+    else:
+        j = json.loads(data)
+
+        newversion = j["tag_name"]
+
+        if version is not None:
+            new = parse_version(newversion)
+            old = parse_version(version)
+            if new > old:
+                update = True
+                new_version = newversion
+                if hasattr(sys, "frozen"):
+                    # determine which binary URL we need
+                    if sys.platform == "win32":
+                        nbit = 8 * struct.calcsize("P")
+                        if nbit == 32:
+                            dlid = "win_32bit_setup.exe"
+                        else:
+                            dlid = "win_64bit_setup.exe"
+                    elif sys.platform == "darwin":
+                        dlid = ".pkg"
+                    else:
+                        dlid = False
+                    # search for binary download file
+                    if dlid:
+                        for a in j["assets"]:
+                            if a["browser_download_url"].count(dlid):
+                                binary = a["browser_download_url"]
+                                break
+    mdict = {"releases url": web,
+             "binary url": binary,
+             "version": new_version,
+             "update available": update,
+             "errors": errors,
+             }
+    return mdict

dcscope/gui/widgets/__init__.py

@@ -0,0 +1,15 @@
+# flake8: noqa: F401
+from .bg_thread import run_async
+from .double_spin_box_nan import DoubleSpinBoxNan
+from .feature_combobox import FeatureComboBox
+from .get_path import get_directory
+from .key_value_table_widget import KeyValueTableWidget
+from .mdi_subwindow_wo_close import MDISubWindowWOButtons
+from .qrangeslider import QRangeSlider
+from .rangecontrol import RangeControl
+from .simple_image_view import SimpleImageView
+from .simple_plot_widget import (SimplePlotItem,
+                                 SimplePlotWidget,
+                                 SimpleViewBox)
+from .so_colorbaritem import DCscopeColorBarItem
+from .wait_cursor import show_wait_cursor, ShowWaitCursor

dcscope/gui/widgets/bg_thread.py

@@ -0,0 +1,29 @@
+"""https://stackoverflow.com/questions/39304951/"""
+from functools import wraps
+
+from PyQt6 import QtCore
+
+
+class Runner(QtCore.QThread):
+    """Runs a function in the background"""
+
+    def __init__(self, target, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._target = target
+        self._args = args
+        self._kwargs = kwargs
+
+    def run(self):
+        self._target(*self._args, **self._kwargs)
+
+
+def run_async(func):
+    """Decorator for running a function in the background"""
+    @wraps(func)
+    def async_func(*args, **kwargs):
+        runner = Runner(func, *args, **kwargs)
+        # Keep the runner somewhere or it will be destroyed
+        func.__runner = runner
+        runner.start()
+
+    return async_func

dcscope/gui/widgets/bulk_list.py

@@ -0,0 +1,79 @@
+import importlib.resources
+
+from PyQt6 import uic, QtCore, QtWidgets
+
+
+class BulkList(QtWidgets.QWidget):
+
+    def __init__(self, parent, title=None, items=None, *args, **kwargs):
+        """A checkable list with bulk (de-)selection button"""
+        super(BulkList, self).__init__(parent=parent, *args, **kwargs)
+        ref = importlib.resources.files(
+            "dcscope.gui.widgets") / "bulk_list.ui"
+        with importlib.resources.as_file(ref) as path_ui:
+            uic.loadUi(path_ui, self)
+
+        if title is not None:
+            self.set_title(title)
+
+        if items is not None:
+            self.set_items(items)
+
+        # select none by default
+        self.on_select_none()
+
+        # signals
+        self.toolButton_all.clicked.connect(self.on_select_all)
+        self.toolButton_none.clicked.connect(self.on_select_none)
+
+    def get_selection(self):
+        items = []
+        for ii in range(self.listWidget.count()):
+            wid = self.listWidget.item(ii)
+            if wid.checkState() == QtCore.Qt.CheckState.Checked:
+                items.append(wid.data(101))
+        return items
+
+    def set_items(self, items, labels=None):
+        """Set the items of the list widget
+
+        Parameters
+        ----------
+        items: list
+            A list of the items in the list. If `labels` is
+            None then this must be a list of strings. This
+            is what is returned by `get_selection`.
+        labels: list of str
+            If set, use these strings as placeholders in the
+            list widget.
+        """
+        if labels is None:
+            labels = items
+        self.listWidget.clear()
+        for item, label in zip(items, labels):
+            wid = QtWidgets.QListWidgetItem(label)
+            wid.setData(101, item)
+            wid.setCheckState(QtCore.Qt.CheckState.Unchecked)
+            self.listWidget.addItem(wid)
+
+    def set_title(self, title):
+        """Set the title of the group box"""
+        self.groupBox.setTitle(title)
+
+    @QtCore.pyqtSlot()
+    def on_select_all(self):
+        """Select all items"""
+        self.toolButton_none.setVisible(True)
+        self.toolButton_all.setVisible(False)
+        for ii in range(self.listWidget.count()):
+            wid = self.listWidget.item(ii)
+            wid.setCheckState(QtCore.Qt.CheckState.Checked)
+
+    @QtCore.pyqtSlot()
+    def on_select_none(self):
+        """Deselect all items"""
+        self.toolButton_none.setVisible(False)
+        self.toolButton_all.setVisible(True)
+        for ii in range(self.listWidget.count()):
+            wid = self.listWidget.item(ii)
+            wid.setCheckState(QtCore.Qt.CheckState.Unchecked)

dcscope/gui/widgets/bulk_list.ui

@@ -0,0 +1,95 @@
+<?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>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <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="QGroupBox" name="groupBox">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="title">
+      <string>List content</string>
+     </property>
+     <property name="checkable">
+      <bool>false</bool>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_2">
+      <item>
+       <widget class="QListWidget" name="listWidget"/>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <widget class="QLabel" name="label_help_selection">
+          <property name="text">
+           <string>&lt;a href=&quot;https://dcscope.readthedocs.io/en/stable/sec_qg_export_data.html#sec-qg-export-data-faq&quot;&gt;Why are not all selected?&lt;/a&gt;</string>
+          </property>
+          <property name="openExternalLinks">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="QToolButton" name="toolButton_none">
+          <property name="text">
+           <string>select none</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="toolButton_all">
+          <property name="text">
+           <string>select all</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

dcscope/gui/widgets/double_spin_box_nan.py

@@ -0,0 +1,75 @@
+import numpy as np
+from PyQt6 import QtWidgets, QtGui
+
+
+class DoubleSpinBoxNan(QtWidgets.QDoubleSpinBox):
+    """A doubleSpinBox that uses minimum() and maximum() as np.nan"""
+
+    def __init__(self, *args, **kwargs):
+        super(DoubleSpinBoxNan, self).__init__(*args, **kwargs)
+        self._suffix = self.suffix()  # remember initial suffix
+        self.validator = NanFloatValidator()
+
+    def validate(self, text, position):
+        return self.validator.validate(text, position, self.suffix())
+
+    def value(self):
+        value = super(DoubleSpinBoxNan, self).value()
+        if value == self.minimum() or value == self.maximum():
+            value = np.nan
+        return value
+
+    def valueFromText(self, text):
+        if text == "nan":
+            return np.nan
+        else:
+            return convert_string_to_nanfloat(text[:-len(self.suffix())])
+
+    def textFromValue(self, value):
+        if value == self.minimum() or value == self.maximum():
+            return "nan"
+        else:
+            return str(value)
+
+
+class NanFloatValidator(QtGui.QValidator):
+    def validate(self, text, position, suffix):
+        string = text[:-len(suffix)]
+        if string in ["n", "na", "nan"]:
+            text = "nan"
+        if valid_nanfloat_string(string):
+            return self.State.Acceptable, text, position
+        elif string == "":
+            return self.State.Intermediate, text, position
+        return self.State.Invalid, text, position
+
+    def fixup(self, text):
+        try:
+            val = convert_string_to_nanfloat(text)
+        except ValueError:
+            val = ""
+        return str(val)
+
+
+def valid_nanfloat_string(string):
+    try:
+        convert_string_to_nanfloat(string)
+    except ValueError:
+        valid = False
+    else:
+        valid = True
+    return valid
+
+
+def convert_string_to_nanfloat(string):
+    try:
+        val = float(string)
+    except ValueError:
+        string = string.strip()
+        for iid in ["n", "na", "nan"]:
+            if string.startswith(iid):
+                val = np.nan
+                break
+        else:
+            raise ValueError("Not a valid nan-float!")
+    return val