Merge pull request #1767 from VesnaT/boxplot_clickable

OWBoxPlot: Select and send selected data

Author: janezd

Orange/data/filter.py

@@ -286,6 +286,10 @@ def __call__(self, inst):
         else:
             return value in self.values
 
+    def __eq__(self, other):
+        return isinstance(other, FilterDiscrete) and \
+               self.column == other.column and self.values == other.values
+
 
 class FilterContinuous(ValueFilter):
     """
@@ -358,6 +362,11 @@ def __call__(self, inst):
             return True
         raise ValueError("invalid operator")
 
+    def __eq__(self, other):
+        return isinstance(other, FilterContinuous) and \
+               self.column == other.column and self.oper == other.oper and \
+               self.oper == other.oper and self.oper == other.oper
+
     def __str__(self):
         if isinstance(self.column, str):
             column = self.column

Orange/tests/test_filter.py

@@ -246,6 +246,18 @@ def test_str(self):
         flt.oper = -1
         self.assertEqual(str(flt), "invalid operator")
 
+    def test_eq(self):
+        flt1 = FilterContinuous(1, FilterContinuous.Between, 1, 2)
+        flt2 = FilterContinuous(1, FilterContinuous.Between, 1, 2)
+        self.assertEqual(flt1, flt2)
+
+
+class TestFilterDiscrete(unittest.TestCase):
+    def test_eq(self):
+        flt1 = FilterDiscrete(1, None)
+        flt2 = FilterDiscrete(1, None)
+        self.assertEqual(flt1, flt2)
+
 
 class TestFilterString(unittest.TestCase):
 

Orange/widgets/visualize/owboxplot.py

@@ -16,12 +16,16 @@
 from scipy.stats import f_oneway, chisquare
 
 import Orange.data
+from Orange.data.filter import FilterDiscrete, FilterContinuous, Values
 from Orange.statistics import contingency, distribution
 
 from Orange.widgets import widget, gui
 from Orange.widgets.settings import (Setting, DomainContextHandler,
                                      ContextSetting)
 from Orange.widgets.utils.itemmodels import VariableListModel
+from Orange.widgets.utils.annotated_data import (create_annotated_table,
+                                                 ANNOTATED_DATA_SIGNAL_NAME)
+from Orange.widgets.widget import Default
 
 
 def compute_scale(min_, max_):
@@ -41,7 +45,7 @@ def compute_scale(min_, max_):
 
 
 class BoxData:
-    def __init__(self, dist):
+    def __init__(self, dist, attr, group_val_index=None, group_var=None):
         self.dist = dist
         self.n = n = np.sum(dist[1])
         if n == 0:
@@ -69,6 +73,17 @@ def __init__(self, dist):
         else:
             self.q25 = self.q75 = None
             self.median = q[1] if len(q) == 2 else None
+        self.conditions = [FilterContinuous(attr, FilterContinuous.Between,
+                                            self.q25, self.q75)]
+        if group_val_index is not None:
+            self.conditions.append(FilterDiscrete(group_var, [group_val_index]))
+
+
+class FilterGraphicsRectItem(QGraphicsRectItem):
+    def __init__(self, conditions, *args):
+        super().__init__(*args)
+        self.filter = Values(conditions) if conditions else None
+        self.setFlag(QGraphicsItem.ItemIsSelectable)
 
 
 class OWBoxPlot(widget.OWWidget):
@@ -103,11 +118,14 @@ class OWBoxPlot(widget.OWWidget):
     icon = "icons/BoxPlot.svg"
     priority = 100
     inputs = [("Data", Orange.data.Table, "set_data")]
+    outputs = [("Selected Data", Orange.data.Table, Default),
+               (ANNOTATED_DATA_SIGNAL_NAME, Orange.data.Table)]
 
     #: Comparison types for continuous variables
     CompareNone, CompareMedians, CompareMeans = 0, 1, 2
 
     settingsHandler = DomainContextHandler()
+    conditions = ContextSetting([])
 
     attribute = ContextSetting(None)
     order_by_importance = Setting(False)
@@ -117,6 +135,7 @@ class OWBoxPlot(widget.OWWidget):
     stattest = Setting(0)
     sig_threshold = Setting(0.05)
     stretched = Setting(True)
+    auto_commit = Setting(True)
 
     _sorting_criteria_attrs = {
         CompareNone: "", CompareMedians: "median", CompareMeans: "mean"
@@ -201,8 +220,12 @@ def __init__(self):
             callback=self.display_changed,
             sizePolicy=(QSizePolicy.Minimum, QSizePolicy.Maximum)).box
 
+        gui.auto_commit(self.controlArea, self, "auto_commit",
+                        "Send Selection", "Send Automatically")
+
         gui.vBox(self.mainArea, addSpace=True)
         self.box_scene = QGraphicsScene()
+        self.box_scene.selectionChanged.connect(self.commit)
         self.box_view = QGraphicsView(self.box_scene)
         self.box_view.setRenderHints(QPainter.Antialiasing |
                                      QPainter.TextAntialiasing |
@@ -258,6 +281,7 @@ def set_data(self, dataset):
             self.grouping_changed()
         else:
             self.reset_all_data()
+        self.commit()
 
     def apply_sorting(self):
         def compute_score(attr):
@@ -319,6 +343,13 @@ def grouping_changed(self):
         self.apply_sorting()
         self.attr_changed()
 
+    def select_box_items(self):
+        temp_cond = self.conditions.copy()
+        for box in self.box_scene.items():
+            if isinstance(box, FilterGraphicsRectItem):
+                box.setSelected(box.filter.conditions in
+                                [c.conditions for c in temp_cond])
+
     def attr_changed(self):
         self.compute_box_data()
         self.update_display_box()
@@ -346,13 +377,14 @@ def compute_box_data(self):
             self.conts = contingency.get_contingency(
                 dataset, attr, self.group_var)
             if self.is_continuous:
-                self.stats = [BoxData(cont) for cont in self.conts]
+                self.stats = [BoxData(cont, attr, i, self.group_var)
+                              for i, cont in enumerate(self.conts)]
             self.label_txts_all = self.group_var.values
         else:
             self.dist = distribution.get_distribution(dataset, attr)
             self.conts = []
             if self.is_continuous:
-                self.stats = [BoxData(self.dist)]
+                self.stats = [BoxData(self.dist, attr, None)]
             self.label_txts_all = [""]
         self.label_txts = [txts for stat, txts in zip(self.stats,
                                                       self.label_txts_all)
@@ -369,12 +401,15 @@ def update_display_box(self):
             self.display_box.hide()
 
     def clear_scene(self):
+        self.closeContext()
+        self.box_scene.clearSelection()
         self.box_scene.clear()
         self.attr_labels = []
         self.labels = []
         self.boxes = []
         self.mean_labels = []
         self.posthoc_lines = []
+        self.openContext(self.dataset)
 
     def layout_changed(self):
         attr = self.attribute
@@ -395,7 +430,7 @@ def layout_changed(self):
                        for stat, mean_lab in zip(self.stats, self.mean_labels)]
         self.attr_labels = [QGraphicsSimpleTextItem(lab)
                             for lab in self.label_txts]
-        for it in chain(self.labels, self.boxes, self.attr_labels):
+        for it in chain(self.labels, self.attr_labels):
             self.box_scene.addItem(it)
         self.display_changed()
 
@@ -416,7 +451,9 @@ def display_changed(self):
 
         for row, box_index in enumerate(self.order):
             y = (-len(self.stats) + row) * heights + 10
-            self.boxes[box_index].setY(y)
+            for item in self.boxes[box_index].childItems():
+                self.box_scene.addItem(item)
+                item.setY(y)
             labels = self.labels[box_index]
 
             if self.show_annotations:
@@ -448,6 +485,7 @@ def display_changed(self):
 
         self.compute_tests()
         self.show_posthoc()
+        self.select_box_items()
 
     def display_changed_disc(self):
         self.clear_scene()
@@ -465,7 +503,7 @@ def display_changed_disc(self):
 
         self.draw_axis_disc()
         if self.group_var:
-            self.boxes = [self.strudel(cont) for cont in self.conts]
+            self.boxes = [self.strudel(cont, i) for i, cont in enumerate(self.conts)]
         else:
             self.boxes = [self.strudel(self.dist)]
 
@@ -496,12 +534,14 @@ def display_changed_disc(self):
                     self.box_scene.addItem(label)
             for text_item in box.childItems()[1::2]:
                 box.removeFromGroup(text_item)
-            self.box_scene.addItem(box)
-            box.setPos(0, y)
+            for item in box.childItems():
+                self.box_scene.addItem(item)
+                item.setPos(0, y)
         self.box_scene.setSceneRect(-self.label_width - 5,
                                     -30 - len(self.boxes) * 40,
                                     self.scene_width, len(self.boxes * 40) + 90)
         self.infot1.setText("")
+        self.select_box_items()
 
     # noinspection PyPep8Naming
     def compute_tests(self):
@@ -584,7 +624,7 @@ def mean_label(self, stat, attr, val_name):
     def draw_axis(self):
         """Draw the horizontal axis and sets self.scale_x"""
         misssing_stats = not self.stats
-        stats = self.stats or [BoxData(np.array([[0.], [1.]]))]
+        stats = self.stats or [BoxData(np.array([[0.], [1.]]), self.attribute)]
         mean_labels = self.mean_labels or [self.mean_label(stats[0], self.attribute, "")]
         bottom = min(stat.a_min for stat in stats)
         top = max(stat.a_max for stat in stats)
@@ -763,9 +803,9 @@ def line(x0, y0, x1, y1, *args):
         var_line.setPen(self._pen_paramet)
 
         if stat.q25 is not None and stat.q75 is not None:
-            mbox = QGraphicsRectItem(stat.q25 * scale_x, -height / 2,
-                                     (stat.q75 - stat.q25) * scale_x, height,
-                                     box)
+            mbox = FilterGraphicsRectItem(
+                stat.conditions, stat.q25 * scale_x, -height / 2,
+                (stat.q75 - stat.q25) * scale_x, height, box)
             mbox.setBrush(self._box_brush)
             mbox.setPen(QPen(Qt.NoPen))
             mbox.setZValue(-200)
@@ -778,20 +818,26 @@ def line(x0, y0, x1, y1, *args):
 
         return box
 
-    def strudel(self, dist):
+    def strudel(self, dist, group_val_index=None):
         attr = self.attribute
         ss = np.sum(dist)
         box = QGraphicsItemGroup()
         if ss < 1e-6:
-            QGraphicsRectItem(0, -10, 1, 10, box)
+            cond = [FilterDiscrete(attr, None)]
+            if group_val_index is not None:
+                cond.append(FilterDiscrete(self.group_var, [group_val_index]))
+            FilterGraphicsRectItem(cond, 0, -10, 1, 10, box)
         cum = 0
         for i, v in enumerate(dist):
             if v < 1e-6:
                 continue
             if self.stretched:
                 v /= ss
             v *= self.scale_x
-            rect = QGraphicsRectItem(cum + 1, -6, v - 2, 12, box)
+            cond = [FilterDiscrete(attr, [i])]
+            if group_val_index is not None:
+                cond.append(FilterDiscrete(self.group_var, [group_val_index]))
+            rect = FilterGraphicsRectItem(cond, cum + 1, -6, v - 2, 12, box)
             rect.setBrush(QBrush(QColor(*attr.colors[i])))
             rect.setPen(QPen(Qt.NoPen))
             if self.stretched:
@@ -805,6 +851,18 @@ def strudel(self, dist):
             cum += v
         return box
 
+    def commit(self):
+        self.conditions = [item.filter for item in
+                           self.box_scene.selectedItems() if item.filter]
+        selected, selection = None, []
+        if self.conditions:
+            selected = Values(self.conditions, conjunction=False)(self.dataset)
+            selection = [i for i, inst in enumerate(self.dataset)
+                         if inst in selected]
+        self.send("Selected Data", selected)
+        self.send(ANNOTATED_DATA_SIGNAL_NAME,
+                  create_annotated_table(self.dataset, selection))
+
     def show_posthoc(self):
         def line(y0, y1):
             it = self.box_scene.addLine(x, y0, x, y1, self._post_line_pen)

Orange/widgets/visualize/tests/test_owboxplot.py

@@ -1,22 +1,27 @@
 # Test methods with long descriptive names can omit docstrings
 # pylint: disable=missing-docstring
-from unittest import skip
 
 import numpy as np
+
 from Orange.data import Table, ContinuousVariable
-from Orange.widgets.visualize.owboxplot import OWBoxPlot
-from Orange.widgets.tests.base import WidgetTest
+from Orange.widgets.visualize.owboxplot import OWBoxPlot, FilterGraphicsRectItem
+from Orange.widgets.tests.base import WidgetTest, WidgetOutputsTestMixin
 
 
-class OWBoxPlotTests(WidgetTest):
+class TestOWBoxPlot(WidgetTest, WidgetOutputsTestMixin):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
+        WidgetOutputsTestMixin.init(cls)
+
         cls.iris = Table("iris")
         cls.zoo = Table("zoo")
         cls.housing = Table("housing")
         cls.titanic = Table("titanic")
         cls.heart = Table("heart_disease")
+        cls.data = cls.iris
+        cls.signal_name = "Data"
+        cls.signal_data = cls.data
 
     def setUp(self):
         self.widget = self.create_widget(OWBoxPlot)
@@ -36,7 +41,7 @@ def test_input_data(self):
 
     def test_input_data_missings_cont_group_var(self):
         """Check widget with continuous data with missing values and group variable"""
-        data = self.iris
+        data = self.iris.copy()
         data.X[:, 0] = np.nan
         self.send_signal("Data", data)
         # used to crash, see #1568
@@ -100,3 +105,11 @@ def select_group(i):
                           'slope peak exc ST', 'gender', 'age', 'rest SBP',
                           'rest ECG', 'cholesterol',
                           'fasting blood sugar > 120', 'diameter narrowing'])
+
+    def _select_data(self):
+        items = [item for item in self.widget.box_scene.items()
+                 if isinstance(item, FilterGraphicsRectItem)]
+        items[0].setSelected(True)
+        return [100, 103, 104, 108, 110, 111, 112, 115, 116,
+                120, 123, 124, 126, 128, 132, 133, 136, 137,
+                139, 140, 141, 143, 144, 145, 146, 147, 148]