enh: reduce delay after selecting axes in the Plot view

Author: paulmueller

CHANGELOG

@@ -1,4 +1,5 @@
 2.26.2
+ - enh: reduce delay after selecting axes in the Plot view
  - 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

dcscope/gui/analysis/ana_plot.py

@@ -276,7 +276,7 @@ def _set_range_feat_state(self, feat, fmin=None, fmax=None):
         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])
@@ -307,16 +307,19 @@ def _set_range_xy_state(self, axis_x=None, range_x=None,
                                   [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],
@@ -347,12 +350,9 @@ def _set_kde_spacing(self, spacing_x=None, spacing_y=None):
                 spinBox.setSingleStep(10**(-dec + 1))
                 spinBox.setValue(spacing)
 
-    def _set_kde_spacing_auto(self, axis_x=None, axis_y=None):
+    def _set_kde_spacing_simple(self, axis_x=None, axis_y=None):
         """automatically estimate and set the KDE spacing
 
-        - uses :func:`dclab.kde.binning.bin_width_percentile`
-        - uses _set_kde_spacing
-
         Not to be confused with `on_spacing_auto`!
         """
         if len(self.pipeline.slots) == 0:
@@ -361,32 +361,28 @@ def _set_kde_spacing_auto(self, axis_x=None, axis_y=None):
             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.binning.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_kde_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):
@@ -432,14 +428,14 @@ def on_axis_changed(self):
         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_kde_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_kde_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_kde_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_kde_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):

dcscope/pipeline/core.py

@@ -4,6 +4,7 @@
 import warnings
 
 import dclab
+from dclab.rtdc_dataset import RTDC_Hierarchy
 import numpy as np
 
 from ..idiom import FEATURES_MONOTONOUS
@@ -481,7 +482,9 @@ def get_dataset(self, slot_index, filt_index=-1, apply_filter=True):
             ds = ray.get_dataset(apply_filter=apply_filter)
         return ds
 
-    def get_datasets(self, filt_index=-1, apply_filter=True):
+    def get_datasets(self,
+                     filt_index: int | None = -1,
+                     apply_filter: bool = True):
         """Return all datasets with filters applied
 
         The parameters are passed to :func:`Pipeline.get_dataset`.
@@ -654,8 +657,75 @@ def get_min_max(self, feat, plot_id=None, margin=0.0):
                               EmptyDatasetWarning)
         if margin:
             diff = fmax - fmin
-            fmin -= margin*diff
-            fmax += margin*diff
+            fmin -= margin * diff
+            fmax += margin * diff
+
+        if np.any(np.isinf([fmin, fmax])):
+            # Set values to 0 if no
+            fmin = fmax = 0
+        return [fmin, fmax]
+
+    def get_min_max_coarse(self, feat, plot_id=None, margin=0.0):
+        """Return coarse minimum and maximum values for a feature
+
+        Coarse feature computation is faster then the accurate
+        :func:`get_min_max`, because it uses metadata stored in the
+        root dataset. The range is thus always equal to or larger
+        than that returned by :func:`get_min_max`.
+
+        Parameters
+        ----------
+        feat: str
+            Feature name
+        plot_id: str
+            Plot identifier
+        margin: float
+            Fraction by which the minimum and maximum are
+            extended. E.g. for plotting with a 5% margin
+            use `margin=0.05`.
+
+        Returns
+        -------
+        [fmin, fmax]: list of float
+            Minimum and maximum values of the feature. If the feature
+            is empty or only-nan, an :class:`EmptyDatasetWarning` is
+            issued and both return values are set to zero.
+        """
+        if plot_id is not None:
+            dslist_children = self.get_plot_datasets(plot_id)[0]
+            dslist = []
+            for ch in dslist_children:
+                if isinstance(ch, RTDC_Hierarchy):
+                    dslist.append(ch.get_root_parent())
+                else:
+                    dslist.append(ch)
+        else:
+            dslist = self.get_datasets(filt_index=None, apply_filter=False)
+
+        fmin = np.inf
+        fmax = -np.inf
+        for ds in dslist:
+            if np.any(ds.filter.all):
+                if feat in ds:
+                    vmin = ds[feat].min()
+                    if not np.isnan(vmin):
+                        fmin = min(vmin, fmin)
+
+                    vmax = ds[feat].max()
+                    if not np.isnan(vmax):
+                        fmax = max(vmax, fmax)
+                else:
+                    warnings.warn(f"Dataset {ds.identifier} does not "
+                                  f"contain the feature '{feat}'!",
+                                  MissingFeatureWarning)
+            else:
+                warnings.warn(f"Dataset {ds.identifier} does not "
+                              f"contain any events when filtered!",
+                              EmptyDatasetWarning)
+        if margin:
+            diff = fmax - fmin
+            fmin -= margin * diff
+            fmax += margin * diff
 
         if np.any(np.isinf([fmin, fmax])):
             # Set values to 0 if no