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)
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)
def _setup_plot(self):
self.__replot_requested = False
self.clear_plot()
variables = list(self.varmodel_selected)
if not variables:
return
coords = [self._get_data(var) for var in variables]
coords = numpy.vstack(coords)
p, N = coords.shape
assert N == len(self.data), p == len(variables)
axes = linproj.defaultaxes(len(variables))
assert axes.shape == (2, p)
mask = ~numpy.logical_or.reduce(numpy.isnan(coords), axis=0)
coords = coords[:, mask]
X, Y = numpy.dot(axes, coords)
X = plotutils.normalized(X)
Y = plotutils.normalized(Y)
pen_data, brush_data = self._color_data(mask)
size_data = self._size_data(mask)
shape_data = self._shape_data(mask)
if self.jitter_value > 0:
value = [0, 0.01, 0.1, 0.5, 1, 2][self.jitter_value]
rstate = numpy.random.RandomState(0)
jitter_x = (rstate.random_sample(X.shape) * 2 - 1) * value / 100
rstate = numpy.random.RandomState(1)
jitter_y = (rstate.random_sample(Y.shape) * 2 - 1) * value / 100
X += jitter_x
Y += jitter_y
self._item = ScatterPlotItem(
X, Y,
pen=pen_data,
brush=brush_data,
size=size_data,
shape=shape_data,
antialias=True,
data=numpy.arange(len(self.data))[mask]
)
self._item._mask = mask
self.viewbox.addItem(self._item)
for i, axis in enumerate(axes.T):
axis_item = AxisItem(line=QLineF(0, 0, axis[0], axis[1]),
label=variables[i].name)
self.viewbox.addItem(axis_item)
self.viewbox.setRange(QtCore.QRectF(-1.05, -1.05, 2.1, 2.1))
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 setDataPointsVisibility(self, b):
if self.dataPoints is None:
if self.flags == 'peak':
chrom = self.ref.sample.massExtraction(self.ref.mass(), self.ref.sample.ppm, asChromatogram=True)
self.dataPoints = ScatterPlotItem(x=chrom.x_data, y=chrom.y_data)
else:
self.dataPoints = ScatterPlotItem(x=self.ref.x_data, y=self.ref.y_data)
if self.flags != 'spectra':
self.dataPoints.sigClicked.connect(self.requestSpectra)
self.pw.addDataItem(self.dataPoints)
self.dataPoints.setVisible(b)
def setDataPointsVisibility(self, b):
if self.dataPoints is None:
if self.flags == 'peak':
chrom = self.ref.sample.massExtraction(self.ref.mass(),
self.ref.sample.ppm,
asChromatogram=True)
self.dataPoints = ScatterPlotItem(x=chrom.x_data,
y=chrom.y_data)
else:
self.dataPoints = ScatterPlotItem(x=self.ref.x_data,
y=self.ref.y_data)
if self.flags != 'spectra':
self.dataPoints.sigClicked.connect(self.requestSpectra)
self.pw.addDataItem(self.dataPoints)
self.dataPoints.setVisible(b)
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_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_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 _setup_plot(self):
self.__replot_requested = False
self.clear_plot()
variables = list(self.varmodel_selected)
if not variables:
return
coords = [self._get_data(var) for var in variables]
coords = numpy.vstack(coords)
p, N = coords.shape
assert N == len(self.data), p == len(variables)
axes = linproj.defaultaxes(len(variables))
assert axes.shape == (2, p)
mask = ~numpy.logical_or.reduce(numpy.isnan(coords), axis=0)
coords = coords[:, mask]
X, Y = numpy.dot(axes, coords)
X = plotutils.normalized(X)
Y = plotutils.normalized(Y)
pen_data, brush_data = self._color_data(mask)
size_data = self._size_data(mask)
shape_data = self._shape_data(mask)
if self.jitter_value > 0:
value = [0, 0.01, 0.1, 0.5, 1, 2][self.jitter_value]
rstate = numpy.random.RandomState(0)
jitter_x = (rstate.random_sample(X.shape) * 2 - 1) * value / 100
rstate = numpy.random.RandomState(1)
jitter_y = (rstate.random_sample(Y.shape) * 2 - 1) * value / 100
X += jitter_x
Y += jitter_y
self._item = ScatterPlotItem(
X, Y,
pen=pen_data,
brush=brush_data,
size=size_data,
shape=shape_data,
antialias=True,
data=numpy.arange(len(self.data))[mask]
)
self._item._mask = mask
self.viewbox.addItem(self._item)
for i, axis in enumerate(axes.T):
axis_item = AxisItem(line=QLineF(0, 0, axis[0], axis[1]),
label=variables[i].name)
self.viewbox.addItem(axis_item)
self.viewbox.setRange(QtCore.QRectF(-1.05, -1.05, 2.1, 2.1))
self._update_legend()
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 make_shape_legend(self):
shape = self.get_shape()
if shape is None or 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.attr_shape.values):
self.legend.addItem(
ScatterPlotItem(pen=color, brush=color, size=10,
symbol=self.CurveSymbols[i]), escape(value))
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 _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 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 = QColor(0, 0, 0)
color.setAlpha(self.alpha_value)
for i, value in enumerate(shape_var.values):
self.legend.addItem(
ScatterPlotItem(pen=color, brush=color, size=10,
symbol=self.CurveSymbols[i]), escape(value))
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))
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(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
def update_data(self, attr_x, attr_y, reset_view=True):
self.shown_x = attr_x
self.shown_y = attr_y
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", "")
if self.scaled_data is None or not len(self.scaled_data):
self.valid_data = None
self.selection = 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],
also_class_if_exists=False)
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)
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()
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
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 OWLinearProjection(widget.OWWidget):
name = "Linear Projection"
description = "A multi-axes projection of data to a two-dimension plane."
icon = "icons/LinearProjection.svg"
priority = 2000
inputs = [("Data", Orange.data.Table, "set_data", widget.Default),
("Data Subset", Orange.data.Table, "set_subset_data")]
# #TODO: Allow for axes to be supplied from an external source.
# ("Projection", numpy.ndarray, "set_axes"),]
outputs = [("Selected Data", Orange.data.Table)]
settingsHandler = settings.DomainContextHandler()
selected_variables = settings.ContextSetting(
[], required=settings.ContextSetting.REQUIRED
)
variable_state = settings.ContextSetting({})
color_index = settings.ContextSetting(0)
shape_index = settings.ContextSetting(0)
size_index = settings.ContextSetting(0)
label_index = settings.ContextSetting(0)
point_size = settings.Setting(10)
alpha_value = settings.Setting(255)
jitter_value = settings.Setting(0)
auto_commit = settings.Setting(True)
MinPointSize = 6
ReplotRequest = QEvent.registerEventType()
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.subset_data = None
self._subset_mask = None
self._selection_mask = None
self._item = None
self.__selection_item = None
self.__replot_requested = False
box = gui.widgetBox(self.controlArea, "Axes")
box1 = gui.widgetBox(box, "Displayed", margin=0)
box1.setFlat(True)
self.active_view = view = QListView(
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Ignored),
selectionMode=QListView.ExtendedSelection,
dragEnabled=True,
defaultDropAction=Qt.MoveAction,
dragDropOverwriteMode=False,
dragDropMode=QListView.DragDrop,
showDropIndicator=True,
minimumHeight=50,
)
view.viewport().setAcceptDrops(True)
movedown = QAction(
"Move down", view,
shortcut=QKeySequence(Qt.AltModifier | Qt.Key_Down),
triggered=self.__deactivate_selection
)
view.addAction(movedown)
self.varmodel_selected = model = DnDVariableListModel(
parent=self)
model.rowsInserted.connect(self._invalidate_plot)
model.rowsRemoved.connect(self._invalidate_plot)
model.rowsMoved.connect(self._invalidate_plot)
view.setModel(model)
box1.layout().addWidget(view)
box1 = gui.widgetBox(box, "Other", margin=0)
box1.setFlat(True)
self.other_view = view = QListView(
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Ignored),
selectionMode=QListView.ExtendedSelection,
dragEnabled=True,
defaultDropAction=Qt.MoveAction,
dragDropOverwriteMode=False,
dragDropMode=QListView.DragDrop,
showDropIndicator=True,
minimumHeight=50
)
view.viewport().setAcceptDrops(True)
moveup = QtGui.QAction(
"Move up", view,
shortcut=QKeySequence(Qt.AltModifier | Qt.Key_Up),
triggered=self.__activate_selection
)
view.addAction(moveup)
self.varmodel_other = model = DnDVariableListModel(parent=self)
view.setModel(model)
box1.layout().addWidget(view)
box = gui.widgetBox(self.controlArea, "Jittering")
gui.comboBox(box, self, "jitter_value",
items=["None", "0.01%", "0.1%", "0.5%", "1%", "2%"],
callback=self._invalidate_plot)
box.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
box = gui.widgetBox(self.controlArea, "Points")
box.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
self.colorvar_model = itemmodels.VariableListModel(parent=self)
self.shapevar_model = itemmodels.VariableListModel(parent=self)
self.sizevar_model = itemmodels.VariableListModel(parent=self)
self.labelvar_model = itemmodels.VariableListModel(parent=self)
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
spacing=8
)
box.layout().addLayout(form)
cb = gui.comboBox(box, self, "color_index",
callback=self._on_color_change)
cb.setModel(self.colorvar_model)
form.addRow("Colors", cb)
alpha_slider = QSlider(
Qt.Horizontal, minimum=10, maximum=255, pageStep=25,
tickPosition=QSlider.TicksBelow, value=self.alpha_value)
alpha_slider.valueChanged.connect(self._set_alpha)
form.addRow("Opacity", alpha_slider)
cb = gui.comboBox(box, self, "shape_index",
callback=self._on_shape_change)
cb.setModel(self.shapevar_model)
form.addRow("Shape", cb)
cb = gui.comboBox(box, self, "size_index",
callback=self._on_size_change)
cb.setModel(self.sizevar_model)
form.addRow("Size", cb)
size_slider = QSlider(
Qt.Horizontal, minimum=3, maximum=30, value=self.point_size,
pageStep=3,
tickPosition=QSlider.TicksBelow)
size_slider.valueChanged.connect(self._set_size)
form.addRow("", size_slider)
toolbox = gui.widgetBox(self.controlArea, "Zoom/Select")
toollayout = QtGui.QHBoxLayout()
toolbox.layout().addLayout(toollayout)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
# Main area plot
self.view = pg.GraphicsView(background="w")
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setFrameStyle(QtGui.QFrame.StyledPanel)
self.viewbox = pg.ViewBox(enableMouse=True, enableMenu=False)
self.viewbox.grabGesture(Qt.PinchGesture)
self.view.setCentralItem(self.viewbox)
self.mainArea.layout().addWidget(self.view)
self.selection = PlotSelectionTool(
self, selectionMode=PlotSelectionTool.Lasso)
self.selection.setViewBox(self.viewbox)
self.selection.selectionFinished.connect(self._selection_finish)
self.zoomtool = PlotZoomTool(self)
self.pantool = PlotPanTool(self)
self.pinchtool = PlotPinchZoomTool(self)
self.pinchtool.setViewBox(self.viewbox)
self.continuous_palette = colorpalette.ContinuousPaletteGenerator(
QtGui.QColor(220, 220, 220),
QtGui.QColor(0, 0, 0),
False
)
self.discrete_palette = colorpalette.ColorPaletteGenerator(13)
def icon(name):
path = "icons/Dlg_{}.png".format(name)
path = pkg_resources.resource_filename(widget.__name__, path)
return QtGui.QIcon(path)
actions = namespace(
zoomtofit=QAction(
"Zoom to fit", self, icon=icon("zoom_reset"),
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0),
triggered=lambda:
self.viewbox.setRange(QRectF(-1.05, -1.05, 2.1, 2.1))),
zoomin=QAction(
"Zoom in", self,
shortcut=QKeySequence(QKeySequence.ZoomIn),
triggered=lambda: self.viewbox.scaleBy((1 / 1.25, 1 / 1.25))),
zoomout=QAction(
"Zoom out", self,
shortcut=QKeySequence(QKeySequence.ZoomOut),
triggered=lambda: self.viewbox.scaleBy((1.25, 1.25))),
select=QAction(
"Select", self, checkable=True, icon=icon("arrow"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_1)),
zoom=QAction(
"Zoom", self, checkable=True, icon=icon("zoom"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_2)),
pan=QAction(
"Pan", self, checkable=True, icon=icon("pan_hand"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_3)),
)
self.addActions([actions.zoomtofit, actions.zoomin, actions.zoomout])
group = QtGui.QActionGroup(self, exclusive=True)
group.addAction(actions.select)
group.addAction(actions.zoom)
group.addAction(actions.pan)
actions.select.setChecked(True)
currenttool = self.selection
def activated(action):
nonlocal currenttool
if action is actions.select:
tool, cursor = self.selection, Qt.ArrowCursor
elif action is actions.zoom:
tool, cursor = self.zoomtool, Qt.ArrowCursor
elif action is actions.pan:
tool, cursor = self.pantool, Qt.OpenHandCursor
else:
assert False
currenttool.setViewBox(None)
tool.setViewBox(self.viewbox)
self.viewbox.setCursor(QtGui.QCursor(cursor))
currenttool = tool
group.triggered[QAction].connect(activated)
def button(action):
b = QtGui.QToolButton()
b.setDefaultAction(action)
return b
toollayout.addWidget(button(actions.select))
toollayout.addWidget(button(actions.zoom))
toollayout.addWidget(button(actions.pan))
toollayout.addSpacing(4)
toollayout.addWidget(button(actions.zoomtofit))
toollayout.addStretch()
toolbox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
def sizeHint(self):
return QSize(800, 500)
def clear(self):
self.data = None
self._subset_mask = None
self._selection_mask = None
self.varmodel_selected[:] = []
self.varmodel_other[:] = []
self.colorvar_model[:] = []
self.sizevar_model[:] = []
self.shapevar_model[:] = []
self.labelvar_model[:] = []
self.clear_plot()
def clear_plot(self):
if self._item is not None:
self._item.setParentItem(None)
self.viewbox.removeItem(self._item)
self._item = None
self.viewbox.clear()
def _invalidate_plot(self):
"""
Schedule a delayed replot.
"""
if not self.__replot_requested:
self.__replot_requested = True
QApplication.postEvent(self, QEvent(self.ReplotRequest),
Qt.LowEventPriority - 10)
def set_data(self, data):
"""
Set the input dataset.
"""
self.closeContext()
self.clear()
self.data = data
if data is not None:
self._initialize(data)
# get the default encoded state, replacing the position with Inf
state = self._encode_var_state(
[list(self.varmodel_selected), list(self.varmodel_other)]
)
state = {key: (source_ind, numpy.inf) for key, (source_ind, _)
in state.items()}
self.openContext(data.domain)
selected_keys = [key for key, (sind, _) in self.variable_state.items()
if sind == 0]
if set(selected_keys).issubset(set(state.keys())):
pass
# update the defaults state (the encoded state must contain
# all variables in the input domain)
state.update(self.variable_state)
# ... and restore it with saved positions taking precedence over
# the defaults
selected, other = self._decode_var_state(
state, [list(self.varmodel_selected),
list(self.varmodel_other)]
)
self.varmodel_selected[:] = selected
self.varmodel_other[:] = other
self._invalidate_plot()
def set_subset_data(self, subset):
"""
Set the supplementary input subset dataset.
"""
self.subset_data = subset
self._subset_mask = None
def handleNewSignals(self):
if self.subset_data is not None and self._subset_mask is None:
# Update the plot's highlight items
if self.data is not None:
dataids = self.data.ids.ravel()
subsetids = numpy.unique(self.subset_data.ids)
self._subset_mask = numpy.in1d(
dataids, subsetids, assume_unique=True)
self._invalidate_plot()
self.commit()
def customEvent(self, event):
if event.type() == OWLinearProjection.ReplotRequest:
self.__replot_requested = False
self._setup_plot()
else:
super().customEvent(event)
def closeContext(self):
self.variable_state = self._encode_var_state(
[list(self.varmodel_selected), list(self.varmodel_other)]
)
super().closeContext()
def _encode_var_state(self, lists):
return {(type(var), var.name): (source_ind, pos)
for source_ind, var_list in enumerate(lists)
for pos, var in enumerate(var_list)
if isinstance(var, Orange.data.Variable)}
def _decode_var_state(self, state, lists):
all_vars = reduce(list.__iadd__, lists, [])
newlists = [[] for _ in lists]
for var in all_vars:
source, pos = state[(type(var), var.name)]
newlists[source].append((pos, var))
return [[var for _, var in sorted(newlist, key=itemgetter(0))]
for newlist in newlists]
def color_var(self):
"""
Current selected color variable or None (if not selected).
"""
if 1 <= self.color_index < len(self.colorvar_model):
return self.colorvar_model[self.color_index]
else:
return None
def size_var(self):
"""
Current selected size variable or None (if not selected).
"""
if 1 <= self.size_index < len(self.sizevar_model):
return self.sizevar_model[self.size_index]
else:
return None
def shape_var(self):
"""
Current selected shape variable or None (if not selected).
"""
if 1 <= self.shape_index < len(self.shapevar_model):
return self.shapevar_model[self.shape_index]
else:
return None
def _initialize(self, data):
# Initialize the GUI controls from data's domain.
all_vars = list(data.domain.variables)
cont_vars = [var for var in data.domain.variables
if var.is_continuous]
disc_vars = [var for var in data.domain.variables
if var.is_discrete]
string_vars = [var for var in data.domain.variables
if var.is_string]
self.all_vars = data.domain.variables
self.varmodel_selected[:] = cont_vars[:3]
self.varmodel_other[:] = cont_vars[3:]
self.colorvar_model[:] = ["Same color"] + all_vars
self.sizevar_model[:] = ["Same size"] + cont_vars
self.shapevar_model[:] = ["Same shape"] + disc_vars
self.labelvar_model[:] = ["No label"] + string_vars
if data.domain.has_discrete_class:
self.color_index = all_vars.index(data.domain.class_var) + 1
def __activate_selection(self):
view = self.other_view
model = self.varmodel_other
indices = view.selectionModel().selectedRows()
variables = [model.data(ind, Qt.EditRole) for ind in indices]
for i in sorted((ind.row() for ind in indices), reverse=True):
del model[i]
self.varmodel_selected.extend(variables)
def __deactivate_selection(self):
view = self.active_view
model = self.varmodel_selected
indices = view.selectionModel().selectedRows()
variables = [model.data(ind, Qt.EditRole) for ind in indices]
for i in sorted((ind.row() for ind in indices), reverse=True):
del model[i]
self.varmodel_other.extend(variables)
def _get_data(self, var):
"""Return the column data for variable `var`."""
X, _ = self.data.get_column_view(var)
return X.ravel()
def _setup_plot(self):
self.__replot_requested = False
self.clear_plot()
variables = list(self.varmodel_selected)
if not variables:
return
coords = [self._get_data(var) for var in variables]
coords = numpy.vstack(coords)
p, N = coords.shape
assert N == len(self.data), p == len(variables)
axes = linproj.defaultaxes(len(variables))
assert axes.shape == (2, p)
mask = ~numpy.logical_or.reduce(numpy.isnan(coords), axis=0)
coords = coords[:, mask]
X, Y = numpy.dot(axes, coords)
X = plotutils.normalized(X)
Y = plotutils.normalized(Y)
pen_data, brush_data = self._color_data(mask)
size_data = self._size_data(mask)
shape_data = self._shape_data(mask)
if self.jitter_value > 0:
value = [0, 0.01, 0.1, 0.5, 1, 2][self.jitter_value]
rstate = numpy.random.RandomState(0)
jitter_x = (rstate.random_sample(X.shape) * 2 - 1) * value / 100
rstate = numpy.random.RandomState(1)
jitter_y = (rstate.random_sample(Y.shape) * 2 - 1) * value / 100
X += jitter_x
Y += jitter_y
self._item = ScatterPlotItem(
X, Y,
pen=pen_data,
brush=brush_data,
size=size_data,
shape=shape_data,
antialias=True,
data=numpy.arange(len(self.data))[mask]
)
self._item._mask = mask
self.viewbox.addItem(self._item)
for i, axis in enumerate(axes.T):
axis_item = AxisItem(line=QLineF(0, 0, axis[0], axis[1]),
label=variables[i].name)
self.viewbox.addItem(axis_item)
self.viewbox.setRange(QtCore.QRectF(-1.05, -1.05, 2.1, 2.1))
def _color_data(self, mask=None):
color_var = self.color_var()
if color_var is not None:
color_data = self._get_data(color_var)
if color_var.is_continuous:
color_data = plotutils.continuous_colors(color_data)
else:
color_data = plotutils.discrete_colors(
color_data, len(color_var.values)
)
if mask is not None:
color_data = color_data[mask]
pen_data = numpy.array(
[pg.mkPen((r, g, b, self.alpha_value / 2))
for r, g, b in color_data],
dtype=object)
brush_data = numpy.array(
[pg.mkBrush((r, g, b, self.alpha_value))
for r, g, b in color_data],
dtype=object)
else:
color = QtGui.QColor(Qt.lightGray)
color.setAlpha(self.alpha_value)
pen_data = QtGui.QPen(color)
pen_data.setCosmetic(True)
color = QtGui.QColor(Qt.darkGray)
color.setAlpha(self.alpha_value)
brush_data = QtGui.QBrush(color)
if self._subset_mask is not None:
assert self._subset_mask.shape == (len(self.data),)
if mask is not None:
subset_mask = self._subset_mask[mask]
else:
subset_mask = self._subset_mask
if isinstance(brush_data, QtGui.QBrush):
brush_data = numpy.array([brush_data] * subset_mask.size,
dtype=object)
brush_data[~subset_mask] = QtGui.QBrush(Qt.NoBrush)
if self._selection_mask is not None:
assert self._selection_mask.shape == (len(self.data),)
if mask is not None:
selection_mask = self._selection_mask[mask]
else:
selection_mask = self._selection_mask
if isinstance(pen_data, QtGui.QPen):
pen_data = numpy.array([pen_data] * selection_mask.size,
dtype=object)
pen_data[selection_mask] = pg.mkPen((200, 200, 0, 150), width=4)
return pen_data, brush_data
def _on_color_change(self):
if self.data is None or self._item is None:
return
pen, brush = self._color_data()
if isinstance(pen, QtGui.QPen):
# Reset the brush for all points
self._item.data["pen"] = None
self._item.setPen(pen)
else:
self._item.setPen(pen[self._item._mask])
if isinstance(brush, QtGui.QBrush):
# Reset the brush for all points
self._item.data["brush"] = None
self._item.setBrush(brush)
else:
self._item.setBrush(brush[self._item._mask])
def _shape_data(self, mask):
shape_var = self.shape_var()
if shape_var is None:
shape_data = numpy.array(["o"] * len(self.data))
else:
assert shape_var.is_discrete
max_symbol = len(ScatterPlotItem.Symbols) - 1
shape = self._get_data(shape_var)
shape_mask = numpy.isnan(shape)
shape = shape % (max_symbol - 1)
shape[shape_mask] = max_symbol
symbols = numpy.array(list(ScatterPlotItem.Symbols))
shape_data = symbols[numpy.asarray(shape, dtype=int)]
if mask is None:
return shape_data
else:
return shape_data[mask]
def _on_shape_change(self):
if self.data is None:
return
self.set_shape(self._shape_data(mask=None))
def _size_data(self, mask=None):
size_var = self.size_var()
if size_var is None:
size_data = numpy.full((len(self.data),), self.point_size)
else:
size_data = plotutils.normalized(self._get_data(size_var))
size_data -= numpy.nanmin(size_data)
size_mask = numpy.isnan(size_data)
size_data = \
size_data * self.point_size + OWLinearProjection.MinPointSize
size_data[size_mask] = OWLinearProjection.MinPointSize - 2
if mask is None:
return size_data
else:
return size_data[mask]
def _on_size_change(self):
if self.data is None:
return
self.set_size(self._size_data(mask=None))
def set_shape(self, shape):
"""
Set (update) the current point shape map.
"""
if self._item is not None:
self._item.setSymbol(shape[self._item._mask])
def set_size(self, size):
"""
Set (update) the current point size.
"""
if self._item is not None:
self._item.setSize(size[self._item._mask])
def _set_alpha(self, value):
self.alpha_value = value
self._on_color_change()
def _set_size(self, value):
self.point_size = value
self._on_size_change()
def _selection_finish(self, path):
self.select(path)
def select(self, selectionshape):
item = self._item
if item is None:
return
indices = [spot.data()
for spot in item.points()
if selectionshape.contains(spot.pos())]
if QApplication.keyboardModifiers() & Qt.ControlModifier:
self.select_indices(indices)
else:
self._selection_mask = None
self.select_indices(indices)
def select_indices(self, indices):
if self.data is None:
return
if self._selection_mask is None:
self._selection_mask = numpy.zeros(len(self.data), dtype=bool)
self._selection_mask[indices] = True
self._on_color_change()
self.commit()
def commit(self):
subset = None
if self.data is not None and self._selection_mask is not None:
indices = numpy.flatnonzero(self._selection_mask)
if len(indices) > 0:
subset = self.data[indices]
self.send("Selected Data", subset)
class MSQtCanvas(QWidget, MSDialogController):
"""
DONE:the current peak is not updated while the user press up and down key on the treeView
TODO: think about a mjor redesign of those classes
"""
#linePlotted = pyqtSignal(object, str)
#lineRemoved = pyqtSignal(object)
def __init__(self, data, title, flags="chroma", parent=None, **k):
QWidget.__init__(self, parent)
MSDialogController.__init__(self, 0, parent)
self.model = self.qApp.model
self.view = self.qApp.view
self.data = data
self.title = title
self.flags = flags
if self.flags == 'peak':
if self.acTree not in (self.view.treeView_2, self.view.treeView_3):
print "Unknown Error"
return
idx = self.acTree.selectedIndexes()[0]
s = qApp.instance().dockControl.currentSample[
1 if self.acTree is self.view.treeView_2 else 2]
if s is None:
print "unknow error"
return
values = map(float, idx.data().toString().split('/')[:2])
self.currentPeak = s.peakAt(*values)
#connection to update the selected Peak object
self.connect(self.acTree, SIGNAL("changedLine"),
self.updateCurrentPeak)
self.minX, self.maxX, self.maxY = [0] * 3
#if flags != 'peak':
# self.minX, self.maxX, self.maxY = self.getMax()
self.pw = PlotWidget(self.minX, self.maxX, self.maxY, parent=self,
**k) #parent=self,
#self.pw.setAttribute(Qt.WA_DeleteOnClose)#plotItem.setAttribute(Qt.WA_PaintOnScreen & Qt.WA_PaintUnclipped)
if k.get('antialiased', False):
self.pw.setRenderHint(0x01) #antialiasing i suppose
self.pw.setTitle(title)
self.pw.updateGrid()
self._setupUi()
self.connect(self, SIGNAL('linePlotted'), self.updateContextMenu)
self.connect(self.view.sampleTableView,
SIGNAL("disHighlightRequested(QModelIndex)"),
self.disHighlightOne)
self.connect(self.view.sampleTableView,
SIGNAL("highlightRequested(QModelIndex)"), self.highlight)
self.connect(self.view.sampleTableView,
SIGNAL("noHighlightRequested()"), self.disHighlight)
self.connect(self.view.ppmEditer, SIGNAL('valueChanged(double)'),
self.redrawAll)
self.drawnItems = {}
self.trashItems = [] #why unecessary? nope to collect annotation stuff
self.textLabels = []
self.pixmaps = []
self.dataPoints = None
self._plotting(self.data) #initial plotting
def getMax(self):
localXmin = []
localXmax = []
localYmax = []
for el in self.data:
if el is None:
continue
localXmin.append(min_f(el.x_data))
localXmax.append(max_f(el.x_data))
localYmax.append(max_l(el.y_data))
return min_f(np.array(localXmin)), max_f(np.array(localXmax)), max_l(
np.array(localYmax))
def _plotting(self, data):
"""
refactor this shit
c = Line(chrom.x_data, chrom.y_data,
QColor.fromRgbF(*(self.ref.sample.color+(.7,))),
parent=self.pw.plotItem.vb,
scene=self.pw.scene())
#test scatter plot
self.scatter = ScatterPlotItem(x=chrom.x_data, y=chrom.y_data)
self.pw.addDataItem(self.scatter)
self.scatter.sigClicked.connect(self.requestSpectra)
"""
if self.flags == 'peak':
self.connect(self.pw.plotItem.vb,
SIGNAL('showDiffOrSpectra(PyQt_PyObject)'),
self.drawSpectra)
self.ref = sorted([e for e in data if e is not None],
key=lambda x: x.height)[-1]
ppm = self.view.ppmEditer.value() if self.view.usePpm.isChecked(
) else self.ref.sample.ppm
chrom = self.ref.sample.massExtraction(self.ref.mass(),
ppm,
asChromatogram=True)
#show labels
self.textLabels += self.showTextLabel(chrom.x_data, chrom.y_data)
#drawing
color = QColor.fromRgbF(*self.ref.sample.color + (.5, ))
c = self.pw.plotItem.plot(chrom.x_data, chrom.y_data, pen=color)
self.drawnItems[self.ref.sample] = c
# peak's pixmap on the ref peak
pix = PeakArrowItem(self.ref,
pen=color,
brush=color,
pos=(self.ref.rt, self.ref.height +
(self.ref.height * 6) / 100.),
angle=-90,
parent=self.pw.plotItem.vb)
pix.setZValue(1000)
self.pw.addItem(pix)
#both these connections are emitted
#in peak Indicator by effictivamente qApp
self.connect(qApp.instance(), SIGNAL("highlightRequested"),
c.setHighlighted)
self.connect(qApp.instance(), SIGNAL('updateBarPlot'),
self.barPlot.setPeakGroup) #
self.emit(SIGNAL('linePlotted'), self.ref.sample.shortName())
#if qApp.instance().lowMemory:
# chromatograms=[el.sample.loadAndExtract(el.mass(), el.sample.ppm, asChromatogram=True) \
# for el in data if el != ref and el is not None]
#else:
ppm = self.view.ppmEditer.value() if self.view.usePpm.isChecked(
) else self.ref.sample.ppm
chromatograms=[el.sample.massExtraction(el.mass(), ppm, asChromatogram=True) \
for el in data if el is not None and el != self.ref]
self.drawEics(chromatograms)
#initialisation zoom on the peak
self.pw.setYRange(0.,
self.ref.height + (self.ref.height * 12) / 100.)
self.pw.setXRange(self.ref.rtmin - 20, self.ref.rtmax + 20)
elif self.flags == 'chroma':
ref = [d for d in data if d is not None]
if not ref:
print "Error, empty data to plot"
return
self.ref = ref[0]
self.textLabels += self.showTextLabel(self.ref.x_data,
self.ref.y_data)
self.drawEics(data)
else: #spectrum
if not data:
#print "NOTHING TO PLOT"
return
self.ref = data[0]
for el in data:
c = SpectrumItem(el, centroid=True, scene=self.pw.scene())
self.pw.addItem(c)
self.drawnItems[el.sample] = c
self.pw.plotItem.curves.append(c)
self.emit(SIGNAL('linePlotted'), el.sample.shortName())
#just put time information
if data:
i = 0
while data[i] is None and i < len(data):
i += 1
self.textLabels += self.showTextLabel(data[i].x_data,
data[i].y_data)
#setting the range
#warning: autoRange pw function does not work well
#on spectrum item
maxY = max([el.y_data.max() for el in data])
minX, maxX = min([el.x_data.min() for el in data
]), max([el.x_data.max() for el in data])
self.pw.setXRange(minX, maxX, padding=0)
self.pw.setYRange(0., maxY, padding=0)
def drawEics(self, data):
for chrom in data:
color = QColor.fromRgbF(*(chrom.sample.color + (.5, )))
c = self.pw.plotItem.plot(x=chrom.x_data,
y=chrom.y_data,
pen=color)
#c = Line(chrom.x_data, chrom.y_data,
# color,
# parent=self.pw.plotItem.vb,
# scene=self.pw.scene())
self.drawnItems[chrom.sample] = c
#self.pw.addItem(c)
#self.pw.plotItem.curves.append(c)
self.emit(SIGNAL('linePlotted'), chrom.sample.shortName())
if self.flags != 'peaks':
self.pw.autoRange()
#===========================================================================
# UI stuffs
#===========================================================================
def _setupUi(self):
# self.stop = QToolButton()
# self.stop.setIcon(QIcon('gui/icons/tools_wizard.png'))
# self.stop.setToolTip('Enable or disable the appearance of the contextMenu')
layout = QVBoxLayout(self)
self.smoothButton = QToolButton()
#self.smoothButton.setToolButtonStyle(2)
self.smoothButton.setPopupMode(2)
self.smoothButton.setToolTip("Smooth the visualized data")
#self.smoothButton.setText("Smooth...")
self.smoothButton.setIcon(
QIcon(os.path.normcase('gui/icons/smooth.png')))
self.smoothMenu = QMenu()
self.connect(self.smoothMenu, SIGNAL('triggered(QAction*)'),
self.smooth)
self.smoothButton.setMenu(self.smoothMenu)
self.pw.plotItem.toolBar.addWidget(self.smoothButton)
self.flipButton = QToolButton()
#self.flipButton.setToolButtonStyle(2)
self.flipButton.setIcon(QIcon(os.path.normcase('gui/icons/flip.png')))
self.flipButton.setToolTip("Flip the visualized data")
#self.flipButton.setText("Flip...")
self.flipButton.setPopupMode(2)
self.flipMenu = QMenu()
self.connect(self.flipMenu, SIGNAL('triggered(QAction*)'), self.flip)
self.flipButton.setMenu(self.flipMenu)
self.pw.plotItem.toolBar.addWidget(self.flipButton)
self.annotButton = QToolButton()
#self.annotButton.setToolButtonStyle(2)
self.annotButton.setPopupMode(2)
#self.annotButton.setText("&Annotate...")
self.annotButton.setIcon(
QIcon(os.path.normcase('gui/icons/attach.png')))
self.annotMenu = QMenu()
self.annotMenu.addAction("&Add Annotation")
self.annotMenu.addAction("&Remove last Annotation")
self.annotMenu.addAction("&Remove All Annotation")
self.annotButton.setMenu(self.annotMenu)
self.connect(self.annotMenu.actions()[0], SIGNAL("triggered()"),
self.annotate)
self.connect(self.annotMenu.actions()[1], SIGNAL("triggered()"),
self.removeLastAnnot)
self.connect(self.annotMenu.actions()[2], SIGNAL("triggered()"),
self.removeAllAnnot)
self.pw.plotItem.toolBar.addWidget(self.annotButton)
self.addPlotButton = QToolButton()
#self.addPlotButton.setToolButtonStyle(2)
self.addPlotButton.setText("Add...")
self.addPlotButton.setIcon(
QIcon(os.path.normcase('gui/icons/list_add.png')))
self.addPlotButton.setToolTip("Add a new plot to the current figure")
#self.addPlotButton.setText('&Add Plot')
self.pw.plotItem.toolBar.addWidget(self.addPlotButton)
self.showSpectra = QToolButton()
self.showSpectra.setPopupMode(2) #instant popup
#self.showSpectra.setToolButtonStyle(2)
self.showSpectra.setIcon(
QIcon(os.path.normcase('gui/icons/file_export.png')))
#self.showSpectra.setText('&Show /hide...')
self.showSpectra.setToolTip('Show/hide ...')
self.showMenu = QMenu()
self.showTextLabels = QAction("&Show Labels", self.showMenu)
self.showTextLabels.setCheckable(True)
self.showTextLabels.setChecked(True)
self.showMenu.addAction(self.showTextLabels)
self.connect(self.showMenu.actions()[0], SIGNAL('toggled(bool)'),
self.setTextLabelsVisibility)
showSpectrum = QAction("&Merged Spectrum", self.showMenu)
showSpectrum.setCheckable(True)
if self.flags == 'chroma' or self.flags == 'spectra':
showSpectrum.setEnabled(False)
self.showMenu.addAction(showSpectrum)
self.connect(self.showMenu.actions()[1], SIGNAL('toggled(bool)'),
self.drawSpectraRequested)
showNonXCMSPeak = QAction("&Show Non XCMS Peak", self.showMenu)
showNonXCMSPeak.setCheckable(True)
if self.flags == 'spectra':
showNonXCMSPeak.setEnabled(False)
self.showMenu.addAction(showNonXCMSPeak)
self.connect(self.showMenu.actions()[2], SIGNAL('toggled(bool)'),
self.setPixmapVisibility)
showDataPoints = QAction("&Show DataPoints", self.showMenu)
showDataPoints.setCheckable(True)
showDataPoints.setChecked(False)
self.showMenu.addAction(showDataPoints)
self.connect(self.showMenu.actions()[3], SIGNAL('toggled(bool)'),
self.setDataPointsVisibility)
self.showSpectra.setMenu(self.showMenu)
self.pw.plotItem.toolBar.addWidget(self.showSpectra)
self.saveToPng = QToolButton()
self.saveToPng.setIcon(
QIcon(os.path.normcase('gui/icons/thumbnail.png')))
#self.saveToPng.setToolButtonStyle(2)
#self.saveToPng.setText("Save to Png...")
self.pw.plotItem.toolBar.addWidget(self.saveToPng)
self.connect(self.saveToPng, SIGNAL('clicked()'), self.pw.writeImage)
#add bar plot even if we are plotting chroma
#cause we can find non xcms peaks
self.barPlot = BarPlot(scene=self.pw.sceneObj)
#self.barPlot.rotate(-90.)
if self.flags == 'peak':
self.barPlot.setPeakGroup(self.data)
#TODO modify to get this close to us
#on the left part
xpos = self.barPlot.scene().width() * 3.5 #-bwidth;
ypos = self.barPlot.scene().height() * 1.1
self.barPlot.setPos(xpos, ypos)
self.barPlot.setZValue(1000)
layout.addWidget(self.pw)
layout.addWidget(self.pw.plotItem.toolBar)
def showTextLabel(self, x, y, secure=25):
"""
add labels of principle peaks of spectrum or chroma
on the plot, return the labels, that we can show hide
"""
maxis = [] #will contain tuple(rt, intens)
indexes = []
#from core.MetObjects import MSAbstractTypes
from scipy.ndimage import gaussian_filter1d as gauss
z = gauss(y, 1)
#z = MSAbstractTypes.computeBaseLine(z, 92., 0.8)
i = 0
while i < len(z) - 1:
while z[i + 1] >= z[i] and i < len(y) - 2:
i += 1
maxis.append((x[i], y[i]))
indexes.append(i)
while z[i + 1] <= z[i] and i < len(z) - 2:
i += 1
i += 1
labels = []
for t in sorted(maxis, key=lambda x: x[1])[-5:]:
g = QGraphicsTextItem(str(t[0]))
g.setFlag(QGraphicsItem.ItemIgnoresTransformations)
font = QApplication.font()
font.setPointSizeF(6.5)
g.setFont(font)
g.setDefaultTextColor(Qt.black)
g.setPos(t[0], t[1])
labels.append(g)
self.pw.addItem(g)
return labels
#===============================================================================
#SLOTS
#===============================================================================
def redrawAll(self, value):
self.pw.clear()
self._plotting(self.data)
def disHighlightOne(self, idx):
if not idx.isValid():
return
sample = self.model.sample(idx.data().toString(), fullNameEntry=False)
if sample is None:
return
try:
self.drawnItems[sample].setHighlighted(False)
except KeyError:
pass
def highlight(self, idx):
if not idx.isValid():
return
sample = self.model.sample(idx.data().toString(), fullNameEntry=False)
if sample is None:
return
try:
self.drawnItems[sample].setHighlighted(True)
except KeyError:
pass
#print "sample not found"
self.pw.plotItem.update() #works
def disHighlight(self):
for key in self.drawnItems.iterkeys():
self.drawnItems[key].setHighlighted(False)
self.pw.plotItem.update()
def setTextLabelsVisibility(self, bool_):
for t in self.textLabels:
t.setVisible(bool_)
def setDataPointsVisibility(self, b):
if self.dataPoints is None:
if self.flags == 'peak':
chrom = self.ref.sample.massExtraction(self.ref.mass(),
self.ref.sample.ppm,
asChromatogram=True)
self.dataPoints = ScatterPlotItem(x=chrom.x_data,
y=chrom.y_data)
else:
self.dataPoints = ScatterPlotItem(x=self.ref.x_data,
y=self.ref.y_data)
if self.flags != 'spectra':
self.dataPoints.sigClicked.connect(self.requestSpectra)
self.pw.addDataItem(self.dataPoints)
self.dataPoints.setVisible(b)
def setPixmapVisibility(self, bool_):
"""
draw other peaks than the xcms peak
"""
if not self.pixmaps and bool_:
ppm = 1. if self.ref.sample.kind == 'MRM' else self.ref.sample.ppm
chrom = self.ref.sample.massExtraction(self.ref.mass(), ppm, asChromatogram=True) \
if self.flags == 'peak' else self.ref
chrom.findNonXCMSPeaks()
for p in chrom.peaks.ipeaks():
if self.flags == 'peak':
diff = (p.height * 10) / 100
if abs(p.height - self.ref.height) < diff:
continue #we assume that they are the same peaks
pix = PeakIndicator(p, icon='flags')
#self.connect(pix, SIGNAL("highlightRequested"), c.setHighlighted)
self.connect(pix, SIGNAL('updateBarPlot'),
self.barPlot.setPeakGroup)
pix.setPos(p.rt, p.height + (p.height * 10) / 100.)
pix.setZValue(1000)
self.pixmaps.append(pix)
self.pw.addItem(pix)
if self.pixmaps:
for t in self.pixmaps:
t.setVisible(bool_)
@pyqtSlot()
def updateCurrentPeak(self):
idx = self.acTree.selectedIndexes()[0]
s = self.model.sample(idx.parent().data().toString(),
fullNameEntry=False)
if s is not None:
self.currentPeak = s.peakAt(*map(float,
idx.data().toString().split('/')))
def requestSpectra(self, scatter, l):
"""
idea plot all spectra between a time range
and not only with only one spectra
"""
if not l:
return
ref = l[0]
self.emit(SIGNAL("drawSpectrumByTime"), ref.pos(), self.ref.sample)
@pyqtSlot()
def drawSpectraRequested(self, bool_):
"""
i think this is for plotting merged spectrum
"""
if bool_:
self.emit(SIGNAL('drawSpectraRequested'), self.currentPeak)
else:
self.hideRequested()
def drawSpectra(self, l):
self.emit(
SIGNAL('drawSpectra(PyQt_PyObject, PyQt_PyObject, PyQt_PyObject)'),
l[0], l[1], self.ref.sample)
@pyqtSlot()
def hideRequested(self):
self.emit(SIGNAL('hideRequested'))
self.showMenu.actions()[1].setChecked(False)
@pyqtSlot()
def redraw(self):
"""
this is for updating the view port
when hiding or not samples
"""
chromas = []
for spl in self.model:
if spl.checked:
if spl in self.drawnItems.keys():
self.drawnItems[spl].setVisible(True)
else:
chromas.append(spl.chroma[0])
else:
self.drawnItems[spl].setVisible(False)
self._plotting(chromas)
self.pw.plotItem.update() #works
def cleanScene(self):
"""
remove all items in the trash
"""
for element in self.trashItems:
self.pw.sceneObj.removeItem(element)
@pyqtSlot()
def updateContextMenu(self, line):
self.flipMenu.addAction(line)
self.smoothMenu.addAction(line)
#===============================================================================
# CONTEXT MENU SLOTS
#===============================================================================
@pyqtSlot(str)
def flip(self, action):
spl = self.model.sample(self.fullXmlPath(action.text()))
if spl is None:
print "can not flip, can not recognize the selected sample"
return
try:
self.drawnItems[spl].updateData(-self.drawnItems[spl].getData()[1],
self.drawnItems[spl].getData()[0])
except KeyError:
pass
if len(self.data) == 1:
#we are flipping the text labels only
#if only one dataset is flipped
for item in self.textLabels:
item.setPos(item.pos().x(), -item.pos().y())
@pyqtSlot(str)
def smooth(self, action):
"""
TODO:
would be good to reuse the widget in the menuControl
"""
from core.MetObjects import MSAbstractTypes
class Dial(QDialog):
choices = ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']
def __init__(self, parent):
QDialog.__init__(self, parent)
f = QFormLayout(self)
self.a = QSpinBox(self)
self.a.setValue(30)
self.b = QComboBox(self)
self.b.addItems(self.choices)
self.c = QDialogButtonBox(self)
self.c.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
f.addRow("window:", self.a)
f.addRow("method:", self.b)
f.addRow("", self.c)
self.connect(self.c, SIGNAL("accepted()"), self.sendData)
self.connect(self.c, SIGNAL("rejected()"), self.reinitialize)
def sendData(self):
self.parent().window = self.a.value()
self.parent().method = self.b.currentText()
self.close()
def reinitialize(self):
self.parent().window = None
self.parent().method = None
self.close()
Dial(self).exec_()
if self.window and self.method:
for spl in self.drawnItems.keys():
if action.text() == spl.shortName():
self.drawnItems[spl].updateData(
MSAbstractTypes.averageSmoothing(
self.drawnItems[spl].getData()[1], self.window,
self.method), self.drawnItems[spl].getData()[0])
@pyqtSlot()
def plotEIC(self):
if self.flags == 'spectra':
#show double combobox
#select the good spectra then draw
pass
else:
mass, ok = QInputDialog.getText(self.view, "EIC query", "mass:")
if not (mass and ok):
return
xmlfile = self.fullXmlPath(self.selection[0].data().toString())
if not xmlfile:
xmlfile = self.fullXmlPath(
self.selection[0].parent().data().toString())
if not xmlfile:
print "item clicked not recognized..."
return
sample = self.model.sample(xmlfile)
if sample.kind == 'HighRes':
error = (sample.ppm / 1e6) * float(mass)
x, y = massExtraction(sample, float(mass), error)
from core.MetObjects import MSChromatogram
chrom = MSChromatogram(x_data=x, y_data=y, sample=sample)
else:
chrom = sample.getChromWithTrans(math.ceil(float(mass)))
self.view.addMdiSubWindow(
MSQtCanvas([chrom],
"EIC %s" % str(mass),
labels={
'bottom': 'RT(s)',
'left': 'INTENSITY'
}))
#===========================================================================
# annotate stuff
#===========================================================================
@pyqtSlot()
def annotate(self):
text, bool_ = QInputDialog.getText(self.view, "Annotation dialog",
"Annotation:")
g = QGraphicsTextItem(str(text))
g.setFlag(QGraphicsItem.ItemIgnoresTransformations)
g.setFlag(QGraphicsItem.ItemIsMovable)
g.setTextInteractionFlags(Qt.TextEditorInteraction)
font = qApp.instance().font()
font.setPointSizeF(10.)
g.setFont(font)
g.setDefaultTextColor(Qt.blue)
g.setPos(500, 1e4)
self.trashItems.append(g)
self.pw.addItem(g)
def removeAllAnnot(self):
if not self.trashItems:
self.view.showErrorMessage("Error", "No annotation detected")
return
for i in self.trashItems:
self.pw.removeItem(i)
def removeLastAnnot(self):
if not self.trashItems:
self.view.showErrorMessage("Error", "No annotation detected")
self.pw.removeItem(self.trashItems[-1])
def _setup_plot(self):
have_data = self.data is not None
have_matrix_transposed = self.matrix is not None and not self.matrix.axis
def column(data, variable):
a, _ = data.get_column_view(variable)
return a.ravel()
def attributes(matrix):
return matrix.row_items.domain.attributes
def scale(a):
dmin, dmax = numpy.nanmin(a), numpy.nanmax(a)
if dmax - dmin > 0:
return (a - dmin) / (dmax - dmin)
else:
return numpy.zeros_like(a)
if self._pen_data is None:
if self._selection_mask is not None:
pointflags = numpy.where(self._selection_mask,
mdsplotutils.Selected,
mdsplotutils.NoFlags)
else:
pointflags = None
if have_data and self.color_index > 0:
color_var = self.colorvar_model[self.color_index]
if color_var.is_discrete:
palette = colorpalette.ColorPaletteGenerator(
len(color_var.values))
else:
palette = None
color_data = mdsplotutils.color_data(
self.data, color_var, plotstyle=mdsplotutils.plotstyle)
color_data = numpy.hstack((color_data,
numpy.full((len(color_data), 1),
self.symbol_opacity)))
pen_data = mdsplotutils.pen_data(color_data, pointflags)
elif have_matrix_transposed and self.colorvar_model[
self.color_index] == 'Attribute names':
attr = attributes(self.matrix)
palette = colorpalette.ColorPaletteGenerator(len(attr))
color_data = [palette.getRGB(i) for i in range(len(attr))]
color_data = numpy.hstack(
color_data,
numpy.full((len(color_data), 1), self.symbol_opacity))
pen_data = mdsplotutils.pen_data(color_data, pointflags)
else:
pen_data = make_pen(QtGui.QColor(Qt.darkGray), cosmetic=True)
pen_data = numpy.full(len(self.data), pen_data, dtype=object)
self._pen_data = pen_data
if self._shape_data is None:
if have_data and self.shape_index > 0:
Symbols = ScatterPlotItem.Symbols
symbols = numpy.array(list(Symbols.keys()))
shape_var = self.shapevar_model[self.shape_index]
data = column(self.data, shape_var)
data = data % (len(Symbols) - 1)
data[numpy.isnan(data)] = len(Symbols) - 1
shape_data = symbols[data.astype(int)]
elif have_matrix_transposed and self.shapevar_model[
self.shape_index] == 'Attribute names':
Symbols = ScatterPlotItem.Symbols
symbols = numpy.array(list(Symbols.keys()))
attr = [
i % (len(Symbols) - 1)
for i, _ in enumerate(attributes(self.matrix))
]
shape_data = symbols[attr]
else:
shape_data = "o"
self._shape_data = shape_data
if self._size_data is None:
MinPointSize = 3
point_size = self.symbol_size + MinPointSize
if have_data and self.size_index == 1:
# size by stress
size_data = stress(self.embedding, self._effective_matrix.X)
size_data = scale(size_data)
size_data = MinPointSize + size_data * point_size
elif have_data and self.size_index > 0:
size_var = self.sizevar_model[self.size_index]
size_data = column(self.data, size_var)
size_data = scale(size_data)
size_data = MinPointSize + size_data * point_size
else:
size_data = point_size
if self._label_data is None:
if have_data and self.label_index > 0:
label_var = self.labelvar_model[self.label_index]
label_data = column(self.data, label_var)
label_data = [label_var.repr_val(val) for val in label_data]
label_items = [
pg.TextItem(text, anchor=(0.5, 0)) for text in label_data
]
elif have_matrix_transposed and self.labelvar_model[
self.label_index] == 'Attribute names':
attr = attributes(self.matrix)
label_items = [
pg.TextItem(str(text), anchor=(0.5, 0)) for text in attr
]
else:
label_items = None
self._label_data = label_items
self._scatter_item = item = ScatterPlotItem(
x=self.embedding[:, 0],
y=self.embedding[:, 1],
pen=self._pen_data,
symbol=self._shape_data,
brush=QtGui.QBrush(Qt.transparent),
size=size_data,
data=numpy.arange(len(self.data)),
antialias=True)
self.plot.addItem(item)
if self._label_data is not None:
for (x, y), text_item in zip(self.embedding, self._label_data):
self.plot.addItem(text_item)
text_item.setPos(x, y)
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
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 _setup_plot(self):
have_data = self.data is not None
have_matrix_transposed = self.matrix is not None and not self.matrix.axis
plotstyle = mdsplotutils.plotstyle
size = self._effective_matrix.shape[0]
def column(data, variable):
a, _ = data.get_column_view(variable)
return a.ravel()
def attributes(matrix):
return matrix.row_items.domain.attributes
def scale(a):
dmin, dmax = numpy.nanmin(a), numpy.nanmax(a)
if dmax - dmin > 0:
return (a - dmin) / (dmax - dmin)
else:
return numpy.zeros_like(a)
def jitter(x, factor=1, rstate=None):
if rstate is None:
rstate = numpy.random.RandomState()
elif not isinstance(rstate, numpy.random.RandomState):
rstate = numpy.random.RandomState(rstate)
span = numpy.nanmax(x) - numpy.nanmin(x)
if span < numpy.finfo(x.dtype).eps * 100:
span = 1
a = factor * span / 100.
return x + (rstate.random_sample(x.shape) - 0.5) * a
if self._pen_data is None:
if self._selection_mask is not None:
pointflags = numpy.where(
self._selection_mask,
mdsplotutils.Selected, mdsplotutils.NoFlags)
else:
pointflags = None
color_index = self.cb_color_value.currentIndex()
if have_data and color_index > 0:
color_var = self.colorvar_model[color_index]
if color_var.is_discrete:
palette = colorpalette.ColorPaletteGenerator(
len(color_var.values)
)
plotstyle = plotstyle.updated(discrete_palette=palette)
else:
palette = None
color_data = mdsplotutils.color_data(
self.data, color_var, plotstyle=plotstyle)
color_data = numpy.hstack(
(color_data,
numpy.full((len(color_data), 1), self.symbol_opacity,
dtype=float))
)
pen_data = mdsplotutils.pen_data(color_data * 0.8, pointflags)
brush_data = mdsplotutils.brush_data(color_data)
elif have_matrix_transposed and \
self.colorvar_model[color_index] == 'Attribute names':
attr = attributes(self.matrix)
palette = colorpalette.ColorPaletteGenerator(len(attr))
color_data = [palette.getRGB(i) for i in range(len(attr))]
color_data = numpy.hstack((
color_data,
numpy.full((len(color_data), 1), self.symbol_opacity,
dtype=float))
)
pen_data = mdsplotutils.pen_data(color_data * 0.8, pointflags)
brush_data = mdsplotutils.brush_data(color_data)
else:
pen_data = make_pen(QtGui.QColor(Qt.darkGray), cosmetic=True)
if self._selection_mask is not None:
pen_data = numpy.array(
[pen_data, plotstyle.selected_pen])
pen_data = pen_data[self._selection_mask.astype(int)]
else:
pen_data = numpy.full(self._effective_matrix.dim, pen_data,
dtype=object)
brush_data = numpy.full(
size, pg.mkColor((192, 192, 192, self.symbol_opacity)),
dtype=object)
if self._subset_mask is not None and have_data and \
self._subset_mask.shape == (size, ):
# clear brush fill for non subset data
brush_data[~self._subset_mask] = QtGui.QBrush(Qt.NoBrush)
self._pen_data = pen_data
self._brush_data = brush_data
if self._shape_data is None:
shape_index = self.cb_shape_value.currentIndex()
if have_data and shape_index > 0:
Symbols = ScatterPlotItem.Symbols
symbols = numpy.array(list(Symbols.keys()))
shape_var = self.shapevar_model[shape_index]
data = column(self.data, shape_var).astype(numpy.float)
data = data % (len(Symbols) - 1)
data[numpy.isnan(data)] = len(Symbols) - 1
shape_data = symbols[data.astype(int)]
elif have_matrix_transposed and \
self.shapevar_model[shape_index] == 'Attribute names':
Symbols = ScatterPlotItem.Symbols
symbols = numpy.array(list(Symbols.keys()))
attr = [i % (len(Symbols) - 1)
for i, _ in enumerate(attributes(self.matrix))]
shape_data = symbols[attr]
else:
shape_data = "o"
self._shape_data = shape_data
if self._size_data is None:
MinPointSize = 3
point_size = self.symbol_size + MinPointSize
size_index = self.cb_size_value.currentIndex()
if have_data and size_index == 1:
# size by stress
size_data = stress(self.embedding, self._effective_matrix)
size_data = scale(size_data)
size_data = MinPointSize + size_data * point_size
elif have_data and size_index > 0:
size_var = self.sizevar_model[size_index]
size_data = column(self.data, size_var)
size_data = scale(size_data)
size_data = MinPointSize + size_data * point_size
else:
size_data = point_size
self._size_data = size_data
if self._label_data is None:
label_index = self.cb_label_value.currentIndex()
if have_data and label_index > 0:
label_var = self.labelvar_model[label_index]
label_data = column(self.data, label_var)
label_data = [label_var.str_val(val) for val in label_data]
label_items = [pg.TextItem(text, anchor=(0.5, 0), color=0.0)
for text in label_data]
elif have_matrix_transposed and \
self.labelvar_model[label_index] == 'Attribute names':
attr = attributes(self.matrix)
label_items = [pg.TextItem(str(text), anchor=(0.5, 0))
for text in attr]
else:
label_items = None
self._label_data = label_items
emb_x, emb_y = self.embedding[:, 0], self.embedding[:, 1]
if self.jitter > 0:
_, jitter_factor = self.JitterAmount[self.jitter]
emb_x = jitter(emb_x, jitter_factor, rstate=42)
emb_y = jitter(emb_y, jitter_factor, rstate=667)
if self.connected_pairs and self.__draw_similar_pairs:
if self._similar_pairs is None:
# This code requires storing lower triangle of X (n x n / 2
# doubles), n x n / 2 * 2 indices to X, n x n / 2 indices for
# argsort result. If this becomes an issue, it can be reduced to
# n x n argsort indices by argsorting the entire X. Then we
# take the first n + 2 * p indices. We compute their coordinates
# i, j in the original matrix. We keep those for which i < j.
# n + 2 * p will suffice to exclude the diagonal (i = j). If the
# number of those for which i < j is smaller than p, we instead
# take i > j. Among those that remain, we take the first p.
# Assuming that MDS can't show so many points that memory could
# become an issue, I preferred using simpler code.
m = self._effective_matrix
n = len(m)
p = (n * (n - 1) // 2 * self.connected_pairs) // 100
indcs = numpy.triu_indices(n, 1)
sorted = numpy.argsort(m[indcs])[:p]
self._similar_pairs = fpairs = numpy.empty(2 * p, dtype=int)
fpairs[::2] = indcs[0][sorted]
fpairs[1::2] = indcs[1][sorted]
for i in range(int(len(emb_x[self._similar_pairs]) / 2)):
item = QtGui.QGraphicsLineItem(
emb_x[self._similar_pairs][i * 2],
emb_y[self._similar_pairs][i * 2],
emb_x[self._similar_pairs][i * 2 + 1],
emb_y[self._similar_pairs][i * 2 + 1]
)
pen = QtGui.QPen(QtGui.QBrush(QtGui.QColor(204, 204, 204)), 2)
pen.setCosmetic(True)
item.setPen(pen)
self.plot.addItem(item)
data = numpy.arange(size)
self._scatter_item = item = ScatterPlotItem(
x=emb_x, y=emb_y,
pen=self._pen_data, brush=self._brush_data, symbol=self._shape_data,
size=self._size_data, data=data,
antialias=True
)
self.plot.addItem(item)
if self._label_data is not None:
if self.label_only_selected:
if self._selection_mask is not None:
for (x, y), text_item, selected \
in zip(self.embedding, self._label_data,
self._selection_mask):
if selected:
self.plot.addItem(text_item)
text_item.setPos(x, y)
else:
for (x, y), text_item in zip(self.embedding, self._label_data):
self.plot.addItem(text_item)
text_item.setPos(x, y)
self._legend_item = LegendItem()
viewbox = self.plot.getViewBox()
self._legend_item.setParentItem(self.plot.getViewBox())
self._legend_item.setZValue(viewbox.zValue() + 10)
self._legend_item.restoreAnchor(self.legend_anchor)
color_var = shape_var = None
color_index = self.cb_color_value.currentIndex()
if have_data and 1 <= color_index < len(self.colorvar_model):
color_var = self.colorvar_model[color_index]
assert isinstance(color_var, Orange.data.Variable)
shape_index = self.cb_shape_value.currentIndex()
if have_data and 1 <= shape_index < len(self.shapevar_model):
shape_var = self.shapevar_model[shape_index]
assert isinstance(shape_var, Orange.data.Variable)
if shape_var is not None or \
(color_var is not None and color_var.is_discrete):
legend_data = mdsplotutils.legend_data(
color_var, shape_var, plotstyle=plotstyle)
for color, symbol, text in legend_data:
self._legend_item.addItem(
ScatterPlotItem(pen=color, brush=color, symbol=symbol,
size=10),
escape(text)
)
else:
self._legend_item.hide()
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)
if self.scatterplot_item_sel:
self.plot_widget.removeItem(self.scatterplot_item_sel)
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 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()
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.scatterplot_item_sel = ScatterPlotItem(
x=x_data, y=y_data, data=np.arange(self.n_points),
symbol=shape_data, size=size_data + SELECTION_WIDTH,
pen=color_data_sel, brush=brush_data_sel
)
self.plot_widget.addItem(self.scatterplot_item)
self.plot_widget.addItem(self.scatterplot_item_sel)
self.scatterplot_item.selected_points = []
self.scatterplot_item.sigClicked.connect(self.select_by_click)
self.update_labels()
self.make_legend()
self.view_box.init_history()
self.plot_widget.replot()
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.tag_history()
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 OWLinearProjection(widget.OWWidget):
name = "Linear Projection"
description = "A multi-axes projection of data to a two-dimension plane."
icon = "icons/LinearProjection.svg"
priority = 2000
inputs = [("Data", Orange.data.Table, "set_data", widget.Default),
("Data Subset", Orange.data.Table, "set_subset_data")]
# #TODO: Allow for axes to be supplied from an external source.
# ("Projection", numpy.ndarray, "set_axes"),]
outputs = [("Selected Data", Orange.data.Table)]
settingsHandler = settings.DomainContextHandler()
selected_variables = settings.ContextSetting(
[], required=settings.ContextSetting.REQUIRED
)
variable_state = settings.ContextSetting({})
color_index = settings.ContextSetting(0)
shape_index = settings.ContextSetting(0)
size_index = settings.ContextSetting(0)
label_index = settings.ContextSetting(0)
point_size = settings.Setting(10)
alpha_value = settings.Setting(255)
jitter_value = settings.Setting(0)
auto_commit = settings.Setting(True)
legend_anchor = settings.Setting(((1, 0), (1, 0)))
MinPointSize = 6
ReplotRequest = QEvent.registerEventType()
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.subset_data = None
self._subset_mask = None
self._selection_mask = None
self._item = None
self.__legend = None
self.__selection_item = None
self.__replot_requested = False
box = gui.widgetBox(self.controlArea, "Axes")
box1 = gui.widgetBox(box, "Displayed", margin=0)
box1.setFlat(True)
self.active_view = view = QListView(
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Ignored),
selectionMode=QListView.ExtendedSelection,
dragEnabled=True,
defaultDropAction=Qt.MoveAction,
dragDropOverwriteMode=False,
dragDropMode=QListView.DragDrop,
showDropIndicator=True,
minimumHeight=50,
)
view.viewport().setAcceptDrops(True)
movedown = QAction(
"Move down", view,
shortcut=QKeySequence(Qt.AltModifier | Qt.Key_Down),
triggered=self.__deactivate_selection
)
view.addAction(movedown)
self.varmodel_selected = model = DnDVariableListModel(
parent=self)
model.rowsInserted.connect(self._invalidate_plot)
model.rowsRemoved.connect(self._invalidate_plot)
model.rowsMoved.connect(self._invalidate_plot)
view.setModel(model)
box1.layout().addWidget(view)
box1 = gui.widgetBox(box, "Other", margin=0)
box1.setFlat(True)
self.other_view = view = QListView(
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Ignored),
selectionMode=QListView.ExtendedSelection,
dragEnabled=True,
defaultDropAction=Qt.MoveAction,
dragDropOverwriteMode=False,
dragDropMode=QListView.DragDrop,
showDropIndicator=True,
minimumHeight=50
)
view.viewport().setAcceptDrops(True)
moveup = QtGui.QAction(
"Move up", view,
shortcut=QKeySequence(Qt.AltModifier | Qt.Key_Up),
triggered=self.__activate_selection
)
view.addAction(moveup)
self.varmodel_other = model = DnDVariableListModel(parent=self)
view.setModel(model)
box1.layout().addWidget(view)
box = gui.widgetBox(self.controlArea, "Jittering")
gui.comboBox(box, self, "jitter_value",
items=["None", "0.01%", "0.1%", "0.5%", "1%", "2%"],
callback=self._invalidate_plot)
box.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
box = gui.widgetBox(self.controlArea, "Points")
box.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
self.colorvar_model = itemmodels.VariableListModel(parent=self)
self.shapevar_model = itemmodels.VariableListModel(parent=self)
self.sizevar_model = itemmodels.VariableListModel(parent=self)
self.labelvar_model = itemmodels.VariableListModel(parent=self)
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
spacing=8
)
box.layout().addLayout(form)
cb = gui.comboBox(box, self, "color_index",
callback=self._on_color_change)
cb.setModel(self.colorvar_model)
form.addRow("Colors", cb)
alpha_slider = QSlider(
Qt.Horizontal, minimum=10, maximum=255, pageStep=25,
tickPosition=QSlider.TicksBelow, value=self.alpha_value)
alpha_slider.valueChanged.connect(self._set_alpha)
form.addRow("Opacity", alpha_slider)
cb = gui.comboBox(box, self, "shape_index",
callback=self._on_shape_change)
cb.setModel(self.shapevar_model)
form.addRow("Shape", cb)
cb = gui.comboBox(box, self, "size_index",
callback=self._on_size_change)
cb.setModel(self.sizevar_model)
form.addRow("Size", cb)
size_slider = QSlider(
Qt.Horizontal, minimum=3, maximum=30, value=self.point_size,
pageStep=3,
tickPosition=QSlider.TicksBelow)
size_slider.valueChanged.connect(self._set_size)
form.addRow("", size_slider)
toolbox = gui.widgetBox(self.controlArea, "Zoom/Select")
toollayout = QtGui.QHBoxLayout()
toolbox.layout().addLayout(toollayout)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
# Main area plot
self.view = pg.GraphicsView(background="w")
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setFrameStyle(QtGui.QFrame.StyledPanel)
self.viewbox = pg.ViewBox(enableMouse=True, enableMenu=False)
self.viewbox.grabGesture(Qt.PinchGesture)
self.view.setCentralItem(self.viewbox)
self.mainArea.layout().addWidget(self.view)
self.selection = PlotSelectionTool(
self, selectionMode=PlotSelectionTool.Lasso)
self.selection.setViewBox(self.viewbox)
self.selection.selectionFinished.connect(self._selection_finish)
self.zoomtool = PlotZoomTool(self)
self.pantool = PlotPanTool(self)
self.pinchtool = PlotPinchZoomTool(self)
self.pinchtool.setViewBox(self.viewbox)
self.continuous_palette = colorpalette.ContinuousPaletteGenerator(
QtGui.QColor(220, 220, 220),
QtGui.QColor(0, 0, 0),
False
)
self.discrete_palette = colorpalette.ColorPaletteGenerator(13)
def icon(name):
path = "icons/Dlg_{}.png".format(name)
path = pkg_resources.resource_filename(widget.__name__, path)
return QtGui.QIcon(path)
actions = namespace(
zoomtofit=QAction(
"Zoom to fit", self, icon=icon("zoom_reset"),
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0),
triggered=lambda:
self.viewbox.setRange(QRectF(-1.05, -1.05, 2.1, 2.1))),
zoomin=QAction(
"Zoom in", self,
shortcut=QKeySequence(QKeySequence.ZoomIn),
triggered=lambda: self.viewbox.scaleBy((1 / 1.25, 1 / 1.25))),
zoomout=QAction(
"Zoom out", self,
shortcut=QKeySequence(QKeySequence.ZoomOut),
triggered=lambda: self.viewbox.scaleBy((1.25, 1.25))),
select=QAction(
"Select", self, checkable=True, icon=icon("arrow"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_1)),
zoom=QAction(
"Zoom", self, checkable=True, icon=icon("zoom"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_2)),
pan=QAction(
"Pan", self, checkable=True, icon=icon("pan_hand"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_3)),
)
self.addActions([actions.zoomtofit, actions.zoomin, actions.zoomout])
group = QtGui.QActionGroup(self, exclusive=True)
group.addAction(actions.select)
group.addAction(actions.zoom)
group.addAction(actions.pan)
actions.select.setChecked(True)
currenttool = self.selection
self.selection.setViewBox(None)
def activated(action):
nonlocal currenttool
if action is actions.select:
tool, cursor = self.selection, Qt.ArrowCursor
elif action is actions.zoom:
tool, cursor = self.zoomtool, Qt.ArrowCursor
elif action is actions.pan:
tool, cursor = self.pantool, Qt.OpenHandCursor
else:
assert False
currenttool.setViewBox(None)
tool.setViewBox(self.viewbox)
self.viewbox.setCursor(QtGui.QCursor(cursor))
currenttool = tool
group.triggered[QAction].connect(activated)
def button(action):
b = QtGui.QToolButton()
b.setDefaultAction(action)
return b
toollayout.addWidget(button(actions.select))
toollayout.addWidget(button(actions.zoom))
toollayout.addWidget(button(actions.pan))
toollayout.addSpacing(4)
toollayout.addWidget(button(actions.zoomtofit))
toollayout.addStretch()
toolbox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
def sizeHint(self):
return QSize(800, 500)
def clear(self):
self.data = None
self._subset_mask = None
self._selection_mask = None
self.varmodel_selected[:] = []
self.varmodel_other[:] = []
self.colorvar_model[:] = []
self.sizevar_model[:] = []
self.shapevar_model[:] = []
self.labelvar_model[:] = []
self.clear_plot()
def clear_plot(self):
if self._item is not None:
self._item.setParentItem(None)
self.viewbox.removeItem(self._item)
self._item = None
if self.__legend is not None:
anchor = legend_anchor_pos(self.__legend)
if anchor is not None:
self.legend_anchor = anchor
self.__legend.setParentItem(None)
self.__legend.clear()
self.__legend.setVisible(False)
self.viewbox.clear()
def _invalidate_plot(self):
"""
Schedule a delayed replot.
"""
if not self.__replot_requested:
self.__replot_requested = True
QApplication.postEvent(self, QEvent(self.ReplotRequest),
Qt.LowEventPriority - 10)
def set_data(self, data):
"""
Set the input dataset.
"""
self.closeContext()
self.clear()
self.data = data
if data is not None:
self._initialize(data)
# get the default encoded state, replacing the position with Inf
state = self._encode_var_state(
[list(self.varmodel_selected), list(self.varmodel_other)]
)
state = {key: (source_ind, numpy.inf) for key, (source_ind, _)
in state.items()}
self.openContext(data.domain)
selected_keys = [key for key, (sind, _) in self.variable_state.items()
if sind == 0]
if set(selected_keys).issubset(set(state.keys())):
pass
# update the defaults state (the encoded state must contain
# all variables in the input domain)
state.update(self.variable_state)
# ... and restore it with saved positions taking precedence over
# the defaults
selected, other = self._decode_var_state(
state, [list(self.varmodel_selected),
list(self.varmodel_other)]
)
self.varmodel_selected[:] = selected
self.varmodel_other[:] = other
self._invalidate_plot()
def set_subset_data(self, subset):
"""
Set the supplementary input subset dataset.
"""
self.subset_data = subset
self._subset_mask = None
def handleNewSignals(self):
if self.subset_data is not None and self._subset_mask is None:
# Update the plot's highlight items
if self.data is not None:
dataids = self.data.ids.ravel()
subsetids = numpy.unique(self.subset_data.ids)
self._subset_mask = numpy.in1d(
dataids, subsetids, assume_unique=True)
self._invalidate_plot()
self.commit()
def customEvent(self, event):
if event.type() == OWLinearProjection.ReplotRequest:
self.__replot_requested = False
self._setup_plot()
else:
super().customEvent(event)
def closeContext(self):
self.variable_state = self._encode_var_state(
[list(self.varmodel_selected), list(self.varmodel_other)]
)
super().closeContext()
def _encode_var_state(self, lists):
return {(type(var), var.name): (source_ind, pos)
for source_ind, var_list in enumerate(lists)
for pos, var in enumerate(var_list)
if isinstance(var, Orange.data.Variable)}
def _decode_var_state(self, state, lists):
all_vars = reduce(list.__iadd__, lists, [])
newlists = [[] for _ in lists]
for var in all_vars:
source, pos = state[(type(var), var.name)]
newlists[source].append((pos, var))
return [[var for _, var in sorted(newlist, key=itemgetter(0))]
for newlist in newlists]
def color_var(self):
"""
Current selected color variable or None (if not selected).
"""
if 1 <= self.color_index < len(self.colorvar_model):
return self.colorvar_model[self.color_index]
else:
return None
def size_var(self):
"""
Current selected size variable or None (if not selected).
"""
if 1 <= self.size_index < len(self.sizevar_model):
return self.sizevar_model[self.size_index]
else:
return None
def shape_var(self):
"""
Current selected shape variable or None (if not selected).
"""
if 1 <= self.shape_index < len(self.shapevar_model):
return self.shapevar_model[self.shape_index]
else:
return None
def _initialize(self, data):
# Initialize the GUI controls from data's domain.
all_vars = list(data.domain.variables)
cont_vars = [var for var in data.domain.variables
if var.is_continuous]
disc_vars = [var for var in data.domain.variables
if var.is_discrete]
string_vars = [var for var in data.domain.variables
if var.is_string]
self.all_vars = data.domain.variables
self.varmodel_selected[:] = cont_vars[:3]
self.varmodel_other[:] = cont_vars[3:]
self.colorvar_model[:] = ["Same color"] + all_vars
self.sizevar_model[:] = ["Same size"] + cont_vars
self.shapevar_model[:] = ["Same shape"] + disc_vars
self.labelvar_model[:] = ["No label"] + string_vars
if data.domain.has_discrete_class:
self.color_index = all_vars.index(data.domain.class_var) + 1
def __activate_selection(self):
view = self.other_view
model = self.varmodel_other
indices = view.selectionModel().selectedRows()
variables = [model.data(ind, Qt.EditRole) for ind in indices]
for i in sorted((ind.row() for ind in indices), reverse=True):
del model[i]
self.varmodel_selected.extend(variables)
def __deactivate_selection(self):
view = self.active_view
model = self.varmodel_selected
indices = view.selectionModel().selectedRows()
variables = [model.data(ind, Qt.EditRole) for ind in indices]
for i in sorted((ind.row() for ind in indices), reverse=True):
del model[i]
self.varmodel_other.extend(variables)
def _get_data(self, var):
"""Return the column data for variable `var`."""
X, _ = self.data.get_column_view(var)
return X.ravel()
def _setup_plot(self):
self.__replot_requested = False
self.clear_plot()
variables = list(self.varmodel_selected)
if not variables:
return
coords = [self._get_data(var) for var in variables]
coords = numpy.vstack(coords)
p, N = coords.shape
assert N == len(self.data), p == len(variables)
axes = linproj.defaultaxes(len(variables))
assert axes.shape == (2, p)
mask = ~numpy.logical_or.reduce(numpy.isnan(coords), axis=0)
coords = coords[:, mask]
X, Y = numpy.dot(axes, coords)
X = plotutils.normalized(X)
Y = plotutils.normalized(Y)
pen_data, brush_data = self._color_data(mask)
size_data = self._size_data(mask)
shape_data = self._shape_data(mask)
if self.jitter_value > 0:
value = [0, 0.01, 0.1, 0.5, 1, 2][self.jitter_value]
rstate = numpy.random.RandomState(0)
jitter_x = (rstate.random_sample(X.shape) * 2 - 1) * value / 100
rstate = numpy.random.RandomState(1)
jitter_y = (rstate.random_sample(Y.shape) * 2 - 1) * value / 100
X += jitter_x
Y += jitter_y
self._item = ScatterPlotItem(
X, Y,
pen=pen_data,
brush=brush_data,
size=size_data,
shape=shape_data,
antialias=True,
data=numpy.arange(len(self.data))[mask]
)
self._item._mask = mask
self.viewbox.addItem(self._item)
for i, axis in enumerate(axes.T):
axis_item = AxisItem(line=QLineF(0, 0, axis[0], axis[1]),
label=variables[i].name)
self.viewbox.addItem(axis_item)
self.viewbox.setRange(QtCore.QRectF(-1.05, -1.05, 2.1, 2.1))
self._update_legend()
def _color_data(self, mask=None):
color_var = self.color_var()
if color_var is not None:
color_data = self._get_data(color_var)
if color_var.is_continuous:
color_data = plotutils.continuous_colors(color_data)
else:
color_data = plotutils.discrete_colors(
color_data, len(color_var.values)
)
if mask is not None:
color_data = color_data[mask]
pen_data = numpy.array(
[pg.mkPen((r, g, b, self.alpha_value / 2))
for r, g, b in color_data],
dtype=object)
brush_data = numpy.array(
[pg.mkBrush((r, g, b, self.alpha_value))
for r, g, b in color_data],
dtype=object)
else:
color = QtGui.QColor(Qt.lightGray)
color.setAlpha(self.alpha_value)
pen_data = QtGui.QPen(color)
pen_data.setCosmetic(True)
color = QtGui.QColor(Qt.darkGray)
color.setAlpha(self.alpha_value)
brush_data = QtGui.QBrush(color)
if self._subset_mask is not None:
assert self._subset_mask.shape == (len(self.data),)
if mask is not None:
subset_mask = self._subset_mask[mask]
else:
subset_mask = self._subset_mask
if isinstance(brush_data, QtGui.QBrush):
brush_data = numpy.array([brush_data] * subset_mask.size,
dtype=object)
brush_data[~subset_mask] = QtGui.QBrush(Qt.NoBrush)
if self._selection_mask is not None:
assert self._selection_mask.shape == (len(self.data),)
if mask is not None:
selection_mask = self._selection_mask[mask]
else:
selection_mask = self._selection_mask
if isinstance(pen_data, QtGui.QPen):
pen_data = numpy.array([pen_data] * selection_mask.size,
dtype=object)
pen_data[selection_mask] = pg.mkPen((200, 200, 0, 150), width=4)
return pen_data, brush_data
def _on_color_change(self):
if self.data is None or self._item is None:
return
pen, brush = self._color_data()
if isinstance(pen, QtGui.QPen):
# Reset the brush for all points
self._item.data["pen"] = None
self._item.setPen(pen)
else:
self._item.setPen(pen[self._item._mask])
if isinstance(brush, QtGui.QBrush):
# Reset the brush for all points
self._item.data["brush"] = None
self._item.setBrush(brush)
else:
self._item.setBrush(brush[self._item._mask])
self._update_legend()
def _shape_data(self, mask):
shape_var = self.shape_var()
if shape_var is None:
shape_data = numpy.array(["o"] * len(self.data))
else:
assert shape_var.is_discrete
max_symbol = len(ScatterPlotItem.Symbols) - 1
shape = self._get_data(shape_var)
shape_mask = numpy.isnan(shape)
shape = shape % (max_symbol - 1)
shape[shape_mask] = max_symbol
symbols = numpy.array(list(ScatterPlotItem.Symbols))
shape_data = symbols[numpy.asarray(shape, dtype=int)]
if mask is None:
return shape_data
else:
return shape_data[mask]
def _on_shape_change(self):
if self.data is None:
return
self.set_shape(self._shape_data(mask=None))
self._update_legend()
def _size_data(self, mask=None):
size_var = self.size_var()
if size_var is None:
size_data = numpy.full((len(self.data),), self.point_size)
else:
size_data = plotutils.normalized(self._get_data(size_var))
size_data -= numpy.nanmin(size_data)
size_mask = numpy.isnan(size_data)
size_data = \
size_data * self.point_size + OWLinearProjection.MinPointSize
size_data[size_mask] = OWLinearProjection.MinPointSize - 2
if mask is None:
return size_data
else:
return size_data[mask]
def _on_size_change(self):
if self.data is None:
return
self.set_size(self._size_data(mask=None))
def _update_legend(self):
if self.__legend is None:
self.__legend = legend = LegendItem()
legend.setParentItem(self.viewbox)
legend.setZValue(self.viewbox.zValue() + 10)
legend.anchor(*self.legend_anchor)
else:
legend = self.__legend
legend.clear()
color_var, shape_var = self.color_var(), self.shape_var()
if color_var is not None and not color_var.is_discrete:
color_var = None
assert shape_var is None or shape_var.is_discrete
if color_var is None and shape_var is None:
legend.setParentItem(None)
legend.hide()
return
else:
if legend.parentItem() is None:
legend.setParentItem(self.viewbox)
legend.setVisible(True)
palette = self.discrete_palette
symbols = list(ScatterPlotItem.Symbols)
if shape_var is color_var:
items = [(palette[i], symbols[i], name)
for i, name in enumerate(color_var.values)]
else:
colors = shapes = []
if color_var is not None:
colors = [(palette[i], "o", name)
for i, name in enumerate(color_var.values)]
if shape_var is not None:
shapes = [(QtGui.QColor(Qt.gray),
symbols[i % (len(symbols) - 1)], name)
for i, name in enumerate(shape_var.values)]
items = colors + shapes
for color, symbol, name in items:
legend.addItem(
ScatterPlotItem(pen=color, brush=color, symbol=symbol, size=10),
name
)
def set_shape(self, shape):
"""
Set (update) the current point shape map.
"""
if self._item is not None:
self._item.setSymbol(shape[self._item._mask])
def set_size(self, size):
"""
Set (update) the current point size.
"""
if self._item is not None:
self._item.setSize(size[self._item._mask])
def _set_alpha(self, value):
self.alpha_value = value
self._on_color_change()
def _set_size(self, value):
self.point_size = value
self._on_size_change()
def _selection_finish(self, path):
self.select(path)
def select(self, selectionshape):
item = self._item
if item is None:
return
indices = [spot.data()
for spot in item.points()
if selectionshape.contains(spot.pos())]
if QApplication.keyboardModifiers() & Qt.ControlModifier:
self.select_indices(indices)
else:
self._selection_mask = None
self.select_indices(indices)
def select_indices(self, indices):
if self.data is None:
return
if self._selection_mask is None:
self._selection_mask = numpy.zeros(len(self.data), dtype=bool)
self._selection_mask[indices] = True
self._on_color_change()
self.commit()
def commit(self):
subset = None
if self.data is not None and self._selection_mask is not None:
indices = numpy.flatnonzero(self._selection_mask)
if len(indices) > 0:
subset = self.data[indices]
self.send("Selected Data", subset)
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)
if self.scatterplot_item_sel:
self.plot_widget.removeItem(self.scatterplot_item_sel)
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 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()
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.scatterplot_item_sel = ScatterPlotItem(
x=x_data,
y=y_data,
data=np.arange(self.n_points),
symbol=shape_data,
size=size_data + SELECTION_WIDTH,
pen=color_data_sel,
brush=brush_data_sel)
self.plot_widget.addItem(self.scatterplot_item)
self.plot_widget.addItem(self.scatterplot_item_sel)
self.scatterplot_item.selected_points = []
self.scatterplot_item.sigClicked.connect(self.select_by_click)
self.update_labels()
self.make_legend()
self.view_box.init_history()
self.plot_widget.replot()
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.tag_history()
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()
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])
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 update_data(self, attr_x, attr_y, reset_view=True):
self.shown_x = attr_x
self.shown_y = attr_y
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", "")
if self.scaled_data is None or not len(self.scaled_data):
self.valid_data = None
self.selection = 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],
also_class_if_exists=False)
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)
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 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()
class MSQtCanvas(QWidget, MSDialogController):
"""
DONE:the current peak is not updated while the user press up and down key on the treeView
TODO: think about a mjor redesign of those classes
"""
#linePlotted = pyqtSignal(object, str)
#lineRemoved = pyqtSignal(object)
def __init__(self, data, title, flags="chroma", parent=None, **k):
QWidget.__init__(self, parent)
MSDialogController.__init__(self, 0, parent)
self.model = self.qApp.model
self.view = self.qApp.view
self.data=data
self.title=title
self.flags=flags
if self.flags == 'peak':
if self.acTree not in (self.view.treeView_2, self.view.treeView_3):
print "Unknown Error"
return
idx=self.acTree.selectedIndexes()[0]
s = qApp.instance().dockControl.currentSample[1 if self.acTree is self.view.treeView_2 else 2]
if s is None:
print "unknow error"
return
values = map(float, idx.data().toString().split('/')[:2])
self.currentPeak = s.peakAt(*values)
#connection to update the selected Peak object
self.connect(self.acTree, SIGNAL("changedLine"), self.updateCurrentPeak)
self.minX, self.maxX, self.maxY = [0] * 3
#if flags != 'peak':
# self.minX, self.maxX, self.maxY = self.getMax()
self.pw = PlotWidget(self.minX, self.maxX, self.maxY, parent=self, **k)#parent=self,
#self.pw.setAttribute(Qt.WA_DeleteOnClose)#plotItem.setAttribute(Qt.WA_PaintOnScreen & Qt.WA_PaintUnclipped)
if k.get('antialiased', False):
self.pw.setRenderHint(0x01)#antialiasing i suppose
self.pw.setTitle(title)
self.pw.updateGrid()
self._setupUi()
self.connect(self, SIGNAL('linePlotted'), self.updateContextMenu)
self.connect(self.view.sampleTableView, SIGNAL("disHighlightRequested(QModelIndex)"), self.disHighlightOne)
self.connect(self.view.sampleTableView, SIGNAL("highlightRequested(QModelIndex)"), self.highlight)
self.connect(self.view.sampleTableView, SIGNAL("noHighlightRequested()"), self.disHighlight)
self.connect(self.view.ppmEditer, SIGNAL('valueChanged(double)'), self.redrawAll)
self.drawnItems = {}
self.trashItems=[]#why unecessary? nope to collect annotation stuff
self.textLabels = []
self.pixmaps = []
self.dataPoints = None
self._plotting(self.data)#initial plotting
def getMax(self):
localXmin =[]
localXmax = []
localYmax = []
for el in self.data:
if el is None:
continue
localXmin.append(min_f(el.x_data))
localXmax.append(max_f(el.x_data))
localYmax.append(max_l(el.y_data))
return min_f(np.array(localXmin)), max_f(np.array(localXmax)), max_l(np.array(localYmax))
def _plotting(self, data):
"""
refactor this shit
c = Line(chrom.x_data, chrom.y_data,
QColor.fromRgbF(*(self.ref.sample.color+(.7,))),
parent=self.pw.plotItem.vb,
scene=self.pw.scene())
#test scatter plot
self.scatter = ScatterPlotItem(x=chrom.x_data, y=chrom.y_data)
self.pw.addDataItem(self.scatter)
self.scatter.sigClicked.connect(self.requestSpectra)
"""
if self.flags == 'peak':
self.connect(self.pw.plotItem.vb, SIGNAL('showDiffOrSpectra(PyQt_PyObject)'), self.drawSpectra)
self.ref = sorted([e for e in data if e is not None], key=lambda x:x.height)[-1]
ppm = self.view.ppmEditer.value() if self.view.usePpm.isChecked() else self.ref.sample.ppm
chrom = self.ref.sample.massExtraction(self.ref.mass(),
ppm,
asChromatogram=True)
#show labels
self.textLabels += self.showTextLabel(chrom.x_data, chrom.y_data)
#drawing
color = QColor.fromRgbF(*self.ref.sample.color +(.5, ))
c = self.pw.plotItem.plot(chrom.x_data, chrom.y_data, pen=color)
self.drawnItems[self.ref.sample] = c
# peak's pixmap on the ref peak
pix= PeakArrowItem(self.ref,
pen=color,
brush=color,
pos=(self.ref.rt, self.ref.height + (self.ref.height * 6) / 100.),
angle=-90,
parent=self.pw.plotItem.vb)
pix.setZValue(1000)
self.pw.addItem(pix)
#both these connections are emitted
#in peak Indicator by effictivamente qApp
self.connect(qApp.instance(), SIGNAL("highlightRequested"), c.setHighlighted)
self.connect(qApp.instance(), SIGNAL('updateBarPlot'), self.barPlot.setPeakGroup) #
self.emit(SIGNAL('linePlotted'), self.ref.sample.shortName())
#if qApp.instance().lowMemory:
# chromatograms=[el.sample.loadAndExtract(el.mass(), el.sample.ppm, asChromatogram=True) \
# for el in data if el != ref and el is not None]
#else:
ppm = self.view.ppmEditer.value() if self.view.usePpm.isChecked() else self.ref.sample.ppm
chromatograms=[el.sample.massExtraction(el.mass(), ppm, asChromatogram=True) \
for el in data if el is not None and el != self.ref]
self.drawEics(chromatograms)
#initialisation zoom on the peak
self.pw.setYRange(0., self.ref.height + (self.ref.height * 12) / 100.)
self.pw.setXRange(self.ref.rtmin - 20, self.ref.rtmax + 20)
elif self.flags == 'chroma':
ref = [d for d in data if d is not None]
if not ref:
print "Error, empty data to plot"
return
self.ref = ref[0]
self.textLabels+=self.showTextLabel(self.ref.x_data, self.ref.y_data)
self.drawEics(data)
else:#spectrum
if not data:
#print "NOTHING TO PLOT"
return
self.ref = data[0]
for el in data:
c=SpectrumItem(el, centroid=True, scene=self.pw.scene())
self.pw.addItem(c)
self.drawnItems[el.sample] = c
self.pw.plotItem.curves.append(c)
self.emit(SIGNAL('linePlotted'), el.sample.shortName())
#just put time information
if data:
i=0
while data[i] is None and i < len(data):
i+=1
self.textLabels+=self.showTextLabel(data[i].x_data, data[i].y_data)
#setting the range
#warning: autoRange pw function does not work well
#on spectrum item
maxY = max([el.y_data.max() for el in data])
minX, maxX = min([el.x_data.min() for el in data]), max([el.x_data.max() for el in data])
self.pw.setXRange(minX, maxX, padding=0)
self.pw.setYRange(0., maxY, padding=0)
def drawEics(self, data):
for chrom in data:
color = QColor.fromRgbF(*(chrom.sample.color+(.5,)))
c=self.pw.plotItem.plot(x=chrom.x_data, y=chrom.y_data, pen=color)
#c = Line(chrom.x_data, chrom.y_data,
# color,
# parent=self.pw.plotItem.vb,
# scene=self.pw.scene())
self.drawnItems[chrom.sample] = c
#self.pw.addItem(c)
#self.pw.plotItem.curves.append(c)
self.emit(SIGNAL('linePlotted'), chrom.sample.shortName())
if self.flags != 'peaks':
self.pw.autoRange()
#===========================================================================
# UI stuffs
#===========================================================================
def _setupUi (self):
# self.stop = QToolButton()
# self.stop.setIcon(QIcon('gui/icons/tools_wizard.png'))
# self.stop.setToolTip('Enable or disable the appearance of the contextMenu')
layout=QVBoxLayout(self)
self.smoothButton=QToolButton()
#self.smoothButton.setToolButtonStyle(2)
self.smoothButton.setPopupMode(2)
self.smoothButton.setToolTip("Smooth the visualized data")
#self.smoothButton.setText("Smooth...")
self.smoothButton.setIcon(QIcon(os.path.normcase('gui/icons/smooth.png')))
self.smoothMenu = QMenu()
self.connect(self.smoothMenu, SIGNAL('triggered(QAction*)'), self.smooth)
self.smoothButton.setMenu(self.smoothMenu)
self.pw.plotItem.toolBar.addWidget(self.smoothButton)
self.flipButton=QToolButton()
#self.flipButton.setToolButtonStyle(2)
self.flipButton.setIcon(QIcon(os.path.normcase('gui/icons/flip.png')))
self.flipButton.setToolTip("Flip the visualized data")
#self.flipButton.setText("Flip...")
self.flipButton.setPopupMode(2)
self.flipMenu = QMenu()
self.connect(self.flipMenu, SIGNAL('triggered(QAction*)'), self.flip)
self.flipButton.setMenu(self.flipMenu)
self.pw.plotItem.toolBar.addWidget(self.flipButton)
self.annotButton=QToolButton()
#self.annotButton.setToolButtonStyle(2)
self.annotButton.setPopupMode(2)
#self.annotButton.setText("&Annotate...")
self.annotButton.setIcon(QIcon(os.path.normcase('gui/icons/attach.png')))
self.annotMenu = QMenu()
self.annotMenu.addAction("&Add Annotation")
self.annotMenu.addAction("&Remove last Annotation")
self.annotMenu.addAction("&Remove All Annotation")
self.annotButton.setMenu(self.annotMenu)
self.connect(self.annotMenu.actions()[0], SIGNAL("triggered()"), self.annotate)
self.connect(self.annotMenu.actions()[1], SIGNAL("triggered()"), self.removeLastAnnot)
self.connect(self.annotMenu.actions()[2], SIGNAL("triggered()"), self.removeAllAnnot)
self.pw.plotItem.toolBar.addWidget(self.annotButton)
self.addPlotButton=QToolButton()
#self.addPlotButton.setToolButtonStyle(2)
self.addPlotButton.setText("Add...")
self.addPlotButton.setIcon(QIcon(os.path.normcase('gui/icons/list_add.png')))
self.addPlotButton.setToolTip("Add a new plot to the current figure")
#self.addPlotButton.setText('&Add Plot')
self.pw.plotItem.toolBar.addWidget(self.addPlotButton)
self.showSpectra=QToolButton()
self.showSpectra.setPopupMode(2) #instant popup
#self.showSpectra.setToolButtonStyle(2)
self.showSpectra.setIcon(QIcon(os.path.normcase('gui/icons/file_export.png')))
#self.showSpectra.setText('&Show /hide...')
self.showSpectra.setToolTip('Show/hide ...')
self.showMenu=QMenu()
self.showTextLabels=QAction("&Show Labels", self.showMenu)
self.showTextLabels.setCheckable(True)
self.showTextLabels.setChecked(True)
self.showMenu.addAction(self.showTextLabels)
self.connect(self.showMenu.actions()[0], SIGNAL('toggled(bool)'), self.setTextLabelsVisibility)
showSpectrum=QAction("&Merged Spectrum", self.showMenu)
showSpectrum.setCheckable(True)
if self.flags == 'chroma' or self.flags == 'spectra':
showSpectrum.setEnabled(False)
self.showMenu.addAction(showSpectrum)
self.connect(self.showMenu.actions()[1], SIGNAL('toggled(bool)'), self.drawSpectraRequested)
showNonXCMSPeak=QAction("&Show Non XCMS Peak", self.showMenu)
showNonXCMSPeak.setCheckable(True)
if self.flags == 'spectra':
showNonXCMSPeak.setEnabled(False)
self.showMenu.addAction(showNonXCMSPeak)
self.connect(self.showMenu.actions()[2],
SIGNAL('toggled(bool)'),
self.setPixmapVisibility)
showDataPoints = QAction("&Show DataPoints", self.showMenu)
showDataPoints.setCheckable(True)
showDataPoints.setChecked(False)
self.showMenu.addAction(showDataPoints)
self.connect(self.showMenu.actions()[3],
SIGNAL('toggled(bool)'),
self.setDataPointsVisibility)
self.showSpectra.setMenu(self.showMenu)
self.pw.plotItem.toolBar.addWidget(self.showSpectra)
self.saveToPng = QToolButton()
self.saveToPng.setIcon(QIcon(os.path.normcase('gui/icons/thumbnail.png')))
#self.saveToPng.setToolButtonStyle(2)
#self.saveToPng.setText("Save to Png...")
self.pw.plotItem.toolBar.addWidget(self.saveToPng)
self.connect(self.saveToPng, SIGNAL('clicked()'), self.pw.writeImage)
#add bar plot even if we are plotting chroma
#cause we can find non xcms peaks
self.barPlot = BarPlot(scene=self.pw.sceneObj)
#self.barPlot.rotate(-90.)
if self.flags == 'peak':
self.barPlot.setPeakGroup(self.data)
#TODO modify to get this close to us
#on the left part
xpos = self.barPlot.scene().width()*3.5#-bwidth;
ypos = self.barPlot.scene().height()*1.1
self.barPlot.setPos(xpos,ypos)
self.barPlot.setZValue(1000)
layout.addWidget(self.pw)
layout.addWidget(self.pw.plotItem.toolBar)
def showTextLabel(self, x, y, secure=25):
"""
add labels of principle peaks of spectrum or chroma
on the plot, return the labels, that we can show hide
"""
maxis=[]#will contain tuple(rt, intens)
indexes=[]
#from core.MetObjects import MSAbstractTypes
from scipy.ndimage import gaussian_filter1d as gauss
z=gauss(y, 1)
#z = MSAbstractTypes.computeBaseLine(z, 92., 0.8)
i=0
while i <len(z)-1:
while z[i+1] >= z[i] and i < len(y)-2:
i+=1
maxis.append((x[i], y[i]))
indexes.append(i)
while z[i+1] <= z[i] and i<len(z)-2:
i+=1
i+=1
labels=[]
for t in sorted(maxis, key=lambda x:x[1])[-5:]:
g=QGraphicsTextItem(str(t[0]))
g.setFlag(QGraphicsItem.ItemIgnoresTransformations)
font=QApplication.font()
font.setPointSizeF(6.5)
g.setFont(font)
g.setDefaultTextColor(Qt.black)
g.setPos(t[0], t[1])
labels.append(g)
self.pw.addItem(g)
return labels
#===============================================================================
#SLOTS
#===============================================================================
def redrawAll(self, value):
self.pw.clear()
self._plotting(self.data)
def disHighlightOne(self, idx):
if not idx.isValid():
return
sample = self.model.sample(idx.data().toString(), fullNameEntry=False)
if sample is None:
return
try:
self.drawnItems[sample].setHighlighted(False)
except KeyError:
pass
def highlight(self, idx):
if not idx.isValid():
return
sample = self.model.sample(idx.data().toString(), fullNameEntry=False)
if sample is None:
return
try:
self.drawnItems[sample].setHighlighted(True)
except KeyError:
pass
#print "sample not found"
self.pw.plotItem.update()#works
def disHighlight(self):
for key in self.drawnItems.iterkeys():
self.drawnItems[key].setHighlighted(False)
self.pw.plotItem.update()
def setTextLabelsVisibility(self, bool_):
for t in self.textLabels:
t.setVisible(bool_)
def setDataPointsVisibility(self, b):
if self.dataPoints is None:
if self.flags == 'peak':
chrom = self.ref.sample.massExtraction(self.ref.mass(), self.ref.sample.ppm, asChromatogram=True)
self.dataPoints = ScatterPlotItem(x=chrom.x_data, y=chrom.y_data)
else:
self.dataPoints = ScatterPlotItem(x=self.ref.x_data, y=self.ref.y_data)
if self.flags != 'spectra':
self.dataPoints.sigClicked.connect(self.requestSpectra)
self.pw.addDataItem(self.dataPoints)
self.dataPoints.setVisible(b)
def setPixmapVisibility(self, bool_):
"""
draw other peaks than the xcms peak
"""
if not self.pixmaps and bool_:
ppm = 1. if self.ref.sample.kind=='MRM' else self.ref.sample.ppm
chrom = self.ref.sample.massExtraction(self.ref.mass(), ppm, asChromatogram=True) \
if self.flags == 'peak' else self.ref
chrom.findNonXCMSPeaks()
for p in chrom.peaks.ipeaks():
if self.flags == 'peak':
diff=(p.height*10)/100
if abs(p.height-self.ref.height) < diff:
continue #we assume that they are the same peaks
pix=PeakIndicator(p, icon='flags')
#self.connect(pix, SIGNAL("highlightRequested"), c.setHighlighted)
self.connect(pix, SIGNAL('updateBarPlot'), self.barPlot.setPeakGroup)
pix.setPos(p.rt, p.height + (p.height * 10) / 100.)
pix.setZValue(1000)
self.pixmaps.append(pix)
self.pw.addItem(pix)
if self.pixmaps:
for t in self.pixmaps:
t.setVisible(bool_)
@pyqtSlot()
def updateCurrentPeak(self):
idx=self.acTree.selectedIndexes()[0]
s=self.model.sample(idx.parent().data().toString(), fullNameEntry=False)
if s is not None:
self.currentPeak=s.peakAt(*map(float, idx.data().toString().split('/')))
def requestSpectra(self, scatter, l):
"""
idea plot all spectra between a time range
and not only with only one spectra
"""
if not l:
return
ref = l[0]
self.emit(SIGNAL("drawSpectrumByTime"), ref.pos(), self.ref.sample)
@pyqtSlot()
def drawSpectraRequested(self, bool_):
"""
i think this is for plotting merged spectrum
"""
if bool_:
self.emit(SIGNAL('drawSpectraRequested'), self.currentPeak)
else:
self.hideRequested()
def drawSpectra(self, l):
self.emit(SIGNAL('drawSpectra(PyQt_PyObject, PyQt_PyObject, PyQt_PyObject)'), l[0], l[1], self.ref.sample)
@pyqtSlot()
def hideRequested(self):
self.emit(SIGNAL('hideRequested'))
self.showMenu.actions()[1].setChecked(False)
@pyqtSlot()
def redraw(self):
"""
this is for updating the view port
when hiding or not samples
"""
chromas =[]
for spl in self.model:
if spl.checked:
if spl in self.drawnItems.keys():
self.drawnItems[spl].setVisible(True)
else:
chromas.append(spl.chroma[0])
else:
self.drawnItems[spl].setVisible(False)
self._plotting(chromas)
self.pw.plotItem.update()#works
def cleanScene(self):
"""
remove all items in the trash
"""
for element in self.trashItems:
self.pw.sceneObj.removeItem(element)
@pyqtSlot()
def updateContextMenu(self, line):
self.flipMenu.addAction(line)
self.smoothMenu.addAction(line)
#===============================================================================
# CONTEXT MENU SLOTS
#===============================================================================
@pyqtSlot(str)
def flip(self, action):
spl=self.model.sample(self.fullXmlPath(action.text()))
if spl is None:
print "can not flip, can not recognize the selected sample"
return
try:
self.drawnItems[spl].updateData(-self.drawnItems[spl].getData()[1],
self.drawnItems[spl].getData()[0])
except KeyError:
pass
if len(self.data) == 1:
#we are flipping the text labels only
#if only one dataset is flipped
for item in self.textLabels:
item.setPos(item.pos().x(), -item.pos().y())
@pyqtSlot(str)
def smooth(self, action):
"""
TODO:
would be good to reuse the widget in the menuControl
"""
from core.MetObjects import MSAbstractTypes
class Dial(QDialog):
choices =['flat', 'hanning', 'hamming', 'bartlett', 'blackman']
def __init__(self, parent):
QDialog.__init__(self, parent)
f =QFormLayout(self)
self.a =QSpinBox(self)
self.a.setValue(30)
self.b = QComboBox(self)
self.b.addItems(self.choices)
self.c= QDialogButtonBox(self)
self.c.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
f.addRow("window:" ,self.a)
f.addRow("method:", self.b)
f.addRow("", self.c)
self.connect(self.c, SIGNAL("accepted()"), self.sendData)
self.connect(self.c, SIGNAL("rejected()"), self.reinitialize)
def sendData(self):
self.parent().window = self.a.value()
self.parent().method = self.b.currentText()
self.close()
def reinitialize(self):
self.parent().window = None
self.parent().method = None
self.close()
Dial(self).exec_()
if self.window and self.method:
for spl in self.drawnItems.keys():
if action.text() == spl.shortName():
self.drawnItems[spl].updateData(
MSAbstractTypes.averageSmoothing(self.drawnItems[spl].getData()[1],self.window , self.method),
self.drawnItems[spl].getData()[0])
@pyqtSlot()
def plotEIC(self):
if self.flags == 'spectra':
#show double combobox
#select the good spectra then draw
pass
else:
mass, ok = QInputDialog.getText(self.view, "EIC query", "mass:")
if not (mass and ok):
return
xmlfile = self.fullXmlPath(self.selection[0].data().toString())
if not xmlfile:
xmlfile = self.fullXmlPath(self.selection[0].parent().data().toString())
if not xmlfile:
print "item clicked not recognized..."
return
sample = self.model.sample(xmlfile)
if sample.kind =='HighRes':
error=(sample.ppm/1e6)*float(mass)
x, y = massExtraction(sample, float(mass), error)
from core.MetObjects import MSChromatogram
chrom = MSChromatogram(x_data=x, y_data=y, sample=sample)
else:
chrom = sample.getChromWithTrans(math.ceil(float(mass)))
self.view.addMdiSubWindow(MSQtCanvas([chrom], "EIC %s"%str(mass),
labels={'bottom':'RT(s)', 'left':'INTENSITY'}))
#===========================================================================
# annotate stuff
#===========================================================================
@pyqtSlot()
def annotate(self):
text, bool_ = QInputDialog.getText(self.view, "Annotation dialog", "Annotation:")
g=QGraphicsTextItem(str(text))
g.setFlag(QGraphicsItem.ItemIgnoresTransformations)
g.setFlag(QGraphicsItem.ItemIsMovable)
g.setTextInteractionFlags(Qt.TextEditorInteraction)
font=qApp.instance().font()
font.setPointSizeF(10.)
g.setFont(font)
g.setDefaultTextColor(Qt.blue)
g.setPos(500,1e4)
self.trashItems.append(g)
self.pw.addItem(g)
def removeAllAnnot(self):
if not self.trashItems:
self.view.showErrorMessage("Error", "No annotation detected")
return
for i in self.trashItems:
self.pw.removeItem(i)
def removeLastAnnot(self):
if not self.trashItems:
self.view.showErrorMessage("Error", "No annotation detected")
self.pw.removeItem(self.trashItems[-1])
