def is_valid_url(self, url):
if is_valid_url(url):
self.Error.invalid_url.clear()
return True
self.Error.invalid_url()
QToolTip.showText(self.combo.mapToGlobal(QPoint(0, 0)),
self.combo.toolTip())
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 = ""
vars = self.master.model_selected
if len(points):
for i, p in enumerate(points):
index = p.data()
text += "Attributes:\n"
text += "".join(
" {} = {}\n".format(attr.name, self.data[index][attr])
for attr in vars)
if len(vars[:]) > 10:
text += " ... and {} others\n\n".format(len(vars[:]) - 12)
# class_var is always:
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
return False
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 = ""
attr = lambda i: self.domain.attributes[i]
if len(points):
for i, p in enumerate(points):
index = p.data()
text += "Attributes:\n"
text += "".join(" {} = {}\n".format(
attr(i).name, self.data[index][attr(i)])
for i in self.master.plotdata.topattrs[index])
if len(self.domain.attributes) > 10:
text += " ... and {} others\n\n".format(
len(self.domain.attributes) - 12)
# class_var is always:
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 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 = ""
vars = self.master.model_selected
if len(points):
for i, p in enumerate(points):
index = p.data()
text += "Attributes:\n"
text += "".join(
" {} = {}\n".format(attr.name, self.data[index][attr])
for attr in vars
)
if len(vars[:]) > 10:
text += " ... and {} others\n\n".format(len(vars[:]) - 12)
# class_var is always:
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
return False
def _handleHelpEvent(self, event):
# Handle a help event for the plot
viewbox = self.graph.getViewBox()
pos = viewbox.mapToView(viewbox.mapFromScene(event.scenePos()))
logr = pos.x()
logp = pos.y()
text = ""
points = []
if self.graph._item is not None:
points = self.graph._item.pointsAt(pos)
if points:
point = points[0]
pos = point.pos()
logr, logp = pos.x(), pos.y()
index = point.data()
text = ("<b>{index}</b><hr/>"
"log<sub>2</sub>(ratio): {logr:.5f}<br/>"
"p-value: {p:.5f}").format(logr=logr, p=10 ** -logp,
index=index)
if len(points) > 1:
text += "<br/>... (and {} not shown)".format(len(points) - 1)
else:
text = ""
QToolTip.showText(event.screenPos(), text, widget=self.graph)
return True
def _handleHelpEvent(self, event):
# Handle a help event for the plot
viewbox = self.graph.getViewBox()
pos = viewbox.mapToView(viewbox.mapFromScene(event.scenePos()))
logr = pos.x()
logp = pos.y()
text = ""
points = []
if self.graph._item is not None:
points = self.graph._item.pointsAt(pos)
if points:
point = points[0]
pos = point.pos()
logr, logp = pos.x(), pos.y()
index = point.data()
text = ("<b>{index}</b><hr/>"
"log<sub>2</sub>(ratio): {logr:.5f}<br/>"
"p-value: {p:.5f}").format(logr=logr,
p=10**-logp,
index=index)
if len(points) > 1:
text += "<br/>... (and {} not shown)".format(len(points) - 1)
else:
text = ""
QToolTip.showText(event.screenPos(), text, widget=self.graph)
return True
def mouseMoved(self, evt):
pos = evt[0]
if self.plot.sceneBoundingRect().contains(pos):
mousePoint = self.plot.vb.mapSceneToView(pos)
posx, posy = mousePoint.x(), mousePoint.y()
labels = []
for a, vs in sorted(self.reports.items()):
for v in vs:
if isinstance(v, tuple) and len(v) == 2:
if v[0] == "x":
labels.append(
("%0." + str(self.important_decimals[0]) + "f")
% v[1])
continue
labels.append(str(v))
labels = " ".join(labels)
self.crosshair_hidden = bool(labels)
if self.location and not labels:
fs = "%0." + str(self.important_decimals[0]) + "f %0." + str(
self.important_decimals[1]) + "f"
labels = fs % (posx, posy)
self.label.setText(labels, color=(0, 0, 0))
if self.curves and len(self.curves[0][0]): # need non-zero x axis!
cache = {}
bd = None
if self.markclosest and self.plot.vb.action != ZOOMING:
xpixel, ypixel = self.plot.vb.viewPixelSize()
distances = distancetocurves(self.curves[0],
posx,
posy,
xpixel,
ypixel,
r=self.MOUSE_RADIUS,
cache=cache)
try:
mindi = np.nanargmin(distances)
if distances[mindi] < self.MOUSE_RADIUS:
bd = mindi
except ValueError: # if all distances are NaN
pass
if self.highlighted != bd:
QToolTip.hideText()
if self.highlighted is not None and bd is None:
self.highlighted = None
self.highlighted_curve.hide()
if bd is not None:
self.highlighted = bd
x = self.curves[0][0]
y = self.curves[0][1][self.highlighted]
self.highlighted_curve.setData(x=x, y=y)
self.highlighted_curve.show()
self.vLine.setPos(posx)
self.hLine.setPos(posy)
self.viewhelpers_show()
else:
self.viewhelpers_hide()
def help_event(self, ev):
pos = self.plot.vb.mapSceneToView(ev.scenePos())
sel = self._points_at_pos(pos)
prepared = []
if sel is not None:
data, vals, points = self.data[sel], self.data_values[
sel], self.data_points[sel]
for d, v, p in zip(data, vals, points):
basic = "({}, {}): {}".format(p[0], p[1], v)
variables = [
v for v in self.data.domain.metas +
self.data.domain.class_vars
if v not in [self.attr_x, self.attr_y]
]
features = [
'{} = {}'.format(attr.name, d[attr]) for attr in variables
]
prepared.append("\n".join([basic] + features))
text = "\n\n".join(prepared)
if text:
text = ('<span style="white-space:pre">{}</span>'.format(
escape(text)))
QToolTip.showText(ev.screenPos(), text, widget=self.plotview)
return True
else:
return False
def help_event(self, ev):
text = ""
if self.highlighted is not None:
if self.viewtype == INDIVIDUAL:
index = self.sampled_indices[self.highlighted]
variables = self.data.domain.metas + self.data.domain.class_vars
text += "".join(
'{} = {}\n'.format(attr.name, self.data[index][attr])
for attr in variables)
elif self.viewtype == AVERAGE:
c = self.multiple_curves_info[self.highlighted]
nc = sum(c[2])
if c[0] is not None:
text += str(c[0]) + " "
if c[1]:
text += "({})".format(c[1])
if text:
text += "\n"
text += "{} curves".format(nc)
if text:
text = text.rstrip()
text = ('<span style="white-space:pre">{}</span>'.format(
escape(text)))
QToolTip.showText(ev.screenPos(), text, widget=self.plotview)
return True
else:
return False
def helpEvent(self, event, view, option, index):
if self.tooltip is not None:
# ... but can be an empty string, so the current tooltip is removed
QToolTip.showText(event.globalPos(), self.tooltip, view)
return True
else:
return super().helpEvent(event, view, option, index)
def graphicsscene_help_event(scene: QGraphicsScene,
event: QGraphicsSceneHelpEvent) -> None:
"""
Send the help event to every graphics item that is under the `event`
scene position.
"""
widget = event.widget()
if widget is not None and isinstance(widget.parentWidget(), QGraphicsView):
view = widget.parentWidget()
deviceTransform = view.viewportTransform()
else:
deviceTransform = QTransform()
items = scene.items(
event.scenePos(),
Qt.IntersectsItemShape,
Qt.DescendingOrder,
deviceTransform,
)
text = ""
event.setAccepted(False)
for item in items:
scene.sendEvent(item, event)
if event.isAccepted():
return
elif item.toolTip():
text = item.toolTip()
break
QToolTip.showText(event.screenPos(), text, event.widget())
event.setAccepted(bool(text))
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 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 test_tooltips(self):
data_in = Orange.data.Table("titanic")
res = Orange.evaluation.TestOnTrainingData(
data=data_in,
learners=[
Orange.classification.KNNLearner(),
Orange.classification.LogisticRegressionLearner()
],
store_data=True)
self.send_signal(self.widget.Inputs.evaluation_results, res)
self.widget.roc_averaging = OWROCAnalysis.Merge
self.widget.target_index = 0
self.widget.selected_classifiers = [0, 1]
vb = self.widget.plot.getViewBox()
vb.childTransform() # Force pyqtgraph to update transforms
curve = self.widget.plot_curves(self.widget.target_index, 0)
curve_merge = curve.merge()
view = self.widget.plotview
item = curve_merge.curve_item # type: pg.PlotCurveItem
# no tooltips to be shown
pos = item.mapToScene(0.0, 1.0)
pos = view.mapFromScene(pos)
mouseMove(view.viewport(), pos)
self.assertIs(self.widget._tooltip_cache, None)
# test single point
pos = item.mapToScene(0.22504, 0.45400)
pos = view.mapFromScene(pos)
mouseMove(view.viewport(), pos)
shown_thresh = self.widget._tooltip_cache[1]
self.assertTrue(QToolTip.isVisible())
np.testing.assert_almost_equal(shown_thresh, [0.40000], decimal=5)
pos = item.mapToScene(0.0, 0.0)
pos = view.mapFromScene(pos)
# test overlapping points
mouseMove(view.viewport(), pos)
shown_thresh = self.widget._tooltip_cache[1]
self.assertTrue(QToolTip.isVisible())
np.testing.assert_almost_equal(shown_thresh, [1.8, 1.89336], decimal=5)
# test that cache is invalidated when changing averaging mode
self.widget.roc_averaging = OWROCAnalysis.Threshold
self.widget._replot()
mouseMove(view.viewport(), pos)
shown_thresh = self.widget._tooltip_cache[1]
self.assertTrue(QToolTip.isVisible())
np.testing.assert_almost_equal(shown_thresh, [1, 1])
# test nan thresholds
self.widget.roc_averaging = OWROCAnalysis.Vertical
self.widget._replot()
mouseMove(view.viewport(), pos)
self.assertIs(self.widget._tooltip_cache, None)
def event(self, event: QEvent) -> bool:
if event.type() == QEvent.ToolTip and self.toolTip():
action = self.defaultAction()
if action is not None and action.toolTip():
text = tooltip_with_shortcut(action.toolTip(),
action.shortcut())
QToolTip.showText(event.globalPos(), text)
return True
return super().event(event)
def test_tooltips(self):
data_in = Orange.data.Table("titanic")
res = Orange.evaluation.TestOnTrainingData(
data=data_in,
learners=[Orange.classification.KNNLearner(),
Orange.classification.LogisticRegressionLearner()],
store_data=True
)
self.send_signal(self.widget.Inputs.evaluation_results, res)
self.widget.roc_averaging = OWROCAnalysis.Merge
self.widget.target_index = 0
self.widget.selected_classifiers = [0, 1]
vb = self.widget.plot.getViewBox()
vb.childTransform() # Force pyqtgraph to update transforms
curve = self.widget.plot_curves(self.widget.target_index, 0)
curve_merge = curve.merge()
view = self.widget.plotview
item = curve_merge.curve_item # type: pg.PlotCurveItem
# no tooltips to be shown
pos = item.mapToScene(0.0, 1.0)
pos = view.mapFromScene(pos)
mouseMove(view.viewport(), pos)
self.assertIs(self.widget._tooltip_cache, None)
# test single point
pos = item.mapToScene(0.22504, 0.45400)
pos = view.mapFromScene(pos)
mouseMove(view.viewport(), pos)
shown_thresh = self.widget._tooltip_cache[1]
self.assertTrue(QToolTip.isVisible())
np.testing.assert_almost_equal(shown_thresh, [0.40000], decimal=5)
pos = item.mapToScene(0.0, 0.0)
pos = view.mapFromScene(pos)
# test overlapping points
mouseMove(view.viewport(), pos)
shown_thresh = self.widget._tooltip_cache[1]
self.assertTrue(QToolTip.isVisible())
np.testing.assert_almost_equal(shown_thresh, [1.8, 1.89336], decimal=5)
# test that cache is invalidated when changing averaging mode
self.widget.roc_averaging = OWROCAnalysis.Threshold
self.widget._replot()
mouseMove(view.viewport(), pos)
shown_thresh = self.widget._tooltip_cache[1]
self.assertTrue(QToolTip.isVisible())
np.testing.assert_almost_equal(shown_thresh, [1, 1])
# test nan thresholds
self.widget.roc_averaging = OWROCAnalysis.Vertical
self.widget._replot()
mouseMove(view.viewport(), pos)
self.assertIs(self.widget._tooltip_cache, None)
def help_event(self, ev: QGraphicsSceneHelpEvent) -> bool:
if self.marg_prob_item is None:
return False
index = self.__get_index_at(
self.marg_prob_item.mapFromScene(ev.scenePos()))
if index is not None:
QToolTip.showText(ev.screenPos(), self.labels[index], widget=self)
return True
return False
def helpEvent(self, event: QGraphicsSceneHelpEvent):
idx = self.indexAt(self.mapFromScene(event.scenePos()))
if idx is not None:
rect = self.__textitems[idx].sceneBoundingRect()
viewport = event.widget()
view = viewport.parentWidget()
rect = view.mapFromScene(rect).boundingRect()
QToolTip.showText(event.screenPos(), self.__items[idx],
view, rect)
event.setAccepted(True)
def help_event(self, ev):
in_graph_coor = self.plot.mapSceneToView(ev.scenePos())
ctooltip = []
for vb, item in self.tooltip_items:
if isinstance(item, pg.PlotCurveItem) and item.mouseShape().contains(vb.mapSceneToView(ev.scenePos())):
ctooltip.append(item.tooltip)
elif isinstance(item, DistributionBarItem) and item.boundingRect().contains(vb.mapSceneToView(ev.scenePos())):
ctooltip.append(item.tooltip)
if ctooltip:
QToolTip.showText(ev.screenPos(), "\n\n".join(ctooltip), widget=self.plotview)
return True
return False
def help_event(self, ev):
if self.__dots is None:
return False
dot = self._dotAt(self.__dots.mapFromScene(ev.scenePos()))
if dot is not None and dot.data() is not None:
var, p, n = dot.data()
q = round(p / n * 100, 1)
text = f"{var.name}\nExpressed in {int(p)}/{int(n)} cells ({q}%)"
QToolTip.showText(ev.screenPos(), text, widget=self)
return True
else:
return False
def hide(self):
"""Override Qt method."""
self.completion_position = None
self.completion_list = None
self.clear()
self.textedit.setFocus()
tooltip = getattr(self.textedit, 'tooltip_widget', None)
if tooltip:
tooltip.hide()
QListWidget.hide(self)
QToolTip.hideText()
def help_event(self, ev):
in_graph_coor = self.plot.mapSceneToView(ev.scenePos())
ctooltip = []
for vb, item in self.tooltip_items:
if isinstance(item, pg.PlotCurveItem) and item.mouseShape().contains(vb.mapSceneToView(ev.scenePos())):
ctooltip.append(item.tooltip)
elif isinstance(item, DistributionBarItem) and item.boundingRect().contains(vb.mapSceneToView(ev.scenePos())):
ctooltip.append(item.tooltip)
if ctooltip:
QToolTip.showText(ev.screenPos(), "\n\n".join(ctooltip), widget=self.plotview)
return True
return False
def help_event(self, ev: QGraphicsSceneHelpEvent):
if self.bar_item is None:
return False
index = self.__get_index_at(self.bar_item.mapFromScene(ev.scenePos()))
text = ""
if index is not None:
text = self.master.get_tooltip(index)
if text:
QToolTip.showText(ev.screenPos(), text, widget=self)
return True
else:
return False
def help_event(self, event):
"""Tooltip"""
if not self.choropleth_items:
return False
act_pos = self.choropleth_items[0].mapFromScene(event.scenePos())
ci = next((ci for ci in self.choropleth_items
if ci.contains(act_pos)), None)
if ci is not None:
QToolTip.showText(event.screenPos(), ci.tooltip(),
widget=self.plot_widget)
return True
else:
return False
def helpEvent(self, event, view, option, index):
# reimplemented
# NOTE: This is a slot in Qt4, but is a virtual func in Qt5
value = index.data(Qt.EditRole)
if isinstance(value, tuple) and len(value) == 2:
try:
tooltip = tool_tip(value)
except ValueError:
return False
QToolTip.showText(event.globalPos(), tooltip, view)
return True
else:
return super().helpEvent(event, view, option, index)
def helpEvent(self, event, view, option, index):
# reimplemented
# NOTE: This is a slot in Qt4, but is a virtual func in Qt5
value = index.data(Qt.EditRole)
if isinstance(value, tuple) and len(value) == 2:
try:
tooltip = tool_tip(value)
except ValueError:
return False
QToolTip.showText(event.globalPos(), tooltip, view)
return True
else:
return super().helpEvent(event, view, option, index)
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
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
def event(self, event):
# type: (QEvent) -> bool
if event.type() == QEvent.ToolTip and self.toolTip():
action = self.defaultAction()
if action is not None:
text = "<span>{}</span> <kbd>{}</kbd>".format(
action.toolTip(),
action.shortcut().toString(QKeySequence.NativeText))
QToolTip.showText(event.globalPos(), text)
else:
QToolTip.hideText()
return True
else:
return super().event(event)
def event(self, event):
# type: (QEvent) -> bool
if event.type() == QEvent.ToolTip and self.toolTip():
action = self.defaultAction()
if action is not None:
text = "<span>{}</span> <kbd>{}</kbd>".format(
action.toolTip(),
action.shortcut().toString(QKeySequence.NativeText)
)
QToolTip.showText(event.globalPos(), text)
else:
QToolTip.hideText()
return True
else:
return super().event(event)
def show_tool_tip(pos: QPoint, text: str, widget: Optional[QWidget] = None,
rect=QRect(), elide=Qt.ElideRight):
"""
Show a plain text tool tip with limited length, eliding if necessary.
"""
if widget is not None:
screen = widget.screen()
else:
screen = QApplication.screenAt(pos)
font = QApplication.font("QTipLabel")
fm = QFontMetrics(font)
geom = screen.availableSize()
etext = fm.elidedText(text, elide, geom.width())
if etext != text:
text = f"<span>{etext}</span>"
QToolTip.showText(pos, text, widget, rect)
def test_tool_tips(self):
scene = GraphicsScene()
view = QGraphicsView(scene)
w = TextListWidget()
text = "A" * 10
w.setItems([text, text])
scene.addItem(w)
view.grab() # ensure w is laid out
wrect = view.mapFromScene(w.mapToScene(
w.contentsRect())).boundingRect()
p = QPoint(wrect.topLeft() + QPoint(5, 5))
ev = QHelpEvent(QHelpEvent.ToolTip, p, view.viewport().mapToGlobal(p))
try:
QApplication.sendEvent(view.viewport(), ev)
self.assertEqual(QToolTip.text(), text)
finally:
QToolTip.hideText()
def mouseDragEvent(self, ev, axis=None):
master = self.graph.master
if master.data is None or master.graph.data is None:
super().mouseDragEvent(ev, axis)
return
pos = self.childGroup.mapFromParent(ev.pos())
points = master.plotdata.points
np_pos = np.array([[pos.x(), pos.y()]])
distances = distance.cdist(np_pos, points[:, :2])
is_near = np.min(distances) < 0.1
if ev.button() != Qt.LeftButton or (ev.start and not is_near):
self.mouse_state = 2
if self.mouse_state == 2:
if ev.finish:
self.mouse_state = 0
super().mouseDragEvent(ev, axis)
return
ev.accept()
if ev.start:
self.setCursor(Qt.ClosedHandCursor)
self.mouse_state = 1
self.point_i = np.argmin(distances)
master.randomize_indices()
if self.mouse_state == 1:
if ev.finish:
self.setCursor(Qt.ArrowCursor)
self.mouse_state = 0
angle = np.arctan2(pos.y(), pos.x())
QToolTip.showText(
QPoint(ev.screenPos().x(), ev.screenPos().y()),
"{:.2f}".format(np.rad2deg(angle)),
)
points[self.point_i][0] = np.cos(angle)
points[self.point_i][1] = np.sin(angle)
if ev.finish:
master.setup_plot()
master.commit()
else:
master.manual_move()
self.graph.show_arc_arrow(pos.x(), pos.y())
def help_event(self, ev):
pos = self.plot.vb.mapSceneToView(ev.scenePos())
sel, wavenumber_ind = self._points_at_pos(pos)
prepared = []
if sel is not None:
prepared.append(str(self.wavenumbers[wavenumber_ind]))
for d in self.data[sel]:
variables = [v for v in self.data.domain.metas + self.data.domain.class_vars
if v not in [self.attr_x]]
features = ['{} = {}'.format(attr.name, d[attr]) for attr in variables]
features.append('value = {}'.format(d[wavenumber_ind]))
prepared.append("\n".join(features))
text = "\n\n".join(prepared)
if text:
text = ('<span style="white-space:pre">{}</span>'
.format(escape(text)))
QToolTip.showText(ev.screenPos(), text, widget=self.plotview)
return True
else:
return False
def help_event(self, ev):
pos = self.plot.vb.mapSceneToView(ev.scenePos())
sel = self._points_at_pos(pos)
prepared = []
if sel is not None:
data, vals, points = self.data[sel], self.data_values[sel], self.data_points[sel]
for d, v, p in zip(data, vals, points):
basic = "({}, {}): {}".format(p[0], p[1], v)
variables = [v for v in self.data.domain.metas + self.data.domain.class_vars
if v not in [self.attr_x, self.attr_y]]
features = ['{} = {}'.format(attr.name, d[attr]) for attr in variables]
prepared.append("\n".join([basic] + features))
text = "\n\n".join(prepared)
if text:
text = ('<span style="white-space:pre">{}</span>'
.format(escape(text)))
QToolTip.showText(ev.screenPos(), text, widget=self.plotview)
return True
else:
return False
def mouseDragEvent(self, ev, axis=None):
master = self.graph.master
if master.data is None or master.graph.data is None:
super().mouseDragEvent(ev, axis)
return
pos = self.childGroup.mapFromParent(ev.pos())
points = master.plotdata.points
np_pos = np.array([[pos.x(), pos.y()]])
distances = distance.cdist(np_pos, points[:, :2])
is_near = np.min(distances) < 0.1
if ev.button() != Qt.LeftButton or (ev.start and not is_near):
self.mouse_state = 2
if self.mouse_state == 2:
if ev.finish:
self.mouse_state = 0
super().mouseDragEvent(ev, axis)
return
ev.accept()
if ev.start:
self.setCursor(Qt.ClosedHandCursor)
self.mouse_state = 1
self.point_i = np.argmin(distances)
master.randomize_indices()
if self.mouse_state == 1:
if ev.finish:
self.setCursor(Qt.ArrowCursor)
self.mouse_state = 0
angle = np.arctan2(pos.y(), pos.x())
QToolTip.showText(
QPoint(ev.screenPos().x(), ev.screenPos().y()), "{:.2f}".format(np.rad2deg(angle)))
points[self.point_i][0] = np.cos(angle)
points[self.point_i][1] = np.sin(angle)
if ev.finish:
master.setup_plot()
master.commit()
else:
master.manual_move()
self.graph.show_arc_arrow(pos.x(), pos.y())
def mouseMoveEvent(self, e):
if hasattr(self, "pressed_arrow"):
canvas_position = self.mapToScene(e.pos())
y = min(1, max(0, self.inv_transform(yLeft, canvas_position.y())))
index, pos = self.pressed_arrow
attr = self.domain[self.attributes[index]]
old_condition = self.selection_conditions.get(attr.name, [0, 1])
old_condition[pos] = y
self.selection_conditions[attr.name] = old_condition
self.update_data(self.attributes, self.visualized_mid_labels)
if attr.is_continuous:
val = self.attr_values[attr][0] + old_condition[pos] * (
self.attr_values[attr][1] - self.attr_values[attr][0])
strVal = attr.name + "= %.2f" % val
QToolTip.showText(e.globalPos(), strVal)
if self.sendSelectionOnUpdate and self.auto_send_selection_callback:
self.auto_send_selection_callback()
else:
OWPlot.mouseMoveEvent(self, e)
def mouseMoveEvent(self, e):
if hasattr(self, "pressed_arrow"):
canvas_position = self.mapToScene(e.pos())
y = min(1, max(0, self.inv_transform(yLeft, canvas_position.y())))
index, pos = self.pressed_arrow
attr = self.domain[self.attributes[index]]
old_condition = self.selection_conditions.get(attr.name, [0, 1])
old_condition[pos] = y
self.selection_conditions[attr.name] = old_condition
self.update_data(self.attributes, self.visualized_mid_labels)
if attr.is_continuous:
val = self.attr_values[attr][0] + old_condition[pos] * (
self.attr_values[attr][1] - self.attr_values[attr][0])
strVal = attr.name + "= %.2f" % val
QToolTip.showText(e.globalPos(), strVal)
if self.sendSelectionOnUpdate and self.auto_send_selection_callback:
self.auto_send_selection_callback()
else:
OWPlot.mouseMoveEvent(self, e)
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 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 help_event(self, ev):
pos = self.plot.vb.mapSceneToView(ev.scenePos())
sel, wavenumber_ind = self._points_at_pos(pos)
prepared = []
if sel is not None:
prepared.append(str(self.wavenumbers[wavenumber_ind]))
for d in self.data[sel]:
variables = [
v for v in self.data.domain.metas +
self.data.domain.class_vars if v not in [self.attr_x]
]
features = [
'{} = {}'.format(attr.name, d[attr]) for attr in variables
]
features.append('value = {}'.format(d[wavenumber_ind]))
prepared.append("\n".join(features))
text = "\n\n".join(prepared)
if text:
text = ('<span style="white-space:pre">{}</span>'.format(
escape(text)))
QToolTip.showText(ev.screenPos(), text, widget=self.plotview)
return True
else:
return False
def show_tip(widget: QWidget,
pos: QPoint,
text: str,
timeout=-1,
textFormat=Qt.AutoText,
wordWrap=None):
propname = __name__ + "::show_tip_qlabel"
if timeout < 0:
timeout = widget.toolTipDuration()
if timeout < 0:
timeout = 5000 + 40 * max(0, len(text) - 100)
tip = widget.property(propname)
if not text and tip is None:
return
def hide():
w = tip.parent()
w.setProperty(propname, None)
tip.timer.stop()
tip.close()
tip.deleteLater()
if not isinstance(tip, QLabel):
tip = QLabel(objectName="tip-label", focusPolicy=Qt.NoFocus)
tip.setBackgroundRole(QPalette.ToolTipBase)
tip.setForegroundRole(QPalette.ToolTipText)
tip.setPalette(QToolTip.palette())
tip.setFont(QApplication.font("QTipLabel"))
tip.timer = QTimer(tip, singleShot=True, objectName="hide-timer")
tip.timer.timeout.connect(hide)
widget.setProperty(propname, tip)
tip.setParent(widget, Qt.ToolTip)
tip.setText(text)
tip.setTextFormat(textFormat)
if wordWrap is None:
wordWrap = textFormat != Qt.PlainText
tip.setWordWrap(wordWrap)
if not text:
hide()
else:
tip.timer.start(timeout)
tip.show()
tip.move(pos)
def event(self, ev):
if ev.type() == QEvent.ToolTip:
x = self.inv_transform(xBottom, ev.pos().x())
y = self.inv_transform(yLeft, ev.pos().y())
canvas_position = self.mapToScene(ev.pos())
x_float = self.inv_transform(xBottom, canvas_position.x())
contact, (index,
pos) = self.testArrowContact(int(round(x_float)),
canvas_position.x(),
canvas_position.y())
if contact:
attr = self.domain[self.attributes[index]]
if attr.is_continuous:
condition = self.selection_conditions.get(
attr.name, [0, 1])
val = self.attr_values[attr][0] + condition[pos] * (
self.attr_values[attr][1] - self.attr_values[attr][0])
str_val = attr.name + "= %%.%df" % attr.number_of_decimals % val
QToolTip.showText(ev.globalPos(), str_val)
else:
for curve in self.items():
if type(curve) == PolygonCurve and \
curve.boundingRect().contains(x, y) and \
getattr(curve, "tooltip", None):
(name, value, total, dist) = curve.tooltip
count = sum([v[1] for v in dist])
if count == 0:
continue
tooltip_text = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>" \
"Total instances: <b>%i</b> (%.1f%%)<br>" \
"Class distribution:<br>" % (
name, value, count, 100.0 * count / float(total))
for (val, n) in dist:
tooltip_text += " <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % (
val, n, 100.0 * float(n) / float(count))
QToolTip.showText(ev.globalPos(), tooltip_text[:-4])
elif ev.type() == QEvent.MouseMove:
QToolTip.hideText()
return OWPlot.event(self, ev)
def event(self, ev):
if ev.type() == QEvent.ToolTip:
x = self.inv_transform(xBottom, ev.pos().x())
y = self.inv_transform(yLeft, ev.pos().y())
canvas_position = self.mapToScene(ev.pos())
x_float = self.inv_transform(xBottom, canvas_position.x())
contact, (index, pos) = self.testArrowContact(int(round(x_float)), canvas_position.x(),
canvas_position.y())
if contact:
attr = self.domain[self.attributes[index]]
if attr.is_continuous:
condition = self.selection_conditions.get(attr.name, [0, 1])
val = self.attr_values[attr][0] + condition[pos] * (
self.attr_values[attr][1] - self.attr_values[attr][0])
str_val = attr.name + "= %%.%df" % attr.number_of_decimals % val
QToolTip.showText(ev.globalPos(), str_val)
else:
for curve in self.items():
if type(curve) == PolygonCurve and \
curve.boundingRect().contains(x, y) and \
getattr(curve, "tooltip", None):
(name, value, total, dist) = curve.tooltip
count = sum([v[1] for v in dist])
if count == 0:
continue
tooltip_text = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>" \
"Total instances: <b>%i</b> (%.1f%%)<br>" \
"Class distribution:<br>" % (
name, value, count, 100.0 * count / float(total))
for (val, n) in dist:
tooltip_text += " <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % (
val, n, 100.0 * float(n) / float(count))
QToolTip.showText(ev.globalPos(), tooltip_text[:-4])
elif ev.type() == QEvent.MouseMove:
QToolTip.hideText()
return OWPlot.event(self, ev)
def is_valid_url(self, url):
if is_valid_url(url):
self.Error.invalid_url.clear()
return True
self.Error.invalid_url()
QToolTip.showText(self.combo.mapToGlobal(QPoint(0, 0)), self.combo.toolTip())
def _on_mouse_moved(self, pos):
target = self.target_index
selected = self.selected_classifiers
curves = [(clf_idx, self.plot_curves(target, clf_idx))
for clf_idx in selected] # type: List[Tuple[int, plot_curves]]
valid_thresh, valid_clf = [], []
pt, ave_mode = None, self.roc_averaging
for clf_idx, crv in curves:
if self.roc_averaging == OWROCAnalysis.Merge:
curve = crv.merge()
elif self.roc_averaging == OWROCAnalysis.Vertical:
curve = crv.avg_vertical()
elif self.roc_averaging == OWROCAnalysis.Threshold:
curve = crv.avg_threshold()
else:
# currently not implemented for 'Show Individual Curves'
return
sp = curve.curve_item.childItems()[0] # type: pg.ScatterPlotItem
act_pos = sp.mapFromScene(pos)
pts = sp.pointsAt(act_pos)
if len(pts) > 0:
mouse_pt = pts[0].pos()
if self._tooltip_cache:
cache_pt, cache_thresh, cache_clf, cache_ave = self._tooltip_cache
curr_thresh, curr_clf = [], []
if numpy.linalg.norm(mouse_pt - cache_pt) < 10e-6 \
and cache_ave == self.roc_averaging:
mask = numpy.equal(cache_clf, clf_idx)
curr_thresh = numpy.compress(mask, cache_thresh).tolist()
curr_clf = numpy.compress(mask, cache_clf).tolist()
else:
QToolTip.showText(QCursor.pos(), "")
self._tooltip_cache = None
if curr_thresh:
valid_thresh.append(*curr_thresh)
valid_clf.append(*curr_clf)
pt = cache_pt
continue
curve_pts = curve.curve.points
roc_points = numpy.column_stack((curve_pts.fpr, curve_pts.tpr))
diff = numpy.subtract(roc_points, mouse_pt)
# Find closest point on curve and save the corresponding threshold
idx_closest = numpy.argmin(numpy.linalg.norm(diff, axis=1))
thresh = curve_pts.thresholds[idx_closest]
if not numpy.isnan(thresh):
valid_thresh.append(thresh)
valid_clf.append(clf_idx)
pt = [curve_pts.fpr[idx_closest], curve_pts.tpr[idx_closest]]
if valid_thresh:
clf_names = self.classifier_names
msg = "Thresholds:\n" + "\n".join(["({:s}) {:.3f}".format(clf_names[i], thresh)
for i, thresh in zip(valid_clf, valid_thresh)])
QToolTip.showText(QCursor.pos(), msg)
self._tooltip_cache = (pt, valid_thresh, valid_clf, ave_mode)
