class OWScatterPlotGraph(gui.OWComponent, ScaleScatterPlotData): attr_color = ContextSetting(None, required=ContextSetting.OPTIONAL) attr_label = ContextSetting(None, required=ContextSetting.OPTIONAL) attr_shape = ContextSetting(None, required=ContextSetting.OPTIONAL) attr_size = ContextSetting(None, required=ContextSetting.OPTIONAL) label_only_selected = Setting(False) point_width = Setting(10) alpha_value = Setting(128) show_grid = Setting(False) show_legend = Setting(True) tooltip_shows_all = Setting(False) class_density = Setting(False) show_reg_line = Setting(False) resolution = 256 CurveSymbols = np.array("o x t + d s t2 t3 p h star ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) def __init__(self, scatter_widget, parent=None, _="None", view_box=InteractiveViewBox): gui.OWComponent.__init__(self, scatter_widget) self.view_box = view_box(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent, background="w") self.plot_widget.getPlotItem().buttonsHidden = True self.plot_widget.setAntialiasing(True) self.plot_widget.sizeHint = lambda: QSize(500, 500) scene = self.plot_widget.scene() self._create_drag_tooltip(scene) self._data = None # Original Table as passed from widget to new_data before transformations self.replot = self.plot_widget.replot ScaleScatterPlotData.__init__(self) self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.reg_line_item = None self.labels = [] self.master = scatter_widget self.master.Warning.add_message( "missing_coords", "Plot cannot be displayed because '{}' or '{}' is missing for " "all data points") self.master.Information.add_message( "missing_coords", "Points with missing '{}' or '{}' are not displayed") self.master.Information.add_message( "missing_size", "Points with undefined '{}' are shown in smaller size") self.master.Information.add_message( "missing_shape", "Points with undefined '{}' are shown as crossed circles") self.shown_attribute_indices = [] self.shown_x = self.shown_y = None self.pen_colors = self.brush_colors = None self.valid_data = None # np.ndarray self.selection = None # np.ndarray self.n_points = 0 self.gui = OWPlotGUI(self) self.continuous_palette = ContinuousPaletteGenerator( QColor(255, 255, 0), QColor(0, 0, 255), True) self.discrete_palette = ColorPaletteGenerator() self.selection_behavior = 0 self.legend = self.color_legend = None self.__legend_anchor = (1, 0), (1, 0) self.__color_legend_anchor = (1, 1), (1, 1) self.scale = None # DiscretizedScale self.subset_indices = None # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid() self._tooltip_delegate = HelpEventDelegate(self.help_event) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) def _create_drag_tooltip(self, scene): tip_parts = [(Qt.ShiftModifier, "Shift: Add group"), (Qt.ShiftModifier + Qt.ControlModifier, "Shift-{}: Append to group".format( "Cmd" if sys.platform == "darwin" else "Ctrl")), (Qt.AltModifier, "Alt: Remove")] all_parts = ", ".join(part for _, part in tip_parts) self.tiptexts = { int(modifier): all_parts.replace(part, "<b>{}</b>".format(part)) for modifier, part in tip_parts } self.tiptexts[0] = all_parts self.tip_textitem = text = QGraphicsTextItem() # Set to the longest text text.setHtml(self.tiptexts[Qt.ShiftModifier + Qt.ControlModifier]) text.setPos(4, 2) r = text.boundingRect() rect = QGraphicsRectItem(0, 0, r.width() + 8, r.height() + 4) rect.setBrush(QColor(224, 224, 224, 212)) rect.setPen(QPen(Qt.NoPen)) self.update_tooltip(Qt.NoModifier) scene.drag_tooltip = scene.createItemGroup([rect, text]) scene.drag_tooltip.hide() def update_tooltip(self, modifiers): modifiers &= Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier text = self.tiptexts.get(int(modifiers), self.tiptexts[0]) self.tip_textitem.setHtml(text) def new_data(self, data, subset_data=None, new=True, **args): if new: self.plot_widget.clear() self.remove_legend() self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.reg_line_item = None self.labels = [] self.selection = None self.valid_data = None self.subset_indices = set( e.id for e in subset_data) if subset_data else None self._data = data data = self.sparse_to_dense() self.set_data(data, **args) def set_domain(self, data): domain = data.domain if data and len(data) else None for attr in ("attr_color", "attr_shape", "attr_size", "attr_label"): getattr(self.controls, attr).model().set_domain(domain) setattr(self, attr, None) if domain is not None: self.attr_color = domain.class_var def sparse_to_dense(self): data = self._data if data is None or not data.is_sparse(): return data attrs = { self.shown_x, self.shown_y, self.attr_color, self.attr_shape, self.attr_size, self.attr_label } domain = data.domain all_attrs = domain.variables + domain.metas attrs = list(set(all_attrs) & attrs) selected_data = data[:, attrs].to_dense() return selected_data def _clear_plot_widget(self): self.remove_legend() if self.density_img: self.plot_widget.removeItem(self.density_img) self.density_img = None if self.scatterplot_item: self.plot_widget.removeItem(self.scatterplot_item) self.scatterplot_item = None if self.scatterplot_item_sel: self.plot_widget.removeItem(self.scatterplot_item_sel) self.scatterplot_item_sel = None if self.reg_line_item: self.plot_widget.removeItem(self.reg_line_item) self.reg_line_item = None for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] self.set_axis_title("bottom", "") self.set_axis_title("left", "") def update_data(self, attr_x, attr_y, reset_view=True): self.master.Warning.missing_coords.clear() self.master.Information.missing_coords.clear() self._clear_plot_widget() if self.shown_y != attr_y: # 'reset' the axis text width estimation. Without this the left # axis tick labels space only ever expands yaxis = self.plot_widget.getAxis("left") yaxis.textWidth = 30 self.shown_x, self.shown_y = attr_x, attr_y if attr_x not in self.data.domain or attr_y not in self.data.domain: data = self.sparse_to_dense() self.set_data(data) if self.jittered_data is None or not len(self.jittered_data): self.valid_data = None else: self.valid_data = self.get_valid_list([attr_x, attr_y]) if not np.any(self.valid_data): self.valid_data = None if self.valid_data is None: self.selection = None self.n_points = 0 self.master.Warning.missing_coords(self.shown_x.name, self.shown_y.name) return x_data, y_data = self.get_xy_data_positions(attr_x, attr_y, self.valid_data) self.n_points = len(x_data) if reset_view: min_x, max_x = np.nanmin(x_data), np.nanmax(x_data) min_y, max_y = np.nanmin(y_data), np.nanmax(y_data) self.view_box.setRange(QRectF(min_x, min_y, max_x - min_x, max_y - min_y), padding=0.025) self.view_box.init_history() self.view_box.tag_history() [min_x, max_x], [min_y, max_y] = self.view_box.viewRange() for axis, var in (("bottom", attr_x), ("left", attr_y)): self.set_axis_title(axis, var) if var.is_discrete: self.set_labels(axis, get_variable_values_sorted(var)) else: self.set_labels(axis, None) color_data, brush_data = self.compute_colors() color_data_sel, brush_data_sel = self.compute_colors_sel() size_data = self.compute_sizes() shape_data = self.compute_symbols() if self.should_draw_density(): rgb_data = [pen.color().getRgb()[:3] for pen in color_data] self.density_img = classdensity.class_density_image( min_x, max_x, min_y, max_y, self.resolution, x_data, y_data, rgb_data) self.plot_widget.addItem(self.density_img) self.data_indices = np.flatnonzero(self.valid_data) if len(self.data_indices) != len(self.data): self.master.Information.missing_coords(self.shown_x.name, self.shown_y.name) self.scatterplot_item = ScatterPlotItem(x=x_data, y=y_data, data=self.data_indices, symbol=shape_data, size=size_data, pen=color_data, brush=brush_data) self.scatterplot_item_sel = ScatterPlotItem(x=x_data, y=y_data, data=self.data_indices, symbol=shape_data, size=size_data + SELECTION_WIDTH, pen=color_data_sel, brush=brush_data_sel) self.plot_widget.addItem(self.scatterplot_item_sel) self.plot_widget.addItem(self.scatterplot_item) self.scatterplot_item.selected_points = [] self.scatterplot_item.sigClicked.connect(self.select_by_click) if self.show_reg_line: _x_data = self.data.get_column_view(self.shown_x)[0] _y_data = self.data.get_column_view(self.shown_y)[0] _x_data = _x_data[self.valid_data] _y_data = _y_data[self.valid_data] assert _x_data.size assert _y_data.size self.draw_regression_line(_x_data, _y_data, np.min(_x_data), np.max(_y_data)) self.update_labels() self.make_legend() self.plot_widget.replot() def draw_regression_line(self, x_data, y_data, min_x, max_x): if self.show_reg_line and self.can_draw_regresssion_line(): slope, intercept, rvalue, _, _ = linregress(x_data, y_data) start_y = min_x * slope + intercept end_y = max_x * slope + intercept angle = np.degrees(np.arctan((end_y - start_y) / (max_x - min_x))) rotate = ((angle + 45) % 180) - 45 > 90 color = QColor("#505050") l_opts = dict(color=color, position=abs(int(rotate) - 0.85), rotateAxis=(1, 0), movable=True) self.reg_line_item = InfiniteLine( pos=QPointF(min_x, start_y), pen=pg.mkPen(color=color, width=1), angle=angle, label="r = {:.2f}".format(rvalue), labelOpts=l_opts) if rotate: self.reg_line_item.label.angle = 180 self.reg_line_item.label.updateTransform() self.plot_widget.addItem(self.reg_line_item) def can_draw_density(self): return self.domain is not None and \ self.attr_color is not None and \ self.attr_color.is_discrete and \ self.shown_x.is_continuous and \ self.shown_y.is_continuous def should_draw_density(self): return self.class_density and self.n_points > 1 and self.can_draw_density( ) def can_draw_regresssion_line(self): return self.domain is not None and \ self.shown_x.is_continuous and \ self.shown_y.is_continuous def set_labels(self, axis, labels): axis = self.plot_widget.getAxis(axis) if labels: ticks = [[(i, labels[i]) for i in range(len(labels))]] axis.setTicks(ticks) else: axis.setTicks(None) def set_axis_title(self, axis, title): self.plot_widget.setLabel(axis=axis, text=title) def compute_sizes(self): self.master.Information.missing_size.clear() if self.attr_size is None: size_data = np.full((self.n_points, ), self.point_width, dtype=float) else: size_data = \ self.MinShapeSize + \ self.scaled_data.get_column_view(self.attr_size)[0][self.valid_data] * \ self.point_width nans = np.isnan(size_data) if np.any(nans): size_data[nans] = self.MinShapeSize - 2 self.master.Information.missing_size(self.attr_size) return size_data def update_sizes(self): self.set_data(self.sparse_to_dense()) self.update_point_size() def update_point_size(self): if self.scatterplot_item: size_data = self.compute_sizes() self.scatterplot_item.setSize(size_data) self.scatterplot_item_sel.setSize(size_data + SELECTION_WIDTH) def get_color(self): if self.attr_color is None: return None colors = self.attr_color.colors if self.attr_color.is_discrete: self.discrete_palette = ColorPaletteGenerator( number_of_colors=min(len(colors), MAX), rgb_colors=colors if len(colors) <= MAX else DefaultRGBColors) else: self.continuous_palette = ContinuousPaletteGenerator(*colors) return self.attr_color def compute_colors_sel(self, keep_colors=False): if not keep_colors: self.pen_colors_sel = self.brush_colors_sel = None nopen = QPen(Qt.NoPen) if self.selection is not None: sels = np.max(self.selection) if sels == 1: pens = [ nopen, _make_pen(QColor(255, 190, 0, 255), SELECTION_WIDTH + 1.) ] else: # Start with the first color so that the colors of the # additional attribute in annotation (which start with 0, # unselected) will match these colors palette = ColorPaletteGenerator(number_of_colors=sels + 1) pens = [nopen] + \ [_make_pen(palette[i + 1], SELECTION_WIDTH + 1.) for i in range(sels)] pen = [pens[a] for a in self.selection[self.valid_data]] else: pen = [nopen] * self.n_points brush = [QBrush(QColor(255, 255, 255, 0))] * self.n_points return pen, brush def _reduce_values(self, attr): """ If discrete variable has more than maximium allowed values, less used values are joined as "Other" """ c_data = self.data.get_column_view(attr)[0][self.valid_data] if attr.is_continuous or len(attr.values) <= MAX: return None, c_data values_to_replace = Counter(c_data) values_to_replace = sorted(values_to_replace, key=values_to_replace.get, reverse=True) return values_to_replace, c_data def _get_values(self, attr): if len(attr.values) <= MAX: return attr.values values_to_replace, _ = self._reduce_values(attr) return [ attr.values[int(i)] for i in values_to_replace if not np.isnan(i) ][:MAX - 1] + ["Other"] def _get_data(self, attr): values_to_replace, c_data = self._reduce_values(attr) if values_to_replace is not None: c_data_2 = c_data.copy() for i, v in enumerate(values_to_replace): c_data[c_data_2 == v] = i if i < MAX - 1 else MAX - 1 return c_data def compute_colors(self, keep_colors=False): if not keep_colors: self.pen_colors = self.brush_colors = None self.get_color() subset = None if self.subset_indices: subset = np.array([ ex.id in self.subset_indices for ex in self.data[self.valid_data] ]) if self.attr_color is None: # same color color = self.plot_widget.palette().color(OWPalette.Data) pen = [_make_pen(color, 1.5)] * self.n_points if subset is not None: brush = [(QBrush(QColor(128, 128, 128, 0)), QBrush(QColor(128, 128, 128, 255)))[s] for s in subset] else: brush = [QBrush(QColor(128, 128, 128, self.alpha_value))] \ * self.n_points return pen, brush c_data = self._get_data(self.attr_color) if self.attr_color.is_continuous: if self.pen_colors is None: self.scale = DiscretizedScale(np.nanmin(c_data), np.nanmax(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) palette = self.continuous_palette self.pen_colors = palette.getRGB(c_data) self.brush_colors = np.hstack([ self.pen_colors, np.full((self.n_points, 1), self.alpha_value, dtype=int) ]) self.pen_colors *= 100 self.pen_colors //= self.DarkerValue self.pen_colors = [ _make_pen(QColor(*col), 1.5) for col in self.pen_colors.tolist() ] if subset is not None: self.brush_colors[:, 3] = 0 self.brush_colors[subset, 3] = 255 else: self.brush_colors[:, 3] = self.alpha_value pen = self.pen_colors brush = np.array( [QBrush(QColor(*col)) for col in self.brush_colors.tolist()]) else: if self.pen_colors is None: palette = self.discrete_palette n_colors = palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = np.r_[palette.getRGB(np.arange(n_colors)), [[128, 128, 128]]] pens = np.array([ _make_pen(QColor(*col).darker(self.DarkerValue), 1.5) for col in colors ]) self.pen_colors = pens[c_data] alpha = self.alpha_value if subset is None else 255 self.brush_colors = np.array([[ QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], alpha)) ] for col in colors]) self.brush_colors = self.brush_colors[c_data] if subset is not None: brush = np.where(subset, self.brush_colors[:, 1], self.brush_colors[:, 0]) else: brush = self.brush_colors[:, 1] pen = self.pen_colors return pen, brush def update_colors(self, keep_colors=False): self.master.update_colors() self.set_data(self.sparse_to_dense()) self.update_alpha_value(keep_colors) def update_alpha_value(self, keep_colors=False): if self.scatterplot_item: pen_data, brush_data = self.compute_colors(keep_colors) pen_data_sel, brush_data_sel = self.compute_colors_sel(keep_colors) self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) self.scatterplot_item_sel.setPen(pen_data_sel, update=False, mask=None) self.scatterplot_item_sel.setBrush(brush_data_sel, mask=None) if not keep_colors: self.make_legend() if self.should_draw_density(): self.update_data(self.shown_x, self.shown_y) elif self.density_img: self.plot_widget.removeItem(self.density_img) def create_labels(self): for x, y in zip(*self.scatterplot_item.getData()): ti = TextItem() self.plot_widget.addItem(ti) ti.setPos(x, y) self.labels.append(ti) def _create_label_column(self): if self.attr_label in self.data.domain: label_column = self.data.get_column_view(self.attr_label)[0] else: label_column = self.master.data.get_column_view(self.attr_label)[0] return label_column[self.data_indices] def update_labels(self): if self.attr_label is None or \ self.label_only_selected and self.selection is None: for label in self.labels: label.setText("") return self.assure_attribute_present(self.attr_label) if not self.labels: self.create_labels() label_column = self._create_label_column() formatter = self.attr_label.str_val label_data = map(formatter, label_column) black = pg.mkColor(0, 0, 0) selection = self.selection[ self.valid_data] if self.selection is not None else [] if self.label_only_selected: for label, text, selected \ in zip(self.labels, label_data, selection): label.setText(text if selected else "", black) else: for label, text in zip(self.labels, label_data): label.setText(text, black) def compute_symbols(self): self.master.Information.missing_shape.clear() if self.attr_shape is None: shape_data = self.CurveSymbols[np.zeros(self.n_points, dtype=int)] else: shape_data = self._get_data(self.attr_shape) nans = np.isnan(shape_data) if np.any(nans): shape_data[nans] = len(self.CurveSymbols) - 1 self.master.Information.missing_shape(self.attr_shape) shape_data = self.CurveSymbols[shape_data.astype(int)] return shape_data def update_shapes(self): self.assure_attribute_present(self.attr_shape) if self.scatterplot_item: shape_data = self.compute_symbols() self.scatterplot_item.setSymbol(shape_data) self.make_legend() def assure_attribute_present(self, attr): if self.data is not None and attr not in self.data.domain: self.set_data(self.sparse_to_dense()) def update_grid(self): self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend(self): if self.legend: self.legend.setVisible(self.show_legend) def create_legend(self): self.legend = LegendItem() self.legend.setParentItem(self.plot_widget.getViewBox()) self.legend.restoreAnchor(self.__legend_anchor) def remove_legend(self): if self.legend: anchor = legend_anchor_pos(self.legend) if anchor is not None: self.__legend_anchor = anchor self.legend.setParent(None) self.legend = None if self.color_legend: anchor = legend_anchor_pos(self.color_legend) if anchor is not None: self.__color_legend_anchor = anchor self.color_legend.setParent(None) self.color_legend = None def make_legend(self): self.remove_legend() self.make_color_legend() self.make_shape_legend() self.update_legend() def make_color_legend(self): if self.attr_color is None: return use_shape = self.attr_shape == self.get_color() if self.attr_color.is_discrete: if not self.legend: self.create_legend() palette = self.discrete_palette for i, value in enumerate(self._get_values(self.attr_color)): color = QColor(*palette.getRGB(i)) pen = _make_pen(color.darker(self.DarkerValue), 1.5) color.setAlpha( self.alpha_value if self.subset_indices is None else 255) brush = QBrush(color) self.legend.addItem( ScatterPlotItem( pen=pen, brush=brush, size=10, symbol=self.CurveSymbols[i] if use_shape else "o"), escape(value)) else: legend = self.color_legend = LegendItem() legend.setParentItem(self.plot_widget.getViewBox()) legend.restoreAnchor(self.__color_legend_anchor) label = PaletteItemSample(self.continuous_palette, self.scale) legend.addItem(label, "") legend.setGeometry(label.boundingRect()) def make_shape_legend(self): if self.attr_shape is None or self.attr_shape == self.get_color(): return if not self.legend: self.create_legend() color = QColor(0, 0, 0) color.setAlpha(self.alpha_value) for i, value in enumerate(self._get_values(self.attr_shape)): self.legend.addItem( ScatterPlotItem(pen=color, brush=color, size=10, symbol=self.CurveSymbols[i]), escape(value)) def zoom_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def pan_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().PanMode) def select_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def reset_button_clicked(self): self.update_data(self.shown_x, self.shown_y, reset_view=True) # also redraw density image # self.view_box.autoRange() def select_by_click(self, _, points): if self.scatterplot_item is not None: self.select(points) def select_by_rectangle(self, value_rect): if self.scatterplot_item is not None: points = [ point for point in self.scatterplot_item.points() if value_rect.contains(QPointF(point.pos())) ] self.select(points) def unselect_all(self): self.selection = None self.update_colors(keep_colors=True) if self.label_only_selected: self.update_labels() self.master.selection_changed() def select(self, points): # noinspection PyArgumentList if self.data is None: return if self.selection is None: self.selection = np.zeros(len(self.data), dtype=np.uint8) indices = [p.data() for p in points] keys = QApplication.keyboardModifiers() # Remove from selection if keys & Qt.AltModifier: self.selection[indices] = 0 # Append to the last group elif keys & Qt.ShiftModifier and keys & Qt.ControlModifier: self.selection[indices] = np.max(self.selection) # Create a new group elif keys & Qt.ShiftModifier: self.selection[indices] = np.max(self.selection) + 1 # No modifiers: new selection else: self.selection = np.zeros(len(self.data), dtype=np.uint8) self.selection[indices] = 1 self.update_colors(keep_colors=True) if self.label_only_selected: self.update_labels() self.master.selection_changed() def get_selection(self): if self.selection is None: return np.array([], dtype=np.uint8) else: return np.flatnonzero(self.selection) def set_palette(self, p): self.plot_widget.setPalette(p) def save_to_file(self, size): pass def help_event(self, event): if self.scatterplot_item is None: return False domain = self.data.domain PARTS = (("Class", "Classes", 4, domain.class_vars), ("Meta", "Metas", 4, domain.metas), ("Feature", "Features", 10, domain.attributes)) def format_val(var, point_data, bold=False): text = escape('{} = {}'.format(var.name, point_data[var])) if bold: text = "<b>{}</b>".format(text) return text def show_part(point_data, singular, plural, max_shown, vars): cols = [ format_val(var, point_data) for var in vars[:max_shown + 2] if vars == domain.class_vars or var not in (self.shown_x, self.shown_y) ][:max_shown] if not cols: return "" n_vars = len(vars) if n_vars > max_shown: cols[-1] = "... and {} others".format(n_vars - max_shown + 1) return \ "<br/><b>{}</b>:<br/>".format(singular if n_vars < 2 else plural) \ + "<br/>".join(cols) def point_data(p): point_data = self.data[p.data()] text = "<br/>".join( format_val(var, point_data, bold=self.tooltip_shows_all) for var in (self.shown_x, self.shown_y)) if self.tooltip_shows_all: text += "<br/>" + \ "".join(show_part(point_data, *columns) for columns in PARTS) return text act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) if len(points): if len(points) > MAX_POINTS_IN_TOOLTIP: text = "{} instances<hr/>{}<hr/>...".format( len(points), "<hr/>".join( point_data(point) for point in points[:MAX_POINTS_IN_TOOLTIP])) else: text = "<hr/>".join(point_data(point) for point in points) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False def box_zoom_select(self, parent): g = self.gui box_zoom_select = gui.vBox(parent, "Zoom/Select") zoom_select_toolbar = g.zoom_select_toolbar(box_zoom_select, nomargin=True, buttons=[ g.StateButtonsBegin, g.SimpleSelect, g.Pan, g.Zoom, g.StateButtonsEnd, g.ZoomReset ]) buttons = zoom_select_toolbar.buttons buttons[g.Zoom].clicked.connect(self.zoom_button_clicked) buttons[g.Pan].clicked.connect(self.pan_button_clicked) buttons[g.SimpleSelect].clicked.connect(self.select_button_clicked) buttons[g.ZoomReset].clicked.connect(self.reset_button_clicked) return box_zoom_select def zoom_actions(self, parent): def zoom(s): """ Zoom in/out by factor `s`. scaleBy scales the view's bounds (the axis range) """ self.view_box.scaleBy((1 / s, 1 / s)) def fit_to_view(): self.viewbox.autoRange() zoom_in = QAction("Zoom in", parent, triggered=lambda: zoom(1.25)) zoom_in.setShortcuts([ QKeySequence(QKeySequence.ZoomIn), QKeySequence(parent.tr("Ctrl+=")) ]) zoom_out = QAction("Zoom out", parent, shortcut=QKeySequence.ZoomOut, triggered=lambda: zoom(1 / 1.25)) zoom_fit = QAction("Fit in view", parent, shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0), triggered=fit_to_view) parent.addActions([zoom_in, zoom_out, zoom_fit])
class OWScatterPlotBase(gui.OWComponent, QObject): """ Provide a graph component for widgets that show any kind of point plot The component plots a set of points with given coordinates, shapes, sizes and colors. Its function is similar to that of a *view*, whereas the widget represents a *model* and a *controler*. The model (widget) needs to provide methods: - `get_coordinates_data`, `get_size_data`, `get_color_data`, `get_shape_data`, `get_label_data`, which return a 1d array (or two arrays, for `get_coordinates_data`) of `dtype` `float64`, except for `get_label_data`, which returns formatted labels; - `get_color_labels`, `get_shape_labels`, which are return lists of strings used for the color and shape legend; - `get_tooltip`, which gives a tooltip for a single data point - (optional) `impute_sizes`, `impute_shapes` get final coordinates and shapes, and replace nans; - `get_subset_mask` returns a bool array indicating whether a data point is in the subset or not (e.g. in the 'Data Subset' signal in the Scatter plot and similar widgets); - `get_palette` returns a palette appropriate for visualizing the current color data; - `is_continuous_color` decides the type of the color legend; The widget (in a role of controller) must also provide methods - `selection_changed` If `get_coordinates_data` returns `(None, None)`, the plot is cleared. If `get_size_data`, `get_color_data` or `get_shape_data` return `None`, all points will have the same size, color or shape, respectively. If `get_label_data` returns `None`, there are no labels. The view (this compomnent) provides methods `update_coordinates`, `update_sizes`, `update_colors`, `update_shapes` and `update_labels` that the widget (in a role of a controler) should call when any of these properties are changed. If the widget calls, for instance, the plot's `update_colors`, the plot will react by calling the widget's `get_color_data` as well as the widget's methods needed to construct the legend. The view also provides a method `reset_graph`, which should be called only when - the widget gets entirely new data - the number of points may have changed, for instance when selecting a different attribute for x or y in the scatter plot, where the points with missing x or y coordinates are hidden. Every `update_something` calls the plot's `get_something`, which calls the model's `get_something_data`, then it transforms this data into whatever is needed (colors, shapes, scaled sizes) and changes the plot. For the simplest example, here is `update_shapes`: ``` def update_shapes(self): if self.scatterplot_item: shape_data = self.get_shapes() self.scatterplot_item.setSymbol(shape_data) self.update_legends() def get_shapes(self): shape_data = self.master.get_shape_data() shape_data = self.master.impute_shapes( shape_data, len(self.CurveSymbols) - 1) return self.CurveSymbols[shape_data] ``` On the widget's side, `get_something_data` is essentially just: ``` def get_size_data(self): return self.get_column(self.attr_size) ``` where `get_column` retrieves a column while also filtering out the points with missing x and y and so forth. (Here we present the simplest two cases, "shapes" for the view and "sizes" for the model. The colors for the view are more complicated since they deal with discrete and continuous palettes, and the shapes for the view merge infrequent shapes.) The plot can also show just a random sample of the data. The sample size is set by `set_sample_size`, and the rest is taken care by the plot: the widget keeps providing the data for all points, selection indices refer to the entire set etc. Internally, sampling happens as early as possible (in methods `get_<something>`). """ too_many_labels = Signal(bool) label_only_selected = Setting(False) point_width = Setting(10) alpha_value = Setting(128) show_grid = Setting(False) show_legend = Setting(True) class_density = Setting(False) jitter_size = Setting(0) resolution = 256 CurveSymbols = np.array("o x t + d s t2 t3 p h star ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) COLOR_NOT_SUBSET = (128, 128, 128, 0) COLOR_SUBSET = (128, 128, 128, 255) COLOR_DEFAULT = (128, 128, 128, 0) MAX_VISIBLE_LABELS = 500 def __init__(self, scatter_widget, parent=None, view_box=ViewBox): QObject.__init__(self) gui.OWComponent.__init__(self, scatter_widget) self.subset_is_shown = False self.view_box = view_box(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent, background="w") self.plot_widget.hideAxis("left") self.plot_widget.hideAxis("bottom") self.plot_widget.getPlotItem().buttonsHidden = True self.plot_widget.setAntialiasing(True) self.plot_widget.sizeHint = lambda: QSize(500, 500) self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self.master = scatter_widget self._create_drag_tooltip(self.plot_widget.scene()) self.selection = None # np.ndarray self.n_valid = 0 self.n_shown = 0 self.sample_size = None self.sample_indices = None self.palette = None self.shape_legend = self._create_legend(((1, 0), (1, 0))) self.color_legend = self._create_legend(((1, 1), (1, 1))) self.update_legend_visibility() self.scale = None # DiscretizedScale self._too_many_labels = False # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid_visibility() self._tooltip_delegate = EventDelegate(self.help_event) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) self.view_box.sigTransformChanged.connect(self.update_density) self.view_box.sigRangeChangedManually.connect(self.update_labels) self.timer = None def _create_legend(self, anchor): legend = LegendItem() legend.setParentItem(self.plot_widget.getViewBox()) legend.restoreAnchor(anchor) return legend def _create_drag_tooltip(self, scene): tip_parts = [ (Qt.ShiftModifier, "Shift: Add group"), (Qt.ShiftModifier + Qt.ControlModifier, "Shift-{}: Append to group". format("Cmd" if sys.platform == "darwin" else "Ctrl")), (Qt.AltModifier, "Alt: Remove") ] all_parts = ", ".join(part for _, part in tip_parts) self.tiptexts = { int(modifier): all_parts.replace(part, "<b>{}</b>".format(part)) for modifier, part in tip_parts } self.tiptexts[0] = all_parts self.tip_textitem = text = QGraphicsTextItem() # Set to the longest text text.setHtml(self.tiptexts[Qt.ShiftModifier + Qt.ControlModifier]) text.setPos(4, 2) r = text.boundingRect() rect = QGraphicsRectItem(0, 0, r.width() + 8, r.height() + 4) rect.setBrush(QColor(224, 224, 224, 212)) rect.setPen(QPen(Qt.NoPen)) self.update_tooltip() scene.drag_tooltip = scene.createItemGroup([rect, text]) scene.drag_tooltip.hide() def update_tooltip(self, modifiers=Qt.NoModifier): modifiers &= Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier text = self.tiptexts.get(int(modifiers), self.tiptexts[0]) self.tip_textitem.setHtml(text + self._get_jittering_tooltip()) def _get_jittering_tooltip(self): warn_jittered = "" if self.jitter_size: warn_jittered = \ '<br/><br/>' \ '<span style="background-color: red; color: white; ' \ 'font-weight: 500;">' \ ' Warning: Selection is applied to unjittered data ' \ '</span>' return warn_jittered def update_jittering(self): self.update_tooltip() x, y = self.get_coordinates() if x is None or not len(x) or self.scatterplot_item is None: return self._update_plot_coordinates(self.scatterplot_item, x, y) self._update_plot_coordinates(self.scatterplot_item_sel, x, y) self.update_labels() # TODO: Rename to remove_plot_items def clear(self): """ Remove all graphical elements from the plot Calls the pyqtgraph's plot widget's clear, sets all handles to `None`, removes labels and selections. This method should generally not be called by the widget. If the data is gone (*e.g.* upon receiving `None` as an input data signal), this should be handler by calling `reset_graph`, which will in turn call `clear`. Derived classes should override this method if they add more graphical elements. For instance, the regression line in the scatterplot adds `self.reg_line_item = None` (the line in the plot is already removed in this method). """ self.plot_widget.clear() self.density_img = None if self.timer is not None and self.timer.isActive(): self.timer.stop() self.timer = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self._signal_too_many_labels(False) self.view_box.init_history() self.view_box.tag_history() # TODO: I hate `keep_something` and `reset_something` arguments # __keep_selection is used exclusively be set_sample size which would # otherwise just repeat the code from reset_graph except for resetting # the selection. I'm uncomfortable with this; we may prefer to have a # method _reset_graph which does everything except resetting the selection, # and reset_graph would call it. def reset_graph(self, __keep_selection=False): """ Reset the graph to new data (or no data) The method must be called when the plot receives new data, in particular when the number of points change. If only their properties - like coordinates or shapes - change, an update method (`update_coordinates`, `update_shapes`...) should be called instead. The method must also be called when the data is gone. The method calls `clear`, followed by calls of all update methods. NB. Argument `__keep_selection` is for internal use only """ self.clear() if not __keep_selection: self.selection = None self.sample_indices = None self.update_coordinates() self.update_point_props() def set_sample_size(self, sample_size): """ Set the sample size Args: sample_size (int or None): sample size or `None` to show all points """ if self.sample_size != sample_size: self.sample_size = sample_size self.reset_graph(True) def update_point_props(self): """ Update the sizes, colors, shapes and labels The method calls the appropriate update methods for individual properties. """ self.update_sizes() self.update_colors() self.update_selection_colors() self.update_shapes() self.update_labels() # Coordinates # TODO: It could be nice if this method was run on entire data, not just # a sample. For this, however, it would need to either be called from # `get_coordinates` before sampling (very ugly) or call # `self.master.get_coordinates_data` (beyond ugly) or the widget would # have to store the ranges of unsampled data (ugly). # Maybe we leave it as it is. def _reset_view(self, x_data, y_data): """ Set the range of the view box Args: x_data (np.ndarray): x coordinates y_data (np.ndarray) y coordinates """ min_x, max_x = np.min(x_data), np.max(x_data) min_y, max_y = np.min(y_data), np.max(y_data) self.view_box.setRange( QRectF(min_x, min_y, max_x - min_x or 1, max_y - min_y or 1), padding=0.025) def _filter_visible(self, data): """Return the sample from the data using the stored sample_indices""" if data is None or self.sample_indices is None: return data else: return np.asarray(data[self.sample_indices]) def get_coordinates(self): """ Prepare coordinates of the points in the plot The method is called by `update_coordinates`. It gets the coordinates from the widget, jitters them and return them. The methods also initializes the sample indices if neededd and stores the original and sampled number of points. Returns: (tuple): a pair of numpy arrays containing (sampled) coordinates, or `(None, None)`. """ x, y = self.master.get_coordinates_data() if x is None: self.n_valid = self.n_shown = 0 return None, None self.n_valid = len(x) self._create_sample() x = self._filter_visible(x) y = self._filter_visible(y) # Jittering after sampling is OK if widgets do not change the sample # semi-permanently, e.g. take a sample for the duration of some # animation. If the sample size changes dynamically (like by adding # a "sample size" slider), points would move around when the sample # size changes. To prevent this, jittering should be done before # sampling (i.e. two lines earlier). This would slow it down somewhat. x, y = self.jitter_coordinates(x, y) return x, y def _create_sample(self): """ Create a random sample if the data is larger than the set sample size """ self.n_shown = min(self.n_valid, self.sample_size or self.n_valid) if self.sample_size is not None \ and self.sample_indices is None \ and self.n_valid != self.n_shown: random = np.random.RandomState(seed=0) self.sample_indices = random.choice( self.n_valid, self.n_shown, replace=False) # TODO: Is this really needed? np.sort(self.sample_indices) def jitter_coordinates(self, x, y): """ Display coordinates to random positions within ellipses with radiuses of `self.jittter_size` percents of spans """ if self.jitter_size == 0: return x, y return self._jitter_data(x, y) def _jitter_data(self, x, y, span_x=None, span_y=None): if span_x is None: span_x = np.max(x) - np.min(x) if span_y is None: span_y = np.max(y) - np.min(y) random = np.random.RandomState(seed=0) rs = random.uniform(0, 1, len(x)) phis = random.uniform(0, 2 * np.pi, len(x)) magnitude = self.jitter_size / 100 return (x + magnitude * span_x * rs * np.cos(phis), y + magnitude * span_y * rs * np.sin(phis)) def _update_plot_coordinates(self, plot, x, y): """ Change the coordinates of points while keeping other properites Note. Pyqtgraph does not offer a method for this: setting coordinates invalidates other data. We therefore retrieve the data to set it together with the coordinates. Pyqtgraph also does not offer a (documented) method for retrieving the data, yet using `plot.data[prop]` looks reasonably safe. The alternative, calling update for every property would essentially reset the graph, which can be time consuming. """ data = dict(x=x, y=y) for prop in ('pen', 'brush', 'size', 'symbol', 'data', 'sourceRect', 'targetRect'): data[prop] = plot.data[prop] plot.setData(**data) def update_coordinates(self): """ Trigger the update of coordinates while keeping other features intact. The method gets the coordinates by calling `self.get_coordinates`, which in turn calls the widget's `get_coordinate_data`. The number of coordinate pairs returned by the latter must match the current number of points. If this is not the case, the widget should trigger the complete update by calling `reset_graph` instead of this method. """ x, y = self.get_coordinates() if x is None or not len(x): return if self.scatterplot_item is None: if self.sample_indices is None: indices = np.arange(self.n_valid) else: indices = self.sample_indices kwargs = dict(x=x, y=y, data=indices) self.scatterplot_item = ScatterPlotItem(**kwargs) self.scatterplot_item.sigClicked.connect(self.select_by_click) self.scatterplot_item_sel = ScatterPlotItem(**kwargs) self.plot_widget.addItem(self.scatterplot_item_sel) self.plot_widget.addItem(self.scatterplot_item) else: self._update_plot_coordinates(self.scatterplot_item, x, y) self._update_plot_coordinates(self.scatterplot_item_sel, x, y) self.update_labels() self.update_density() # Todo: doesn't work: try MDS with density on self._reset_view(x, y) # Sizes def get_sizes(self): """ Prepare data for sizes of points in the plot The method is called by `update_sizes`. It gets the sizes from the widget and performs the necessary scaling and sizing. Returns: (np.ndarray): sizes """ size_column = self.master.get_size_data() if size_column is None: return np.full((self.n_shown,), self.MinShapeSize + (5 + self.point_width) * 0.5) size_column = self._filter_visible(size_column) size_column = size_column.copy() with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) size_column -= np.nanmin(size_column) mx = np.nanmax(size_column) if mx > 0: size_column /= mx else: size_column[:] = 0.5 return self.MinShapeSize + (5 + self.point_width) * size_column def update_sizes(self): """ Trigger an update of point sizes The method calls `self.get_sizes`, which in turn calls the widget's `get_size_data`. The result are properly scaled and then passed back to widget for imputing (`master.impute_sizes`). """ if self.scatterplot_item: size_data = self.get_sizes() size_imputer = getattr( self.master, "impute_sizes", self.default_impute_sizes) size_imputer(size_data) if self.timer is not None and self.timer.isActive(): self.timer.stop() self.timer = None current_size_data = self.scatterplot_item.data["size"].copy() diff = size_data - current_size_data widget = self class Timeout: # 0.5 - np.cos(np.arange(0.17, 1, 0.17) * np.pi) / 2 factors = [0.07, 0.26, 0.52, 0.77, 0.95, 1] def __init__(self): self._counter = 0 def __call__(self): factor = self.factors[self._counter] self._counter += 1 size = current_size_data + diff * factor if len(self.factors) == self._counter: widget.timer.stop() widget.timer = None size = size_data widget.scatterplot_item.setSize(size) widget.scatterplot_item_sel.setSize(size + SELECTION_WIDTH) if np.sum(current_size_data) / self.n_valid != -1 and np.sum(diff): # If encountered any strange behaviour when updating sizes, # implement it with threads self.timer = QTimer(self.scatterplot_item, interval=50) self.timer.timeout.connect(Timeout()) self.timer.start() else: self.scatterplot_item.setSize(size_data) self.scatterplot_item_sel.setSize(size_data + SELECTION_WIDTH) update_point_size = update_sizes # backward compatibility (needed?!) update_size = update_sizes @classmethod def default_impute_sizes(cls, size_data): """ Fallback imputation for sizes. Set the size to two pixels smaller than the minimal size Returns: (bool): True if there was any missing data """ nans = np.isnan(size_data) if np.any(nans): size_data[nans] = cls.MinShapeSize - 2 return True else: return False # Colors def get_colors(self): """ Prepare data for colors of the points in the plot The method is called by `update_colors`. It gets the colors and the indices of the data subset from the widget (`get_color_data`, `get_subset_mask`), and constructs lists of pens and brushes for each data point. The method uses different palettes for discrete and continuous data, as determined by calling the widget's method `is_continuous_color`. If also marks the points that are in the subset as defined by, for instance the 'Data Subset' signal in the Scatter plot and similar widgets. (Do not confuse this with *selected points*, which are marked by circles around the points, which are colored by groups and thus independent of this method.) Returns: (tuple): a list of pens and list of brushes """ self.palette = self.master.get_palette() c_data = self.master.get_color_data() c_data = self._filter_visible(c_data) subset = self.master.get_subset_mask() subset = self._filter_visible(subset) self.subset_is_shown = subset is not None if c_data is None: # same color return self._get_same_colors(subset) elif self.master.is_continuous_color(): return self._get_continuous_colors(c_data, subset) else: return self._get_discrete_colors(c_data, subset) def _get_same_colors(self, subset): """ Return the same pen for all points while the brush color depends upon whether the point is in the subset or not Args: subset (np.ndarray): a bool array indicating whether a data point is in the subset or not (e.g. in the 'Data Subset' signal in the Scatter plot and similar widgets); Returns: (tuple): a list of pens and list of brushes """ color = self.plot_widget.palette().color(OWPalette.Data) pen = [_make_pen(color, 1.5) for _ in range(self.n_shown)] if subset is not None: brush = np.where( subset, *(QBrush(QColor(*col)) for col in (self.COLOR_SUBSET, self.COLOR_NOT_SUBSET))) else: color = QColor(*self.COLOR_DEFAULT) color.setAlpha(self.alpha_value) brush = [QBrush(color) for _ in range(self.n_shown)] return pen, brush def _get_continuous_colors(self, c_data, subset): """ Return the pens and colors whose color represent an index into a continuous palette. The same color is used for pen and brush, except the former is darker. If the data has a subset, the brush is transparent for points that are not in the subset. """ if np.isnan(c_data).all(): self.scale = None else: self.scale = DiscretizedScale(np.nanmin(c_data), np.nanmax(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) pen = self.palette.getRGB(c_data) brush = np.hstack( [pen, np.full((len(pen), 1), self.alpha_value, dtype=int)]) pen *= 100 pen //= self.DarkerValue pen = [_make_pen(QColor(*col), 1.5) for col in pen.tolist()] if subset is not None: brush[:, 3] = 0 brush[subset, 3] = 255 brush = np.array([QBrush(QColor(*col)) for col in brush.tolist()]) return pen, brush def _get_discrete_colors(self, c_data, subset): """ Return the pens and colors whose color represent an index into a discrete palette. The same color is used for pen and brush, except the former is darker. If the data has a subset, the brush is transparent for points that are not in the subset. """ n_colors = self.palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = np.r_[self.palette.getRGB(np.arange(n_colors)), [[128, 128, 128]]] pens = np.array( [_make_pen(QColor(*col).darker(self.DarkerValue), 1.5) for col in colors]) pen = pens[c_data] alpha = self.alpha_value if subset is None else 255 brushes = np.array([ [QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], alpha))] for col in colors]) brush = brushes[c_data] if subset is not None: brush = np.where(subset, brush[:, 1], brush[:, 0]) else: brush = brush[:, 1] return pen, brush def update_colors(self): """ Trigger an update of point sizes The method calls `self.get_colors`, which in turn calls the widget's `get_color_data` to get the indices in the pallette. `get_colors` returns a list of pens and brushes to which this method uses to update the colors. Finally, the method triggers the update of the legend and the density plot. """ if self.scatterplot_item is not None: pen_data, brush_data = self.get_colors() self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) self.update_legends() self.update_density() update_alpha_value = update_colors def update_density(self): """ Remove the existing density plot (if there is one) and replace it with a new one (if enabled). The method gets the colors from the pens of the currently plotted points. """ if self.density_img: self.plot_widget.removeItem(self.density_img) self.density_img = None if self.class_density and self.scatterplot_item is not None: rgb_data = [ pen.color().getRgb()[:3] if pen is not None else (255, 255, 255) for pen in self.scatterplot_item.data['pen']] if len(set(rgb_data)) <= 1: return [min_x, max_x], [min_y, max_y] = self.view_box.viewRange() x_data, y_data = self.scatterplot_item.getData() self.density_img = classdensity.class_density_image( min_x, max_x, min_y, max_y, self.resolution, x_data, y_data, rgb_data) self.plot_widget.addItem(self.density_img) def update_selection_colors(self): """ Trigger an update of selection markers This update method is usually not called by the widget but by the plot, since it is the plot that handles the selections. Like other update methods, it calls the corresponding get method (`get_colors_sel`) which returns a list of pens and brushes. """ if self.scatterplot_item_sel is None: return pen, brush = self.get_colors_sel() self.scatterplot_item_sel.setPen(pen, update=False, mask=None) self.scatterplot_item_sel.setBrush(brush, mask=None) def get_colors_sel(self): """ Return pens and brushes for selection markers. A pen can is set to `Qt.NoPen` if a point is not selected. All brushes are completely transparent whites. Returns: (tuple): a list of pens and a list of brushes """ nopen = QPen(Qt.NoPen) if self.selection is None: pen = [nopen] * self.n_shown else: sels = np.max(self.selection) if sels == 1: pen = np.where( self._filter_visible(self.selection), _make_pen(QColor(255, 190, 0, 255), SELECTION_WIDTH + 1), nopen) else: palette = ColorPaletteGenerator(number_of_colors=sels + 1) pen = np.choose( self._filter_visible(self.selection), [nopen] + [_make_pen(palette[i], SELECTION_WIDTH + 1) for i in range(sels)]) return pen, [QBrush(QColor(255, 255, 255, 0))] * self.n_shown # Labels def get_labels(self): """ Prepare data for labels for points The method returns the results of the widget's `get_label_data` Returns: (labels): a sequence of labels """ return self._filter_visible(self.master.get_label_data()) def update_labels(self): """ Trigger an update of labels The method calls `get_labels` which in turn calls the widget's `get_label_data`. The obtained labels are shown if the corresponding points are selected or if `label_only_selected` is `false`. """ for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] mask = None if self.scatterplot_item is not None: x, y = self.scatterplot_item.getData() mask = self._label_mask(x, y) if mask is not None: labels = self.get_labels() if labels is None: mask = None self._signal_too_many_labels( mask is not None and mask.sum() > self.MAX_VISIBLE_LABELS) if self._too_many_labels or mask is None or not np.any(mask): return black = pg.mkColor(0, 0, 0) labels = labels[mask] x = x[mask] y = y[mask] for label, xp, yp in zip(labels, x, y): ti = TextItem(label, black) ti.setPos(xp, yp) self.plot_widget.addItem(ti) self.labels.append(ti) def _signal_too_many_labels(self, too_many): if self._too_many_labels != too_many: self._too_many_labels = too_many self.too_many_labels.emit(too_many) def _label_mask(self, x, y): (x0, x1), (y0, y1) = self.view_box.viewRange() mask = np.logical_and( np.logical_and(x >= x0, x <= x1), np.logical_and(y >= y0, y <= y1)) if self.label_only_selected: sub_mask = self._filter_visible(self.master.get_subset_mask()) if self.selection is None: if sub_mask is None: return None else: sel_mask = sub_mask else: sel_mask = self._filter_visible(self.selection) != 0 if sub_mask is not None: sel_mask = np.logical_or(sel_mask, sub_mask) mask = np.logical_and(mask, sel_mask) return mask # Shapes def get_shapes(self): """ Prepare data for shapes of points in the plot The method is called by `update_shapes`. It gets the data from the widget's `get_shape_data`, and then calls its `impute_shapes` to impute the missing shape (usually with some default shape). Returns: (np.ndarray): an array of symbols (e.g. o, x, + ...) """ shape_data = self.master.get_shape_data() shape_data = self._filter_visible(shape_data) # Data has to be copied so the imputation can change it in-place # TODO: Try avoiding this when we move imputation to the widget if shape_data is not None: shape_data = np.copy(shape_data) shape_imputer = getattr( self.master, "impute_shapes", self.default_impute_shapes) shape_imputer(shape_data, len(self.CurveSymbols) - 1) if isinstance(shape_data, np.ndarray): shape_data = shape_data.astype(int) else: shape_data = np.zeros(self.n_shown, dtype=int) return self.CurveSymbols[shape_data] @staticmethod def default_impute_shapes(shape_data, default_symbol): """ Fallback imputation for shapes. Use the default symbol, usually the last symbol in the list. Returns: (bool): True if there was any missing data """ if shape_data is None: return False nans = np.isnan(shape_data) if np.any(nans): shape_data[nans] = default_symbol return True else: return False def update_shapes(self): """ Trigger an update of point symbols The method calls `get_shapes` to obtain an array with a symbol for each point and uses it to update the symbols. Finally, the method updates the legend. """ if self.scatterplot_item: shape_data = self.get_shapes() self.scatterplot_item.setSymbol(shape_data) self.update_legends() def update_grid_visibility(self): """Show or hide the grid""" self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend_visibility(self): """ Show or hide legends based on whether they are enabled and non-empty """ self.shape_legend.setVisible( self.show_legend and bool(self.shape_legend.items)) self.color_legend.setVisible( self.show_legend and bool(self.color_legend.items)) def update_legends(self): """Update content of legends and their visibility""" cont_color = self.master.is_continuous_color() shape_labels = self.master.get_shape_labels() color_labels = None if cont_color else self.master.get_color_labels() if shape_labels == color_labels and shape_labels is not None: self._update_combined_legend(shape_labels) else: self._update_shape_legend(shape_labels) if cont_color: self._update_continuous_color_legend() else: self._update_color_legend(color_labels) self.update_legend_visibility() def _update_shape_legend(self, labels): self.shape_legend.clear() if labels is None or self.scatterplot_item is None: return color = QColor(0, 0, 0) color.setAlpha(self.alpha_value) for label, symbol in zip(labels, self.CurveSymbols): self.shape_legend.addItem( ScatterPlotItem(pen=color, brush=color, size=10, symbol=symbol), escape(label)) def _update_continuous_color_legend(self): self.color_legend.clear() if self.scale is None or self.scatterplot_item is None: return label = PaletteItemSample(self.palette, self.scale) self.color_legend.addItem(label, "") self.color_legend.setGeometry(label.boundingRect()) def _update_color_legend(self, labels): self.color_legend.clear() if labels is None: return self._update_colored_legend(self.color_legend, labels, 'o') def _update_combined_legend(self, labels): # update_colored_legend will already clear the shape legend # so we remove colors here use_legend = \ self.shape_legend if self.shape_legend.items else self.color_legend self.color_legend.clear() self.shape_legend.clear() self._update_colored_legend(use_legend, labels, self.CurveSymbols) def _update_colored_legend(self, legend, labels, symbols): if self.scatterplot_item is None or not self.palette: return if isinstance(symbols, str): symbols = itertools.repeat(symbols, times=len(labels)) for i, (label, symbol) in enumerate(zip(labels, symbols)): color = QColor(*self.palette.getRGB(i)) pen = _make_pen(color.darker(self.DarkerValue), 1.5) color.setAlpha(255 if self.subset_is_shown else self.alpha_value) brush = QBrush(color) legend.addItem( ScatterPlotItem(pen=pen, brush=brush, size=10, symbol=symbol), escape(label)) def zoom_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def pan_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().PanMode) def select_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def reset_button_clicked(self): self.plot_widget.getViewBox().autoRange() self.update_labels() def select_by_click(self, _, points): if self.scatterplot_item is not None: self.select(points) def select_by_rectangle(self, value_rect): if self.scatterplot_item is not None: x0, y0 = value_rect.topLeft().x(), value_rect.topLeft().y() x1, y1 = value_rect.bottomRight().x(), value_rect.bottomRight().y() x, y = self.master.get_coordinates_data() indices = np.flatnonzero( (x0 <= x) & (x <= x1) & (y0 <= y) & (y <= y1)) self.select_by_indices(indices.astype(int)) def unselect_all(self): if self.selection is not None: self.selection = None self.update_selection_colors() if self.label_only_selected: self.update_labels() self.master.selection_changed() def select(self, points): # noinspection PyArgumentList if self.scatterplot_item is None: return indices = [p.data() for p in points] self.select_by_indices(indices) def select_by_indices(self, indices): if self.selection is None: self.selection = np.zeros(self.n_valid, dtype=np.uint8) keys = QApplication.keyboardModifiers() if keys & Qt.AltModifier: self.selection_remove(indices) elif keys & Qt.ShiftModifier and keys & Qt.ControlModifier: self.selection_append(indices) elif keys & Qt.ShiftModifier: self.selection_new_group(indices) else: self.selection_select(indices) def selection_select(self, indices): self.selection = np.zeros(self.n_valid, dtype=np.uint8) self.selection[indices] = 1 self._update_after_selection() def selection_append(self, indices): self.selection[indices] = np.max(self.selection) self._update_after_selection() def selection_new_group(self, indices): self.selection[indices] = np.max(self.selection) + 1 self._update_after_selection() def selection_remove(self, indices): self.selection[indices] = 0 self._update_after_selection() def _update_after_selection(self): self._compress_indices() self.update_selection_colors() if self.label_only_selected: self.update_labels() self.master.selection_changed() def _compress_indices(self): indices = sorted(set(self.selection) | {0}) if len(indices) == max(indices) + 1: return mapping = np.zeros((max(indices) + 1,), dtype=int) for i, ind in enumerate(indices): mapping[ind] = i self.selection = mapping[self.selection] def get_selection(self): if self.selection is None: return np.array([], dtype=np.uint8) else: return np.flatnonzero(self.selection) def help_event(self, event): """ Create a `QToolTip` for the point hovered by the mouse """ 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 else: return False
class OWScatterPlotGraph(gui.OWComponent, ScaleScatterPlotData): attr_color = ContextSetting("", ContextSetting.OPTIONAL) attr_label = ContextSetting("", ContextSetting.OPTIONAL) attr_shape = ContextSetting("", ContextSetting.OPTIONAL) attr_size = ContextSetting("", ContextSetting.OPTIONAL) point_width = Setting(10) alpha_value = Setting(128) show_grid = Setting(False) show_legend = Setting(True) tooltip_shows_all = Setting(False) class_density = Setting(False) resolution = 256 CurveSymbols = np.array("o x t + d s ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) ID_MISSING_COORDS, ID_MISSING_SIZE, ID_MISSING_SHAPE = range(1, 4) def __init__(self, scatter_widget, parent=None, _="None"): gui.OWComponent.__init__(self, scatter_widget) self.view_box = InteractiveViewBox(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent, background="w") self.plot_widget.getPlotItem().buttonsHidden = True self.plot_widget.setAntialiasing(True) self.plot_widget.sizeHint = lambda: QtCore.QSize(500, 500) self.replot = self.plot_widget.replot ScaleScatterPlotData.__init__(self) self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self.master = scatter_widget self.shown_attribute_indices = [] self.shown_x = "" self.shown_y = "" self.pen_colors = self.brush_colors = None self.valid_data = None # np.ndarray self.selection = None # np.ndarray self.n_points = 0 self.gui = OWPlotGUI(self) self.continuous_palette = ContinuousPaletteGenerator( QColor(255, 255, 0), QColor(0, 0, 255), True) self.discrete_palette = ColorPaletteGenerator() self.selection_behavior = 0 self.legend = self.color_legend = None self.__legend_anchor = (1, 0), (1, 0) self.__color_legend_anchor = (1, 1), (1, 1) self.scale = None # DiscretizedScale self.subset_indices = None # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid() self._tooltip_delegate = HelpEventDelegate(self.help_event) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) def new_data(self, data, subset_data=None, **args): self.plot_widget.clear() self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self.selection = None self.valid_data = None self.subset_indices = set(e.id for e in subset_data) if subset_data else None self.set_data(data, **args) def _clear_plot_widget(self): self.remove_legend() if self.density_img: self.plot_widget.removeItem(self.density_img) self.density_img = None if self.scatterplot_item: self.plot_widget.removeItem(self.scatterplot_item) self.scatterplot_item = None if self.scatterplot_item_sel: self.plot_widget.removeItem(self.scatterplot_item_sel) self.scatterplot_item_sel = None for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] self.set_axis_title("bottom", "") self.set_axis_title("left", "") def update_data(self, attr_x, attr_y, reset_view=True): self.master.warning(self.ID_MISSING_COORDS) self.master.information(self.ID_MISSING_COORDS) self._clear_plot_widget() self.shown_x = attr_x self.shown_y = attr_y if self.scaled_data is None or not len(self.scaled_data): self.valid_data = None else: index_x = self.attribute_name_index[attr_x] index_y = self.attribute_name_index[attr_y] self.valid_data = self.get_valid_list([index_x, index_y], also_class_if_exists=False) if not np.any(self.valid_data): self.valid_data = None if self.valid_data is None: self.selection = None self.n_points = 0 self.master.warning( self.ID_MISSING_COORDS, "Plot cannot be displayed because '{}' or '{}' is missing for " "all data points".format(self.shown_x, self.shown_y)) return x_data, y_data = self.get_xy_data_positions( attr_x, attr_y, self.valid_data) self.n_points = len(x_data) if reset_view: min_x, max_x = np.nanmin(x_data), np.nanmax(x_data) min_y, max_y = np.nanmin(y_data), np.nanmax(y_data) self.view_box.setRange( QRectF(min_x, min_y, max_x - min_x, max_y - min_y), padding=0.025) self.view_box.init_history() self.view_box.tag_history() [min_x, max_x], [min_y, max_y] = self.view_box.viewRange() for axis, name, index in (("bottom", attr_x, index_x), ("left", attr_y, index_y)): self.set_axis_title(axis, name) var = self.data_domain[index] if var.is_discrete: self.set_labels(axis, get_variable_values_sorted(var)) else: self.set_labels(axis, None) color_data, brush_data = self.compute_colors() color_data_sel, brush_data_sel = self.compute_colors_sel() size_data = self.compute_sizes() shape_data = self.compute_symbols() if self.should_draw_density(): rgb_data = [pen.color().getRgb()[:3] for pen in color_data] self.density_img = classdensity.class_density_image( min_x, max_x, min_y, max_y, self.resolution, x_data, y_data, rgb_data) self.plot_widget.addItem(self.density_img) data_indices = np.flatnonzero(self.valid_data) if len(data_indices) != self.original_data.shape[1]: self.master.information( self.ID_MISSING_COORDS, "Points with missing '{}' or '{}' are not displayed". format(self.shown_x, self.shown_y)) self.scatterplot_item = ScatterPlotItem( x=x_data, y=y_data, data=data_indices, symbol=shape_data, size=size_data, pen=color_data, brush=brush_data ) self.scatterplot_item_sel = ScatterPlotItem( x=x_data, y=y_data, data=data_indices, symbol=shape_data, size=size_data + SELECTION_WIDTH, pen=color_data_sel, brush=brush_data_sel ) self.plot_widget.addItem(self.scatterplot_item_sel) self.plot_widget.addItem(self.scatterplot_item) self.scatterplot_item.selected_points = [] self.scatterplot_item.sigClicked.connect(self.select_by_click) self.update_labels() self.make_legend() self.plot_widget.replot() def can_draw_density(self): if self.data_domain is None: return False discrete_color = False attr_color = self.attr_color if attr_color != "" and attr_color != "(Same color)": color_var = self.data_domain[attr_color] discrete_color = color_var.is_discrete continuous_x = False continuous_y = False if self.shown_x and self.shown_y: continuous_x = self.data_domain[self.shown_x].is_continuous continuous_y = self.data_domain[self.shown_y].is_continuous return discrete_color and continuous_x and continuous_y def should_draw_density(self): return self.class_density and self.n_points > 1 and self.can_draw_density() def set_labels(self, axis, labels): axis = self.plot_widget.getAxis(axis) if labels: ticks = [[(i, labels[i]) for i in range(len(labels))]] axis.setTicks(ticks) else: axis.setTicks(None) def set_axis_title(self, axis, title): self.plot_widget.setLabel(axis=axis, text=title) def get_size_index(self): size_index = -1 attr_size = self.attr_size if attr_size != "" and attr_size != "(Same size)": size_index = self.attribute_name_index[attr_size] return size_index def compute_sizes(self): self.master.information(self.ID_MISSING_SIZE) size_index = self.get_size_index() if size_index == -1: size_data = np.full((self.n_points,), self.point_width) else: size_data = \ self.MinShapeSize + \ self.no_jittering_scaled_data[size_index, self.valid_data] * \ self.point_width nans = np.isnan(size_data) if np.any(nans): size_data[nans] = self.MinShapeSize - 2 self.master.information( self.ID_MISSING_SIZE, "Points with undefined '{}' are shown in smaller size". format(self.attr_size)) return size_data def update_sizes(self): if self.scatterplot_item: size_data = self.compute_sizes() self.scatterplot_item.setSize(size_data) self.scatterplot_item_sel.setSize(size_data + SELECTION_WIDTH) update_point_size = update_sizes def get_color_index(self): color_index = -1 attr_color = self.attr_color if attr_color != "" and attr_color != "(Same color)": color_index = self.attribute_name_index[attr_color] color_var = self.data_domain[attr_color] colors = color_var.colors if color_var.is_discrete: self.discrete_palette = ColorPaletteGenerator( number_of_colors=len(colors), rgb_colors=colors) else: self.continuous_palette = ContinuousPaletteGenerator(*colors) return color_index def compute_colors_sel(self, keep_colors=False): if not keep_colors: self.pen_colors_sel = self.brush_colors_sel = None def make_pen(color, width): p = QPen(color, width) p.setCosmetic(True) return p pens = [QPen(Qt.NoPen), make_pen(QColor(255, 190, 0, 255), SELECTION_WIDTH + 1.)] if self.selection is not None: pen = [pens[a] for a in self.selection[self.valid_data]] else: pen = [pens[0]] * self.n_points brush = [QBrush(QColor(255, 255, 255, 0))] * self.n_points return pen, brush def compute_colors(self, keep_colors=False): if not keep_colors: self.pen_colors = self.brush_colors = None color_index = self.get_color_index() def make_pen(color, width): p = QPen(color, width) p.setCosmetic(True) return p subset = None if self.subset_indices: subset = np.array([ex.id in self.subset_indices for ex in self.raw_data[self.valid_data]]) if color_index == -1: # same color color = self.plot_widget.palette().color(OWPalette.Data) pen = [make_pen(color, 1.5)] * self.n_points if subset is not None: brush = [(QBrush(QColor(128, 128, 128, 0)), QBrush(QColor(128, 128, 128, self.alpha_value)))[s] for s in subset] else: brush = [QBrush(QColor(128, 128, 128, self.alpha_value))] \ * self.n_points return pen, brush c_data = self.original_data[color_index, self.valid_data] if self.data_domain[color_index].is_continuous: if self.pen_colors is None: self.scale = DiscretizedScale(np.nanmin(c_data), np.nanmax(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) palette = self.continuous_palette self.pen_colors = palette.getRGB(c_data) self.brush_colors = np.hstack( [self.pen_colors, np.full((self.n_points, 1), self.alpha_value)]) self.pen_colors *= 100 // self.DarkerValue self.pen_colors = [make_pen(QColor(*col), 1.5) for col in self.pen_colors.tolist()] if subset is not None: self.brush_colors[:, 3] = 0 self.brush_colors[subset, 3] = self.alpha_value else: self.brush_colors[:, 3] = self.alpha_value pen = self.pen_colors brush = np.array([QBrush(QColor(*col)) for col in self.brush_colors.tolist()]) else: if self.pen_colors is None: palette = self.discrete_palette n_colors = palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = np.r_[palette.getRGB(np.arange(n_colors)), [[128, 128, 128]]] pens = np.array( [make_pen(QColor(*col).darker(self.DarkerValue), 1.5) for col in colors]) self.pen_colors = pens[c_data] self.brush_colors = np.array([ [QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], self.alpha_value))] for col in colors]) self.brush_colors = self.brush_colors[c_data] if subset is not None: brush = np.where( subset, self.brush_colors[:, 1], self.brush_colors[:, 0]) else: brush = self.brush_colors[:, 1] pen = self.pen_colors return pen, brush def update_colors(self, keep_colors=False): if self.scatterplot_item: pen_data, brush_data = self.compute_colors(keep_colors) pen_data_sel, brush_data_sel = self.compute_colors_sel(keep_colors) self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) self.scatterplot_item_sel.setPen(pen_data_sel, update=False, mask=None) self.scatterplot_item_sel.setBrush(brush_data_sel, mask=None) if not keep_colors: self.make_legend() if self.should_draw_density(): self.update_data(self.shown_x, self.shown_y) elif self.density_img: self.plot_widget.removeItem(self.density_img) update_alpha_value = update_colors def create_labels(self): for x, y in zip(*self.scatterplot_item.getData()): ti = TextItem() self.plot_widget.addItem(ti) ti.setPos(x, y) self.labels.append(ti) def update_labels(self): if not self.attr_label: for label in self.labels: label.setText("") return if not self.labels: self.create_labels() label_column = self.raw_data.get_column_view(self.attr_label)[0] formatter = self.raw_data.domain[self.attr_label].str_val label_data = map(formatter, label_column) black = pg.mkColor(0, 0, 0) for label, text in zip(self.labels, label_data): label.setText(text, black) def get_shape_index(self): shape_index = -1 attr_shape = self.attr_shape if attr_shape and attr_shape != "(Same shape)" and \ len(self.data_domain[attr_shape].values) <= \ len(self.CurveSymbols): shape_index = self.attribute_name_index[attr_shape] return shape_index def compute_symbols(self): self.master.information(self.ID_MISSING_SHAPE) shape_index = self.get_shape_index() if shape_index == -1: shape_data = self.CurveSymbols[np.zeros(self.n_points, dtype=int)] else: shape_data = self.original_data[shape_index, self.valid_data] nans = np.isnan(shape_data) if np.any(nans): shape_data[nans] = len(self.CurveSymbols) - 1 self.master.information( self.ID_MISSING_SHAPE, "Points with undefined '{}' are shown as crossed circles". format(self.attr_shape)) shape_data = self.CurveSymbols[shape_data.astype(int)] return shape_data def update_shapes(self): if self.scatterplot_item: shape_data = self.compute_symbols() self.scatterplot_item.setSymbol(shape_data) self.make_legend() def update_grid(self): self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend(self): if self.legend: self.legend.setVisible(self.show_legend) def create_legend(self): self.legend = LegendItem() self.legend.setParentItem(self.plot_widget.getViewBox()) self.legend.restoreAnchor(self.__legend_anchor) def remove_legend(self): if self.legend: anchor = legend_anchor_pos(self.legend) if anchor is not None: self.__legend_anchor = anchor self.legend.setParent(None) self.legend = None if self.color_legend: anchor = legend_anchor_pos(self.color_legend) if anchor is not None: self.__color_legend_anchor = anchor self.color_legend.setParent(None) self.color_legend = None def make_legend(self): self.remove_legend() self.make_color_legend() self.make_shape_legend() self.update_legend() def make_color_legend(self): color_index = self.get_color_index() if color_index == -1: return color_var = self.data_domain[color_index] use_shape = self.get_shape_index() == color_index if color_var.is_discrete: if not self.legend: self.create_legend() palette = self.discrete_palette for i, value in enumerate(color_var.values): color = QColor(*palette.getRGB(i)) brush = color.lighter(self.DarkerValue) self.legend.addItem( ScatterPlotItem( pen=color, brush=brush, size=10, symbol=self.CurveSymbols[i] if use_shape else "o"), escape(value)) else: legend = self.color_legend = LegendItem() legend.setParentItem(self.plot_widget.getViewBox()) legend.restoreAnchor(self.__color_legend_anchor) label = PaletteItemSample(self.continuous_palette, self.scale) legend.addItem(label, "") legend.setGeometry(label.boundingRect()) def make_shape_legend(self): shape_index = self.get_shape_index() if shape_index == -1 or shape_index == self.get_color_index(): return if not self.legend: self.create_legend() shape_var = self.data_domain[shape_index] color = self.plot_widget.palette().color(OWPalette.Data) pen = QPen(color.darker(self.DarkerValue)) color.setAlpha(self.alpha_value) for i, value in enumerate(shape_var.values): self.legend.addItem( ScatterPlotItem(pen=pen, brush=color, size=10, symbol=self.CurveSymbols[i]), escape(value)) def zoom_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def pan_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().PanMode) def select_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def reset_button_clicked(self): self.update_data(self.shown_x, self.shown_y, reset_view=True) # also redraw density image # self.view_box.autoRange() def select_by_click(self, _, points): if self.scatterplot_item is not None: self.select(points) def select_by_rectangle(self, value_rect): if self.scatterplot_item is not None: points = [point for point in self.scatterplot_item.points() if value_rect.contains(QPointF(point.pos()))] self.select(points) def unselect_all(self): self.selection = None self.update_colors(keep_colors=True) self.master.selection_changed() def select(self, points): # noinspection PyArgumentList if self.raw_data is None: return keys = QApplication.keyboardModifiers() if self.selection is None or not keys & ( Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier): self.selection = np.full(len(self.raw_data), False, dtype=np.bool) indices = [p.data() for p in points] if keys & Qt.AltModifier: self.selection[indices] = False elif keys & Qt.ControlModifier: self.selection[indices] = ~self.selection[indices] else: # Handle shift and no modifiers self.selection[indices] = True self.update_colors(keep_colors=True) self.master.selection_changed() def get_selection(self): if self.selection is None: return np.array([], dtype=int) else: return np.flatnonzero(self.selection) def set_palette(self, p): self.plot_widget.setPalette(p) def save_to_file(self, size): pass def help_event(self, event): if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) text = "" if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" if self.tooltip_shows_all and \ len(self.data_domain.attributes) < 30: text += "".join( ' {} = {}\n'.format(attr.name, self.raw_data[index][attr]) for attr in self.data_domain.attributes) else: text += ' {} = {}\n {} = {}\n'.format( self.shown_x, self.raw_data[index][self.shown_x], self.shown_y, self.raw_data[index][self.shown_y]) if self.tooltip_shows_all: text += " ... and {} others\n\n".format( len(self.data_domain.attributes) - 2) if self.data_domain.class_var: text += 'Class:\n {} = {}\n'.format( self.data_domain.class_var.name, self.raw_data[index][self.raw_data.domain.class_var]) if i < len(points) - 1: text += '------------------\n' text = ('<span style="white-space:pre">{}</span>' .format(escape(text))) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False
class OWScatterPlotGraph(gui.OWComponent, ScaleScatterPlotData): attr_color = ContextSetting(None, ContextSetting.OPTIONAL, exclude_metas=False) attr_label = ContextSetting(None, ContextSetting.OPTIONAL, exclude_metas=False) attr_shape = ContextSetting(None, ContextSetting.OPTIONAL, exclude_metas=False) attr_size = ContextSetting(None, ContextSetting.OPTIONAL, exclude_metas=False) label_only_selected = Setting(False) point_width = Setting(10) alpha_value = Setting(128) show_grid = Setting(False) show_legend = Setting(True) tooltip_shows_all = Setting(False) class_density = Setting(False) resolution = 256 CurveSymbols = np.array("o x t + d s ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) def __init__(self, scatter_widget, parent=None, _="None"): gui.OWComponent.__init__(self, scatter_widget) self.view_box = InteractiveViewBox(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent, background="w") self.plot_widget.getPlotItem().buttonsHidden = True self.plot_widget.setAntialiasing(True) self.plot_widget.sizeHint = lambda: QtCore.QSize(500, 500) self.replot = self.plot_widget.replot ScaleScatterPlotData.__init__(self) self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self.master = scatter_widget self.master.Warning.add_message( "missing_coords", "Plot cannot be displayed because '{}' or '{}' is missing for " "all data points") self.master.Information.add_message( "missing_coords", "Points with missing '{}' or '{}' are not displayed") self.master.Information.add_message( "missing_size", "Points with undefined '{}' are shown in smaller size") self.master.Information.add_message( "missing_shape", "Points with undefined '{}' are shown as crossed circles") self.shown_attribute_indices = [] self.shown_x = self.shown_y = None self.pen_colors = self.brush_colors = None self.valid_data = None # np.ndarray self.selection = None # np.ndarray self.n_points = 0 self.gui = OWPlotGUI(self) self.continuous_palette = ContinuousPaletteGenerator( QColor(255, 255, 0), QColor(0, 0, 255), True) self.discrete_palette = ColorPaletteGenerator() self.selection_behavior = 0 self.legend = self.color_legend = None self.__legend_anchor = (1, 0), (1, 0) self.__color_legend_anchor = (1, 1), (1, 1) self.scale = None # DiscretizedScale self.subset_indices = None # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid() self._tooltip_delegate = HelpEventDelegate(self.help_event) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) def new_data(self, data, subset_data=None, **args): self.plot_widget.clear() self.remove_legend() self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self.selection = None self.valid_data = None self.subset_indices = set( e.id for e in subset_data) if subset_data else None self.set_data(data, **args) def _clear_plot_widget(self): self.remove_legend() if self.density_img: self.plot_widget.removeItem(self.density_img) self.density_img = None if self.scatterplot_item: self.plot_widget.removeItem(self.scatterplot_item) self.scatterplot_item = None if self.scatterplot_item_sel: self.plot_widget.removeItem(self.scatterplot_item_sel) self.scatterplot_item_sel = None for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] self.set_axis_title("bottom", "") self.set_axis_title("left", "") def update_data(self, attr_x, attr_y, reset_view=True): self.master.Warning.missing_coords.clear() self.master.Information.missing_coords.clear() self._clear_plot_widget() self.shown_x, self.shown_y = attr_x, attr_y if self.jittered_data is None or not len(self.jittered_data): self.valid_data = None else: index_x = self.domain.index(attr_x) index_y = self.domain.index(attr_y) self.valid_data = self.get_valid_list([index_x, index_y]) if not np.any(self.valid_data): self.valid_data = None if self.valid_data is None: self.selection = None self.n_points = 0 self.master.Warning.missing_coords(self.shown_x.name, self.shown_y.name) return x_data, y_data = self.get_xy_data_positions(attr_x, attr_y, self.valid_data) self.n_points = len(x_data) if reset_view: min_x, max_x = np.nanmin(x_data), np.nanmax(x_data) min_y, max_y = np.nanmin(y_data), np.nanmax(y_data) self.view_box.setRange(QRectF(min_x, min_y, max_x - min_x, max_y - min_y), padding=0.025) self.view_box.init_history() self.view_box.tag_history() [min_x, max_x], [min_y, max_y] = self.view_box.viewRange() for axis, name, index in (("bottom", attr_x, index_x), ("left", attr_y, index_y)): self.set_axis_title(axis, name) var = self.domain[index] if var.is_discrete: self.set_labels(axis, get_variable_values_sorted(var)) else: self.set_labels(axis, None) color_data, brush_data = self.compute_colors() color_data_sel, brush_data_sel = self.compute_colors_sel() size_data = self.compute_sizes() shape_data = self.compute_symbols() if self.should_draw_density(): rgb_data = [pen.color().getRgb()[:3] for pen in color_data] self.density_img = classdensity.class_density_image( min_x, max_x, min_y, max_y, self.resolution, x_data, y_data, rgb_data) self.plot_widget.addItem(self.density_img) data_indices = np.flatnonzero(self.valid_data) if len(data_indices) != self.original_data.shape[1]: self.master.Information.missing_coords(self.shown_x.name, self.shown_y.name) self.scatterplot_item = ScatterPlotItem(x=x_data, y=y_data, data=data_indices, symbol=shape_data, size=size_data, pen=color_data, brush=brush_data) self.scatterplot_item_sel = ScatterPlotItem(x=x_data, y=y_data, data=data_indices, symbol=shape_data, size=size_data + SELECTION_WIDTH, pen=color_data_sel, brush=brush_data_sel) self.plot_widget.addItem(self.scatterplot_item_sel) self.plot_widget.addItem(self.scatterplot_item) self.scatterplot_item.selected_points = [] self.scatterplot_item.sigClicked.connect(self.select_by_click) self.update_labels() self.make_legend() self.plot_widget.replot() def can_draw_density(self): return self.domain is not None and \ self.attr_color is not None and \ self.attr_color.is_discrete and \ self.shown_x.is_continuous and \ self.shown_y.is_continuous def should_draw_density(self): return self.class_density and self.n_points > 1 and self.can_draw_density( ) def set_labels(self, axis, labels): axis = self.plot_widget.getAxis(axis) if labels: ticks = [[(i, labels[i]) for i in range(len(labels))]] axis.setTicks(ticks) else: axis.setTicks(None) def set_axis_title(self, axis, title): self.plot_widget.setLabel(axis=axis, text=title) def get_size_index(self): if self.attr_size is None: return -1 return self.domain.index(self.attr_size) def compute_sizes(self): self.master.Information.missing_size.clear() size_index = self.get_size_index() if size_index == -1: size_data = np.full((self.n_points, ), self.point_width) else: size_data = \ self.MinShapeSize + \ self.scaled_data[size_index, self.valid_data] * \ self.point_width nans = np.isnan(size_data) if np.any(nans): size_data[nans] = self.MinShapeSize - 2 self.master.Information.missing_size(self.attr_size) return size_data def update_sizes(self): if self.scatterplot_item: size_data = self.compute_sizes() self.scatterplot_item.setSize(size_data) self.scatterplot_item_sel.setSize(size_data + SELECTION_WIDTH) update_point_size = update_sizes def get_color_index(self): if self.attr_color is None: return -1 colors = self.attr_color.colors if self.attr_color.is_discrete: self.discrete_palette = ColorPaletteGenerator( number_of_colors=len(colors), rgb_colors=colors) else: self.continuous_palette = ContinuousPaletteGenerator(*colors) return self.domain.index(self.attr_color) def compute_colors_sel(self, keep_colors=False): if not keep_colors: self.pen_colors_sel = self.brush_colors_sel = None def make_pen(color, width): p = QPen(color, width) p.setCosmetic(True) return p pens = [ QPen(Qt.NoPen), make_pen(QColor(255, 190, 0, 255), SELECTION_WIDTH + 1.) ] if self.selection is not None: pen = [pens[a] for a in self.selection[self.valid_data]] else: pen = [pens[0]] * self.n_points brush = [QBrush(QColor(255, 255, 255, 0))] * self.n_points return pen, brush def compute_colors(self, keep_colors=False): if not keep_colors: self.pen_colors = self.brush_colors = None color_index = self.get_color_index() def make_pen(color, width): p = QPen(color, width) p.setCosmetic(True) return p subset = None if self.subset_indices: subset = np.array([ ex.id in self.subset_indices for ex in self.data[self.valid_data] ]) if color_index == -1: # same color color = self.plot_widget.palette().color(OWPalette.Data) pen = [make_pen(color, 1.5)] * self.n_points if subset is not None: brush = [(QBrush(QColor(128, 128, 128, 0)), QBrush(QColor(128, 128, 128, 255)))[s] for s in subset] else: brush = [QBrush(QColor(128, 128, 128, self.alpha_value))] \ * self.n_points return pen, brush c_data = self.original_data[color_index, self.valid_data] if self.domain[color_index].is_continuous: if self.pen_colors is None: self.scale = DiscretizedScale(np.nanmin(c_data), np.nanmax(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) palette = self.continuous_palette self.pen_colors = palette.getRGB(c_data) self.brush_colors = np.hstack([ self.pen_colors, np.full((self.n_points, 1), self.alpha_value) ]) self.pen_colors *= 100 // self.DarkerValue self.pen_colors = [ make_pen(QColor(*col), 1.5) for col in self.pen_colors.tolist() ] if subset is not None: self.brush_colors[:, 3] = 0 self.brush_colors[subset, 3] = 255 else: self.brush_colors[:, 3] = self.alpha_value pen = self.pen_colors brush = np.array( [QBrush(QColor(*col)) for col in self.brush_colors.tolist()]) else: if self.pen_colors is None: palette = self.discrete_palette n_colors = palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = np.r_[palette.getRGB(np.arange(n_colors)), [[128, 128, 128]]] pens = np.array([ make_pen(QColor(*col).darker(self.DarkerValue), 1.5) for col in colors ]) self.pen_colors = pens[c_data] alpha = self.alpha_value if subset is None else 255 self.brush_colors = np.array([[ QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], alpha)) ] for col in colors]) self.brush_colors = self.brush_colors[c_data] if subset is not None: brush = np.where(subset, self.brush_colors[:, 1], self.brush_colors[:, 0]) else: brush = self.brush_colors[:, 1] pen = self.pen_colors return pen, brush def update_colors(self, keep_colors=False): if self.scatterplot_item: pen_data, brush_data = self.compute_colors(keep_colors) pen_data_sel, brush_data_sel = self.compute_colors_sel(keep_colors) self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) self.scatterplot_item_sel.setPen(pen_data_sel, update=False, mask=None) self.scatterplot_item_sel.setBrush(brush_data_sel, mask=None) if not keep_colors: self.make_legend() if self.should_draw_density(): self.update_data(self.shown_x, self.shown_y) elif self.density_img: self.plot_widget.removeItem(self.density_img) update_alpha_value = update_colors def create_labels(self): for x, y in zip(*self.scatterplot_item.getData()): ti = TextItem() self.plot_widget.addItem(ti) ti.setPos(x, y) self.labels.append(ti) def update_labels(self): if self.attr_label is None or \ self.label_only_selected and self.selection is None: for label in self.labels: label.setText("") return if not self.labels: self.create_labels() label_column = self.data.get_column_view(self.attr_label)[0] formatter = self.attr_label.str_val label_data = map(formatter, label_column) black = pg.mkColor(0, 0, 0) if self.label_only_selected: for label, text, selected \ in zip(self.labels, label_data, self.selection): label.setText(text if selected else "", black) else: for label, text in zip(self.labels, label_data): label.setText(text, black) def get_shape_index(self): if self.attr_shape is None or \ len(self.attr_shape.values) > len(self.CurveSymbols): return -1 return self.domain.index(self.attr_shape) def compute_symbols(self): self.master.Information.missing_shape.clear() shape_index = self.get_shape_index() if shape_index == -1: shape_data = self.CurveSymbols[np.zeros(self.n_points, dtype=int)] else: shape_data = self.original_data[shape_index, self.valid_data] nans = np.isnan(shape_data) if np.any(nans): shape_data[nans] = len(self.CurveSymbols) - 1 self.master.Information.missing_shape(self.attr_shape) shape_data = self.CurveSymbols[shape_data.astype(int)] return shape_data def update_shapes(self): if self.scatterplot_item: shape_data = self.compute_symbols() self.scatterplot_item.setSymbol(shape_data) self.make_legend() def update_grid(self): self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend(self): if self.legend: self.legend.setVisible(self.show_legend) def create_legend(self): self.legend = LegendItem() self.legend.setParentItem(self.plot_widget.getViewBox()) self.legend.restoreAnchor(self.__legend_anchor) def remove_legend(self): if self.legend: anchor = legend_anchor_pos(self.legend) if anchor is not None: self.__legend_anchor = anchor self.legend.setParent(None) self.legend = None if self.color_legend: anchor = legend_anchor_pos(self.color_legend) if anchor is not None: self.__color_legend_anchor = anchor self.color_legend.setParent(None) self.color_legend = None def make_legend(self): self.remove_legend() self.make_color_legend() self.make_shape_legend() self.update_legend() def make_color_legend(self): color_index = self.get_color_index() if color_index == -1: return color_var = self.domain[color_index] use_shape = self.get_shape_index() == color_index if color_var.is_discrete: if not self.legend: self.create_legend() palette = self.discrete_palette for i, value in enumerate(color_var.values): color = QColor(*palette.getRGB(i)) brush = color.lighter(self.DarkerValue) self.legend.addItem( ScatterPlotItem( pen=color, brush=brush, size=10, symbol=self.CurveSymbols[i] if use_shape else "o"), escape(value)) else: legend = self.color_legend = LegendItem() legend.setParentItem(self.plot_widget.getViewBox()) legend.restoreAnchor(self.__color_legend_anchor) label = PaletteItemSample(self.continuous_palette, self.scale) legend.addItem(label, "") legend.setGeometry(label.boundingRect()) def make_shape_legend(self): shape_index = self.get_shape_index() if shape_index == -1 or shape_index == self.get_color_index(): return if not self.legend: self.create_legend() shape_var = self.domain[shape_index] color = self.plot_widget.palette().color(OWPalette.Data) pen = QPen(color.darker(self.DarkerValue)) color.setAlpha(self.alpha_value) for i, value in enumerate(shape_var.values): self.legend.addItem( ScatterPlotItem(pen=pen, brush=color, size=10, symbol=self.CurveSymbols[i]), escape(value)) def zoom_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def pan_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().PanMode) def select_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def reset_button_clicked(self): self.update_data(self.shown_x, self.shown_y, reset_view=True) # also redraw density image # self.view_box.autoRange() def select_by_click(self, _, points): if self.scatterplot_item is not None: self.select(points) def select_by_rectangle(self, value_rect): if self.scatterplot_item is not None: points = [ point for point in self.scatterplot_item.points() if value_rect.contains(QPointF(point.pos())) ] self.select(points) def unselect_all(self): self.selection = None self.update_colors(keep_colors=True) if self.label_only_selected: self.update_labels() self.master.selection_changed() def select(self, points): # noinspection PyArgumentList if self.data is None: return keys = QApplication.keyboardModifiers() if self.selection is None or not keys & ( Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier): self.selection = np.full(len(self.data), False, dtype=np.bool) indices = [p.data() for p in points] if keys & Qt.AltModifier: self.selection[indices] = False elif keys & Qt.ControlModifier: self.selection[indices] = ~self.selection[indices] else: # Handle shift and no modifiers self.selection[indices] = True self.update_colors(keep_colors=True) if self.label_only_selected: self.update_labels() self.master.selection_changed() def get_selection(self): if self.selection is None: return np.array([], dtype=int) else: return np.flatnonzero(self.selection) def set_palette(self, p): self.plot_widget.setPalette(p) def save_to_file(self, size): pass def help_event(self, event): if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) text = "" if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" if self.tooltip_shows_all and \ len(self.domain.attributes) < 30: text += "".join(' {} = {}\n'.format( attr.name, self.data[index][attr]) for attr in self.domain.attributes) else: text += ' {} = {}\n {} = {}\n'.format( self.shown_x, self.data[index][self.shown_x], self.shown_y, self.data[index][self.shown_y]) if self.tooltip_shows_all: text += " ... and {} others\n\n".format( len(self.domain.attributes) - 2) if self.domain.class_var: text += 'Class:\n {} = {}\n'.format( self.domain.class_var.name, self.data[index][self.data.domain.class_var]) if i < len(points) - 1: text += '------------------\n' text = ('<span style="white-space:pre">{}</span>'.format( escape(text))) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False
class OWScatterPlotBase(gui.OWComponent, QObject): """ Provide a graph component for widgets that show any kind of point plot The component plots a set of points with given coordinates, shapes, sizes and colors. Its function is similar to that of a *view*, whereas the widget represents a *model* and a *controler*. The model (widget) needs to provide methods: - `get_coordinates_data`, `get_size_data`, `get_color_data`, `get_shape_data`, `get_label_data`, which return a 1d array (or two arrays, for `get_coordinates_data`) of `dtype` `float64`, except for `get_label_data`, which returns formatted labels; - `get_color_labels`, `get_shape_labels`, which are return lists of strings used for the color and shape legend; - `get_tooltip`, which gives a tooltip for a single data point - (optional) `impute_sizes`, `impute_shapes` get final coordinates and shapes, and replace nans; - `get_subset_mask` returns a bool array indicating whether a data point is in the subset or not (e.g. in the 'Data Subset' signal in the Scatter plot and similar widgets); - `get_palette` returns a palette appropriate for visualizing the current color data; - `is_continuous_color` decides the type of the color legend; The widget (in a role of controller) must also provide methods - `selection_changed` If `get_coordinates_data` returns `(None, None)`, the plot is cleared. If `get_size_data`, `get_color_data` or `get_shape_data` return `None`, all points will have the same size, color or shape, respectively. If `get_label_data` returns `None`, there are no labels. The view (this compomnent) provides methods `update_coordinates`, `update_sizes`, `update_colors`, `update_shapes` and `update_labels` that the widget (in a role of a controler) should call when any of these properties are changed. If the widget calls, for instance, the plot's `update_colors`, the plot will react by calling the widget's `get_color_data` as well as the widget's methods needed to construct the legend. The view also provides a method `reset_graph`, which should be called only when - the widget gets entirely new data - the number of points may have changed, for instance when selecting a different attribute for x or y in the scatter plot, where the points with missing x or y coordinates are hidden. Every `update_something` calls the plot's `get_something`, which calls the model's `get_something_data`, then it transforms this data into whatever is needed (colors, shapes, scaled sizes) and changes the plot. For the simplest example, here is `update_shapes`: ``` def update_shapes(self): if self.scatterplot_item: shape_data = self.get_shapes() self.scatterplot_item.setSymbol(shape_data) self.update_legends() def get_shapes(self): shape_data = self.master.get_shape_data() shape_data = self.master.impute_shapes( shape_data, len(self.CurveSymbols) - 1) return self.CurveSymbols[shape_data] ``` On the widget's side, `get_something_data` is essentially just: ``` def get_size_data(self): return self.get_column(self.attr_size) ``` where `get_column` retrieves a column while also filtering out the points with missing x and y and so forth. (Here we present the simplest two cases, "shapes" for the view and "sizes" for the model. The colors for the view are more complicated since they deal with discrete and continuous palettes, and the shapes for the view merge infrequent shapes.) The plot can also show just a random sample of the data. The sample size is set by `set_sample_size`, and the rest is taken care by the plot: the widget keeps providing the data for all points, selection indices refer to the entire set etc. Internally, sampling happens as early as possible (in methods `get_<something>`). """ too_many_labels = Signal(bool) label_only_selected = Setting(False) point_width = Setting(10) alpha_value = Setting(128) show_grid = Setting(False) show_legend = Setting(True) class_density = Setting(False) jitter_size = Setting(0) resolution = 256 CurveSymbols = np.array("o x t + d s t2 t3 p h star ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) COLOR_NOT_SUBSET = (128, 128, 128, 0) COLOR_SUBSET = (128, 128, 128, 255) COLOR_DEFAULT = (128, 128, 128, 0) MAX_VISIBLE_LABELS = 500 def __init__(self, scatter_widget, parent=None, view_box=ViewBox): QObject.__init__(self) gui.OWComponent.__init__(self, scatter_widget) self.subset_is_shown = False self.view_box = view_box(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent, background="w") self.plot_widget.hideAxis("left") self.plot_widget.hideAxis("bottom") self.plot_widget.getPlotItem().buttonsHidden = True self.plot_widget.setAntialiasing(True) self.plot_widget.sizeHint = lambda: QSize(500, 500) self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self.master = scatter_widget self._create_drag_tooltip(self.plot_widget.scene()) self.selection = None # np.ndarray self.n_valid = 0 self.n_shown = 0 self.sample_size = None self.sample_indices = None self.palette = None self.shape_legend = self._create_legend(((1, 0), (1, 0))) self.color_legend = self._create_legend(((1, 1), (1, 1))) self.update_legend_visibility() self.scale = None # DiscretizedScale self._too_many_labels = False # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid_visibility() self._tooltip_delegate = EventDelegate(self.help_event) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) self.view_box.sigTransformChanged.connect(self.update_density) self.view_box.sigRangeChangedManually.connect(self.update_labels) self.timer = None def _create_legend(self, anchor): legend = LegendItem() legend.setParentItem(self.plot_widget.getViewBox()) legend.restoreAnchor(anchor) return legend def _create_drag_tooltip(self, scene): tip_parts = [(Qt.ShiftModifier, "Shift: Add group"), (Qt.ShiftModifier + Qt.ControlModifier, "Shift-{}: Append to group".format( "Cmd" if sys.platform == "darwin" else "Ctrl")), (Qt.AltModifier, "Alt: Remove")] all_parts = ", ".join(part for _, part in tip_parts) self.tiptexts = { int(modifier): all_parts.replace(part, "<b>{}</b>".format(part)) for modifier, part in tip_parts } self.tiptexts[0] = all_parts self.tip_textitem = text = QGraphicsTextItem() # Set to the longest text text.setHtml(self.tiptexts[Qt.ShiftModifier + Qt.ControlModifier]) text.setPos(4, 2) r = text.boundingRect() rect = QGraphicsRectItem(0, 0, r.width() + 8, r.height() + 4) rect.setBrush(QColor(224, 224, 224, 212)) rect.setPen(QPen(Qt.NoPen)) self.update_tooltip() scene.drag_tooltip = scene.createItemGroup([rect, text]) scene.drag_tooltip.hide() def update_tooltip(self, modifiers=Qt.NoModifier): modifiers &= Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier text = self.tiptexts.get(int(modifiers), self.tiptexts[0]) self.tip_textitem.setHtml(text + self._get_jittering_tooltip()) def _get_jittering_tooltip(self): warn_jittered = "" if self.jitter_size: warn_jittered = \ '<br/><br/>' \ '<span style="background-color: red; color: white; ' \ 'font-weight: 500;">' \ ' Warning: Selection is applied to unjittered data ' \ '</span>' return warn_jittered def update_jittering(self): self.update_tooltip() x, y = self.get_coordinates() if x is None or not len(x) or self.scatterplot_item is None: return self._update_plot_coordinates(self.scatterplot_item, x, y) self._update_plot_coordinates(self.scatterplot_item_sel, x, y) self.update_labels() # TODO: Rename to remove_plot_items def clear(self): """ Remove all graphical elements from the plot Calls the pyqtgraph's plot widget's clear, sets all handles to `None`, removes labels and selections. This method should generally not be called by the widget. If the data is gone (*e.g.* upon receiving `None` as an input data signal), this should be handler by calling `reset_graph`, which will in turn call `clear`. Derived classes should override this method if they add more graphical elements. For instance, the regression line in the scatterplot adds `self.reg_line_item = None` (the line in the plot is already removed in this method). """ self.plot_widget.clear() self.density_img = None if self.timer is not None and self.timer.isActive(): self.timer.stop() self.timer = None self.scatterplot_item = None self.scatterplot_item_sel = None self.labels = [] self._signal_too_many_labels(False) self.view_box.init_history() self.view_box.tag_history() # TODO: I hate `keep_something` and `reset_something` arguments # __keep_selection is used exclusively be set_sample size which would # otherwise just repeat the code from reset_graph except for resetting # the selection. I'm uncomfortable with this; we may prefer to have a # method _reset_graph which does everything except resetting the selection, # and reset_graph would call it. def reset_graph(self, __keep_selection=False): """ Reset the graph to new data (or no data) The method must be called when the plot receives new data, in particular when the number of points change. If only their properties - like coordinates or shapes - change, an update method (`update_coordinates`, `update_shapes`...) should be called instead. The method must also be called when the data is gone. The method calls `clear`, followed by calls of all update methods. NB. Argument `__keep_selection` is for internal use only """ self.clear() if not __keep_selection: self.selection = None self.sample_indices = None self.update_coordinates() self.update_point_props() def set_sample_size(self, sample_size): """ Set the sample size Args: sample_size (int or None): sample size or `None` to show all points """ if self.sample_size != sample_size: self.sample_size = sample_size self.reset_graph(True) def update_point_props(self): """ Update the sizes, colors, shapes and labels The method calls the appropriate update methods for individual properties. """ self.update_sizes() self.update_colors() self.update_selection_colors() self.update_shapes() self.update_labels() # Coordinates # TODO: It could be nice if this method was run on entire data, not just # a sample. For this, however, it would need to either be called from # `get_coordinates` before sampling (very ugly) or call # `self.master.get_coordinates_data` (beyond ugly) or the widget would # have to store the ranges of unsampled data (ugly). # Maybe we leave it as it is. def _reset_view(self, x_data, y_data): """ Set the range of the view box Args: x_data (np.ndarray): x coordinates y_data (np.ndarray) y coordinates """ min_x, max_x = np.min(x_data), np.max(x_data) min_y, max_y = np.min(y_data), np.max(y_data) self.view_box.setRange(QRectF(min_x, min_y, max_x - min_x or 1, max_y - min_y or 1), padding=0.025) def _filter_visible(self, data): """Return the sample from the data using the stored sample_indices""" if data is None or self.sample_indices is None: return data else: return np.asarray(data[self.sample_indices]) def get_coordinates(self): """ Prepare coordinates of the points in the plot The method is called by `update_coordinates`. It gets the coordinates from the widget, jitters them and return them. The methods also initializes the sample indices if neededd and stores the original and sampled number of points. Returns: (tuple): a pair of numpy arrays containing (sampled) coordinates, or `(None, None)`. """ x, y = self.master.get_coordinates_data() if x is None: self.n_valid = self.n_shown = 0 return None, None self.n_valid = len(x) self._create_sample() x = self._filter_visible(x) y = self._filter_visible(y) # Jittering after sampling is OK if widgets do not change the sample # semi-permanently, e.g. take a sample for the duration of some # animation. If the sample size changes dynamically (like by adding # a "sample size" slider), points would move around when the sample # size changes. To prevent this, jittering should be done before # sampling (i.e. two lines earlier). This would slow it down somewhat. x, y = self.jitter_coordinates(x, y) return x, y def _create_sample(self): """ Create a random sample if the data is larger than the set sample size """ self.n_shown = min(self.n_valid, self.sample_size or self.n_valid) if self.sample_size is not None \ and self.sample_indices is None \ and self.n_valid != self.n_shown: random = np.random.RandomState(seed=0) self.sample_indices = random.choice(self.n_valid, self.n_shown, replace=False) # TODO: Is this really needed? np.sort(self.sample_indices) def jitter_coordinates(self, x, y): """ Display coordinates to random positions within ellipses with radiuses of `self.jittter_size` percents of spans """ if self.jitter_size == 0: return x, y return self._jitter_data(x, y) def _jitter_data(self, x, y, span_x=None, span_y=None): if span_x is None: span_x = np.max(x) - np.min(x) if span_y is None: span_y = np.max(y) - np.min(y) random = np.random.RandomState(seed=0) rs = random.uniform(0, 1, len(x)) phis = random.uniform(0, 2 * np.pi, len(x)) magnitude = self.jitter_size / 100 return (x + magnitude * span_x * rs * np.cos(phis), y + magnitude * span_y * rs * np.sin(phis)) def _update_plot_coordinates(self, plot, x, y): """ Change the coordinates of points while keeping other properites Note. Pyqtgraph does not offer a method for this: setting coordinates invalidates other data. We therefore retrieve the data to set it together with the coordinates. Pyqtgraph also does not offer a (documented) method for retrieving the data, yet using `plot.data[prop]` looks reasonably safe. The alternative, calling update for every property would essentially reset the graph, which can be time consuming. """ data = dict(x=x, y=y) for prop in ('pen', 'brush', 'size', 'symbol', 'data', 'sourceRect', 'targetRect'): data[prop] = plot.data[prop] plot.setData(**data) def update_coordinates(self): """ Trigger the update of coordinates while keeping other features intact. The method gets the coordinates by calling `self.get_coordinates`, which in turn calls the widget's `get_coordinate_data`. The number of coordinate pairs returned by the latter must match the current number of points. If this is not the case, the widget should trigger the complete update by calling `reset_graph` instead of this method. """ x, y = self.get_coordinates() if x is None or not len(x): return if self.scatterplot_item is None: if self.sample_indices is None: indices = np.arange(self.n_valid) else: indices = self.sample_indices kwargs = dict(x=x, y=y, data=indices) self.scatterplot_item = ScatterPlotItem(**kwargs) self.scatterplot_item.sigClicked.connect(self.select_by_click) self.scatterplot_item_sel = ScatterPlotItem(**kwargs) self.plot_widget.addItem(self.scatterplot_item_sel) self.plot_widget.addItem(self.scatterplot_item) else: self._update_plot_coordinates(self.scatterplot_item, x, y) self._update_plot_coordinates(self.scatterplot_item_sel, x, y) self.update_labels() self.update_density() # Todo: doesn't work: try MDS with density on self._reset_view(x, y) # Sizes def get_sizes(self): """ Prepare data for sizes of points in the plot The method is called by `update_sizes`. It gets the sizes from the widget and performs the necessary scaling and sizing. Returns: (np.ndarray): sizes """ size_column = self.master.get_size_data() if size_column is None: return np.full((self.n_shown, ), self.MinShapeSize + (5 + self.point_width) * 0.5) size_column = self._filter_visible(size_column) size_column = size_column.copy() with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) size_column -= np.nanmin(size_column) mx = np.nanmax(size_column) if mx > 0: size_column /= mx else: size_column[:] = 0.5 return self.MinShapeSize + (5 + self.point_width) * size_column def update_sizes(self): """ Trigger an update of point sizes The method calls `self.get_sizes`, which in turn calls the widget's `get_size_data`. The result are properly scaled and then passed back to widget for imputing (`master.impute_sizes`). """ if self.scatterplot_item: size_data = self.get_sizes() size_imputer = getattr(self.master, "impute_sizes", self.default_impute_sizes) size_imputer(size_data) if self.timer is not None and self.timer.isActive(): self.timer.stop() self.timer = None current_size_data = self.scatterplot_item.data["size"].copy() diff = size_data - current_size_data widget = self class Timeout: # 0.5 - np.cos(np.arange(0.17, 1, 0.17) * np.pi) / 2 factors = [0.07, 0.26, 0.52, 0.77, 0.95, 1] def __init__(self): self._counter = 0 def __call__(self): factor = self.factors[self._counter] self._counter += 1 size = current_size_data + diff * factor if len(self.factors) == self._counter: widget.timer.stop() widget.timer = None size = size_data widget.scatterplot_item.setSize(size) widget.scatterplot_item_sel.setSize(size + SELECTION_WIDTH) if np.sum(current_size_data) / self.n_valid != -1 and np.sum(diff): # If encountered any strange behaviour when updating sizes, # implement it with threads self.timer = QTimer(self.scatterplot_item, interval=50) self.timer.timeout.connect(Timeout()) self.timer.start() else: self.scatterplot_item.setSize(size_data) self.scatterplot_item_sel.setSize(size_data + SELECTION_WIDTH) update_point_size = update_sizes # backward compatibility (needed?!) update_size = update_sizes @classmethod def default_impute_sizes(cls, size_data): """ Fallback imputation for sizes. Set the size to two pixels smaller than the minimal size Returns: (bool): True if there was any missing data """ nans = np.isnan(size_data) if np.any(nans): size_data[nans] = cls.MinShapeSize - 2 return True else: return False # Colors def get_colors(self): """ Prepare data for colors of the points in the plot The method is called by `update_colors`. It gets the colors and the indices of the data subset from the widget (`get_color_data`, `get_subset_mask`), and constructs lists of pens and brushes for each data point. The method uses different palettes for discrete and continuous data, as determined by calling the widget's method `is_continuous_color`. If also marks the points that are in the subset as defined by, for instance the 'Data Subset' signal in the Scatter plot and similar widgets. (Do not confuse this with *selected points*, which are marked by circles around the points, which are colored by groups and thus independent of this method.) Returns: (tuple): a list of pens and list of brushes """ self.palette = self.master.get_palette() c_data = self.master.get_color_data() c_data = self._filter_visible(c_data) subset = self.master.get_subset_mask() subset = self._filter_visible(subset) self.subset_is_shown = subset is not None if c_data is None: # same color return self._get_same_colors(subset) elif self.master.is_continuous_color(): return self._get_continuous_colors(c_data, subset) else: return self._get_discrete_colors(c_data, subset) def _get_same_colors(self, subset): """ Return the same pen for all points while the brush color depends upon whether the point is in the subset or not Args: subset (np.ndarray): a bool array indicating whether a data point is in the subset or not (e.g. in the 'Data Subset' signal in the Scatter plot and similar widgets); Returns: (tuple): a list of pens and list of brushes """ color = self.plot_widget.palette().color(OWPalette.Data) pen = [_make_pen(color, 1.5) for _ in range(self.n_shown)] if subset is not None: brush = np.where( subset, *(QBrush(QColor(*col)) for col in (self.COLOR_SUBSET, self.COLOR_NOT_SUBSET))) else: color = QColor(*self.COLOR_DEFAULT) color.setAlpha(self.alpha_value) brush = [QBrush(color) for _ in range(self.n_shown)] return pen, brush def _get_continuous_colors(self, c_data, subset): """ Return the pens and colors whose color represent an index into a continuous palette. The same color is used for pen and brush, except the former is darker. If the data has a subset, the brush is transparent for points that are not in the subset. """ self.scale = DiscretizedScale(np.nanmin(c_data), np.nanmax(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) pen = self.palette.getRGB(c_data) brush = np.hstack( [pen, np.full((len(pen), 1), self.alpha_value, dtype=int)]) pen *= 100 pen //= self.DarkerValue pen = [_make_pen(QColor(*col), 1.5) for col in pen.tolist()] if subset is not None: brush[:, 3] = 0 brush[subset, 3] = 255 brush = np.array([QBrush(QColor(*col)) for col in brush.tolist()]) return pen, brush def _get_discrete_colors(self, c_data, subset): """ Return the pens and colors whose color represent an index into a discrete palette. The same color is used for pen and brush, except the former is darker. If the data has a subset, the brush is transparent for points that are not in the subset. """ n_colors = self.palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = np.r_[self.palette.getRGB(np.arange(n_colors)), [[128, 128, 128]]] pens = np.array([ _make_pen(QColor(*col).darker(self.DarkerValue), 1.5) for col in colors ]) pen = pens[c_data] alpha = self.alpha_value if subset is None else 255 brushes = np.array([[ QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], alpha)) ] for col in colors]) brush = brushes[c_data] if subset is not None: brush = np.where(subset, brush[:, 1], brush[:, 0]) else: brush = brush[:, 1] return pen, brush def update_colors(self): """ Trigger an update of point sizes The method calls `self.get_colors`, which in turn calls the widget's `get_color_data` to get the indices in the pallette. `get_colors` returns a list of pens and brushes to which this method uses to update the colors. Finally, the method triggers the update of the legend and the density plot. """ if self.scatterplot_item is not None: pen_data, brush_data = self.get_colors() self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) self.update_legends() self.update_density() update_alpha_value = update_colors def update_density(self): """ Remove the existing density plot (if there is one) and replace it with a new one (if enabled). The method gets the colors from the pens of the currently plotted points. """ if self.density_img: self.plot_widget.removeItem(self.density_img) self.density_img = None if self.class_density and self.scatterplot_item is not None: rgb_data = [ pen.color().getRgb()[:3] if pen is not None else (255, 255, 255) for pen in self.scatterplot_item.data['pen'] ] if len(set(rgb_data)) <= 1: return [min_x, max_x], [min_y, max_y] = self.view_box.viewRange() x_data, y_data = self.scatterplot_item.getData() self.density_img = classdensity.class_density_image( min_x, max_x, min_y, max_y, self.resolution, x_data, y_data, rgb_data) self.plot_widget.addItem(self.density_img) def update_selection_colors(self): """ Trigger an update of selection markers This update method is usually not called by the widget but by the plot, since it is the plot that handles the selections. Like other update methods, it calls the corresponding get method (`get_colors_sel`) which returns a list of pens and brushes. """ if self.scatterplot_item_sel is None: return pen, brush = self.get_colors_sel() self.scatterplot_item_sel.setPen(pen, update=False, mask=None) self.scatterplot_item_sel.setBrush(brush, mask=None) def get_colors_sel(self): """ Return pens and brushes for selection markers. A pen can is set to `Qt.NoPen` if a point is not selected. All brushes are completely transparent whites. Returns: (tuple): a list of pens and a list of brushes """ nopen = QPen(Qt.NoPen) if self.selection is None: pen = [nopen] * self.n_shown else: sels = np.max(self.selection) if sels == 1: pen = np.where( self._filter_visible(self.selection), _make_pen(QColor(255, 190, 0, 255), SELECTION_WIDTH + 1), nopen) else: palette = ColorPaletteGenerator(number_of_colors=sels + 1) pen = np.choose(self._filter_visible(self.selection), [nopen] + [ _make_pen(palette[i], SELECTION_WIDTH + 1) for i in range(sels) ]) return pen, [QBrush(QColor(255, 255, 255, 0))] * self.n_shown # Labels def get_labels(self): """ Prepare data for labels for points The method returns the results of the widget's `get_label_data` Returns: (labels): a sequence of labels """ return self._filter_visible(self.master.get_label_data()) def update_labels(self): """ Trigger an update of labels The method calls `get_labels` which in turn calls the widget's `get_label_data`. The obtained labels are shown if the corresponding points are selected or if `label_only_selected` is `false`. """ for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] mask = None if self.scatterplot_item is not None: x, y = self.scatterplot_item.getData() mask = self._label_mask(x, y) if mask is not None: labels = self.get_labels() if labels is None: mask = None self._signal_too_many_labels(mask is not None and mask.sum() > self.MAX_VISIBLE_LABELS) if self._too_many_labels or mask is None or not np.any(mask): return black = pg.mkColor(0, 0, 0) labels = labels[mask] x = x[mask] y = y[mask] for label, xp, yp in zip(labels, x, y): ti = TextItem(label, black) ti.setPos(xp, yp) self.plot_widget.addItem(ti) self.labels.append(ti) def _signal_too_many_labels(self, too_many): if self._too_many_labels != too_many: self._too_many_labels = too_many self.too_many_labels.emit(too_many) def _label_mask(self, x, y): (x0, x1), (y0, y1) = self.view_box.viewRange() mask = np.logical_and(np.logical_and(x >= x0, x <= x1), np.logical_and(y >= y0, y <= y1)) if self.label_only_selected: sub_mask = self._filter_visible(self.master.get_subset_mask()) if self.selection is None: if sub_mask is None: return None else: sel_mask = sub_mask else: sel_mask = self._filter_visible(self.selection) != 0 if sub_mask is not None: sel_mask = np.logical_or(sel_mask, sub_mask) mask = np.logical_and(mask, sel_mask) return mask # Shapes def get_shapes(self): """ Prepare data for shapes of points in the plot The method is called by `update_shapes`. It gets the data from the widget's `get_shape_data`, and then calls its `impute_shapes` to impute the missing shape (usually with some default shape). Returns: (np.ndarray): an array of symbols (e.g. o, x, + ...) """ shape_data = self.master.get_shape_data() shape_data = self._filter_visible(shape_data) # Data has to be copied so the imputation can change it in-place # TODO: Try avoiding this when we move imputation to the widget if shape_data is not None: shape_data = np.copy(shape_data) shape_imputer = getattr(self.master, "impute_shapes", self.default_impute_shapes) shape_imputer(shape_data, len(self.CurveSymbols) - 1) if isinstance(shape_data, np.ndarray): shape_data = shape_data.astype(int) else: shape_data = np.zeros(self.n_shown, dtype=int) return self.CurveSymbols[shape_data] @staticmethod def default_impute_shapes(shape_data, default_symbol): """ Fallback imputation for shapes. Use the default symbol, usually the last symbol in the list. Returns: (bool): True if there was any missing data """ if shape_data is None: return False nans = np.isnan(shape_data) if np.any(nans): shape_data[nans] = default_symbol return True else: return False def update_shapes(self): """ Trigger an update of point symbols The method calls `get_shapes` to obtain an array with a symbol for each point and uses it to update the symbols. Finally, the method updates the legend. """ if self.scatterplot_item: shape_data = self.get_shapes() self.scatterplot_item.setSymbol(shape_data) self.update_legends() def update_grid_visibility(self): """Show or hide the grid""" self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend_visibility(self): """ Show or hide legends based on whether they are enabled and non-empty """ self.shape_legend.setVisible(self.show_legend and bool(self.shape_legend.items)) self.color_legend.setVisible(self.show_legend and bool(self.color_legend.items)) def update_legends(self): """Update content of legends and their visibility""" cont_color = self.master.is_continuous_color() shape_labels = self.master.get_shape_labels() color_labels = None if cont_color else self.master.get_color_labels() if shape_labels == color_labels and shape_labels is not None: self._update_combined_legend(shape_labels) else: self._update_shape_legend(shape_labels) if cont_color: self._update_continuous_color_legend() else: self._update_color_legend(color_labels) self.update_legend_visibility() def _update_shape_legend(self, labels): self.shape_legend.clear() if labels is None or self.scatterplot_item is None: return color = QColor(0, 0, 0) color.setAlpha(self.alpha_value) for label, symbol in zip(labels, self.CurveSymbols): self.shape_legend.addItem( ScatterPlotItem(pen=color, brush=color, size=10, symbol=symbol), escape(label)) def _update_continuous_color_legend(self): self.color_legend.clear() if self.scale is None or self.scatterplot_item is None: return label = PaletteItemSample(self.palette, self.scale) self.color_legend.addItem(label, "") self.color_legend.setGeometry(label.boundingRect()) def _update_color_legend(self, labels): self.color_legend.clear() if labels is None: return self._update_colored_legend(self.color_legend, labels, 'o') def _update_combined_legend(self, labels): # update_colored_legend will already clear the shape legend # so we remove colors here use_legend = \ self.shape_legend if self.shape_legend.items else self.color_legend self.color_legend.clear() self.shape_legend.clear() self._update_colored_legend(use_legend, labels, self.CurveSymbols) def _update_colored_legend(self, legend, labels, symbols): if self.scatterplot_item is None or not self.palette: return if isinstance(symbols, str): symbols = itertools.repeat(symbols, times=len(labels)) for i, (label, symbol) in enumerate(zip(labels, symbols)): color = QColor(*self.palette.getRGB(i)) pen = _make_pen(color.darker(self.DarkerValue), 1.5) color.setAlpha(255 if self.subset_is_shown else self.alpha_value) brush = QBrush(color) legend.addItem( ScatterPlotItem(pen=pen, brush=brush, size=10, symbol=symbol), escape(label)) def zoom_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def pan_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().PanMode) def select_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def reset_button_clicked(self): self.plot_widget.getViewBox().autoRange() self.update_labels() def select_by_click(self, _, points): if self.scatterplot_item is not None: self.select(points) def select_by_rectangle(self, value_rect): if self.scatterplot_item is not None: x0, y0 = value_rect.topLeft().x(), value_rect.topLeft().y() x1, y1 = value_rect.bottomRight().x(), value_rect.bottomRight().y() x, y = self.master.get_coordinates_data() indices = np.flatnonzero((x0 <= x) & (x <= x1) & (y0 <= y) & (y <= y1)) self.select_by_indices(indices.astype(int)) def unselect_all(self): if self.selection is not None: self.selection = None self.update_selection_colors() if self.label_only_selected: self.update_labels() self.master.selection_changed() def select(self, points): # noinspection PyArgumentList if self.scatterplot_item is None: return indices = [p.data() for p in points] self.select_by_indices(indices) def select_by_indices(self, indices): if self.selection is None: self.selection = np.zeros(self.n_valid, dtype=np.uint8) keys = QApplication.keyboardModifiers() if keys & Qt.AltModifier: self.selection_remove(indices) elif keys & Qt.ShiftModifier and keys & Qt.ControlModifier: self.selection_append(indices) elif keys & Qt.ShiftModifier: self.selection_new_group(indices) else: self.selection_select(indices) def selection_select(self, indices): self.selection = np.zeros(self.n_valid, dtype=np.uint8) self.selection[indices] = 1 self._update_after_selection() def selection_append(self, indices): self.selection[indices] = np.max(self.selection) self._update_after_selection() def selection_new_group(self, indices): self.selection[indices] = np.max(self.selection) + 1 self._update_after_selection() def selection_remove(self, indices): self.selection[indices] = 0 self._update_after_selection() def _update_after_selection(self): self._compress_indices() self.update_selection_colors() if self.label_only_selected: self.update_labels() self.master.selection_changed() def _compress_indices(self): indices = sorted(set(self.selection) | {0}) if len(indices) == max(indices) + 1: return mapping = np.zeros((max(indices) + 1, ), dtype=int) for i, ind in enumerate(indices): mapping[ind] = i self.selection = mapping[self.selection] def get_selection(self): if self.selection is None: return np.array([], dtype=np.uint8) else: return np.flatnonzero(self.selection) def help_event(self, event): """ Create a `QToolTip` for the point hovered by the mouse """ 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 else: return False
class OWScatterPlotGraph(gui.OWComponent, ScaleScatterPlotData): attr_color = ContextSetting(None, required=ContextSetting.OPTIONAL) attr_label = ContextSetting(None, required=ContextSetting.OPTIONAL) attr_shape = ContextSetting(None, required=ContextSetting.OPTIONAL) attr_size = ContextSetting(None, required=ContextSetting.OPTIONAL) label_only_selected = Setting(False) point_width = Setting(10) alpha_value = Setting(128) show_grid = Setting(False) show_legend = Setting(True) tooltip_shows_all = Setting(False) class_density = Setting(False) show_reg_line = Setting(False) resolution = 256 CurveSymbols = np.array("o x t + d s t2 t3 p h star ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) def __init__(self, scatter_widget, parent=None, _="None", view_box=InteractiveViewBox): gui.OWComponent.__init__(self, scatter_widget) self.view_box = view_box(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent, background="w") self.plot_widget.getPlotItem().buttonsHidden = True self.plot_widget.setAntialiasing(True) self.plot_widget.sizeHint = lambda: QSize(500, 500) scene = self.plot_widget.scene() self._create_drag_tooltip(scene) self._data = None # Original Table as passed from widget to new_data before transformations self.replot = self.plot_widget.replot ScaleScatterPlotData.__init__(self) self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.reg_line_item = None self.labels = [] self.master = scatter_widget self.master.Warning.add_message( "missing_coords", "Plot cannot be displayed because '{}' or '{}' is missing for " "all data points") self.master.Information.add_message( "missing_coords", "Points with missing '{}' or '{}' are not displayed") self.master.Information.add_message( "missing_size", "Points with undefined '{}' are shown in smaller size") self.master.Information.add_message( "missing_shape", "Points with undefined '{}' are shown as crossed circles") self.shown_attribute_indices = [] self.shown_x = self.shown_y = None self.pen_colors = self.brush_colors = None self.valid_data = None # np.ndarray self.selection = None # np.ndarray self.n_points = 0 self.gui = OWPlotGUI(self) self.continuous_palette = ContinuousPaletteGenerator( QColor(255, 255, 0), QColor(0, 0, 255), True) self.discrete_palette = ColorPaletteGenerator() self.selection_behavior = 0 self.legend = self.color_legend = None self.__legend_anchor = (1, 0), (1, 0) self.__color_legend_anchor = (1, 1), (1, 1) self.scale = None # DiscretizedScale self.subset_indices = None # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid() self._tooltip_delegate = HelpEventDelegate(self.help_event) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) def _create_drag_tooltip(self, scene): tip_parts = [ (Qt.ShiftModifier, "Shift: Add group"), (Qt.ShiftModifier + Qt.ControlModifier, "Shift-{}: Append to group". format("Cmd" if sys.platform == "darwin" else "Ctrl")), (Qt.AltModifier, "Alt: Remove") ] all_parts = ", ".join(part for _, part in tip_parts) self.tiptexts = { int(modifier): all_parts.replace(part, "<b>{}</b>".format(part)) for modifier, part in tip_parts } self.tiptexts[0] = all_parts self.tip_textitem = text = QGraphicsTextItem() # Set to the longest text text.setHtml(self.tiptexts[Qt.ShiftModifier + Qt.ControlModifier]) text.setPos(4, 2) r = text.boundingRect() rect = QGraphicsRectItem(0, 0, r.width() + 8, r.height() + 4) rect.setBrush(QColor(224, 224, 224, 212)) rect.setPen(QPen(Qt.NoPen)) self.update_tooltip(Qt.NoModifier) scene.drag_tooltip = scene.createItemGroup([rect, text]) scene.drag_tooltip.hide() def update_tooltip(self, modifiers): modifiers &= Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier text = self.tiptexts.get(int(modifiers), self.tiptexts[0]) self.tip_textitem.setHtml(text) def new_data(self, data, subset_data=None, new=True, **args): if new: self.plot_widget.clear() self.remove_legend() self.density_img = None self.scatterplot_item = None self.scatterplot_item_sel = None self.reg_line_item = None self.labels = [] self.selection = None self.valid_data = None self.subset_indices = set(e.id for e in subset_data) if subset_data else None self._data = data data = self.sparse_to_dense() self.set_data(data, **args) def set_domain(self, data): domain = data.domain if data and len(data) else None for attr in ("attr_color", "attr_shape", "attr_size", "attr_label"): getattr(self.controls, attr).model().set_domain(domain) setattr(self, attr, None) if domain is not None: self.attr_color = domain.class_var def sparse_to_dense(self): data = self._data if data is None or not data.is_sparse(): return data attrs = {self.shown_x, self.shown_y, self.attr_color, self.attr_shape, self.attr_size, self.attr_label} domain = data.domain all_attrs = domain.variables + domain.metas attrs = list(set(all_attrs) & attrs) selected_data = data[:, attrs].to_dense() return selected_data def _clear_plot_widget(self): self.remove_legend() if self.density_img: self.plot_widget.removeItem(self.density_img) self.density_img = None if self.scatterplot_item: self.plot_widget.removeItem(self.scatterplot_item) self.scatterplot_item = None if self.scatterplot_item_sel: self.plot_widget.removeItem(self.scatterplot_item_sel) self.scatterplot_item_sel = None if self.reg_line_item: self.plot_widget.removeItem(self.reg_line_item) self.reg_line_item = None for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] self.set_axis_title("bottom", "") self.set_axis_title("left", "") def update_data(self, attr_x, attr_y, reset_view=True): self.master.Warning.missing_coords.clear() self.master.Information.missing_coords.clear() self._clear_plot_widget() if self.shown_y != attr_y: # 'reset' the axis text width estimation. Without this the left # axis tick labels space only ever expands yaxis = self.plot_widget.getAxis("left") yaxis.textWidth = 30 self.shown_x, self.shown_y = attr_x, attr_y if attr_x not in self.data.domain or attr_y not in self.data.domain: data = self.sparse_to_dense() self.set_data(data) if self.jittered_data is None or not len(self.jittered_data): self.valid_data = None else: self.valid_data = self.get_valid_list([attr_x, attr_y]) if not np.any(self.valid_data): self.valid_data = None if self.valid_data is None: self.selection = None self.n_points = 0 self.master.Warning.missing_coords( self.shown_x.name, self.shown_y.name) return x_data, y_data = self.get_xy_data_positions( attr_x, attr_y, self.valid_data) self.n_points = len(x_data) if reset_view: min_x, max_x = np.nanmin(x_data), np.nanmax(x_data) min_y, max_y = np.nanmin(y_data), np.nanmax(y_data) self.view_box.setRange( QRectF(min_x, min_y, max_x - min_x, max_y - min_y), padding=0.025) self.view_box.init_history() self.view_box.tag_history() [min_x, max_x], [min_y, max_y] = self.view_box.viewRange() for axis, var in (("bottom", attr_x), ("left", attr_y)): self.set_axis_title(axis, var) if var.is_discrete: self.set_labels(axis, get_variable_values_sorted(var)) else: self.set_labels(axis, None) color_data, brush_data = self.compute_colors() color_data_sel, brush_data_sel = self.compute_colors_sel() size_data = self.compute_sizes() shape_data = self.compute_symbols() if self.should_draw_density(): rgb_data = [pen.color().getRgb()[:3] for pen in color_data] self.density_img = classdensity.class_density_image( min_x, max_x, min_y, max_y, self.resolution, x_data, y_data, rgb_data) self.plot_widget.addItem(self.density_img) self.data_indices = np.flatnonzero(self.valid_data) if len(self.data_indices) != len(self.data): self.master.Information.missing_coords( self.shown_x.name, self.shown_y.name) self.scatterplot_item = ScatterPlotItem( x=x_data, y=y_data, data=self.data_indices, symbol=shape_data, size=size_data, pen=color_data, brush=brush_data ) self.scatterplot_item_sel = ScatterPlotItem( x=x_data, y=y_data, data=self.data_indices, symbol=shape_data, size=size_data + SELECTION_WIDTH, pen=color_data_sel, brush=brush_data_sel ) self.plot_widget.addItem(self.scatterplot_item_sel) self.plot_widget.addItem(self.scatterplot_item) self.scatterplot_item.selected_points = [] self.scatterplot_item.sigClicked.connect(self.select_by_click) if self.show_reg_line: _x_data = self.data.get_column_view(self.shown_x)[0] _y_data = self.data.get_column_view(self.shown_y)[0] _x_data = _x_data[self.valid_data] _y_data = _y_data[self.valid_data] assert _x_data.size assert _y_data.size self.draw_regression_line( _x_data, _y_data, np.min(_x_data), np.max(_y_data)) self.update_labels() self.make_legend() self.plot_widget.replot() def draw_regression_line(self, x_data, y_data, min_x, max_x): if self.show_reg_line and self.can_draw_regresssion_line(): slope, intercept, rvalue, _, _ = linregress(x_data, y_data) start_y = min_x * slope + intercept end_y = max_x * slope + intercept angle = np.degrees(np.arctan((end_y - start_y) / (max_x - min_x))) rotate = ((angle + 45) % 180) - 45 > 90 color = QColor("#505050") l_opts = dict(color=color, position=abs(int(rotate) - 0.85), rotateAxis=(1, 0), movable=True) self.reg_line_item = InfiniteLine( pos=QPointF(min_x, start_y), pen=pg.mkPen(color=color, width=1), angle=angle, label="r = {:.2f}".format(rvalue), labelOpts=l_opts) if rotate: self.reg_line_item.label.angle = 180 self.reg_line_item.label.updateTransform() self.plot_widget.addItem(self.reg_line_item) def can_draw_density(self): return self.domain is not None and \ self.attr_color is not None and \ self.attr_color.is_discrete and \ self.shown_x.is_continuous and \ self.shown_y.is_continuous def should_draw_density(self): return self.class_density and self.n_points > 1 and self.can_draw_density() def can_draw_regresssion_line(self): return self.domain is not None and \ self.shown_x.is_continuous and \ self.shown_y.is_continuous def set_labels(self, axis, labels): axis = self.plot_widget.getAxis(axis) if labels: ticks = [[(i, labels[i]) for i in range(len(labels))]] axis.setTicks(ticks) else: axis.setTicks(None) def set_axis_title(self, axis, title): self.plot_widget.setLabel(axis=axis, text=title) def compute_sizes(self): self.master.Information.missing_size.clear() if self.attr_size is None: size_data = np.full((self.n_points,), self.point_width, dtype=float) else: size_data = \ self.MinShapeSize + \ self.scaled_data.get_column_view(self.attr_size)[0][self.valid_data] * \ self.point_width nans = np.isnan(size_data) if np.any(nans): size_data[nans] = self.MinShapeSize - 2 self.master.Information.missing_size(self.attr_size) return size_data def update_sizes(self): self.set_data(self.sparse_to_dense()) self.update_point_size() def update_point_size(self): if self.scatterplot_item: size_data = self.compute_sizes() self.scatterplot_item.setSize(size_data) self.scatterplot_item_sel.setSize(size_data + SELECTION_WIDTH) def get_color(self): if self.attr_color is None: return None colors = self.attr_color.colors if self.attr_color.is_discrete: self.discrete_palette = ColorPaletteGenerator( number_of_colors=min(len(colors), MAX), rgb_colors=colors if len(colors) <= MAX else DefaultRGBColors) else: self.continuous_palette = ContinuousPaletteGenerator(*colors) return self.attr_color def compute_colors_sel(self, keep_colors=False): if not keep_colors: self.pen_colors_sel = self.brush_colors_sel = None nopen = QPen(Qt.NoPen) if self.selection is not None: sels = np.max(self.selection) if sels == 1: pens = [nopen, _make_pen(QColor(255, 190, 0, 255), SELECTION_WIDTH + 1.)] else: palette = ColorPaletteGenerator(number_of_colors=sels + 1) pens = [nopen] + \ [_make_pen(palette[i], SELECTION_WIDTH + 1.) for i in range(sels)] pen = [pens[a] for a in self.selection[self.valid_data]] else: pen = [nopen] * self.n_points brush = [QBrush(QColor(255, 255, 255, 0))] * self.n_points return pen, brush def _reduce_values(self, attr): """ If discrete variable has more than maximium allowed values, less used values are joined as "Other" """ c_data = self.data.get_column_view(attr)[0][self.valid_data] if attr.is_continuous or len(attr.values) <= MAX: return None, c_data values_to_replace = Counter(c_data) values_to_replace = sorted( values_to_replace, key=values_to_replace.get, reverse=True ) return values_to_replace, c_data def _get_values(self, attr): if len(attr.values) <= MAX: return attr.values values_to_replace, _ = self._reduce_values(attr) return [attr.values[int(i)] for i in values_to_replace if not np.isnan(i)][:MAX - 1] + ["Other"] def _get_data(self, attr): values_to_replace, c_data = self._reduce_values(attr) if values_to_replace is not None: c_data_2 = c_data.copy() for i, v in enumerate(values_to_replace): c_data[c_data_2 == v] = i if i < MAX - 1 else MAX - 1 return c_data def compute_colors(self, keep_colors=False): if not keep_colors: self.pen_colors = self.brush_colors = None self.get_color() subset = None if self.subset_indices: subset = np.array([ex.id in self.subset_indices for ex in self.data[self.valid_data]]) if self.attr_color is None: # same color color = self.plot_widget.palette().color(OWPalette.Data) pen = [_make_pen(color, 1.5)] * self.n_points if subset is not None: brush = [(QBrush(QColor(128, 128, 128, 0)), QBrush(QColor(128, 128, 128, 255)))[s] for s in subset] else: brush = [QBrush(QColor(128, 128, 128, self.alpha_value))] \ * self.n_points return pen, brush c_data = self._get_data(self.attr_color) if self.attr_color.is_continuous: if self.pen_colors is None: self.scale = DiscretizedScale(np.nanmin(c_data), np.nanmax(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) palette = self.continuous_palette self.pen_colors = palette.getRGB(c_data) self.brush_colors = np.hstack( [self.pen_colors, np.full((self.n_points, 1), self.alpha_value, dtype=int)]) self.pen_colors *= 100 self.pen_colors //= self.DarkerValue self.pen_colors = [_make_pen(QColor(*col), 1.5) for col in self.pen_colors.tolist()] if subset is not None: self.brush_colors[:, 3] = 0 self.brush_colors[subset, 3] = 255 else: self.brush_colors[:, 3] = self.alpha_value pen = self.pen_colors brush = np.array([QBrush(QColor(*col)) for col in self.brush_colors.tolist()]) else: if self.pen_colors is None: palette = self.discrete_palette n_colors = palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = np.r_[palette.getRGB(np.arange(n_colors)), [[128, 128, 128]]] pens = np.array( [_make_pen(QColor(*col).darker(self.DarkerValue), 1.5) for col in colors]) self.pen_colors = pens[c_data] alpha = self.alpha_value if subset is None else 255 self.brush_colors = np.array([ [QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], alpha))] for col in colors]) self.brush_colors = self.brush_colors[c_data] if subset is not None: brush = np.where( subset, self.brush_colors[:, 1], self.brush_colors[:, 0]) else: brush = self.brush_colors[:, 1] pen = self.pen_colors return pen, brush def update_colors(self, keep_colors=False): self.master.update_colors() self.set_data(self.sparse_to_dense()) self.update_alpha_value(keep_colors) def update_alpha_value(self, keep_colors=False): if self.scatterplot_item: pen_data, brush_data = self.compute_colors(keep_colors) pen_data_sel, brush_data_sel = self.compute_colors_sel(keep_colors) self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) self.scatterplot_item_sel.setPen(pen_data_sel, update=False, mask=None) self.scatterplot_item_sel.setBrush(brush_data_sel, mask=None) if not keep_colors: self.make_legend() if self.should_draw_density(): self.update_data(self.shown_x, self.shown_y) elif self.density_img: self.plot_widget.removeItem(self.density_img) def create_labels(self): for x, y in zip(*self.scatterplot_item.getData()): ti = TextItem() self.plot_widget.addItem(ti) ti.setPos(x, y) self.labels.append(ti) def _create_label_column(self): if self.attr_label in self.data.domain: label_column = self.data.get_column_view(self.attr_label)[0] else: label_column = self.master.data.get_column_view(self.attr_label)[0] return label_column[self.data_indices] def update_labels(self): if self.attr_label is None or \ self.label_only_selected and self.selection is None: for label in self.labels: label.setText("") return self.assure_attribute_present(self.attr_label) if not self.labels: self.create_labels() label_column = self._create_label_column() formatter = self.attr_label.str_val label_data = map(formatter, label_column) black = pg.mkColor(0, 0, 0) selection = self.selection[self.valid_data] if self.selection is not None else [] if self.label_only_selected: for label, text, selected \ in zip(self.labels, label_data, selection): label.setText(text if selected else "", black) else: for label, text in zip(self.labels, label_data): label.setText(text, black) def compute_symbols(self): self.master.Information.missing_shape.clear() if self.attr_shape is None: shape_data = self.CurveSymbols[np.zeros(self.n_points, dtype=int)] else: shape_data = self._get_data(self.attr_shape) nans = np.isnan(shape_data) if np.any(nans): shape_data[nans] = len(self.CurveSymbols) - 1 self.master.Information.missing_shape(self.attr_shape) shape_data = self.CurveSymbols[shape_data.astype(int)] return shape_data def update_shapes(self): self.assure_attribute_present(self.attr_shape) if self.scatterplot_item: shape_data = self.compute_symbols() self.scatterplot_item.setSymbol(shape_data) self.make_legend() def assure_attribute_present(self, attr): if self.data is not None and attr not in self.data.domain: self.set_data(self.sparse_to_dense()) def update_grid(self): self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend(self): if self.legend: self.legend.setVisible(self.show_legend) def create_legend(self): self.legend = LegendItem() self.legend.setParentItem(self.plot_widget.getViewBox()) self.legend.restoreAnchor(self.__legend_anchor) def remove_legend(self): if self.legend: anchor = legend_anchor_pos(self.legend) if anchor is not None: self.__legend_anchor = anchor self.legend.setParent(None) self.legend = None if self.color_legend: anchor = legend_anchor_pos(self.color_legend) if anchor is not None: self.__color_legend_anchor = anchor self.color_legend.setParent(None) self.color_legend = None def make_legend(self): self.remove_legend() self.make_color_legend() self.make_shape_legend() self.update_legend() def make_color_legend(self): if self.attr_color is None: return use_shape = self.attr_shape == self.get_color() if self.attr_color.is_discrete: if not self.legend: self.create_legend() palette = self.discrete_palette for i, value in enumerate(self._get_values(self.attr_color)): color = QColor(*palette.getRGB(i)) pen = _make_pen(color.darker(self.DarkerValue), 1.5) color.setAlpha(self.alpha_value if self.subset_indices is None else 255) brush = QBrush(color) self.legend.addItem( ScatterPlotItem( pen=pen, brush=brush, size=10, symbol=self.CurveSymbols[i] if use_shape else "o"), escape(value)) else: legend = self.color_legend = LegendItem() legend.setParentItem(self.plot_widget.getViewBox()) legend.restoreAnchor(self.__color_legend_anchor) label = PaletteItemSample(self.continuous_palette, self.scale) legend.addItem(label, "") legend.setGeometry(label.boundingRect()) def make_shape_legend(self): if self.attr_shape is None or self.attr_shape == self.get_color(): return if not self.legend: self.create_legend() color = QColor(0, 0, 0) color.setAlpha(self.alpha_value) for i, value in enumerate(self._get_values(self.attr_shape)): self.legend.addItem( ScatterPlotItem(pen=color, brush=color, size=10, symbol=self.CurveSymbols[i]), escape(value)) def zoom_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def pan_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().PanMode) def select_button_clicked(self): self.plot_widget.getViewBox().setMouseMode( self.plot_widget.getViewBox().RectMode) def reset_button_clicked(self): self.update_data(self.shown_x, self.shown_y, reset_view=True) # also redraw density image # self.view_box.autoRange() def select_by_click(self, _, points): if self.scatterplot_item is not None: self.select(points) def select_by_rectangle(self, value_rect): if self.scatterplot_item is not None: points = [point for point in self.scatterplot_item.points() if value_rect.contains(QPointF(point.pos()))] self.select(points) def unselect_all(self): self.selection = None self.update_colors(keep_colors=True) if self.label_only_selected: self.update_labels() self.master.selection_changed() def select(self, points): # noinspection PyArgumentList if self.data is None: return if self.selection is None: self.selection = np.zeros(len(self.data), dtype=np.uint8) indices = [p.data() for p in points] keys = QApplication.keyboardModifiers() # Remove from selection if keys & Qt.AltModifier: self.selection[indices] = 0 # Append to the last group elif keys & Qt.ShiftModifier and keys & Qt.ControlModifier: self.selection[indices] = np.max(self.selection) # Create a new group elif keys & Qt.ShiftModifier: self.selection[indices] = np.max(self.selection) + 1 # No modifiers: new selection else: self.selection = np.zeros(len(self.data), dtype=np.uint8) self.selection[indices] = 1 self.update_colors(keep_colors=True) if self.label_only_selected: self.update_labels() self.master.selection_changed() def get_selection(self): if self.selection is None: return np.array([], dtype=np.uint8) else: return np.flatnonzero(self.selection) def set_palette(self, p): self.plot_widget.setPalette(p) def save_to_file(self, size): pass def help_event(self, event): if self.scatterplot_item is None: return False domain = self.data.domain PARTS = (("Class", "Classes", 4, domain.class_vars), ("Meta", "Metas", 4, domain.metas), ("Feature", "Features", 10, domain.attributes)) def format_val(var, point_data, bold=False): text = escape('{} = {}'.format(var.name, point_data[var])) if bold: text = "<b>{}</b>".format(text) return text def show_part(point_data, singular, plural, max_shown, vars): cols = [format_val(var, point_data) for var in vars[:max_shown + 2] if vars == domain.class_vars or var not in (self.shown_x, self.shown_y)][:max_shown] if not cols: return "" n_vars = len(vars) if n_vars > max_shown: cols[-1] = "... and {} others".format(n_vars - max_shown + 1) return \ "<br/><b>{}</b>:<br/>".format(singular if n_vars < 2 else plural) \ + "<br/>".join(cols) def point_data(p): point_data = self.data[p.data()] text = "<br/>".join( format_val(var, point_data, bold=self.tooltip_shows_all) for var in (self.shown_x, self.shown_y)) if self.tooltip_shows_all: text += "<br/>" + \ "".join(show_part(point_data, *columns) for columns in PARTS) return text act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) if len(points): if len(points) > MAX_POINTS_IN_TOOLTIP: text = "{} instances<hr/>{}<hr/>...".format( len(points), "<hr/>".join(point_data(point) for point in points[:MAX_POINTS_IN_TOOLTIP]) ) else: text = "<hr/>".join(point_data(point) for point in points) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False def box_zoom_select(self, parent): g = self.gui box_zoom_select = gui.vBox(parent, "Zoom/Select") zoom_select_toolbar = g.zoom_select_toolbar( box_zoom_select, nomargin=True, buttons=[g.StateButtonsBegin, g.SimpleSelect, g.Pan, g.Zoom, g.StateButtonsEnd, g.ZoomReset] ) buttons = zoom_select_toolbar.buttons buttons[g.Zoom].clicked.connect(self.zoom_button_clicked) buttons[g.Pan].clicked.connect(self.pan_button_clicked) buttons[g.SimpleSelect].clicked.connect(self.select_button_clicked) buttons[g.ZoomReset].clicked.connect(self.reset_button_clicked) return box_zoom_select def zoom_actions(self, parent): def zoom(s): """ Zoom in/out by factor `s`. scaleBy scales the view's bounds (the axis range) """ self.view_box.scaleBy((1 / s, 1 / s)) def fit_to_view(): self.viewbox.autoRange() zoom_in = QAction( "Zoom in", parent, triggered=lambda: zoom(1.25) ) zoom_in.setShortcuts([QKeySequence(QKeySequence.ZoomIn), QKeySequence(parent.tr("Ctrl+="))]) zoom_out = QAction( "Zoom out", parent, shortcut=QKeySequence.ZoomOut, triggered=lambda: zoom(1 / 1.25) ) zoom_fit = QAction( "Fit in view", parent, shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0), triggered=fit_to_view ) parent.addActions([zoom_in, zoom_out, zoom_fit])
class OWScatterPlotGraph(gui.OWComponent, ScaleScatterPlotData): attr_color = ContextSetting("", ContextSetting.OPTIONAL) attr_label = ContextSetting("", ContextSetting.OPTIONAL) attr_shape = ContextSetting("", ContextSetting.OPTIONAL) attr_size = ContextSetting("", ContextSetting.OPTIONAL) point_width = Setting(10) alpha_value = Setting(255) show_grid = Setting(False) show_legend = Setting(True) tooltip_shows_all = Setting(False) square_granularity = Setting(3) space_between_cells = Setting(True) CurveSymbols = np.array("o x t + d s ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) def __init__(self, scatter_widget, parent=None, _="None"): gui.OWComponent.__init__(self, scatter_widget) self.view_box = InteractiveViewBox(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent) self.plot_widget.setAntialiasing(True) self.replot = self.plot_widget ScaleScatterPlotData.__init__(self) self.scatterplot_item = None self.tooltip_data = [] self.tooltip = TextItem( border=pg.mkPen(200, 200, 200), fill=pg.mkBrush(250, 250, 200, 220)) self.tooltip.hide() self.labels = [] self.master = scatter_widget self.shown_attribute_indices = [] self.shown_x = "" self.shown_y = "" self.pen_colors = self.brush_colors = None self.valid_data = None # np.ndarray self.selection = None # np.ndarray self.n_points = 0 self.gui = OWPlotGUI(self) self.continuous_palette = ContinuousPaletteGenerator( QColor(255, 255, 0), QColor(0, 0, 255), True) self.discrete_palette = ColorPaletteGenerator() self.selection_behavior = 0 self.legend = self.color_legend = None self.scale = None # DiscretizedScale self.tips = TooltipManager(self) # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid() def set_data(self, data, subset_data=None, **args): self.plot_widget.clear() ScaleScatterPlotData.set_data(self, data, subset_data, **args) def update_data(self, attr_x, attr_y): self.shown_x = attr_x self.shown_y = attr_y self.remove_legend() if self.scatterplot_item: self.plot_widget.removeItem(self.scatterplot_item) for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] self.tooltip_data = [] self.set_axis_title("bottom", "") self.set_axis_title("left", "") if self.scaled_data is None or not len(self.scaled_data): self.valid_data = None self.n_points = 0 return index_x = self.attribute_name_index[attr_x] index_y = self.attribute_name_index[attr_y] self.valid_data = self.get_valid_list([index_x, index_y]) x_data, y_data = self.get_xy_data_positions( attr_x, attr_y, self.valid_data) x_data = x_data[self.valid_data] y_data = y_data[self.valid_data] self.n_points = len(x_data) for axis, name, index in (("bottom", attr_x, index_x), ("left", attr_y, index_y)): self.set_axis_title(axis, name) var = self.data_domain[index] if isinstance(var, DiscreteVariable): self.set_labels(axis, get_variable_values_sorted(var)) color_data, brush_data = self.compute_colors() size_data = self.compute_sizes() shape_data = self.compute_symbols() self.scatterplot_item = ScatterPlotItem( x=x_data, y=y_data, data=np.arange(self.n_points), symbol=shape_data, size=size_data, pen=color_data, brush=brush_data) self.plot_widget.addItem(self.scatterplot_item) self.plot_widget.addItem(self.tooltip) self.scatterplot_item.selected_points = [] self.scatterplot_item.sigClicked.connect(self.select_by_click) self.scatterplot_item.scene().sigMouseMoved.connect(self.mouseMoved) self.update_labels() self.make_legend() self.plot_widget.replot() def set_labels(self, axis, labels): axis = self.plot_widget.getAxis(axis) if labels: ticks = [[(i, labels[i]) for i in range(len(labels))]] axis.setTicks(ticks) else: axis.setTicks(None) def set_axis_title(self, axis, title): self.plot_widget.setLabel(axis=axis, text=title) def get_size_index(self): size_index = -1 attr_size = self.attr_size if attr_size != "" and attr_size != "(Same size)": size_index = self.attribute_name_index[attr_size] return size_index def compute_sizes(self): size_index = self.get_size_index() if size_index == -1: size_data = np.full((self.n_points,), self.point_width) else: size_data = \ self.MinShapeSize + \ self.no_jittering_scaled_data[size_index] * self.point_width size_data[np.isnan(size_data)] = self.MinShapeSize - 2 return size_data def update_sizes(self): if self.scatterplot_item: size_data = self.compute_sizes() self.scatterplot_item.setSize(size_data) update_point_size = update_sizes def get_color_index(self): color_index = -1 attr_color = self.attr_color if attr_color != "" and attr_color != "(Same color)": color_index = self.attribute_name_index[attr_color] color_var = self.data_domain[attr_color] if isinstance(color_var, DiscreteVariable): self.discrete_palette.set_number_of_colors( len(color_var.values)) return color_index def compute_colors(self, keep_colors=False): if not keep_colors: self.pen_colors = self.brush_colors = None color_index = self.get_color_index() if color_index == -1: color = self.plot_widget.palette().color(OWPalette.Data) pen = [QPen(QBrush(color), 1.5)] * self.n_points if self.selection is not None: brush = [(QBrush(QColor(128, 128, 128, 255)), QBrush(QColor(128, 128, 128)))[s] for s in self.selection] else: brush = [QBrush(QColor(128, 128, 128))] * self.n_points return pen, brush c_data = self.original_data[color_index, self.valid_data] if isinstance(self.data_domain[color_index], ContinuousVariable): if self.pen_colors is None: self.scale = DiscretizedScale(np.min(c_data), np.max(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) palette = self.continuous_palette self.pen_colors = palette.getRGB(c_data) self.brush_colors = np.hstack( [self.pen_colors, np.full((self.n_points, 1), self.alpha_value)]) self.pen_colors *= 100 / self.DarkerValue self.pen_colors = [QPen(QBrush(QColor(*col)), 1.5) for col in self.pen_colors.tolist()] if self.selection is not None: self.brush_colors[:, 3] = 0 self.brush_colors[self.selection, 3] = self.alpha_value else: self.brush_colors[:, 3] = self.alpha_value pen = self.pen_colors brush = np.array([QBrush(QColor(*col)) for col in self.brush_colors.tolist()]) else: if self.pen_colors is None: palette = self.discrete_palette n_colors = palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = palette.getRGB(np.arange(n_colors + 1)) colors[n_colors] = (128, 128, 128) pens = np.array( [QPen(QBrush(QColor(*col).darker(self.DarkerValue)), 1.5) for col in colors]) self.pen_colors = pens[c_data] self.brush_colors = np.array([ [QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], self.alpha_value))] for col in colors]) self.brush_colors = self.brush_colors[c_data] if self.selection is not None: brush = np.where( self.selection, self.brush_colors[:, 1], self.brush_colors[:, 0]) else: brush = self.brush_colors[:, 1] pen = self.pen_colors return pen, brush def update_colors(self, keep_colors=False): if self.scatterplot_item: pen_data, brush_data = self.compute_colors(keep_colors) self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) if not keep_colors: self.make_legend() update_alpha_value = update_colors def create_labels(self): for x, y in zip(*self.scatterplot_item.getData()): ti = TextItem() self.plot_widget.addItem(ti) ti.setPos(x, y) self.labels.append(ti) def update_labels(self): if not self.attr_label: for label in self.labels: label.setText("") return if not self.labels: self.create_labels() label_column = self.raw_data.get_column_view(self.attr_label)[0] formatter = self.raw_data.domain[self.attr_label].str_val label_data = map(formatter, label_column) black = pg.mkColor(0, 0, 0) for label, text in zip(self.labels, label_data): label.setText(text, black) def get_shape_index(self): shape_index = -1 attr_shape = self.attr_shape if attr_shape and attr_shape != "(Same shape)" and \ len(self.data_domain[attr_shape].values) <= \ len(self.CurveSymbols): shape_index = self.attribute_name_index[attr_shape] return shape_index def compute_symbols(self): shape_index = self.get_shape_index() if shape_index == -1: shape_data = self.CurveSymbols[np.zeros(self.n_points, dtype=int)] else: shape_data = self.original_data[shape_index] shape_data[np.isnan(shape_data)] = len(self.CurveSymbols) - 1 shape_data = self.CurveSymbols[shape_data.astype(int)] return shape_data def update_shapes(self): if self.scatterplot_item: shape_data = self.compute_symbols() self.scatterplot_item.setSymbol(shape_data) self.make_legend() def update_grid(self): self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend(self): if self.legend: self.legend.setVisible(self.show_legend) def create_legend(self): self.legend = PositionedLegendItem(self.plot_widget.plotItem, self) def remove_legend(self): if self.legend: self.legend.setParent(None) self.legend = None if self.color_legend: self.color_legend.setParent(None) self.color_legend = None def make_legend(self): self.remove_legend() self.make_color_legend() self.make_shape_legend() self.update_legend() def make_color_legend(self): color_index = self.get_color_index() if color_index == -1: return color_var = self.data_domain[color_index] use_shape = self.get_shape_index() == color_index if isinstance(color_var, DiscreteVariable): if not self.legend: self.create_legend() palette = self.discrete_palette for i, value in enumerate(color_var.values): color = QColor(*palette.getRGB(i)) brush = color.lighter(self.DarkerValue) self.legend.addItem( ScatterPlotItem( pen=color, brush=brush, size=10, symbol=self.CurveSymbols[i] if use_shape else "o"), value) else: legend = self.color_legend = PositionedLegendItem( self.plot_widget.plotItem, self, legend_id="colors", at_bottom=True) label = PaletteItemSample(self.continuous_palette, self.scale) legend.addItem(label, "") legend.setGeometry(label.boundingRect()) def make_shape_legend(self): shape_index = self.get_shape_index() if shape_index == -1 or shape_index == self.get_color_index(): return if not self.legend: self.create_legend() shape_var = self.data_domain[shape_index] color = self.plot_widget.palette().color(OWPalette.Data) pen = QPen(color.darker(self.DarkerValue)) color.setAlpha(self.alpha_value) for i, value in enumerate(shape_var.values): self.legend.addItem( ScatterPlotItem(pen=pen, brush=color, size=10, symbol=self.CurveSymbols[i]), value) # noinspection PyPep8Naming def mouseMoved(self, pos): act_pos = self.scatterplot_item.mapFromScene(pos) points = self.scatterplot_item.pointsAt(act_pos) text = "" if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" if self.tooltip_shows_all: text += "".join( ' {} = {}\n'.format(attr.name, self.raw_data[index][attr]) for attr in self.data_domain.attributes) else: text += ' {} = {}\n {} = {}\n'.format( self.shown_x, self.raw_data[index][self.shown_x], self.shown_y, self.raw_data[index][self.shown_y]) if self.data_domain.class_var: text += 'Class:\n {} = {}\n'.format( self.data_domain.class_var.name, self.raw_data[index][self.raw_data.domain.class_var]) if i < len(points) - 1: text += '------------------\n' self.tooltip.setText(text, color=(0, 0, 0)) self.tooltip.setPos(act_pos) self.tooltip.show() self.tooltip.setZValue(10) else: self.tooltip.hide() def zoom_button_clicked(self): self.scatterplot_item.getViewBox().setMouseMode( self.scatterplot_item.getViewBox().RectMode) def pan_button_clicked(self): self.scatterplot_item.getViewBox().setMouseMode( self.scatterplot_item.getViewBox().PanMode) def select_button_clicked(self): self.scatterplot_item.getViewBox().setMouseMode( self.scatterplot_item.getViewBox().RectMode) def reset_button_clicked(self): self.view_box.autoRange() def select_by_click(self, _, points): self.select(points) def select_by_rectangle(self, value_rect): points = [point for point in self.scatterplot_item.points() if value_rect.contains(QPointF(point.pos()))] self.select(points) def unselect_all(self): self.selection = None self.update_colors(keep_colors=True) def select(self, points): # noinspection PyArgumentList keys = QApplication.keyboardModifiers() if self.selection is None or not keys & ( Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier): self.selection = np.full(self.n_points, False, dtype=np.bool) indices = [p.data() for p in points] if keys & Qt.ControlModifier: self.selection[indices] = False elif keys & Qt.AltModifier: self.selection[indices] = 1 - self.selection[indices] else: # Handle shift and no modifiers self.selection[indices] = True self.update_colors(keep_colors=True) self.master.selection_changed() def get_selection(self): if self.selection is None: return np.array([], dtype=int) else: return np.arange(len(self.raw_data) )[self.valid_data][self.selection] def set_palette(self, p): self.plot_widget.setPalette(p) def save_to_file(self, size): pass
class OWScatterPlotGraph(gui.OWComponent, ScaleScatterPlotData): attr_color = ContextSetting("", ContextSetting.OPTIONAL) attr_label = ContextSetting("", ContextSetting.OPTIONAL) attr_shape = ContextSetting("", ContextSetting.OPTIONAL) attr_size = ContextSetting("", ContextSetting.OPTIONAL) point_width = Setting(10) alpha_value = Setting(255) show_grid = Setting(False) show_legend = Setting(True) tooltip_shows_all = Setting(False) square_granularity = Setting(3) space_between_cells = Setting(True) CurveSymbols = np.array("o x t + d s ?".split()) MinShapeSize = 6 DarkerValue = 120 UnknownColor = (168, 50, 168) def __init__(self, scatter_widget, parent=None, _="None"): gui.OWComponent.__init__(self, scatter_widget) self.view_box = InteractiveViewBox(self) self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent, background="w") self.plot_widget.setAntialiasing(True) self.plot_widget.sizeHint = lambda: QtCore.QSize(500, 500) self.replot = self.plot_widget.replot ScaleScatterPlotData.__init__(self) self.scatterplot_item = None self.labels = [] self.master = scatter_widget self.shown_attribute_indices = [] self.shown_x = "" self.shown_y = "" self.pen_colors = self.brush_colors = None self.valid_data = None # np.ndarray self.selection = None # np.ndarray self.n_points = 0 self.gui = OWPlotGUI(self) self.continuous_palette = ContinuousPaletteGenerator( QColor(255, 255, 0), QColor(0, 0, 255), True) self.discrete_palette = ColorPaletteGenerator() self.selection_behavior = 0 self.legend = self.color_legend = None self.scale = None # DiscretizedScale # self.setMouseTracking(True) # self.grabGesture(QPinchGesture) # self.grabGesture(QPanGesture) self.update_grid() self._tooltip_delegate = HelpEventDelegate(self.help_event) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) def set_data(self, data, subset_data=None, **args): self.plot_widget.clear() ScaleScatterPlotData.set_data(self, data, subset_data, **args) def update_data(self, attr_x, attr_y): self.shown_x = attr_x self.shown_y = attr_y self.remove_legend() if self.scatterplot_item: self.plot_widget.removeItem(self.scatterplot_item) for label in self.labels: self.plot_widget.removeItem(label) self.labels = [] self.set_axis_title("bottom", "") self.set_axis_title("left", "") if self.scaled_data is None or not len(self.scaled_data): self.valid_data = None self.n_points = 0 return index_x = self.attribute_name_index[attr_x] index_y = self.attribute_name_index[attr_y] self.valid_data = self.get_valid_list([index_x, index_y]) x_data, y_data = self.get_xy_data_positions(attr_x, attr_y, self.valid_data) x_data = x_data[self.valid_data] y_data = y_data[self.valid_data] self.n_points = len(x_data) for axis, name, index in (("bottom", attr_x, index_x), ("left", attr_y, index_y)): self.set_axis_title(axis, name) var = self.data_domain[index] if isinstance(var, DiscreteVariable): self.set_labels(axis, get_variable_values_sorted(var)) else: self.set_labels(axis, None) color_data, brush_data = self.compute_colors() size_data = self.compute_sizes() shape_data = self.compute_symbols() self.scatterplot_item = ScatterPlotItem(x=x_data, y=y_data, data=np.arange(self.n_points), symbol=shape_data, size=size_data, pen=color_data, brush=brush_data) self.plot_widget.addItem(self.scatterplot_item) self.scatterplot_item.selected_points = [] self.scatterplot_item.sigClicked.connect(self.select_by_click) self.update_labels() self.make_legend() self.plot_widget.replot() def set_labels(self, axis, labels): axis = self.plot_widget.getAxis(axis) if labels: ticks = [[(i, labels[i]) for i in range(len(labels))]] axis.setTicks(ticks) else: axis.setTicks(None) def set_axis_title(self, axis, title): self.plot_widget.setLabel(axis=axis, text=title) def get_size_index(self): size_index = -1 attr_size = self.attr_size if attr_size != "" and attr_size != "(Same size)": size_index = self.attribute_name_index[attr_size] return size_index def compute_sizes(self): size_index = self.get_size_index() if size_index == -1: size_data = np.full((self.n_points, ), self.point_width) else: size_data = \ self.MinShapeSize + \ self.no_jittering_scaled_data[size_index] * self.point_width size_data[np.isnan(size_data)] = self.MinShapeSize - 2 return size_data def update_sizes(self): if self.scatterplot_item: size_data = self.compute_sizes() self.scatterplot_item.setSize(size_data) update_point_size = update_sizes def get_color_index(self): color_index = -1 attr_color = self.attr_color if attr_color != "" and attr_color != "(Same color)": color_index = self.attribute_name_index[attr_color] color_var = self.data_domain[attr_color] if isinstance(color_var, DiscreteVariable): self.discrete_palette.set_number_of_colors( len(color_var.values)) return color_index def compute_colors(self, keep_colors=False): if not keep_colors: self.pen_colors = self.brush_colors = None color_index = self.get_color_index() if color_index == -1: color = self.plot_widget.palette().color(OWPalette.Data) pen = [QPen(QBrush(color), 1.5)] * self.n_points if self.selection is not None: brush = [(QBrush(QColor(128, 128, 128, 255)), QBrush(QColor(128, 128, 128)))[s] for s in self.selection] else: brush = [QBrush(QColor(128, 128, 128))] * self.n_points return pen, brush c_data = self.original_data[color_index, self.valid_data] if isinstance(self.data_domain[color_index], ContinuousVariable): if self.pen_colors is None: self.scale = DiscretizedScale(np.min(c_data), np.max(c_data)) c_data -= self.scale.offset c_data /= self.scale.width c_data = np.floor(c_data) + 0.5 c_data /= self.scale.bins c_data = np.clip(c_data, 0, 1) palette = self.continuous_palette self.pen_colors = palette.getRGB(c_data) self.brush_colors = np.hstack([ self.pen_colors, np.full((self.n_points, 1), self.alpha_value) ]) self.pen_colors *= 100 / self.DarkerValue self.pen_colors = [ QPen(QBrush(QColor(*col)), 1.5) for col in self.pen_colors.tolist() ] if self.selection is not None: self.brush_colors[:, 3] = 0 self.brush_colors[self.selection, 3] = self.alpha_value else: self.brush_colors[:, 3] = self.alpha_value pen = self.pen_colors brush = np.array( [QBrush(QColor(*col)) for col in self.brush_colors.tolist()]) else: if self.pen_colors is None: palette = self.discrete_palette n_colors = palette.number_of_colors c_data = c_data.copy() c_data[np.isnan(c_data)] = n_colors c_data = c_data.astype(int) colors = palette.getRGB(np.arange(n_colors + 1)) colors[n_colors] = (128, 128, 128) pens = np.array([ QPen(QBrush(QColor(*col).darker(self.DarkerValue)), 1.5) for col in colors ]) self.pen_colors = pens[c_data] self.brush_colors = np.array([[ QBrush(QColor(0, 0, 0, 0)), QBrush(QColor(col[0], col[1], col[2], self.alpha_value)) ] for col in colors]) self.brush_colors = self.brush_colors[c_data] if self.selection is not None: brush = np.where(self.selection, self.brush_colors[:, 1], self.brush_colors[:, 0]) else: brush = self.brush_colors[:, 1] pen = self.pen_colors return pen, brush def update_colors(self, keep_colors=False): if self.scatterplot_item: pen_data, brush_data = self.compute_colors(keep_colors) self.scatterplot_item.setPen(pen_data, update=False, mask=None) self.scatterplot_item.setBrush(brush_data, mask=None) if not keep_colors: self.make_legend() update_alpha_value = update_colors def create_labels(self): for x, y in zip(*self.scatterplot_item.getData()): ti = TextItem() self.plot_widget.addItem(ti) ti.setPos(x, y) self.labels.append(ti) def update_labels(self): if not self.attr_label: for label in self.labels: label.setText("") return if not self.labels: self.create_labels() label_column = self.raw_data.get_column_view(self.attr_label)[0] formatter = self.raw_data.domain[self.attr_label].str_val label_data = map(formatter, label_column) black = pg.mkColor(0, 0, 0) for label, text in zip(self.labels, label_data): label.setText(text, black) def get_shape_index(self): shape_index = -1 attr_shape = self.attr_shape if attr_shape and attr_shape != "(Same shape)" and \ len(self.data_domain[attr_shape].values) <= \ len(self.CurveSymbols): shape_index = self.attribute_name_index[attr_shape] return shape_index def compute_symbols(self): shape_index = self.get_shape_index() if shape_index == -1: shape_data = self.CurveSymbols[np.zeros(self.n_points, dtype=int)] else: shape_data = self.original_data[shape_index] shape_data[np.isnan(shape_data)] = len(self.CurveSymbols) - 1 shape_data = self.CurveSymbols[shape_data.astype(int)] return shape_data def update_shapes(self): if self.scatterplot_item: shape_data = self.compute_symbols() self.scatterplot_item.setSymbol(shape_data) self.make_legend() def update_grid(self): self.plot_widget.showGrid(x=self.show_grid, y=self.show_grid) def update_legend(self): if self.legend: self.legend.setVisible(self.show_legend) def create_legend(self): self.legend = PositionedLegendItem(self.plot_widget.plotItem, self) def remove_legend(self): if self.legend: self.legend.setParent(None) self.legend = None if self.color_legend: self.color_legend.setParent(None) self.color_legend = None def make_legend(self): self.remove_legend() self.make_color_legend() self.make_shape_legend() self.update_legend() def make_color_legend(self): color_index = self.get_color_index() if color_index == -1: return color_var = self.data_domain[color_index] use_shape = self.get_shape_index() == color_index if isinstance(color_var, DiscreteVariable): if not self.legend: self.create_legend() palette = self.discrete_palette for i, value in enumerate(color_var.values): color = QColor(*palette.getRGB(i)) brush = color.lighter(self.DarkerValue) self.legend.addItem( ScatterPlotItem( pen=color, brush=brush, size=10, symbol=self.CurveSymbols[i] if use_shape else "o"), value) else: legend = self.color_legend = PositionedLegendItem( self.plot_widget.plotItem, self, legend_id="colors", at_bottom=True) label = PaletteItemSample(self.continuous_palette, self.scale) legend.addItem(label, "") legend.setGeometry(label.boundingRect()) def make_shape_legend(self): shape_index = self.get_shape_index() if shape_index == -1 or shape_index == self.get_color_index(): return if not self.legend: self.create_legend() shape_var = self.data_domain[shape_index] color = self.plot_widget.palette().color(OWPalette.Data) pen = QPen(color.darker(self.DarkerValue)) color.setAlpha(self.alpha_value) for i, value in enumerate(shape_var.values): self.legend.addItem( ScatterPlotItem(pen=pen, brush=color, size=10, symbol=self.CurveSymbols[i]), value) def zoom_button_clicked(self): self.scatterplot_item.getViewBox().setMouseMode( self.scatterplot_item.getViewBox().RectMode) def pan_button_clicked(self): self.scatterplot_item.getViewBox().setMouseMode( self.scatterplot_item.getViewBox().PanMode) def select_button_clicked(self): self.scatterplot_item.getViewBox().setMouseMode( self.scatterplot_item.getViewBox().RectMode) def reset_button_clicked(self): self.view_box.autoRange() def select_by_click(self, _, points): self.select(points) def select_by_rectangle(self, value_rect): points = [ point for point in self.scatterplot_item.points() if value_rect.contains(QPointF(point.pos())) ] self.select(points) def unselect_all(self): self.selection = None self.update_colors(keep_colors=True) def select(self, points): # noinspection PyArgumentList keys = QApplication.keyboardModifiers() if self.selection is None or not keys & ( Qt.ShiftModifier + Qt.ControlModifier + Qt.AltModifier): self.selection = np.full(self.n_points, False, dtype=np.bool) indices = [p.data() for p in points] if keys & Qt.ControlModifier: self.selection[indices] = False elif keys & Qt.AltModifier: self.selection[indices] = 1 - self.selection[indices] else: # Handle shift and no modifiers self.selection[indices] = True self.update_colors(keep_colors=True) self.master.selection_changed() def get_selection(self): if self.selection is None: return np.array([], dtype=int) else: return np.arange(len( self.raw_data))[self.valid_data][self.selection] def set_palette(self, p): self.plot_widget.setPalette(p) def save_to_file(self, size): pass def help_event(self, event): if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) text = "" if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" if self.tooltip_shows_all: text += "".join(' {} = {}\n'.format( attr.name, self.raw_data[index][attr]) for attr in self.data_domain.attributes) else: text += ' {} = {}\n {} = {}\n'.format( self.shown_x, self.raw_data[index][self.shown_x], self.shown_y, self.raw_data[index][self.shown_y]) if self.data_domain.class_var: text += 'Class:\n {} = {}\n'.format( self.data_domain.class_var.name, self.raw_data[index][self.raw_data.domain.class_var]) if i < len(points) - 1: text += '------------------\n' text = ('<span style="white-space:pre">{}</span>'.format( escape(text))) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False