ScatterplotGraph aggregation: Fix tooltips

Author: janezd

Orange/widgets/utils/plot/owplotgui.py

@@ -646,7 +646,7 @@ def aggregate_points_check_box(self, widget):
         cb.setToolTip(
             "Dense regions with many points are aggregated into "
             "circles or pie charts,\n"
-            "unless data is jittered or labels, selection or subset is shown")
+            "unless data is jittered or labels, selection or subset is shown.")
 
     def regression_line_check_box(self, widget):
         self._master.cb_reg_line = \

Orange/widgets/visualize/owscatterplotgraph.py

@@ -2,7 +2,7 @@
 import itertools
 import warnings
 from collections import Counter
-from typing import Callable
+from typing import Callable, NamedTuple
 from xml.sax.saxutils import escape
 from datetime import datetime, timezone
 
@@ -163,6 +163,11 @@ def __init__(self, *args, **kwargs):
         self._agg_size_default = 50
         self._agg_threshold_default = 10
 
+        self._nonaggregated = True
+        self._agg_indices = None
+        self._agg_coords = None
+        self._agg_r2s = None
+
     def setZ(self, z):
         """
         Set z values for all points.
@@ -223,9 +228,14 @@ def setAggregation(self, enabled):
     def paint(self, painter, option, widget=None):
         # super().paint will reset painter.transform, so we must compute
         # all transformations in advance
-        agg_pts, agg_colors = self._get_aggregated_points(painter)
+        self._nonaggregated = True
+        self._agg_indices = None
+        self._agg_coords = None
+        self._agg_r2s = None
+        agg_colors = self._get_aggregated_points(painter)
 
         try:
+            self.data["visible"] = self._nonaggregated
             if self._z_mapping is not None:
                 assert len(self._z_mapping) == len(self.data)
                 self.data = self.data[self._z_mapping]
@@ -235,19 +245,23 @@ def paint(self, painter, option, widget=None):
             painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
             super().paint(painter, option, widget)
         finally:
+            self.data["visible"] = True
             if self._inv_mapping is not None:
                 self.data = self.data[self._inv_mapping]
 
-        self._paint_aggregated_points(painter, agg_pts, agg_colors)
+        self._paint_aggregated_points(painter, agg_colors)
+
+    def _grid_index(self, x, y):
+        assert self._aggregation_grid_pars is not None
 
     def _get_aggregated_points(self, painter):
         if self._aggregation_size is None:
-            return None, None
+            return None
 
         viewmask = self._maskAt(self.viewRect())
         data = self.data[viewmask]
         if len(data) == 0:
-            return None, None
+            return None
 
         x, y = data["x"], data["y"]
         xmi, xma = np.min(x), np.max(x)
@@ -269,43 +283,43 @@ def _get_aggregated_points(self, painter):
         counts = np.bincount(idx, minlength=NX * NY)
 
         if np.max(counts) < self._aggregation_threshold:
-            return None, None
+            return None
 
-        visible = np.ones(len(self.data), dtype=bool)
-        visible[viewmask] = counts[idx] < self._aggregation_threshold
-        self.data["visible"] = visible
+        self._nonaggregated = np.ones(len(self.data), dtype=bool)
+        self._nonaggregated[viewmask] = counts[idx] < self._aggregation_threshold
 
         agg_pts = []
+        self._agg_indices = []
         agg_colors = []
         brushes = data["brush"]
         for i, count in enumerate(counts):
             if count < self._aggregation_threshold:
                 continue
             mask = idx == i
             agg_pts.append([np.mean(x[mask]), np.mean(y[mask])])
+            self._agg_indices.append(np.flatnonzero(mask))
             agg_colors.append(
                 Counter(
                     brush.color().getRgb() for brush in brushes[mask]
                 )
             )
-        agg_pts = fn.transformCoordinates(painter.transform(), np.array(agg_pts).T).T
-
-        return agg_pts, agg_colors
+        self._agg_coords = fn.transformCoordinates(painter.transform(), np.array(agg_pts).T).T
+        return agg_colors
 
-    def _paint_aggregated_points(self, painter, agg_pts, agg_colors):
-        if agg_pts is None:
+    def _paint_aggregated_points(self, painter, agg_colors):
+        if self._agg_coords is None:
             return
 
-        self.data["visible"] = True
-
         countf = 8 / max(sum(c.values()) for c in agg_colors)
         text_opt = QTextOption()
         text_opt.setAlignment(Qt.AlignCenter)
-        for (pt, spot_colors) in zip(agg_pts, agg_colors):
+        rs = []
+        for (pt, spot_colors) in zip(self._agg_coords, agg_colors):
             painter.resetTransform()
             painter.translate(*pt)
             total = sum(spot_colors.values())
             r = int(6 + countf * total)
+            rs.append(r + 12)
             if len(spot_colors) == 1:
                 color = QColor(*next(iter(spot_colors)))
                 painter.setBrush(fn.mkBrush(color))
@@ -332,6 +346,33 @@ def _paint_aggregated_points(self, painter, agg_pts, agg_colors):
             painter.setBrush(fn.mkBrush(QColor(0, 0, 0)))
             painter.setPen(fn.mkPen(QColor(0, 0, 0)))
             painter.drawText(QRectF(-15, -15, 30, 30), str(total), text_opt)
+        self._agg_r2s = np.array(rs) ** 2
+
+    def aggregatedPointsAt(self, pos):
+        """
+        Returns indices of aggregated points for the given **scene** coordinate.
+
+        Note that unlike pointsAt, this function's argument is scene coordinate
+        and not data coordinate. This is because the aggregation is done in scene
+        coordinates.
+        """
+        if self._agg_indices is None:
+            indices = []
+        else:
+            x, y = pos.x(), pos.y()
+            aggs = np.flatnonzero(
+                np.sum((self._agg_coords - np.array([x, y])) ** 2, axis=1)
+                < self._agg_r2s)
+            indices = list(itertools.chain(*(self._agg_indices[i] for i in aggs)))
+        return self.points()[indices][::-1]
+
+    def pointsAt(self, pos):
+        # Override to ignore aggregated points.
+        try:
+            self.data["visible"] = self._nonaggregated
+            return super().pointsAt(pos)
+        finally:
+            self.data["visible"] = True
 
 def _define_symbols():
     """
@@ -628,7 +669,11 @@ def get_size_data(self):
     show_legend = Setting(True)
     class_density = Setting(False)
     jitter_size = Setting(0)
-    aggregate_dense_regions = False  # Override in subclasses
+
+    # Subclasses that want to "opt in" aggregation of dense regions should
+    # override this with `aggregate_dense_regions = Setting(True)`
+    # (or `Setting(False)` if they want to have it disabled by default).
+    aggregate_dense_regions = False
 
     resolution = 256
 
@@ -1749,11 +1794,13 @@ def help_event(self, event):
         """
         if self.scatterplot_item is None:
             return False
-        act_pos = self.scatterplot_item.mapFromScene(event.scenePos())
-        point_data = [p.data() for p in self.scatterplot_item.pointsAt(act_pos)]
-        text = self.master.get_tooltip(point_data)
-        if text:
-            QToolTip.showText(event.screenPos(), text, widget=self.plot_widget)
-            return True
+        pos = event.scenePos()
+        act_pos = self.scatterplot_item.mapFromScene(pos)
+        if len(points := self.scatterplot_item.aggregatedPointsAt(pos)) != 0:
+            text = self.master.get_aggregated_tooltip([p.data() for p in points])
+        elif len(points := self.scatterplot_item.pointsAt(act_pos)) != 0:
+            text = self.master.get_tooltip([p.data() for p in points])
         else:
             return False
+        QToolTip.showText(event.screenPos(), text, widget=self.plot_widget)
+        return True

Orange/widgets/visualize/tests/test_owscatterplot.py

@@ -664,6 +664,8 @@ def test_tooltip(self):
         data = Table("heart_disease")
         self.send_signal(self.widget.Inputs.data, data)
         widget = self.widget
+        widget.graph.aggregate_dense_regions = False
+
         graph = widget.graph
         scatterplot_item = graph.scatterplot_item
 

Orange/widgets/visualize/tests/test_owscatterplotbase.py

@@ -4,10 +4,9 @@
 from unittest.mock import patch, Mock
 import numpy as np
 
-from AnyQt.QtCore import QRectF, Qt
+from AnyQt.QtCore import QRectF, QPointF, Qt
 from AnyQt.QtGui import QColor, QTransform
 from AnyQt.QtTest import QSignalSpy
-
 from pyqtgraph import mkPen, mkBrush
 
 from orangewidget.tests.base import GuiTest
@@ -1364,6 +1363,42 @@ def test_allow_aggregation(self):
         graph.jitter_size = 0
         self.assertTrue(graph.allow_aggregation())
 
+    @patch("AnyQt.QtWidgets.QToolTip.showText")
+    def test_help_event(self, _):
+        master = self.master
+        graph = self.graph
+        event = Mock()
+
+        graph.scatterplot_item = None
+        self.assertFalse(graph.help_event(event))
+
+        scp = graph.scatterplot_item = Mock()
+        scp.mapFromScene = Mock()
+        scp.aggregatedPointsAt = Mock(return_value=[])
+        master.get_aggregated_tooltip = Mock()
+        scp.pointsAt = Mock(return_value=[])
+        master.get_tooltip = Mock()
+
+        self.assertFalse(graph.help_event(event))
+
+        mv = [Mock(), Mock()]
+        scp.pointsAt = Mock(return_value=mv)
+        self.assertTrue(graph.help_event(event))
+        master.get_aggregated_tooltip.assert_not_called()
+        master.get_tooltip.assert_called_with([mv[0].data.return_value,
+                                               mv[1].data.return_value])
+        master.get_aggregated_tooltip.reset_mock()
+        scp.pointsAt.reset_mock()
+        master.get_tooltip.reset_mock()
+
+        scp.aggregatedPointsAt = Mock(return_value=mv)
+        self.assertTrue(graph.help_event(event))
+        master.get_tooltip.assert_not_called()
+        scp.pointsAt.assert_not_called()
+        master.get_aggregated_tooltip.assert_called_with([mv[0].data.return_value,
+                                                          mv[1].data.return_value])
+
+
     def test_show_grid(self):
         graph = self.graph
         show_grid = self.graph.plot_widget.showGrid = Mock()
@@ -1732,43 +1767,86 @@ def test_get_aggregate_points(self):
         painter = Mock()
         painter.transform = lambda: QTransform(1, 0, 0, 0, -1, 0, 0, 0, 1)
 
-        self.assertEqual(scp._get_aggregated_points(painter), (None, None))
+        self.assertIsNone(scp._get_aggregated_points(painter))
         np.testing.assert_equal(scp.data["visible"], np.ones(n))
 
         scp.setAggregation(True)
-        pts, colors = scp._get_aggregated_points(painter)
+        scp._nonaggregated = True
+        colors = scp._get_aggregated_points(painter)
+        pts = scp._agg_coords
         np.testing.assert_almost_equal(pts, [[ 1.16666667, -3.06666667]])
         self.assertEqual(colors, [{(0, 0, 0, 255): 2, (10, 10, 10, 255): 1}])
-        np.testing.assert_equal(scp.data["visible"], [0, 0, 0, 1, 1, 1, 1])
+        np.testing.assert_equal(scp._nonaggregated, [0, 0, 0, 1, 1, 1, 1])
 
         scp._aggregation_threshold = 2
-        pts, colors = scp._get_aggregated_points(painter)
+        scp._nonaggregated = True
+        colors = scp._get_aggregated_points(painter)
+        pts = scp._agg_coords
         np.testing.assert_almost_equal(pts, [[1.16666667, -3.06666667],
                                              [24.25, -100]])
         self.assertEqual(colors, [
             {(0, 0, 0, 255): 2, (10, 10, 10, 255): 1},
             {(20, 20, 20, 255): 1, (40, 40, 40, 255): 1}
         ])
-        np.testing.assert_equal(scp.data["visible"], [0, 0, 0, 0, 1, 0, 1])
+        np.testing.assert_equal(scp._nonaggregated, [0, 0, 0, 0, 1, 0, 1])
         scp.data["visible"] = np.ones(n)
 
         scp._aggregation_threshold = 4
-        self.assertEqual(scp._get_aggregated_points(painter), (None, None))
-        np.testing.assert_equal(scp.data["visible"], np.ones(n))
+        scp._nonaggregated = True
+        self.assertIsNone(scp._get_aggregated_points(painter))
+        np.testing.assert_equal(scp._nonaggregated, np.ones(n))
 
     def test_paint_aggregated_points(self):
         scp = ScatterPlotItem()
         painter = Mock()
 
-        pts = [[1, 2], [3, 4]]
+        scp._agg_coordspts = [[1, 2], [3, 4]]
         colors = [
             {(0, 0, 0, 255): 2, (10, 10, 10, 255): 1},
             {(20, 20, 20, 255): 3}
         ]
 
         # Well ... don't crash, OK?
-        scp._paint_aggregated_points(painter, pts, colors)
-        scp._paint_aggregated_points(painter, None, None)
+        scp._paint_aggregated_points(painter, colors)
+        scp._paint_aggregated_points(painter, None)
+
+    def test_pointsAt(self):
+        x, y = np.array([[1, 3], [1, 3], [1.5, 3.2],
+                         [24, 100],
+                         [200, 1],
+                         [24.5, 100], [200, 20]]).T
+        n = len(x)
+        scp = ScatterPlotItem(x=x, y=y)
+        scp.setBrush([mkBrush(QColor(0, 0, 0))] +
+                     [mkBrush(QColor(10 * i, 10 * i, 10 * i)) for i in range(n - 1)])
+        scp.setPointData(np.arange(n))
+        scp._agg_size_default = 10
+        scp._maskAt = Mock(return_value=np.arange(n - 1))
+        painter = Mock()
+        painter.transform = lambda: QTransform(1, 0, 0, 0, -1, 0, 0, 0, 1)
+        scp.setAggregation(True)
+        scp._aggregation_threshold = 2
+
+        scp._nonaggregated = True
+        agg_colors = scp._get_aggregated_points(painter)
+        scp._paint_aggregated_points(painter, agg_colors)
+
+        self.assertEqual(
+            {p.data() for p in scp.aggregatedPointsAt(QPointF(1.2, 1.3))}, {0, 1, 2})
+        self.assertEqual(
+            len(scp.aggregatedPointsAt(QPointF(200, 1))), 0)
+
+        def test_mask(*_, **__):
+            np.testing.assert_equal(
+                scp.data["visible"],
+                [False, False, False, False, True, False, True])
+
+        with patch(
+                "pyqtgraph.graphicsItems.ScatterPlotItem.ScatterPlotItem.pointsAt",
+                new=test_mask):
+            scp.pointsAt(QPointF(1.2, 1.3))
+        np.testing.assert_equal(scp.data["visible"], True)
+
 
 
 if __name__ == "__main__":

Orange/widgets/visualize/utils/widget.py

@@ -341,6 +341,20 @@ def get_tooltip(self, point_ids):
             text = f"{len(point_ids)} instances<hr/>{text}<hr/>..."
         return text
 
+    def get_aggregated_tooltip(self, point_ids):
+        """
+        Return tooltip for aggregate points (e.g. piecharts).
+
+        Default implementation falls back to get_tooltip
+
+        Args:
+            point_ids (list): indices into 'data'
+
+        Returns:
+            tooltip (str)
+        """
+        return self.get_tooltip(point_ids)
+
     def keyPressEvent(self, event):
         """Update the tip about using the modifier keys when selecting"""
         super().keyPressEvent(event)

i18n/si/msgs.jaml

@@ -13645,7 +13645,7 @@ widgets/utils/plot/owplotgui.py:
             Aggregate points in dense regions: Združi točke v gostih regijah
             'Dense regions with many points are aggregated into ': "Goste regije z veliko točkami so združene v "
             circles or pie charts,\n: kroge ali tortne diagrame,\n
-            unless data is jittered or labels, selection or subset is shown: razen če so točke tresene ali pa so prikazane oznake, izbori ali podmnožice.
+            unless data is jittered or labels, selection or subset is shown.: razen če so točke tresene ali pa so prikazane oznake, izbori ali podmnožice.
         def `regression_line_check_box`:
             show_reg_line: false
             Show regression line: Pokaži regresijsko premico