def __activeControlMoved(self, pos):
# The active control point has moved, update the control
# rectangle
control = self.__activeControl
pos = control.pos()
rect = QRectF(self.__rect)
margins = self.__margins
# TODO: keyboard modifiers and constraints.
anchor = control.anchor()
if anchor & ControlPoint.Top:
rect.setTop(pos.y() + margins.top())
elif anchor & ControlPoint.Bottom:
rect.setBottom(pos.y() - margins.bottom())
if anchor & ControlPoint.Left:
rect.setLeft(pos.x() + margins.left())
elif anchor & ControlPoint.Right:
rect.setRight(pos.x() - margins.right())
changed = self.__rect != rect
self.blockSignals(True)
self.setRect(rect)
self.blockSignals(False)
if changed:
self.rectEdited.emit(rect.normalized())
def testSelection(self, data):
"""
Given a
Parameters
----------
data : (N, 2) array
Point coordinates
"""
if len(data) == 0:
return numpy.zeros(0, dtype=bool)
def contained(a, left, top, right, bottom):
assert left <= right and bottom <= top
x, y = a.T
return (x >= left) & (x <= right) & (y <= top) & (y >= bottom)
data = numpy.asarray(data)
selected = numpy.zeros(len(data), dtype=bool)
for p1, p2 in self.selection:
r = QRectF(p1, p2).normalized()
# Note the inverted top/bottom (Qt coordinate system)
selected |= contained(data, r.left(), r.bottom(),
r.right(), r.top())
return selected
def setupGraphics(self):
"""
Set up the graphics.
"""
shape_rect = QRectF(-24, -24, 48, 48)
self.shapeItem = NodeBodyItem(self)
self.shapeItem.setShapeRect(shape_rect)
self.shapeItem.setAnimationEnabled(self.__animationEnabled)
# Rect for widget's 'ears'.
anchor_rect = QRectF(-31, -31, 62, 62)
self.inputAnchorItem = SinkAnchorItem(self)
input_path = QPainterPath()
start_angle = 180 - self.ANCHOR_SPAN_ANGLE / 2
input_path.arcMoveTo(anchor_rect, start_angle)
input_path.arcTo(anchor_rect, start_angle, self.ANCHOR_SPAN_ANGLE)
self.inputAnchorItem.setAnchorPath(input_path)
self.outputAnchorItem = SourceAnchorItem(self)
output_path = QPainterPath()
start_angle = self.ANCHOR_SPAN_ANGLE / 2
output_path.arcMoveTo(anchor_rect, start_angle)
output_path.arcTo(anchor_rect, start_angle, - self.ANCHOR_SPAN_ANGLE)
self.outputAnchorItem.setAnchorPath(output_path)
self.inputAnchorItem.hide()
self.outputAnchorItem.hide()
# Title caption item
self.captionTextItem = NameTextItem(self)
self.captionTextItem.setPlainText("")
self.captionTextItem.setPos(0, 33)
def iconItem(standard_pixmap):
item = GraphicsIconItem(self, icon=standard_icon(standard_pixmap),
iconSize=QSize(16, 16))
item.hide()
return item
self.errorItem = iconItem(QStyle.SP_MessageBoxCritical)
self.warningItem = iconItem(QStyle.SP_MessageBoxWarning)
self.infoItem = iconItem(QStyle.SP_MessageBoxInformation)
self.backgroundItem = QGraphicsPathItem(self)
backgroundrect = QPainterPath()
backgroundrect.addRoundedRect(anchor_rect.adjusted(-4, -2, 4, 2),
5, 5, mode=Qt.AbsoluteSize)
self.backgroundItem.setPen(QPen(Qt.NoPen))
self.backgroundItem.setBrush(self.palette().brush(QPalette.Highlight))
self.backgroundItem.setOpacity(0.5)
self.backgroundItem.setPath(backgroundrect)
self.backgroundItem.setZValue(-10)
self.backgroundItem.setVisible(self.isSelected())
self.prepareGeometryChange()
self.__boundingRect = None
def updateSelectionRect(self, event):
pos = event.scenePos()
buttonDownPos = event.buttonDownScenePos(Qt.LeftButton)
rect = QRectF(pos, buttonDownPos).normalized()
rect = rect.intersected(self.sceneRect())
if not self.selectionRect:
self.selectionRect = QGraphicsRectItem()
self.selectionRect.setBrush(QColor(10, 10, 10, 20))
self.selectionRect.setPen(QPen(QColor(200, 200, 200, 200)))
self.addItem(self.selectionRect)
self.selectionRect.setRect(rect)
self.selectionRectPointChanged.emit(pos)
def paintEvent(self, event):
if self.__pixmap.isNull():
return
sourcerect = QRect(QPoint(0, 0), self.__pixmap.size())
pixsize = QSizeF(self.__pixmap.size())
rect = self.contentsRect()
pixsize.scale(QSizeF(rect.size()), Qt.KeepAspectRatio)
targetrect = QRectF(QPointF(0, 0), pixsize)
targetrect.moveCenter(QPointF(rect.center()))
painter = QPainter(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(targetrect, self.__pixmap, QRectF(sourcerect))
painter.end()
def paintEvent(self, event):
pixmap = self._shadowPixmap
widget_rect = QRectF(QPointF(0.0, 0.0), QSizeF(self.size()))
frame_rect = QRectF(self.contentsRect())
left, top, right, bottom = self.getContentsMargins()
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self._shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self._shadowPixmapFragments(widget_rect, frame_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
def mousePressEvent(self, event):
pos = event.scenePos()
any_item = self.scene.item_at(pos)
if not any_item and event.button() & Qt.LeftButton:
self.modifiers = event.modifiers()
self.selection_rect = QRectF(pos, QSizeF(0, 0))
self.rect_item = QGraphicsRectItem(
self.selection_rect.normalized()
)
self.rect_item.setPen(
QPen(QBrush(QColor(51, 153, 255, 192)),
0.4, Qt.SolidLine, Qt.RoundCap)
)
self.rect_item.setBrush(
QBrush(QColor(168, 202, 236, 192))
)
self.rect_item.setZValue(-100)
# Clear the focus if necessary.
if not self.scene.stickyFocus():
self.scene.clearFocus()
if not self.modifiers & Qt.ControlModifier:
self.scene.clearSelection()
event.accept()
return True
else:
self.cancel(self.ErrorReason)
return False
def updateScaleBox(self, p1, p2):
"""
Overload to use ViewBox.mapToView instead of mapRectFromParent
mapRectFromParent (from Qt) uses QTransform.invert() which has
floating-point issues and can't invert the matrix with large
coefficients. ViewBox.mapToView uses invertQTransform from pyqtgraph.
This code, except for first three lines, are copied from the overloaded
method.
"""
p1 = self.mapToView(p1)
p2 = self.mapToView(p2)
r = QRectF(p1, p2)
self.rbScaleBox.setPos(r.topLeft())
self.rbScaleBox.resetTransform()
self.rbScaleBox.scale(r.width(), r.height())
self.rbScaleBox.show()
def setLine(self, line):
"""
Set the arrow base line (a `QLineF` in object coordinates).
"""
if self.__line != line:
self.__line = QLineF(line)
# local item coordinate system
geom = self.geometry().translated(-self.pos())
if geom.isNull() and not line.isNull():
geom = QRectF(0, 0, 1, 1)
arrow_shape = arrow_path_concave(line, self.lineWidth())
arrow_rect = arrow_shape.boundingRect()
if not (geom.contains(arrow_rect)):
geom = geom.united(arrow_rect)
if self.__autoAdjustGeometry:
# Shrink the geometry if required.
geom = geom.intersected(arrow_rect)
# topLeft can move changing the local coordinates.
diff = geom.topLeft()
line = QLineF(line.p1() - diff, line.p2() - diff)
self.__arrowItem.setLine(line)
self.__arrowShadowBase.setLine(line)
self.__line = line
# parent item coordinate system
geom.translate(self.pos())
self.setGeometry(geom)
def setRect(self, rect):
"""
Set the control point rectangle (:class:`QRectF`)
"""
if self.__rect != rect:
self.__rect = QRectF(rect)
self.__pointsLayout()
self.prepareGeometryChange()
self.rectChanged.emit(rect.normalized())
def grab_svg(scene):
"""
Return a SVG rendering of the scene contents.
Parameters
----------
scene : :class:`CanvasScene`
"""
from AnyQt.QtSvg import QSvgGenerator
svg_buffer = QBuffer()
gen = QSvgGenerator()
gen.setOutputDevice(svg_buffer)
items_rect = scene.itemsBoundingRect().adjusted(-10, -10, 10, 10)
if items_rect.isNull():
items_rect = QRectF(0, 0, 10, 10)
width, height = items_rect.width(), items_rect.height()
rect_ratio = float(width) / height
# Keep a fixed aspect ratio.
aspect_ratio = 1.618
if rect_ratio > aspect_ratio:
height = int(height * rect_ratio / aspect_ratio)
else:
width = int(width * aspect_ratio / rect_ratio)
target_rect = QRectF(0, 0, width, height)
source_rect = QRectF(0, 0, width, height)
source_rect.moveCenter(items_rect.center())
gen.setSize(target_rect.size().toSize())
gen.setViewBox(target_rect)
painter = QPainter(gen)
# Draw background.
painter.setBrush(QBrush(Qt.white))
painter.drawRect(target_rect)
# Render the scene
scene.render(painter, target_rect, source_rect)
painter.end()
buffer_str = bytes(svg_buffer.buffer())
return buffer_str.decode("utf-8")
def updateSelectionRect(self, event):
pos = event.scenePos()
buttonDownPos = event.buttonDownScenePos(Qt.LeftButton)
rect = QRectF(pos, buttonDownPos).normalized()
rect = rect.intersected(self.sceneRect())
if not self.selectionRect:
self.selectionRect = QGraphicsRectItem()
self.selectionRect.setBrush(QColor(10, 10, 10, 20))
self.selectionRect.setPen(QPen(QColor(200, 200, 200, 200)))
self.addItem(self.selectionRect)
self.selectionRect.setRect(rect)
if event.modifiers() & Qt.ControlModifier or \
event.modifiers() & Qt.ShiftModifier:
path = self.selectionArea()
else:
path = QPainterPath()
path.addRect(rect)
self.setSelectionArea(path)
self.selectionRectPointChanged.emit(pos)
def paint(self, painter, option, widget=0):
if self._pixmap.isNull():
return
rect = self.contentsRect()
pixsize = QSizeF(self._pixmap.size())
aspectmode = (Qt.KeepAspectRatio if self._keepAspect
else Qt.IgnoreAspectRatio)
pixsize.scale(rect.size(), aspectmode)
pixrect = QRectF(QPointF(0, 0), pixsize)
pixrect.moveCenter(rect.center())
painter.save()
painter.setPen(QPen(QColor(0, 0, 0, 50), 3))
painter.drawRoundedRect(pixrect, 2, 2)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
source = QRectF(QPointF(0, 0), QSizeF(self._pixmap.size()))
painter.drawPixmap(pixrect, self._pixmap, source)
painter.restore()
def paint(self, painter, option, widget=0):
if self._pixmap.isNull():
return
rect = self.contentsRect()
pixsize = QSizeF(self._pixmap.size())
aspectmode = (Qt.KeepAspectRatio if self._keepAspect else Qt.IgnoreAspectRatio)
if self._crop:
height, width = pixsize.height(), pixsize.width()
diff = abs(height - width)
if height > width:
y, x = diff / 2, 0
h, w = height - diff, width
else:
x, y = diff / 2, 0
w, h = width - diff, height
source = QRectF(x, y, w, h)
pixrect = QRectF(QPointF(0, 0), rect.size())
else:
source = QRectF(QPointF(0, 0), pixsize)
pixsize.scale(rect.size(), aspectmode)
pixrect = QRectF(QPointF(0, 0), pixsize)
if self._subset:
painter.setOpacity(1.0)
else:
painter.setOpacity(0.35)
pixrect.moveCenter(rect.center())
painter.save()
painter.setPen(QPen(QColor(0, 0, 0, 50), 3))
painter.drawRoundedRect(pixrect, 2, 2)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(pixrect, self._pixmap, source)
painter.restore()
def paint(self, painter, option, widget=None):
if not self.__icon.isNull():
if option.state & QStyle.State_Selected:
mode = QIcon.Selected
elif option.state & QStyle.State_Enabled:
mode = QIcon.Normal
elif option.state & QStyle.State_Active:
mode = QIcon.Active
else:
mode = QIcon.Disabled
transform = self.sceneTransform()
if widget is not None:
# 'widget' is the QGraphicsView.viewport()
view = widget.parent()
if isinstance(view, QGraphicsView):
# Combine the scene transform with the view transform.
view_transform = view.transform()
transform = view_transform * view_transform
lod = option.levelOfDetailFromTransform(transform)
w, h = self.__iconSize.width(), self.__iconSize.height()
target = QRectF(0, 0, w, h)
source = QRectF(0, 0, w * lod, w * lod).toRect()
# The actual size of the requested pixmap can be smaller.
size = self.__icon.actualSize(source.size(), mode=mode)
source.setSize(size)
pixmap = self.__icon.pixmap(source.size(), mode=mode)
painter.setRenderHint(
QPainter.SmoothPixmapTransform,
self.__transformationMode == Qt.SmoothTransformation
)
painter.drawPixmap(target, pixmap, QRectF(source))
def relayout(self):
"""Approximate Fruchterman-Reingold spring layout"""
nodes = list(self.nodes.values())
pos = np.array([(np.cos(i/len(nodes)*2*np.pi + np.pi/4),
np.sin(i/len(nodes)*2*np.pi + np.pi/4))
for i in range(1, 1 + len(nodes))])
K = 1 / np.sqrt(pos.shape[0])
GRAVITY, ITERATIONS = 10, 20
TEMPERATURES = np.linspace(.3, .01, ITERATIONS)
for temp in chain([.8, .5], TEMPERATURES):
# Repulsive forces
delta = pos[:, np.newaxis, :] - pos
delta /= np.abs(delta).sum(2)[:, :, np.newaxis]**2 # NOTE: This warning was expected
delta = np.nan_to_num(delta) # Reverse the effect of zero-division
disp = -delta.sum(0)*K*K
# Attractive forces
for edge in self.edges:
n1, n2 = nodes.index(edge.source), nodes.index(edge.dest)
delta = pos[n1] - pos[n2]
magnitude = np.abs(delta).sum()
disp[n1] -= delta*magnitude/K
disp[n2] += delta*magnitude/K
# Gravity; tend toward center
magnitude = np.sqrt(np.sum(np.abs(pos)**2, 1))
disp -= (pos.T*K*GRAVITY*magnitude).T
# Limit max displacement and reposition
magnitude = np.sqrt(np.sum(np.abs(disp)**2, 1))
pos += (disp.T / magnitude).T * np.clip(np.abs(disp), 0, temp)
for node, position in zip(nodes, 500*pos):
node.setPos(*position)
for edge in self.edges:
edge.adjust()
MARGIN, rect = 10, self.scene().itemsBoundingRect()
rect = QRectF(rect.x() - MARGIN, rect.y() - MARGIN,
rect.width() + 2*MARGIN, rect.height() + 2*MARGIN)
self.scene().setSceneRect(rect)
self.scene().invalidate()
def paintEvent(self, event):
# TODO: Use QPainter.drawPixmapFragments on Qt 4.7
opt = QStyleOption()
opt.initFrom(self)
pixmap = self.__shadowPixmap
shadow_rect = QRectF(opt.rect)
widget_rect = QRectF(self.widget().geometry())
widget_rect.moveTo(self.radius_, self.radius_)
left = top = right = bottom = self.radius_
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle in the source pixmap.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self.__shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self.__shadowPixmapFragments(shadow_rect, widget_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
def update_selection(self, event):
"""
Update the selection rectangle from a QGraphicsSceneMouseEvent
`event` instance.
"""
if self.initial_selection is None:
self.initial_selection = set(self.scene.selectedItems())
self.last_selection = self.initial_selection
pos = event.scenePos()
self.selection_rect = QRectF(self.selection_rect.topLeft(), pos)
# Make sure the rect_item does not cause the scene rect to grow.
rect = self._bound_selection_rect(self.selection_rect.normalized())
# Need that 0.5 constant otherwise the sceneRect will still
# grow (anti-aliasing correction by QGraphicsScene?)
pw = self.rect_item.pen().width() + 0.5
self.rect_item.setRect(rect.adjusted(pw, pw, -pw, -pw))
selected = self.scene.items(self.selection_rect.normalized(),
Qt.IntersectsItemShape,
Qt.AscendingOrder)
selected = set([item for item in selected if \
item.flags() & Qt.ItemIsSelectable])
if self.modifiers & Qt.ControlModifier:
for item in selected | self.last_selection | \
self.initial_selection:
item.setSelected(
(item in selected) ^ (item in self.initial_selection)
)
else:
for item in selected.union(self.last_selection):
item.setSelected(item in selected)
self.last_selection = set(self.scene.selectedItems())
def adjustGeometry(self):
"""
Adjust the widget geometry to exactly fit the arrow inside
while preserving the arrow path scene geometry.
"""
# local system coordinate
geom = self.geometry().translated(-self.pos())
line = self.__line
arrow_rect = self.__arrowItem.shape().boundingRect()
if geom.isNull() and not line.isNull():
geom = QRectF(0, 0, 1, 1)
if not (geom.contains(arrow_rect)):
geom = geom.united(arrow_rect)
geom = geom.intersected(arrow_rect)
diff = geom.topLeft()
line = QLineF(line.p1() - diff, line.p2() - diff)
geom.translate(self.pos())
self.setGeometry(geom)
self.setLine(line)
class SelectTool(DataTool):
cursor = Qt.ArrowCursor
def __init__(self, parent, plot):
super().__init__(parent, plot)
self._item = None
self._start_pos = None
self._selection_rect = None
self._mouse_dragging = False
self._delete_action = QAction("Delete",
self,
shortcutContext=Qt.WindowShortcut)
self._delete_action.setShortcuts(
[QKeySequence.Delete,
QKeySequence("Backspace")])
self._delete_action.triggered.connect(self.delete)
def setSelectionRect(self, rect):
if self._selection_rect != rect:
self._selection_rect = QRectF(rect)
self._item.setRect(self._selection_rect)
def selectionRect(self):
return self._item.rect()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
pos = self.mapToPlot(event.pos())
if self._item.isVisible():
if self.selectionRect().contains(pos):
# Allow the event to propagate to the item.
event.setAccepted(False)
self._item.setCursor(Qt.ClosedHandCursor)
return False
self._mouse_dragging = True
self._start_pos = pos
self._item.setVisible(True)
self._plot.addItem(self._item)
self.setSelectionRect(QRectF(pos, pos))
event.accept()
return True
return super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
pos = self.mapToPlot(event.pos())
self.setSelectionRect(QRectF(self._start_pos, pos).normalized())
event.accept()
return True
return super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
pos = self.mapToPlot(event.pos())
self.setSelectionRect(QRectF(self._start_pos, pos).normalized())
event.accept()
self.issueCommand.emit(SelectRegion(self.selectionRect()))
self._item.setCursor(Qt.OpenHandCursor)
self._mouse_dragging = False
return True
return super().mouseReleaseEvent(event)
def activate(self):
if self._item is None:
self._item = _RectROI((0, 0), (0, 0), pen=(25, 25, 25))
self._item.setAcceptedMouseButtons(Qt.LeftButton)
self._item.setVisible(False)
self._item.setCursor(Qt.OpenHandCursor)
self._item.sigRegionChanged.connect(self._on_region_changed)
self._item.sigRegionChangeStarted.connect(
self._on_region_change_started)
self._item.sigRegionChangeFinished.connect(
self._on_region_change_finished)
self._plot.addItem(self._item)
self._mouse_dragging = False
self._plot.addAction(self._delete_action)
def deactivate(self):
self.reset()
self._plot.removeAction(self._delete_action)
def reset(self):
self.setSelectionRect(QRectF())
self._item.setVisible(False)
self._mouse_dragging = False
def delete(self):
if not self._mouse_dragging and self._item.isVisible():
self.issueCommand.emit(DeleteSelection())
self.reset()
def _on_region_changed(self):
if not self._mouse_dragging:
newrect = self._item.rect()
delta = newrect.topLeft() - self._selection_rect.topLeft()
self._selection_rect = newrect
self.issueCommand.emit(MoveSelection(delta))
def _on_region_change_started(self):
if not self._mouse_dragging:
self.editingStarted.emit()
def _on_region_change_finished(self):
if not self._mouse_dragging:
self.editingFinished.emit()
def draw(self):
"""Uses GraphAttributes class to draw the explanaitons """
self.box_scene.clear()
wp = self.box_view.viewport().rect()
header_height = 30
if self.explanations is not None:
self.painter = GraphAttributes(self.box_scene, min(
self.gui_num_atr, self.explanations.Y.shape[0]))
self.painter.paint(wp, self.explanations, header_h=header_height)
"""set appropriate boxes for different views"""
rect = QRectF(self.box_scene.itemsBoundingRect().x(),
self.box_scene.itemsBoundingRect().y(),
self.box_scene.itemsBoundingRect().width(),
self.box_scene.itemsBoundingRect().height())
self.box_scene.setSceneRect(rect)
self.box_view.setSceneRect(
rect.x(), rect.y()+header_height+2, rect.width(), rect.height() - 80)
self.header_view.setSceneRect(
rect.x(), rect.y(), rect.width(), 10)
self.header_view.setFixedHeight(header_height)
self.footer_view.setSceneRect(
rect.x(), rect.y() + rect.height() - 50, rect.width(), 35)
def _clear_scene(self):
# Clear the graphics scene and associated objects
self.scene.clear()
self.scene.setSceneRect(QRectF())
self._silplot = None
def set_view_box_range(self):
self.view_box.setRange(QRectF(-1.2, -1.05, 2.4, 2.1), padding=0.025)
class ControlPointRect(QGraphicsObject):
Free = 0
KeepAspectRatio = 1
KeepCenter = 2
rectChanged = Signal(QRectF)
rectEdited = Signal(QRectF)
def __init__(self, parent=None, rect=None, constraints=0, **kwargs):
QGraphicsObject.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsItem.ItemHasNoContents)
self.setFlag(QGraphicsItem.ItemIsFocusable)
self.__rect = rect if rect is not None else QRectF()
self.__margins = QMargins()
points = \
[ControlPoint(self, ControlPoint.Left),
ControlPoint(self, ControlPoint.Top),
ControlPoint(self, ControlPoint.TopLeft),
ControlPoint(self, ControlPoint.Right),
ControlPoint(self, ControlPoint.TopRight),
ControlPoint(self, ControlPoint.Bottom),
ControlPoint(self, ControlPoint.BottomLeft),
ControlPoint(self, ControlPoint.BottomRight)
]
assert(points == sorted(points, key=lambda p: p.anchor()))
self.__points = dict((p.anchor(), p) for p in points)
if self.scene():
self.__installFilter()
for p in points:
p.setFlag(QGraphicsItem.ItemIsFocusable)
p.setFocusProxy(self)
self.controlPoint(ControlPoint.Top).setConstraint(Qt.Vertical)
self.controlPoint(ControlPoint.Bottom).setConstraint(Qt.Vertical)
self.controlPoint(ControlPoint.Left).setConstraint(Qt.Horizontal)
self.controlPoint(ControlPoint.Right).setConstraint(Qt.Horizontal)
self.__constraints = constraints
self.__activeControl = None
self.__pointsLayout()
def controlPoint(self, anchor):
"""
Return the anchor point (:class:`ControlPoint`) at anchor position
or `None` if an anchor point is not set.
"""
return self.__points.get(anchor)
def setRect(self, rect):
"""
Set the control point rectangle (:class:`QRectF`)
"""
if self.__rect != rect:
self.__rect = QRectF(rect)
self.__pointsLayout()
self.prepareGeometryChange()
self.rectChanged.emit(rect.normalized())
def rect(self):
"""
Return the control point rectangle.
"""
# Return the rect normalized. During the control point move the
# rect can change to an invalid size, but the layout must still
# know to which point does an unnormalized rect side belong,
# so __rect is left unnormalized.
# NOTE: This means all signal emits (rectChanged/Edited) must
# also emit normalized rects
return self.__rect.normalized()
rect_ = Property(QRectF, fget=rect, fset=setRect, user=True)
def setControlMargins(self, *margins):
"""Set the controls points on the margins around `rect`
"""
if len(margins) > 1:
margins = QMargins(*margins)
else:
margins = margins[0]
if isinstance(margins, int):
margins = QMargins(margins, margins, margins, margins)
if self.__margins != margins:
self.__margins = margins
self.__pointsLayout()
def controlMargins(self):
return self.__margins
def setConstraints(self, constraints):
raise NotImplementedError
def isControlActive(self):
"""Return the state of the control. True if the control is
active (user is dragging one of the points) False otherwise.
"""
return self.__activeControl is not None
def itemChange(self, change, value):
if change == QGraphicsItem.ItemSceneHasChanged and self.scene():
self.__installFilter()
return QGraphicsObject.itemChange(self, change, value)
def sceneEventFilter(self, obj, event):
try:
obj = toGraphicsObjectIfPossible(obj)
if isinstance(obj, ControlPoint):
etype = event.type()
if etype == QEvent.GraphicsSceneMousePress and \
event.button() == Qt.LeftButton:
self.__setActiveControl(obj)
elif etype == QEvent.GraphicsSceneMouseRelease and \
event.button() == Qt.LeftButton:
self.__setActiveControl(None)
except Exception:
log.error("Error in 'ControlPointRect.sceneEventFilter'",
exc_info=True)
return QGraphicsObject.sceneEventFilter(self, obj, event)
def __installFilter(self):
# Install filters on the control points.
try:
for p in self.__points.values():
p.installSceneEventFilter(self)
except Exception:
log.error("Error in ControlPointRect.__installFilter",
exc_info=True)
def __pointsLayout(self):
"""Layout the control points
"""
rect = self.__rect
margins = self.__margins
rect = rect.adjusted(-margins.left(), -margins.top(),
margins.right(), margins.bottom())
center = rect.center()
cx, cy = center.x(), center.y()
left, top, right, bottom = \
rect.left(), rect.top(), rect.right(), rect.bottom()
self.controlPoint(ControlPoint.Left).setPos(left, cy)
self.controlPoint(ControlPoint.Right).setPos(right, cy)
self.controlPoint(ControlPoint.Top).setPos(cx, top)
self.controlPoint(ControlPoint.Bottom).setPos(cx, bottom)
self.controlPoint(ControlPoint.TopLeft).setPos(left, top)
self.controlPoint(ControlPoint.TopRight).setPos(right, top)
self.controlPoint(ControlPoint.BottomLeft).setPos(left, bottom)
self.controlPoint(ControlPoint.BottomRight).setPos(right, bottom)
def __setActiveControl(self, control):
if self.__activeControl != control:
if self.__activeControl is not None:
self.__activeControl.positionChanged[QPointF].disconnect(
self.__activeControlMoved
)
self.__activeControl = control
if control is not None:
control.positionChanged[QPointF].connect(
self.__activeControlMoved
)
def __activeControlMoved(self, pos):
# The active control point has moved, update the control
# rectangle
control = self.__activeControl
pos = control.pos()
rect = QRectF(self.__rect)
margins = self.__margins
# TODO: keyboard modifiers and constraints.
anchor = control.anchor()
if anchor & ControlPoint.Top:
rect.setTop(pos.y() + margins.top())
elif anchor & ControlPoint.Bottom:
rect.setBottom(pos.y() - margins.bottom())
if anchor & ControlPoint.Left:
rect.setLeft(pos.x() + margins.left())
elif anchor & ControlPoint.Right:
rect.setRight(pos.x() - margins.right())
changed = self.__rect != rect
self.blockSignals(True)
self.setRect(rect)
self.blockSignals(False)
if changed:
self.rectEdited.emit(rect.normalized())
def boundingRect(self):
return QRectF()
def set_view_box_range(self):
self.view_box.setRange(QRectF(-1, -1, 2, 2), padding=self.padding)
def _select_data(self):
self.widget.graph.select_by_rectangle(QRectF(4, 3, 3, 1))
return self.widget.graph.get_selection()
def boundingRect(self):
return QRectF(0, 0, 40 + self.text_width, 20 + self.scale.bins * 15)
def boundingRect(self):
return QRectF(0, 0, 25 + self.text_width + self.bin_height,
20 + self.scale.bins * self.bin_height)
def innerGlowBackgroundPixmap(color, size, radius=5):
""" Draws radial gradient pixmap, then uses that to draw
a rounded-corner gradient rectangle pixmap.
Args:
color (QColor): used as outer color (lightness 245 used for inner)
size (QSize): size of output pixmap
radius (int): radius of inner glow rounded corners
"""
key = "InnerGlowBackground " + \
color.name() + " " + \
str(radius)
bg = QPixmapCache.find(key)
if bg:
return bg
# set background colors for gradient
color = color.toHsl()
light_color = color.fromHsl(color.hslHue(), color.hslSaturation(), 245)
dark_color = color
# initialize radial gradient
center = QPoint(radius, radius)
pixRect = QRect(0, 0, radius * 2, radius * 2)
gradientPixmap = QPixmap(radius * 2, radius * 2)
gradientPixmap.fill(dark_color)
# draw radial gradient pixmap
pixPainter = QPainter(gradientPixmap)
pixPainter.setPen(Qt.NoPen)
gradient = QRadialGradient(center, radius - 1)
gradient.setColorAt(0, light_color)
gradient.setColorAt(1, dark_color)
pixPainter.setBrush(gradient)
pixPainter.drawRect(pixRect)
pixPainter.end()
# set tl and br to the gradient's square-shaped rect
tl = QPoint(0, 0)
br = QPoint(size.width(), size.height())
# fragments of radial gradient pixmap to create rounded gradient outline rectangle
frags = [
# top-left corner
QPainter.PixmapFragment.create(
QPointF(tl.x() + radius / 2,
tl.y() + radius / 2), QRectF(0, 0, radius, radius)),
# top-mid 'linear gradient'
QPainter.PixmapFragment.create(QPointF(tl.x() + (br.x() - tl.x()) / 2,
tl.y() + radius / 2),
QRectF(radius, 0, 1, radius),
scaleX=(br.x() - tl.x() - 2 * radius)),
# top-right corner
QPainter.PixmapFragment.create(
QPointF(br.x() - radius / 2,
tl.y() + radius / 2), QRectF(radius, 0, radius, radius)),
# left-mid 'linear gradient'
QPainter.PixmapFragment.create(QPointF(tl.x() + radius / 2,
tl.y() + (br.y() - tl.y()) / 2),
QRectF(0, radius, radius, 1),
scaleY=(br.y() - tl.y() - 2 * radius)),
# mid solid
QPainter.PixmapFragment.create(QPointF(tl.x() + (br.x() - tl.x()) / 2,
tl.y() + (br.y() - tl.y()) / 2),
QRectF(radius, radius, 1, 1),
scaleX=(br.x() - tl.x() - 2 * radius),
scaleY=(br.y() - tl.y() - 2 * radius)),
# right-mid 'linear gradient'
QPainter.PixmapFragment.create(QPointF(br.x() - radius / 2,
tl.y() + (br.y() - tl.y()) / 2),
QRectF(radius, radius, radius, 1),
scaleY=(br.y() - tl.y() - 2 * radius)),
# bottom-left corner
QPainter.PixmapFragment.create(
QPointF(tl.x() + radius / 2,
br.y() - radius / 2), QRectF(0, radius, radius, radius)),
# bottom-mid 'linear gradient'
QPainter.PixmapFragment.create(QPointF(tl.x() + (br.x() - tl.x()) / 2,
br.y() - radius / 2),
QRectF(radius, radius, 1, radius),
scaleX=(br.x() - tl.x() - 2 * radius)),
# bottom-right corner
QPainter.PixmapFragment.create(
QPointF(br.x() - radius / 2,
br.y() - radius / 2), QRectF(radius, radius, radius,
radius)),
]
# draw icon background to pixmap
outPix = QPixmap(size.width(), size.height())
outPainter = QPainter(outPix)
outPainter.setPen(Qt.NoPen)
outPainter.drawPixmapFragments(
frags, gradientPixmap,
QPainter.PixmapFragmentHints(QPainter.OpaqueHint))
outPainter.end()
QPixmapCache.insert(key, outPix)
return outPix
def get_mapped_rect():
p1, p2 = ev.buttonDownPos(ev.button()), ev.pos()
p1 = self.mapToView(p1)
p2 = self.mapToView(p2)
return QRectF(p1, p2)
def reset(self):
self.setSelectionRect(QRectF())
self._item.setVisible(False)
self._mouse_dragging = False
def setSelectionRect(self, rect):
if self._selection_rect != rect:
self._selection_rect = QRectF(rect)
self._item.setRect(self._selection_rect)
def __init__(self):
super().__init__()
self.data = None
self.subset_data = None
self._subset_mask = None
self._selection = None # np.array
self.__replot_requested = False
self._new_plotdata()
self.variable_x = ContinuousVariable("radviz-x")
self.variable_y = ContinuousVariable("radviz-y")
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = OWRadvizGraph(self, box, "Plot", view_box=RadvizInteractiveViewBox)
self.graph.hide_axes()
box.layout().addWidget(self.graph.plot_widget)
plot = self.graph.plot_widget
SIZE_POLICY = (QSizePolicy.Minimum, QSizePolicy.Maximum)
self.variables_selection = VariablesSelection()
self.model_selected = VariableListModel(enable_dnd=True)
self.model_other = VariableListModel(enable_dnd=True)
self.variables_selection(self, self.model_selected, self.model_other)
self.vizrank, self.btn_vizrank = RadvizVizRank.add_vizrank(
self.controlArea, self, "Suggest features", self.vizrank_set_attrs)
self.btn_vizrank.setSizePolicy(*SIZE_POLICY)
self.variables_selection.add_remove.layout().addWidget(self.btn_vizrank)
self.viewbox = plot.getViewBox()
self.replot = None
g = self.graph.gui
pp_box = g.point_properties_box(self.controlArea)
pp_box.setSizePolicy(*SIZE_POLICY)
self.models = g.points_models
box = gui.vBox(self.controlArea, "Plot Properties")
box.setSizePolicy(*SIZE_POLICY)
g.add_widget(g.JitterSizeSlider, box)
g.add_widgets([g.ShowLegend, g.ClassDensity, g.LabelOnlySelected], box)
zoom_select = self.graph.box_zoom_select(self.controlArea)
zoom_select.setSizePolicy(*SIZE_POLICY)
self.icons = gui.attributeIconDict
p = self.graph.plot_widget.palette()
self.graph.set_palette(p)
gui.auto_commit(self.controlArea, self, "auto_commit", "Send Selection",
auto_label="Send Automatically")
self.graph.zoom_actions(self)
self._circle = QGraphicsEllipseItem()
self._circle.setRect(QRectF(-1., -1., 2., 2.))
self._circle.setPen(pg.mkPen(QColor(0, 0, 0), width=2))
def test_saving_selection(self):
self.send_signal(self.widget.Inputs.data, self.data) # iris
self.widget.graph.select_by_rectangle(QRectF(4, 3, 3, 1))
selected_inds = np.flatnonzero(self.widget.graph.selection)
settings = self.widget.settingsHandler.pack_data(self.widget)
np.testing.assert_equal(selected_inds, [i for i, g in settings["selection_group"]])
self._circle_item.setRect(QRectF(-r, -r, 2 * r, 2 * r))
self._circle_item.setPen(pen)
self.plot_widget.addItem(self._circle_item)
def _add_indicator_item(self, point_i):
x, y = self._points[point_i]
dx = (self.view_box.childGroup.mapToDevice(QPoint(1, 0)) -
self.view_box.childGroup.mapToDevice(QPoint(-1, 0))).x()
self._indicator_item = MoveIndicator(x, y, 600 / dx)
self.plot_widget.addItem(self._indicator_item)
MAX_ITERATIONS = 1000
MAX_POINTS = 300
MAX_INSTANCES = 10000
RANGE = QRectF(-1.05, -1.05, 2.1, 2.1)
class InitType(IntEnum):
Circular, Random = 0, 1
@staticmethod
def items():
return ["Circular", "Random"]
class OWFreeViz(OWProjectionWidget):
name = "FreeViz"
description = "Displays FreeViz projection"
icon = "icons/Freeviz.svg"
priority = 240
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 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)
self.data_indices = np.flatnonzero(self.valid_data)
if len(self.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=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)
self.draw_regression_line(x_data, y_data, min_x, max_x)
self.update_labels()
self.make_legend()
self.plot_widget.replot()
def boundingRect(self):
return QRectF(0, 0, self.width, self.height)
def set_view_box_range(self):
self.view_box.setRange(QRectF(-1.05, -1.05, 2.1, 2.1))
def boundingRect(self):
return QRectF(-self.r, -self.r, 2 * self.r, 2 * self.r)
def _select_data(self):
self.widget.graph.select_by_rectangle(
QRectF(QPointF(-20, -20), QPointF(20, 20))
)
return self.widget.graph.get_selection()
def setSchemeNode(self, node):
"""
Set an instance of `SchemeNode`. The widget will be initialized
with its icon and channels.
"""
self.node = node
if self.__direction == Qt.LeftToRight:
channels = node.output_channels()
else:
channels = node.input_channels()
self.channels = channels
loader = icon_loader.from_description(node.description)
icon = loader.get(node.description.icon)
self.setIcon(icon)
label_template = ('<div align="{align}">'
'<span class="channelname">{name}</span>'
'</div>')
if self.__direction == Qt.LeftToRight:
align = "right"
label_alignment = Qt.AlignVCenter | Qt.AlignRight
anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft
label_row = 0
anchor_row = 1
else:
align = "left"
label_alignment = Qt.AlignVCenter | Qt.AlignLeft
anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft
label_row = 1
anchor_row = 0
self.channelAnchors = []
grid = self.__channelLayout
for i, channel in enumerate(channels):
text = label_template.format(align=align,
name=escape(channel.name))
text_item = GraphicsTextWidget(self)
text_item.setHtml(text)
text_item.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
text_item.setToolTip(
escape(getattr(channel, 'description', channel.type)))
grid.addItem(text_item, i, label_row, alignment=label_alignment)
anchor = ChannelAnchor(self,
channel=channel,
rect=QRectF(0, 0, 20, 20))
layout_item = GraphicsItemLayoutItem(grid, item=anchor)
grid.addItem(layout_item,
i,
anchor_row,
alignment=anchor_alignment)
self.channelAnchors.append(anchor)
class SelectTool(DataTool):
cursor = Qt.ArrowCursor
def __init__(self, parent, plot):
super().__init__(parent, plot)
self._item = None
self._start_pos = None
self._selection_rect = None
self._mouse_dragging = False
self._delete_action = QAction(
"Delete", self, shortcutContext=Qt.WindowShortcut
)
self._delete_action.setShortcuts([QKeySequence.Delete,
QKeySequence("Backspace")])
self._delete_action.triggered.connect(self.delete)
def setSelectionRect(self, rect):
if self._selection_rect != rect:
self._selection_rect = QRectF(rect)
self._item.setRect(self._selection_rect)
def selectionRect(self):
return self._item.rect()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
pos = self.mapToPlot(event.pos())
if self._item.isVisible():
if self.selectionRect().contains(pos):
# Allow the event to propagate to the item.
event.setAccepted(False)
self._item.setCursor(Qt.ClosedHandCursor)
return False
self._mouse_dragging = True
self._start_pos = pos
self._item.setVisible(True)
self._plot.addItem(self._item)
self.setSelectionRect(QRectF(pos, pos))
event.accept()
return True
else:
return super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
pos = self.mapToPlot(event.pos())
self.setSelectionRect(QRectF(self._start_pos, pos).normalized())
event.accept()
return True
else:
return super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
pos = self.mapToPlot(event.pos())
self.setSelectionRect(QRectF(self._start_pos, pos).normalized())
event.accept()
self.issueCommand.emit(SelectRegion(self.selectionRect()))
self._item.setCursor(Qt.OpenHandCursor)
self._mouse_dragging = False
return True
else:
return super().mouseReleaseEvent(event)
def activate(self):
if self._item is None:
self._item = _RectROI((0, 0), (0, 0), pen=(25, 25, 25))
self._item.setAcceptedMouseButtons(Qt.LeftButton)
self._item.setVisible(False)
self._item.setCursor(Qt.OpenHandCursor)
self._item.sigRegionChanged.connect(self._on_region_changed)
self._item.sigRegionChangeStarted.connect(
self._on_region_change_started)
self._item.sigRegionChangeFinished.connect(
self._on_region_change_finished)
self._plot.addItem(self._item)
self._mouse_dragging = False
self._plot.addAction(self._delete_action)
def deactivate(self):
self._reset()
self._plot.removeAction(self._delete_action)
def _reset(self):
self.setSelectionRect(QRectF())
self._item.setVisible(False)
self._mouse_dragging = False
def delete(self):
if not self._mouse_dragging and self._item.isVisible():
self.issueCommand.emit(DeleteSelection())
self._reset()
def _on_region_changed(self):
if not self._mouse_dragging:
newrect = self._item.rect()
delta = newrect.topLeft() - self._selection_rect.topLeft()
self._selection_rect = newrect
self.issueCommand.emit(MoveSelection(delta))
def _on_region_change_started(self):
if not self._mouse_dragging:
self.editingStarted.emit()
def _on_region_change_finished(self):
if not self._mouse_dragging:
self.editingFinished.emit()
class RectangleSelectionAction(UserInteraction):
"""
Select items in the scene using a Rectangle selection
"""
def __init__(self, document, *args, **kwargs):
UserInteraction.__init__(self, document, *args, **kwargs)
# The initial selection at drag start
self.initial_selection = None
# Selection when last updated in a mouseMoveEvent
self.last_selection = None
# A selection rect (`QRectF`)
self.selection_rect = None
# Keyboard modifiers
self.modifiers = 0
def mousePressEvent(self, event):
pos = event.scenePos()
any_item = self.scene.item_at(pos)
if not any_item and event.button() & Qt.LeftButton:
self.modifiers = event.modifiers()
self.selection_rect = QRectF(pos, QSizeF(0, 0))
self.rect_item = QGraphicsRectItem(
self.selection_rect.normalized()
)
self.rect_item.setPen(
QPen(QBrush(QColor(51, 153, 255, 192)),
0.4, Qt.SolidLine, Qt.RoundCap)
)
self.rect_item.setBrush(
QBrush(QColor(168, 202, 236, 192))
)
self.rect_item.setZValue(-100)
# Clear the focus if necessary.
if not self.scene.stickyFocus():
self.scene.clearFocus()
if not self.modifiers & Qt.ControlModifier:
self.scene.clearSelection()
event.accept()
return True
else:
self.cancel(self.ErrorReason)
return False
def mouseMoveEvent(self, event):
if not self.rect_item.scene():
# Add the rect item to the scene when the mouse moves.
self.scene.addItem(self.rect_item)
self.update_selection(event)
return True
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
if self.initial_selection is None:
# A single click.
self.scene.clearSelection()
else:
self.update_selection(event)
self.end()
return True
def update_selection(self, event):
"""
Update the selection rectangle from a QGraphicsSceneMouseEvent
`event` instance.
"""
if self.initial_selection is None:
self.initial_selection = set(self.scene.selectedItems())
self.last_selection = self.initial_selection
pos = event.scenePos()
self.selection_rect = QRectF(self.selection_rect.topLeft(), pos)
# Make sure the rect_item does not cause the scene rect to grow.
rect = self._bound_selection_rect(self.selection_rect.normalized())
# Need that 0.5 constant otherwise the sceneRect will still
# grow (anti-aliasing correction by QGraphicsScene?)
pw = self.rect_item.pen().width() + 0.5
self.rect_item.setRect(rect.adjusted(pw, pw, -pw, -pw))
selected = self.scene.items(self.selection_rect.normalized(),
Qt.IntersectsItemShape,
Qt.AscendingOrder)
selected = set([item for item in selected if \
item.flags() & Qt.ItemIsSelectable])
if self.modifiers & Qt.ControlModifier:
for item in selected | self.last_selection | \
self.initial_selection:
item.setSelected(
(item in selected) ^ (item in self.initial_selection)
)
else:
for item in selected.union(self.last_selection):
item.setSelected(item in selected)
self.last_selection = set(self.scene.selectedItems())
def end(self):
self.initial_selection = None
self.last_selection = None
self.modifiers = 0
self.rect_item.hide()
if self.rect_item.scene() is not None:
self.scene.removeItem(self.rect_item)
UserInteraction.end(self)
def viewport_rect(self):
"""
Return the bounding rect of the document's viewport on the scene.
"""
view = self.document.view()
vsize = view.viewport().size()
viewportrect = QRect(0, 0, vsize.width(), vsize.height())
return view.mapToScene(viewportrect).boundingRect()
def _bound_selection_rect(self, rect):
"""
Bound the selection `rect` to a sensible size.
"""
srect = self.scene.sceneRect()
vrect = self.viewport_rect()
maxrect = srect.united(vrect)
return rect.intersected(maxrect)
def boundingRect(self):
# replace undefined (NaN) elements with defaults
bounds = [d if np.isnan(b) else b \
for b, d in zip(self.bounds, self.default_bounds)]
return QRectF(bounds[0], bounds[1], bounds[2] - bounds[0], bounds[3] - bounds[1])
def update_view(self):
self.img.clear()
self.img.setSelection(None)
self.lsx = None
self.lsy = None
self.data_points = None
self.data_values = None
self.data_imagepixels = None
if self.data and self.attr_x and self.attr_y:
xat = self.data.domain[self.attr_x]
yat = self.data.domain[self.attr_y]
ndom = Orange.data.Domain([xat, yat])
datam = Orange.data.Table(ndom, self.data)
coorx = datam.X[:, 0]
coory = datam.X[:, 1]
self.data_points = datam.X
self.lsx = lsx = values_to_linspace(coorx)
self.lsy = lsy = values_to_linspace(coory)
if lsx[-1] * lsy[-1] > IMAGE_TOO_BIG:
self.parent.Error.image_too_big(lsx[-1], lsy[-1])
return
else:
self.parent.Error.image_too_big.clear()
di = {}
if self.parent.value_type == 0: # integrals
imethod = self.parent.integration_methods[self.parent.integration_method]
if imethod != Integrate.PeakAt:
datai = Integrate(methods=imethod,
limits=[[self.parent.lowlim, self.parent.highlim]])(self.data)
else:
datai = Integrate(methods=imethod,
limits=[[self.parent.choose, self.parent.choose]])(self.data)
if np.any(self.parent.curveplot.selection_group):
# curveplot can have a subset of curves on the input> match IDs
ind = np.flatnonzero(self.parent.curveplot.selection_group)[0]
dind = self.data_ids[self.parent.curveplot.data[ind].id]
di = datai.domain.attributes[0].compute_value.draw_info(self.data[dind:dind+1])
d = datai.X[:, 0]
else:
dat = self.data.domain[self.parent.attr_value]
ndom = Orange.data.Domain([dat])
d = Orange.data.Table(ndom, self.data).X[:, 0]
self.refresh_markings(di)
# set data
imdata = np.ones((lsy[2], lsx[2])) * float("nan")
xindex = index_values(coorx, lsx)
yindex = index_values(coory, lsy)
imdata[yindex, xindex] = d
self.data_values = d
self.data_imagepixels = np.vstack((yindex, xindex)).T
self.img.setImage(imdata, autoLevels=False)
self.img.setLevels([0, 1])
self.update_levels()
self.update_color_schema()
# shift centres of the pixels so that the axes are useful
shiftx = _shift(lsx)
shifty = _shift(lsy)
left = lsx[0] - shiftx
bottom = lsy[0] - shifty
width = (lsx[1]-lsx[0]) + 2*shiftx
height = (lsy[1]-lsy[0]) + 2*shifty
self.img.setRect(QRectF(left, bottom, width, height))
self.refresh_img_selection()
def rect(self):
return QRectF(self.pos(), QSizeF(*self.size()))
def setSelectionRect(self, rect):
if self._selection_rect != rect:
self._selection_rect = QRectF(rect)
self._item.setRect(self._selection_rect)
def display_contingency(self):
"""
Set the contingency to display.
"""
cont = self.contingencies
var, cvar = self.var, self.cvar
assert len(cont) > 0
self.plot.clear()
self.plot_prob.clear()
self._legend.clear()
self.tooltip_items = []
if self.show_prob:
self.ploti.showAxis('right')
else:
self.ploti.hideAxis('right')
bottomaxis = self.ploti.getAxis("bottom")
bottomaxis.setLabel(var.name)
bottomaxis.resizeEvent()
cvar_values = cvar.values
colors = [QColor(*col) for col in cvar.colors]
if var and var.is_continuous:
bottomaxis.setTicks(None)
weights, cols, cvar_values, curves = [], [], [], []
for i, dist in enumerate(cont):
v, W = dist
if len(v):
weights.append(numpy.sum(W))
cols.append(colors[i])
cvar_values.append(cvar.values[i])
curves.append(
ash_curve(dist,
cont,
m=OWDistributions.ASH_HIST,
smoothing_factor=self.smoothing_facs[
self.smoothing_index]))
weights = numpy.array(weights)
sumw = numpy.sum(weights)
weights /= sumw
colors = cols
curves = [(X, Y * w) for (X, Y), w in zip(curves, weights)]
ncval = len(cvar_values)
curvesline = [] #from histograms to lines
for (X, Y) in curves:
X = X + (X[1] - X[0]) / 2
X = X[:-1]
X = numpy.array(X)
Y = numpy.array(Y)
curvesline.append((X, Y))
for t in ["fill", "line"]:
for (X, Y), color, w, cval in reversed(
list(zip(curvesline, colors, weights, cvar_values))):
item = pg.PlotCurveItem()
pen = QPen(QBrush(color), 3)
pen.setCosmetic(True)
color = QColor(color)
color.setAlphaF(0.2)
item.setData(X,
Y / (w if self.relative_freq else 1),
antialias=True,
stepMode=False,
fillLevel=0 if t == "fill" else None,
brush=QBrush(color),
pen=pen)
self.plot.addItem(item)
if t == "line":
item.tooltip = ("Normalized density " if self.relative_freq else "Density ") \
+ "\n"+ cvar.name + "=" + cval
self.tooltip_items.append((self.plot, item))
if self.show_prob:
M_EST = 5 #for M estimate
all_X = numpy.array(
numpy.unique(numpy.hstack([X for X, _ in curvesline])))
inter_X = numpy.array(
numpy.linspace(all_X[0], all_X[-1],
len(all_X) * 2))
curvesinterp = [
numpy.interp(inter_X, X, Y) for (X, Y) in curvesline
]
sumprob = numpy.sum(curvesinterp, axis=0)
# allcorrection = M_EST/sumw*numpy.sum(sumprob)/len(inter_X)
legal = sumprob > 0.05 * numpy.max(sumprob)
i = len(curvesinterp) + 1
show_all = self.show_prob == i
for Y, color, cval in reversed(
list(zip(curvesinterp, colors, cvar_values))):
i -= 1
if show_all or self.show_prob == i:
item = pg.PlotCurveItem()
pen = QPen(QBrush(color), 3, style=Qt.DotLine)
pen.setCosmetic(True)
#prob = (Y+allcorrection/ncval)/(sumprob+allcorrection)
prob = Y[legal] / sumprob[legal]
item.setData(inter_X[legal],
prob,
antialias=True,
stepMode=False,
fillLevel=None,
brush=None,
pen=pen)
self.plot_prob.addItem(item)
item.tooltip = "Probability that \n" + cvar.name + "=" + cval
self.tooltip_items.append((self.plot_prob, item))
elif var and var.is_discrete:
bottomaxis.setTicks([list(enumerate(var.values))])
cont = numpy.array(cont)
ncval = len(cvar_values)
maxh = 0 #maximal column height
maxrh = 0 #maximal relative column height
scvar = cont.sum(axis=1)
#a cvar with sum=0 with allways have distribution counts 0,
#therefore we can divide it by anything
scvar[scvar == 0] = 1
for i, (value, dist) in enumerate(zip(var.values, cont.T)):
maxh = max(maxh, max(dist))
maxrh = max(maxrh, max(dist / scvar))
for i, (value, dist) in enumerate(zip(var.values, cont.T)):
dsum = sum(dist)
geom = QRectF(i - 0.333, 0, 0.666,
maxrh if self.relative_freq else maxh)
if self.show_prob:
prob = dist / dsum
ci = 1.96 * numpy.sqrt(prob * (1 - prob) / dsum)
else:
ci = None
item = DistributionBarItem(
geom, dist / scvar /
maxrh if self.relative_freq else dist / maxh, colors)
self.plot.addItem(item)
tooltip = "\n".join("%s: %.*f" %
(n, 3 if self.relative_freq else 1, v)
for n, v in zip(
cvar_values, dist /
scvar if self.relative_freq else dist))
item.tooltip = ("Normalized frequency " if self.relative_freq else "Frequency ") \
+ "(" + cvar.name + "=" + value + "):" \
+ "\n" + tooltip
self.tooltip_items.append((self.plot, item))
if self.show_prob:
item.tooltip += "\n\nProbabilities:"
for ic, a in enumerate(dist):
if self.show_prob - 1 != ic and \
self.show_prob - 1 != len(dist):
continue
position = -0.333 + ((ic + 0.5) * 0.666 / len(dist))
if dsum < 1e-6:
continue
prob = a / dsum
if not 1e-6 < prob < 1 - 1e-6:
continue
ci = 1.96 * sqrt(prob * (1 - prob) / dsum)
item.tooltip += "\n%s: %.3f ± %.3f" % (cvar_values[ic],
prob, ci)
mark = pg.ScatterPlotItem()
bar = pg.ErrorBarItem()
pen = QPen(QBrush(QColor(0)), 1)
pen.setCosmetic(True)
bar.setData(x=[i + position],
y=[prob],
bottom=min(numpy.array([ci]), prob),
top=min(numpy.array([ci]), 1 - prob),
beam=numpy.array([0.05]),
brush=QColor(1),
pen=pen)
mark.setData([i + position], [prob],
antialias=True,
symbol="o",
fillLevel=None,
pxMode=True,
size=10,
brush=QColor(colors[ic]),
pen=pen)
self.plot_prob.addItem(bar)
self.plot_prob.addItem(mark)
for color, name in zip(colors, cvar_values):
self._legend.addItem(
ScatterPlotItem(pen=color, brush=color, size=10, shape="s"),
escape(name))
self._legend.show()
def add_selection_rect(self, x1, x2):
x1, x2 = self._values_to_pixels(np.array([x1, x2]))
rect = QRectF(x1, 0, x2 - x1, self.HEIGHT)
self.__selection_rect = ViolinItem.SelectionRect(self, self.__width)
self.__selection_rect.setRect(rect)
def extend_horizontal(rect):
rect = QRectF(rect)
rect.setLeft(geom.left())
rect.setRight(geom.right())
return rect
def boundingRect(self):
return QRectF(0, 0, self.__iconSize.width(), self.__iconSize.height())
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
RANGE = QRectF(-1.2, -1.05, 2.4, 2.1)
MAX_POINTS = 100
class OWRadviz(widget.OWWidget):
name = "Radviz"
description = "Radviz"
icon = "icons/Radviz.svg"
priority = 240
class Inputs:
data = Input("Data", Table, default=True)
data_subset = Input("Data Subset", Table)
class Outputs:
selected_data = Output("Selected Data", Table, default=True)
def grab_svg(scene):
# type: (QGraphicsScene) -> str
"""
Return a SVG rendering of the scene contents.
Parameters
----------
scene : :class:`CanvasScene`
"""
svg_buffer = QBuffer()
gen = _QSvgGenerator()
gen.setOutputDevice(svg_buffer)
items_rect = scene.itemsBoundingRect().adjusted(-10, -10, 10, 10)
if items_rect.isNull():
items_rect = QRectF(0, 0, 10, 10)
width, height = items_rect.width(), items_rect.height()
rect_ratio = float(width) / height
# Keep a fixed aspect ratio.
aspect_ratio = 1.618
if rect_ratio > aspect_ratio:
height = int(height * rect_ratio / aspect_ratio)
else:
width = int(width * aspect_ratio / rect_ratio)
target_rect = QRectF(0, 0, width, height)
source_rect = QRectF(0, 0, width, height)
source_rect.moveCenter(items_rect.center())
gen.setSize(target_rect.size().toSize())
gen.setViewBox(target_rect)
painter = QPainter(gen)
# Draw background.
painter.setPen(Qt.NoPen)
painter.setBrush(scene.palette().base())
painter.drawRect(target_rect)
# Render the scene
scene.render(painter, target_rect, source_rect)
painter.end()
buffer_str = bytes(svg_buffer.buffer())
return buffer_str.decode("utf-8")
def boundingRect(self):
return QRectF()
def update_scene(self):
self.clear_scene()
if self.domain is None or not len(self.points[0]):
return
n_attrs = self.n_attributes if self.display_index else int(1e10)
attr_inds, attributes = zip(*self.get_ordered_attributes()[:n_attrs])
name_items = [QGraphicsTextItem(attr.name) for attr in attributes]
point_text = QGraphicsTextItem("Points")
probs_text = QGraphicsTextItem("Probabilities (%)")
all_items = name_items + [point_text, probs_text]
name_offset = -max(t.boundingRect().width() for t in all_items) - 10
w = self.view.viewport().rect().width()
max_width = w + name_offset - 30
points = [self.points[i][self.target_class_index]
for i in attr_inds]
if self.align == OWNomogram.ALIGN_LEFT:
points = [p - p.min() for p in points]
max_ = np.nan_to_num(max(max(abs(p)) for p in points))
d = 100 / max_ if max_ else 1
minimums = [p[self.target_class_index].min() for p in self.points]
if self.scale == OWNomogram.POINT_SCALE:
points = [p * d for p in points]
if self.align == OWNomogram.ALIGN_LEFT:
self.scale_marker_values = lambda x: (x - minimums) * d
else:
self.scale_marker_values = lambda x: x * d
else:
if self.align == OWNomogram.ALIGN_LEFT:
self.scale_marker_values = lambda x: x - minimums
else:
self.scale_marker_values = lambda x: x
point_item, nomogram_head = self.create_main_nomogram(
attributes, attr_inds,
name_items, points, max_width, point_text, name_offset)
probs_item, nomogram_foot = self.create_footer_nomogram(
probs_text, d, minimums, max_width, name_offset)
for item in self.feature_items.values():
item.dot.point_dot = point_item.dot
item.dot.probs_dot = probs_item.dot
item.dot.vertical_line = self.hidden_vertical_line
self.nomogram = nomogram = NomogramItem()
nomogram.add_items([nomogram_head, self.nomogram_main, nomogram_foot])
self.scene.addItem(nomogram)
self.set_feature_marker_values()
rect = QRectF(self.scene.itemsBoundingRect().x(),
self.scene.itemsBoundingRect().y(),
self.scene.itemsBoundingRect().width(),
self.nomogram.preferredSize().height()).adjusted(10, 0, 20, 0)
self.scene.setSceneRect(rect)
# Clip top and bottom (60 and 150) parts from the main view
self.view.setSceneRect(rect.x(), rect.y() + 80, rect.width() - 10, rect.height() - 160)
self.view.viewport().setMaximumHeight(rect.height() - 160)
# Clip main part from top/bottom views
# below point values are imprecise (less/more than required) but this
# is not a problem due to clipped scene content still being drawn
self.top_view.setSceneRect(rect.x(), rect.y() + 3, rect.width() - 10, 20)
self.bottom_view.setSceneRect(rect.x(), rect.height() - 110, rect.width() - 10, 30)
def update(self, zoom_only=False):
self.update_ticks()
line_color = self.plot.color(OWPalette.Axis)
text_color = self.plot.color(OWPalette.Text)
if not self.graph_line or not self.scene():
return
self.line_item.setLine(self.graph_line)
self.line_item.setPen(line_color)
if self.title:
self.title_item.setHtml('<b>' + self.title + '</b>')
self.title_item.setDefaultTextColor(text_color)
if self.title_location == AxisMiddle:
title_p = 0.5
elif self.title_location == AxisEnd:
title_p = 0.95
else:
title_p = 0.05
title_pos = self.graph_line.pointAt(title_p)
v = self.graph_line.normalVector().unitVector()
dense_text = False
if hasattr(self, 'title_margin'):
offset = self.title_margin
elif self._ticks:
if self.should_be_expanded():
offset = 55
dense_text = True
else:
offset = 35
else:
offset = 10
if self.title_above:
title_pos += (v.p2() - v.p1()) * (offset + QFontMetrics(self.title_item.font()).height())
else:
title_pos -= (v.p2() - v.p1()) * offset
## TODO: Move it according to self.label_pos
self.title_item.setVisible(self.show_title)
self.title_item.setRotation(-self.graph_line.angle())
c = self.title_item.mapToParent(self.title_item.boundingRect().center())
tl = self.title_item.mapToParent(self.title_item.boundingRect().topLeft())
self.title_item.setPos(title_pos - c + tl)
## Arrows
if not zoom_only:
if self.start_arrow_item:
self.scene().removeItem(self.start_arrow_item)
self.start_arrow_item = None
if self.end_arrow_item:
self.scene().removeItem(self.end_arrow_item)
self.end_arrow_item = None
if self.arrows & AxisStart:
if not zoom_only or not self.start_arrow_item:
self.start_arrow_item = QGraphicsPathItem(self.arrow_path, self)
self.start_arrow_item.setPos(self.graph_line.p1())
self.start_arrow_item.setRotation(-self.graph_line.angle() + 180)
self.start_arrow_item.setBrush(line_color)
self.start_arrow_item.setPen(line_color)
if self.arrows & AxisEnd:
if not zoom_only or not self.end_arrow_item:
self.end_arrow_item = QGraphicsPathItem(self.arrow_path, self)
self.end_arrow_item.setPos(self.graph_line.p2())
self.end_arrow_item.setRotation(-self.graph_line.angle())
self.end_arrow_item.setBrush(line_color)
self.end_arrow_item.setPen(line_color)
## Labels
n = len(self._ticks)
resize_plot_item_list(self.label_items, n, QGraphicsTextItem, self)
resize_plot_item_list(self.label_bg_items, n, QGraphicsRectItem, self)
resize_plot_item_list(self.tick_items, n, QGraphicsLineItem, self)
test_rect = QRectF(self.graph_line.p1(), self.graph_line.p2()).normalized()
test_rect.adjust(-1, -1, 1, 1)
n_v = self.graph_line.normalVector().unitVector()
if self.title_above:
n_p = n_v.p2() - n_v.p1()
else:
n_p = n_v.p1() - n_v.p2()
l_v = self.graph_line.unitVector()
l_p = l_v.p2() - l_v.p1()
for i in range(n):
pos, text, size, step = self._ticks[i]
hs = 0.5 * step
tick_pos = self.map_to_graph(pos)
if not test_rect.contains(tick_pos):
self.tick_items[i].setVisible(False)
self.label_items[i].setVisible(False)
continue
item = self.label_items[i]
item.setVisible(True)
if not zoom_only:
if self.id in XAxes or getattr(self, 'is_horizontal', False):
item.setHtml('<center>' + Qt.escape(text.strip()) + '</center>')
else:
item.setHtml(Qt.escape(text.strip()))
item.setTextWidth(-1)
text_angle = 0
if dense_text:
w = min(item.boundingRect().width(), self.max_text_width)
item.setTextWidth(w)
if self.title_above:
label_pos = tick_pos + n_p * (w + self.text_margin) + l_p * item.boundingRect().height() / 2
else:
label_pos = tick_pos + n_p * self.text_margin + l_p * item.boundingRect().height() / 2
text_angle = -90 if self.title_above else 90
else:
w = min(item.boundingRect().width(),
QLineF(self.map_to_graph(pos - hs), self.map_to_graph(pos + hs)).length())
label_pos = tick_pos + n_p * self.text_margin + l_p * item.boundingRect().height() / 2
item.setTextWidth(w)
if not self.always_horizontal_text:
if self.title_above:
item.setRotation(-self.graph_line.angle() - text_angle)
else:
item.setRotation(self.graph_line.angle() - text_angle)
item.setPos(label_pos)
item.setDefaultTextColor(text_color)
self.label_bg_items[i].setRect(item.boundingRect())
self.label_bg_items[i].setPen(QPen(Qt.NoPen))
self.label_bg_items[i].setBrush(self.plot.color(OWPalette.Canvas))
item = self.tick_items[i]
item.setVisible(True)
tick_line = QLineF(v)
tick_line.translate(-tick_line.p1())
tick_line.setLength(size)
if self.title_above:
tick_line.setAngle(tick_line.angle() + 180)
item.setLine(tick_line)
item.setPen(line_color)
item.setPos(self.map_to_graph(pos))