dcscope 2.26.0__tar.gz → 2.26.2__tar.gz

{dcscope-2.26.0 → dcscope-2.26.2}/CHANGELOG

@@ -1,3 +1,27 @@
+2.26.2
+ - reg: filters not applied in final plots since 2.25.1
+ - fix: prevent `pipeline.lock` deadlocks via Qt signal cluttering
+ - fix: update axes ranges when "Auto XY-range" is selected in plotting
+ - enh: remember plot size when manually resizing
+ - enh: increase default disk store size from 2GB to 9GB
+ - enh: reduce delay after selecting axes in the Plot view
+ - ref: incorporate `PipelinePlot` into sender-receiver signal pyramid
+ - setup: bump dclab to 0.71.2 (disk-caching of DCOR/HTTP/S3 data)
+2.26.1
+ - fix: possibly fix `KeyError` on hover in QuickView by doing a
+   `GraphicsScene.hoverItems.clear()` whenever something changes (#205)
+ - fix: disable Block Matrix QuickView selection when QuickView is closed
+ - fix: don't update hidden QuickView panel when the pipeline changes
+ - fix: don't replot in QuickView when the plot parameters are identical
+ - fix: always show event view in QuickView when initialized
+ - enh: allow to modify caching settings in the "Advanced" preferences tab
+ - enh: joint KDE map for scatter and contour visualization (#111)
+ - enh: setup basic logging
+ - enh: inform user about unavailable contour data with dclab 0.71.0 (#207)
+ - ref: move contour spacing plot settings to "General" section
+ - ref: migrate find smooth contour spacing code to dclab
+ - ref: remove redundant `plotting` submodule
+ - setup: bump dclab to 0.71.1 (smooth contours, joint KDE maps)
 2.26.0
  - feat: edit, duplicate and remove polygon filters in the "Filter" view
  - fix: override-check in filter export did not work
@@ -37,7 +61,7 @@
  - enh: improved presentation of multiple datasets with identical sample names
  - ref: tentative `set_pipeline`, so widgets have direct access to the pipeline
  - ref: raise ValueError in unreachable case in DataSlot creation
- - ref: restructure pipeline management through signaling
+ - ref: restructure pipeline management with sender-receiver signal pyramid
  - ref: move slot, plot, and filter duplication to `Pipeline` class
  - ref: refer power to Slot/Plot/Filter creation to `Pipeline`
  - setup: bump pyqtgraph to 0.14.0
@@ -584,7 +608,7 @@
 2.1.0
  - feat: basic DCOR support
  - fix: improved session support (older pre-release sessions)
- - docs: add DCOR guick guide 
+ - docs: add DCOR guick guide
  - enh: export event image via context menu in Quick View (#35)
  - setup: bump dclab from 0.21.1 to 0.22.1 (DCOR support)
 2.0.3

{dcscope-2.26.0/dcscope.egg-info → dcscope-2.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcscope
-Version: 2.26.0
+Version: 2.26.2
 Summary: User interface for deformability cytometry (DC)
 Author: Benedikt Hartmann, Eoghan O'Connell, Maximilian Schlögel, Paul Müller, Raghava Alajangi
 Maintainer-email: Paul Müller <dev@craban.de>
@@ -16,7 +16,7 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: dclab[dcor,export,http,s3]>=0.69.2
+Requires-Dist: dclab[dcor,export,http,s3]>=0.71.2
 Requires-Dist: h5py>=2.8.0
 Requires-Dist: numpy>=1.21
 Requires-Dist: pygments

dcscope-2.26.2/dcscope/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.26.2'
+__version_tuple__ = version_tuple = (2, 26, 2)
+
+__commit_id__ = commit_id = 'ga09ea9064'

{dcscope-2.26.0 → dcscope-2.26.2}/dcscope/gui/analysis/ana_filter.py

@@ -211,7 +211,7 @@ class FilterPanel(QtWidgets.QWidget):
         with self.pipeline.lock:
             filt_id = self.current_filter.identifier
             new_id = self.pipeline.duplicate_filter(filt_id)
-            self.pp_mod_send.emit({"pipeline": {"filter_added": new_id}})
+        self.pp_mod_send.emit({"pipeline": {"filter_added": new_id}})
 
     def get_polygon_filter_selection(self):
         """Return selected polygon filters"""
@@ -293,7 +293,7 @@ class FilterPanel(QtWidgets.QWidget):
                 self.update_content(filt_index)
 
         qv_dict = data.get("quickview")
-        if qv_dict:
+        if qv_dict and qv_dict.get("enabled"):
             if self.isVisible():
                 # If quickview is clicked, show corresponding filter
                 filt_index = qv_dict.get("filt_index")
@@ -309,7 +309,7 @@ class FilterPanel(QtWidgets.QWidget):
         with self.pipeline.lock:
             filt_id = self.current_filter.identifier
             self.pipeline.remove_filter(filt_id)
-            self.pp_mod_send.emit({"pipeline": {"filter_removed": filt_id}})
+        self.pp_mod_send.emit({"pipeline": {"filter_removed": filt_id}})
 
     @QtCore.pyqtSlot()
     def on_moreless(self):
@@ -442,4 +442,4 @@ class FilterPanel(QtWidgets.QWidget):
             filt_id = filter_state["identifier"]
             filt_index = self.pipeline.filter_ids.index(filt_id)
             self.pipeline.filters[filt_index].__setstate__(filter_state)
-            self.pp_mod_send.emit({"pipeline": {"filter_modified": filt_id}})
+        self.pp_mod_send.emit({"pipeline": {"filter_modified": filt_id}})

{dcscope-2.26.0 → dcscope-2.26.2}/dcscope/gui/analysis/ana_plot.py

@@ -1,20 +1,22 @@
 import importlib.resources
+import logging
 
 import dclab
+import dclab.kde.binning
 import dclab.kde.methods
+import dclab.kde.smooth_contour
 import numpy as np
-from PyQt6 import uic, QtCore, QtWidgets
+from PyQt6 import QtCore, QtWidgets, uic
 
 from ...pipeline.plot import STATE_OPTIONS
-
-from ..pipeline_plot import (
-    compute_contours, compute_contour_opening_angles, compute_contour_reliable)
-
 from ..widgets import show_wait_cursor
 
 COLORMAPS = STATE_OPTIONS["scatter"]["colormap"]
 
 
+logger = logging.getLogger(__name__)
+
+
 class PlotPanel(QtWidgets.QWidget):
     # widgets emit these whenever they changed the pipeline
     pp_mod_send = QtCore.pyqtSignal(dict)
@@ -102,6 +104,8 @@ class PlotPanel(QtWidgets.QWidget):
                 "range y": [ry["start"], ry["end"]],
                 "scale x": self.comboBox_scale_x.currentData(),
                 "scale y": self.comboBox_scale_y.currentData(),
+                "spacing x": self.doubleSpinBox_spacing_x.value(),
+                "spacing y": self.doubleSpinBox_spacing_y.value(),
             },
             "scatter": {
                 "colormap": self.comboBox_colormap.currentData(),
@@ -129,8 +133,6 @@ class PlotPanel(QtWidgets.QWidget):
                 "percentiles": [self.doubleSpinBox_perc_1.value(),
                                 self.doubleSpinBox_perc_2.value(),
                                 ],
-                "spacing x": self.doubleSpinBox_spacing_x.value(),
-                "spacing y": self.doubleSpinBox_spacing_y.value(),
             }
         }
         return state
@@ -210,8 +212,8 @@ class PlotPanel(QtWidgets.QWidget):
         self.comboBox_ls_1.setCurrentIndex(ls1_index)
         ls2_index = self.comboBox_ls_2.findData(con["line styles"][1])
         self.comboBox_ls_2.setCurrentIndex(ls2_index)
-        self._set_contour_spacing(spacing_x=con["spacing x"],
-                                  spacing_y=con["spacing y"])
+        self._set_kde_spacing(spacing_x=gen["spacing x"],
+                              spacing_y=gen["spacing y"])
         for b in toblock:
             b.blockSignals(False)
 
@@ -274,7 +276,7 @@ class PlotPanel(QtWidgets.QWidget):
         else:
             self.setEnabled(True)
         if feat is not None:
-            lim = self.pipeline.get_min_max(
+            lim = self.pipeline.get_min_max_coarse(
                 feat=feat, plot_id=self.current_plot.identifier)
             if not (np.isinf(lim[0]) or np.isinf(lim[1])):
                 self.widget_range_feat.setLimits(vmin=lim[0], vmax=lim[1])
@@ -305,24 +307,27 @@ class PlotPanel(QtWidgets.QWidget):
                                   [self.widget_range_x, self.widget_range_y],
                                   ):
             if axis is not None:
-                lim = self.pipeline.get_min_max(feat=axis, plot_id=plot_id)
+                lim = self.pipeline.get_min_max_coarse(
+                    feat=axis,
+                    plot_id=plot_id)
                 if not (np.isinf(lim[0]) or np.isinf(lim[1])):
                     rc.blockSignals(True)
                     rc.setLimits(vmin=lim[0],
                                  vmax=lim[1])
                     if rang is None or rang[0] == rang[1]:
                         # default range is limits + 5% margin
-                        rang = self.pipeline.get_min_max(feat=axis,
-                                                         plot_id=plot_id,
-                                                         margin=0.05)
+                        rang = self.pipeline.get_min_max_coarse(
+                            feat=axis,
+                            plot_id=plot_id,
+                            margin=0.05)
                     rc.write_pipeline_state({"active": True,
                                              "start": rang[0],
                                              "end": rang[1],
                                              })
                     rc.blockSignals(False)
 
-    def _set_contour_spacing(self, spacing_x=None, spacing_y=None):
-        """Set the contour spacing in the spin boxes
+    def _set_kde_spacing(self, spacing_x=None, spacing_y=None):
+        """Set the KDE spacing in the spin boxes
 
         - sets spinbox limits first
         - sets number of digits
@@ -345,11 +350,8 @@ class PlotPanel(QtWidgets.QWidget):
                 spinBox.setSingleStep(10**(-dec + 1))
                 spinBox.setValue(spacing)
 
-    def _set_contour_spacing_auto(self, axis_x=None, axis_y=None):
-        """automatically set the contour spacing
-
-        - uses :func:`dclab.kde.methods.bin_width_percentile`
-        - uses _set_contour_spacing
+    def _set_kde_spacing_simple(self, axis_x=None, axis_y=None):
+        """automatically estimate and set the KDE spacing
 
         Not to be confused with `on_spacing_auto`!
         """
@@ -359,32 +361,28 @@ class PlotPanel(QtWidgets.QWidget):
             return
         else:
             self.setEnabled(True)
-        dslist, _ = self.pipeline.get_plot_datasets(
-            self.current_plot.identifier)
-        if dslist:
-            spacings_xy = []
-            for axis, scaleCombo in zip([axis_x, axis_y],
-                                        [self.comboBox_scale_x,
-                                         self.comboBox_scale_y]):
-                if axis is None:
-                    # nothing to do
-                    spacings_xy.append(None)
-                else:
-                    # determine good approximation
-                    spacings = []
-                    for ds in dslist:
-                        spa = ds.get_kde_spacing(
-                            a=ds[axis],
-                            feat=axis,
-                            scale=scaleCombo.currentData(),
-                            method=dclab.kde.methods.bin_width_percentile,
-                        )
-                        spacings.append(spa)
-                    spacings_xy.append(np.min(spacings))
-            spacing_x, spacing_y = spacings_xy
-            # sets the limits before setting the value
-            self._set_contour_spacing(spacing_x=spacing_x,
-                                      spacing_y=spacing_y)
+
+        spacings_xy = []
+        for feat, scaleCombo in zip([axis_x, axis_y],
+                                    [self.comboBox_scale_x,
+                                     self.comboBox_scale_y]):
+            if feat is None:
+                spacings_xy.append(None)
+            else:
+                vmin, vmax = self.pipeline.get_min_max_coarse(
+                    feat=feat,
+                    plot_id=self.current_plot.identifier)
+
+                if scaleCombo.currentData() == "log":
+                    vmin = np.log(vmin)
+                    vmax = np.log(vmax)
+
+                spacings_xy.append((vmax-vmin)/300)
+
+        spacing_x, spacing_y = spacings_xy
+        # sets the limits before setting the value
+        self._set_kde_spacing(spacing_x=spacing_x,
+                              spacing_y=spacing_y)
 
     @property
     def current_plot(self):
@@ -430,14 +428,14 @@ class PlotPanel(QtWidgets.QWidget):
         gen = self.read_plot_state()["general"]
         if self.sender() == self.comboBox_axis_x:
             self._set_range_xy_state(axis_x=gen["axis x"])
-            self._set_contour_spacing_auto(axis_x=gen["axis x"])
+            self._set_kde_spacing_simple(axis_x=gen["axis x"])
         elif self.sender() == self.comboBox_axis_y:
             self._set_range_xy_state(axis_y=gen["axis y"])
-            self._set_contour_spacing_auto(axis_y=gen["axis y"])
+            self._set_kde_spacing_simple(axis_y=gen["axis y"])
         elif self.sender() == self.comboBox_scale_x:
-            self._set_contour_spacing_auto(axis_x=gen["axis x"])
+            self._set_kde_spacing_simple(axis_x=gen["axis x"])
         elif self.sender() == self.comboBox_scale_y:
-            self._set_contour_spacing_auto(axis_y=gen["axis y"])
+            self._set_kde_spacing_simple(axis_y=gen["axis y"])
 
     @QtCore.pyqtSlot()
     def on_column_num_changed(self):
@@ -498,21 +496,21 @@ class PlotPanel(QtWidgets.QWidget):
         with self.pipeline.lock:
             plot_id = self.current_plot.identifier
             new_id = self.pipeline.duplicate_plot(plot_id)
-            self.pp_mod_send.emit({"pipeline": {"plot_created": new_id}})
+        self.pp_mod_send.emit({"pipeline": {"plot_created": new_id}})
 
     @QtCore.pyqtSlot()
     def on_plot_removed(self):
         with self.pipeline.lock:
             plot_id = self.current_plot.identifier
             self.pipeline.remove_plot(plot_id)
-            self.pp_mod_send.emit({"pipeline": {"plot_removed": plot_id}})
+        self.pp_mod_send.emit({"pipeline": {"plot_removed": plot_id}})
 
     @QtCore.pyqtSlot(dict)
     def on_pp_mod_recv(self, data):
         """We received a signal that something changed"""
-        pp_dict = data.get("pipeline")
-        if pp_dict:
-            if self.isVisible():
+        if self.isVisible():
+            pp_dict = data.get("pipeline", {})
+            if "plot_added" in pp_dict:
                 plot_id = pp_dict.get("plot_added")
                 if plot_id is not None:
                     plot_index = self.pipeline.plot_ids.index(plot_id)
@@ -520,57 +518,70 @@ class PlotPanel(QtWidgets.QWidget):
                     plot_index = None
                 self.update_content(plot_index)
 
+            pr_dict = data.get("pipeline-rendering", {})
+            if "plot_size_changed" in pr_dict:
+                plot_id = pr_dict.get("plot_size_changed")
+                plot_index = self.pipeline.plot_ids.index(plot_id)
+                state = self.pipeline.plots[plot_index].__getstate__()
+                self.spinBox_size_x.setValue(state["layout"]["size x"])
+                self.spinBox_size_y.setValue(state["layout"]["size y"])
+            elif "plot_range_corrected" in pr_dict:
+                plot_id = pr_dict.get("plot_range_corrected")
+                plot_index = self.pipeline.plot_ids.index(plot_id)
+                state = self.pipeline.plots[plot_index].__getstate__()
+                for nm, rc in [("range x", self.widget_range_x),
+                               ("range y", self.widget_range_y)]:
+                    rc.blockSignals(True)
+                    rc.write_pipeline_state({
+                        "active": True,
+                        "start": state["general"][nm][0],
+                        "end": state["general"][nm][1],
+                        })
+                    rc.blockSignals(False)
+
     @QtCore.pyqtSlot()
     @show_wait_cursor
     def on_spacing_auto(self):
         """Iteratively find a good spacing for smooth contours (#110)"""
         # https://github.com/DC-analysis/DCscope/issues/110
         plot_id = self.current_plot.identifier
-        # Get all datasets belonging to this plot.
-        datasets, _ = self.pipeline.get_plot_datasets(plot_id)
         state = self.read_plot_state()
-        gen = state["general"]
-        # initial guess
-        # sensible start parameters
-        self._set_contour_spacing_auto(axis_x=gen["axis x"],
-                                       axis_y=gen["axis y"])
 
-        # retrieve state with updated spacings
-        state = self.read_plot_state()
-        phi_conv = np.deg2rad(23)
-
-        for ii in range(15):  # hard-limit is 15 iterations
-            # maximum difference of opening angle from 180° [rad]
-            max_dphi = 0
-            for ds in datasets:
-                # Compute the contour for the highest percentile of the plot.
-                state["contour"]["percentiles"] = \
-                    [np.max(state["contour"]["percentiles"])]
-                cc = compute_contours(plot_state=state, rtdc_ds=ds)[0][0]
-                if not compute_contour_reliable(
-                        plot_state=state, contour=cc, thresh_ang=phi_conv):
-                    # Compute the opening angle for each point of the cnotour
-                    # and take the point with the largest opening angle.
-                    angles = compute_contour_opening_angles(
-                        plot_state=state, contour=cc)
-                    dphi = np.max(np.abs(angles))
-                    max_dphi = max(max_dphi, np.abs(dphi))
-            if max_dphi <= phi_conv:
-                # Normal stopping criterion (opening angle <= 23°)
-                break
-            else:
-                # If the absolute opening angle is too large,
-                # we assume that we have to reduce the spacing.
-                state["contour"]["spacing x"] /= 2
-                state["contour"]["spacing y"] /= 2
+        # compute best spacing iteratively
+        res = dclab.kde.smooth_contour.find_smooth_contour_spacing(
+            # All datasets belonging to this plot.
+            ds_list=self.pipeline.get_plot_datasets(plot_id)[0],
+            xax=state["general"]["axis x"],
+            yax=state["general"]["axis y"],
+            xrange=state["general"]["range x"],
+            yrange=state["general"]["range y"],
+            quantiles=np.array(state["contour"]["percentiles"]) / 100,
+            xscale=state["general"]["scale x"],
+            yscale=state["general"]["scale y"],
+            kde_type="histogram",
+            max_iter=15,
+        )
+
+        success = res.get("success", False)
+        reason = res.get("reason", "unknown")
+        num_iter = res.get("total iterations", np.nan)
+        corners_found = res.get("corners found", "unknown")
+
+        if success:
+            logger.info(
+                f"Successfully found smooth contour within {num_iter} "
+                f"iterations: {reason} ({corners_found=})."
+            )
         else:
-            raise ValueError(
-                "Could not automatically determine contour spacing")
+            logger.warning(
+                f"Failed to find smooth contour within {num_iter} "
+                f"iterations: {reason} ({corners_found=})."
+            )
 
         # set the final spacing
         new_state = self.read_plot_state()
-        new_state["contour"]["spacing x"] = state["contour"]["spacing x"]
-        new_state["contour"]["spacing y"] = state["contour"]["spacing y"]
+        new_state["general"]["spacing x"] = res["spacing x"]
+        new_state["general"]["spacing y"] = res["spacing y"]
         self.write_plot_state(new_state)
 
     @QtCore.pyqtSlot()
@@ -645,4 +656,4 @@ class PlotPanel(QtWidgets.QWidget):
             plot_id = plot_state["identifier"]
             plot_index = self.pipeline.plot_ids.index(plot_id)
             self.pipeline.plots[plot_index].__setstate__(plot_state)
-            self.pp_mod_send.emit({"pipeline": {"plot_changed": plot_id}})
+        self.pp_mod_send.emit({"pipeline": {"plot_changed": plot_id}})