624 lines
23 KiB
Python
624 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
from math import atan2, degrees
|
|
from ..Qt import QtGui, QtCore
|
|
from ..Point import Point
|
|
from .GraphicsObject import GraphicsObject
|
|
from .GraphicsItem import GraphicsItem
|
|
from .TextItem import TextItem
|
|
from .ViewBox import ViewBox
|
|
from .. import functions as fn
|
|
import numpy as np
|
|
import weakref
|
|
|
|
|
|
__all__ = ['InfiniteLine', 'InfLineLabel']
|
|
|
|
|
|
class InfiniteLine(GraphicsObject):
|
|
"""
|
|
**Bases:** :class:`GraphicsObject <pyqtgraph.GraphicsObject>`
|
|
|
|
Displays a line of infinite length.
|
|
This line may be dragged to indicate a position in data coordinates.
|
|
|
|
=============================== ===================================================
|
|
**Signals:**
|
|
sigDragged(self)
|
|
sigPositionChangeFinished(self)
|
|
sigPositionChanged(self)
|
|
sigclicked(self, ev)
|
|
=============================== ===================================================
|
|
"""
|
|
|
|
sigDragged = QtCore.Signal(object)
|
|
sigPositionChangeFinished = QtCore.Signal(object)
|
|
sigPositionChanged = QtCore.Signal(object)
|
|
sigClicked = QtCore.Signal(object, object)
|
|
|
|
def __init__(self, pos=None, angle=90, pen=None, movable=False, bounds=None,
|
|
hoverPen=None, label=None, labelOpts=None, span=(0, 1), markers=None,
|
|
name=None):
|
|
"""
|
|
=============== ==================================================================
|
|
**Arguments:**
|
|
pos Position of the line. This can be a QPointF or a single value for
|
|
vertical/horizontal lines.
|
|
angle Angle of line in degrees. 0 is horizontal, 90 is vertical.
|
|
pen Pen to use when drawing line. Can be any arguments that are valid
|
|
for :func:`mkPen <pyqtgraph.mkPen>`. Default pen is transparent
|
|
yellow.
|
|
hoverPen Pen to use when the mouse cursor hovers over the line.
|
|
Only used when movable=True.
|
|
movable If True, the line can be dragged to a new position by the user.
|
|
bounds Optional [min, max] bounding values. Bounds are only valid if the
|
|
line is vertical or horizontal.
|
|
hoverPen Pen to use when drawing line when hovering over it. Can be any
|
|
arguments that are valid for :func:`mkPen <pyqtgraph.mkPen>`.
|
|
Default pen is red.
|
|
label Text to be displayed in a label attached to the line, or
|
|
None to show no label (default is None). May optionally
|
|
include formatting strings to display the line value.
|
|
labelOpts A dict of keyword arguments to use when constructing the
|
|
text label. See :class:`InfLineLabel`.
|
|
span Optional tuple (min, max) giving the range over the view to draw
|
|
the line. For example, with a vertical line, use span=(0.5, 1)
|
|
to draw only on the top half of the view.
|
|
markers List of (marker, position, size) tuples, one per marker to display
|
|
on the line. See the addMarker method.
|
|
name Name of the item
|
|
=============== ==================================================================
|
|
"""
|
|
self._boundingRect = None
|
|
|
|
self._name = name
|
|
|
|
GraphicsObject.__init__(self)
|
|
|
|
if bounds is None: ## allowed value boundaries for orthogonal lines
|
|
self.maxRange = [None, None]
|
|
else:
|
|
self.maxRange = bounds
|
|
self.moving = False
|
|
self.setMovable(movable)
|
|
self.mouseHovering = False
|
|
self.p = [0, 0]
|
|
self.setAngle(angle)
|
|
|
|
if pos is None:
|
|
pos = Point(0,0)
|
|
self.setPos(pos)
|
|
|
|
if pen is None:
|
|
pen = (200, 200, 100)
|
|
self.setPen(pen)
|
|
|
|
if hoverPen is None:
|
|
self.setHoverPen(color=(255,0,0), width=self.pen.width())
|
|
else:
|
|
self.setHoverPen(hoverPen)
|
|
|
|
self.span = span
|
|
self.currentPen = self.pen
|
|
|
|
self.markers = []
|
|
self._maxMarkerSize = 0
|
|
if markers is not None:
|
|
for m in markers:
|
|
self.addMarker(*m)
|
|
|
|
# Cache variables for managing bounds
|
|
self._endPoints = [0, 1] #
|
|
self._bounds = None
|
|
self._lastViewSize = None
|
|
|
|
if label is not None:
|
|
labelOpts = {} if labelOpts is None else labelOpts
|
|
self.label = InfLineLabel(self, text=label, **labelOpts)
|
|
|
|
def setMovable(self, m):
|
|
"""Set whether the line is movable by the user."""
|
|
self.movable = m
|
|
self.setAcceptHoverEvents(m)
|
|
|
|
def setBounds(self, bounds):
|
|
"""Set the (minimum, maximum) allowable values when dragging."""
|
|
self.maxRange = bounds
|
|
self.setValue(self.value())
|
|
|
|
def bounds(self):
|
|
"""Return the (minimum, maximum) values allowed when dragging.
|
|
"""
|
|
return self.maxRange[:]
|
|
|
|
def setPen(self, *args, **kwargs):
|
|
"""Set the pen for drawing the line. Allowable arguments are any that are valid
|
|
for :func:`mkPen <pyqtgraph.mkPen>`."""
|
|
self.pen = fn.mkPen(*args, **kwargs)
|
|
if not self.mouseHovering:
|
|
self.currentPen = self.pen
|
|
self.update()
|
|
|
|
def setHoverPen(self, *args, **kwargs):
|
|
"""Set the pen for drawing the line while the mouse hovers over it.
|
|
Allowable arguments are any that are valid
|
|
for :func:`mkPen <pyqtgraph.mkPen>`.
|
|
|
|
If the line is not movable, then hovering is also disabled.
|
|
|
|
Added in version 0.9.9."""
|
|
# If user did not supply a width, then copy it from pen
|
|
widthSpecified = ((len(args) == 1 and
|
|
(isinstance(args[0], QtGui.QPen) or
|
|
(isinstance(args[0], dict) and 'width' in args[0]))
|
|
) or 'width' in kwargs)
|
|
self.hoverPen = fn.mkPen(*args, **kwargs)
|
|
if not widthSpecified:
|
|
self.hoverPen.setWidth(self.pen.width())
|
|
|
|
if self.mouseHovering:
|
|
self.currentPen = self.hoverPen
|
|
self.update()
|
|
|
|
def addMarker(self, marker, position=0.5, size=10.0):
|
|
"""Add a marker to be displayed on the line.
|
|
|
|
============= =========================================================
|
|
**Arguments**
|
|
marker String indicating the style of marker to add:
|
|
``'<|'``, ``'|>'``, ``'>|'``, ``'|<'``, ``'<|>'``,
|
|
``'>|<'``, ``'^'``, ``'v'``, ``'o'``
|
|
position Position (0.0-1.0) along the visible extent of the line
|
|
to place the marker. Default is 0.5.
|
|
size Size of the marker in pixels. Default is 10.0.
|
|
============= =========================================================
|
|
"""
|
|
path = QtGui.QPainterPath()
|
|
if marker == 'o':
|
|
path.addEllipse(QtCore.QRectF(-0.5, -0.5, 1, 1))
|
|
if '<|' in marker:
|
|
p = QtGui.QPolygonF([Point(0.5, 0), Point(0, -0.5), Point(-0.5, 0)])
|
|
path.addPolygon(p)
|
|
path.closeSubpath()
|
|
if '|>' in marker:
|
|
p = QtGui.QPolygonF([Point(0.5, 0), Point(0, 0.5), Point(-0.5, 0)])
|
|
path.addPolygon(p)
|
|
path.closeSubpath()
|
|
if '>|' in marker:
|
|
p = QtGui.QPolygonF([Point(0.5, -0.5), Point(0, 0), Point(-0.5, -0.5)])
|
|
path.addPolygon(p)
|
|
path.closeSubpath()
|
|
if '|<' in marker:
|
|
p = QtGui.QPolygonF([Point(0.5, 0.5), Point(0, 0), Point(-0.5, 0.5)])
|
|
path.addPolygon(p)
|
|
path.closeSubpath()
|
|
if '^' in marker:
|
|
p = QtGui.QPolygonF([Point(0, -0.5), Point(0.5, 0), Point(0, 0.5)])
|
|
path.addPolygon(p)
|
|
path.closeSubpath()
|
|
if 'v' in marker:
|
|
p = QtGui.QPolygonF([Point(0, -0.5), Point(-0.5, 0), Point(0, 0.5)])
|
|
path.addPolygon(p)
|
|
path.closeSubpath()
|
|
|
|
self.markers.append((path, position, size))
|
|
self._maxMarkerSize = max([m[2] / 2. for m in self.markers])
|
|
self.update()
|
|
|
|
def clearMarkers(self):
|
|
""" Remove all markers from this line.
|
|
"""
|
|
self.markers = []
|
|
self._maxMarkerSize = 0
|
|
self.update()
|
|
|
|
def setAngle(self, angle):
|
|
"""
|
|
Takes angle argument in degrees.
|
|
0 is horizontal; 90 is vertical.
|
|
|
|
Note that the use of value() and setValue() changes if the line is
|
|
not vertical or horizontal.
|
|
"""
|
|
self.angle = angle #((angle+45) % 180) - 45 ## -45 <= angle < 135
|
|
self.resetTransform()
|
|
self.setRotation(self.angle)
|
|
self.update()
|
|
|
|
def setPos(self, pos):
|
|
|
|
if isinstance(pos, (list, tuple, np.ndarray)) and not np.ndim(pos) == 0:
|
|
newPos = list(pos)
|
|
elif isinstance(pos, QtCore.QPointF):
|
|
newPos = [pos.x(), pos.y()]
|
|
else:
|
|
if self.angle == 90:
|
|
newPos = [pos, 0]
|
|
elif self.angle == 0:
|
|
newPos = [0, pos]
|
|
else:
|
|
raise Exception("Must specify 2D coordinate for non-orthogonal lines.")
|
|
|
|
## check bounds (only works for orthogonal lines)
|
|
if self.angle == 90:
|
|
if self.maxRange[0] is not None:
|
|
newPos[0] = max(newPos[0], self.maxRange[0])
|
|
if self.maxRange[1] is not None:
|
|
newPos[0] = min(newPos[0], self.maxRange[1])
|
|
elif self.angle == 0:
|
|
if self.maxRange[0] is not None:
|
|
newPos[1] = max(newPos[1], self.maxRange[0])
|
|
if self.maxRange[1] is not None:
|
|
newPos[1] = min(newPos[1], self.maxRange[1])
|
|
|
|
if self.p != newPos:
|
|
self.p = newPos
|
|
self.viewTransformChanged()
|
|
GraphicsObject.setPos(self, Point(self.p))
|
|
self.sigPositionChanged.emit(self)
|
|
|
|
def getXPos(self):
|
|
return self.p[0]
|
|
|
|
def getYPos(self):
|
|
return self.p[1]
|
|
|
|
def getPos(self):
|
|
return self.p
|
|
|
|
def value(self):
|
|
"""Return the value of the line. Will be a single number for horizontal and
|
|
vertical lines, and a list of [x,y] values for diagonal lines."""
|
|
if self.angle%180 == 0:
|
|
return self.getYPos()
|
|
elif self.angle%180 == 90:
|
|
return self.getXPos()
|
|
else:
|
|
return self.getPos()
|
|
|
|
def setValue(self, v):
|
|
"""Set the position of the line. If line is horizontal or vertical, v can be
|
|
a single value. Otherwise, a 2D coordinate must be specified (list, tuple and
|
|
QPointF are all acceptable)."""
|
|
self.setPos(v)
|
|
|
|
## broken in 4.7
|
|
#def itemChange(self, change, val):
|
|
#if change in [self.ItemScenePositionHasChanged, self.ItemSceneHasChanged]:
|
|
#self.updateLine()
|
|
#print "update", change
|
|
#print self.getBoundingParents()
|
|
#else:
|
|
#print "ignore", change
|
|
#return GraphicsObject.itemChange(self, change, val)
|
|
|
|
def setSpan(self, mn, mx):
|
|
if self.span != (mn, mx):
|
|
self.span = (mn, mx)
|
|
self.update()
|
|
|
|
def _computeBoundingRect(self):
|
|
#br = UIGraphicsItem.boundingRect(self)
|
|
vr = self.viewRect() # bounds of containing ViewBox mapped to local coords.
|
|
if vr is None:
|
|
return QtCore.QRectF()
|
|
|
|
## add a 4-pixel radius around the line for mouse interaction.
|
|
|
|
px = self.pixelLength(direction=Point(1,0), ortho=True) ## get pixel length orthogonal to the line
|
|
if px is None:
|
|
px = 0
|
|
pw = max(self.pen.width() / 2, self.hoverPen.width() / 2)
|
|
w = max(4, self._maxMarkerSize + pw) + 1
|
|
w = w * px
|
|
br = QtCore.QRectF(vr)
|
|
br.setBottom(-w)
|
|
br.setTop(w)
|
|
|
|
length = br.width()
|
|
left = br.left() + length * self.span[0]
|
|
right = br.left() + length * self.span[1]
|
|
br.setLeft(left)
|
|
br.setRight(right)
|
|
br = br.normalized()
|
|
|
|
vs = self.getViewBox().size()
|
|
|
|
if self._bounds != br or self._lastViewSize != vs:
|
|
self._bounds = br
|
|
self._lastViewSize = vs
|
|
self.prepareGeometryChange()
|
|
|
|
self._endPoints = (left, right)
|
|
self._lastViewRect = vr
|
|
|
|
return self._bounds
|
|
|
|
def boundingRect(self):
|
|
if self._boundingRect is None:
|
|
self._boundingRect = self._computeBoundingRect()
|
|
return self._boundingRect
|
|
|
|
def paint(self, p, *args):
|
|
p.setRenderHint(p.Antialiasing)
|
|
|
|
left, right = self._endPoints
|
|
pen = self.currentPen
|
|
pen.setJoinStyle(QtCore.Qt.MiterJoin)
|
|
p.setPen(pen)
|
|
p.drawLine(Point(left, 0), Point(right, 0))
|
|
|
|
|
|
if len(self.markers) == 0:
|
|
return
|
|
|
|
# paint markers in native coordinate system
|
|
tr = p.transform()
|
|
p.resetTransform()
|
|
|
|
start = tr.map(Point(left, 0))
|
|
end = tr.map(Point(right, 0))
|
|
up = tr.map(Point(left, 1))
|
|
dif = end - start
|
|
length = Point(dif).length()
|
|
angle = degrees(atan2(dif.y(), dif.x()))
|
|
|
|
p.translate(start)
|
|
p.rotate(angle)
|
|
|
|
up = up - start
|
|
det = up.x() * dif.y() - dif.x() * up.y()
|
|
p.scale(1, 1 if det > 0 else -1)
|
|
|
|
p.setBrush(fn.mkBrush(self.currentPen.color()))
|
|
#p.setPen(fn.mkPen(None))
|
|
tr = p.transform()
|
|
for path, pos, size in self.markers:
|
|
p.setTransform(tr)
|
|
x = length * pos
|
|
p.translate(x, 0)
|
|
p.scale(size, size)
|
|
p.drawPath(path)
|
|
|
|
def dataBounds(self, axis, frac=1.0, orthoRange=None):
|
|
if axis == 0:
|
|
return None ## x axis should never be auto-scaled
|
|
else:
|
|
return (0,0)
|
|
|
|
def mouseDragEvent(self, ev):
|
|
if self.movable and ev.button() == QtCore.Qt.LeftButton:
|
|
if ev.isStart():
|
|
self.moving = True
|
|
self.cursorOffset = self.pos() - self.mapToParent(ev.buttonDownPos())
|
|
self.startPosition = self.pos()
|
|
ev.accept()
|
|
|
|
if not self.moving:
|
|
return
|
|
|
|
self.setPos(self.cursorOffset + self.mapToParent(ev.pos()))
|
|
self.sigDragged.emit(self)
|
|
if ev.isFinish():
|
|
self.moving = False
|
|
self.sigPositionChangeFinished.emit(self)
|
|
|
|
def mouseClickEvent(self, ev):
|
|
self.sigClicked.emit(self, ev)
|
|
if self.moving and ev.button() == QtCore.Qt.RightButton:
|
|
ev.accept()
|
|
self.setPos(self.startPosition)
|
|
self.moving = False
|
|
self.sigDragged.emit(self)
|
|
self.sigPositionChangeFinished.emit(self)
|
|
|
|
def hoverEvent(self, ev):
|
|
if (not ev.isExit()) and self.movable and ev.acceptDrags(QtCore.Qt.LeftButton):
|
|
self.setMouseHover(True)
|
|
else:
|
|
self.setMouseHover(False)
|
|
|
|
def setMouseHover(self, hover):
|
|
## Inform the item that the mouse is (not) hovering over it
|
|
if self.mouseHovering == hover:
|
|
return
|
|
self.mouseHovering = hover
|
|
if hover:
|
|
self.currentPen = self.hoverPen
|
|
else:
|
|
self.currentPen = self.pen
|
|
self.update()
|
|
|
|
def viewTransformChanged(self):
|
|
"""
|
|
Called whenever the transformation matrix of the view has changed.
|
|
(eg, the view range has changed or the view was resized)
|
|
"""
|
|
self._boundingRect = None
|
|
GraphicsItem.viewTransformChanged(self)
|
|
|
|
def setName(self, name):
|
|
self._name = name
|
|
|
|
def name(self):
|
|
return self._name
|
|
|
|
|
|
class InfLineLabel(TextItem):
|
|
"""
|
|
A TextItem that attaches itself to an InfiniteLine.
|
|
|
|
This class extends TextItem with the following features:
|
|
|
|
* Automatically positions adjacent to the line at a fixed position along
|
|
the line and within the view box.
|
|
* Automatically reformats text when the line value has changed.
|
|
* Can optionally be dragged to change its location along the line.
|
|
* Optionally aligns to its parent line.
|
|
|
|
=============== ==================================================================
|
|
**Arguments:**
|
|
line The InfiniteLine to which this label will be attached.
|
|
text String to display in the label. May contain a {value} formatting
|
|
string to display the current value of the line.
|
|
movable Bool; if True, then the label can be dragged along the line.
|
|
position Relative position (0.0-1.0) within the view to position the label
|
|
along the line.
|
|
anchors List of (x,y) pairs giving the text anchor positions that should
|
|
be used when the line is moved to one side of the view or the
|
|
other. This allows text to switch to the opposite side of the line
|
|
as it approaches the edge of the view. These are automatically
|
|
selected for some common cases, but may be specified if the
|
|
default values give unexpected results.
|
|
=============== ==================================================================
|
|
|
|
All extra keyword arguments are passed to TextItem. A particularly useful
|
|
option here is to use `rotateAxis=(1, 0)`, which will cause the text to
|
|
be automatically rotated parallel to the line.
|
|
"""
|
|
def __init__(self, line, text="", movable=False, position=0.5, anchors=None, **kwds):
|
|
self.line = line
|
|
self.movable = movable
|
|
self.moving = False
|
|
self.orthoPos = position # text will always be placed on the line at a position relative to view bounds
|
|
self.format = text
|
|
self.line.sigPositionChanged.connect(self.valueChanged)
|
|
self._endpoints = (None, None)
|
|
if anchors is None:
|
|
# automatically pick sensible anchors
|
|
rax = kwds.get('rotateAxis', None)
|
|
if rax is not None:
|
|
if tuple(rax) == (1,0):
|
|
anchors = [(0.5, 0), (0.5, 1)]
|
|
else:
|
|
anchors = [(0, 0.5), (1, 0.5)]
|
|
else:
|
|
if line.angle % 180 == 0:
|
|
anchors = [(0.5, 0), (0.5, 1)]
|
|
else:
|
|
anchors = [(0, 0.5), (1, 0.5)]
|
|
|
|
self.anchors = anchors
|
|
TextItem.__init__(self, **kwds)
|
|
self.setParentItem(line)
|
|
self.valueChanged()
|
|
|
|
def valueChanged(self):
|
|
if not self.isVisible():
|
|
return
|
|
value = self.line.value()
|
|
self.setText(self.format.format(value=value))
|
|
self.updatePosition()
|
|
|
|
def getEndpoints(self):
|
|
# calculate points where line intersects view box
|
|
# (in line coordinates)
|
|
if self._endpoints[0] is None:
|
|
lr = self.line.boundingRect()
|
|
pt1 = Point(lr.left(), 0)
|
|
pt2 = Point(lr.right(), 0)
|
|
|
|
if self.line.angle % 90 != 0:
|
|
# more expensive to find text position for oblique lines.
|
|
view = self.getViewBox()
|
|
if not self.isVisible() or not isinstance(view, ViewBox):
|
|
# not in a viewbox, skip update
|
|
return (None, None)
|
|
p = QtGui.QPainterPath()
|
|
p.moveTo(pt1)
|
|
p.lineTo(pt2)
|
|
p = self.line.itemTransform(view)[0].map(p)
|
|
vr = QtGui.QPainterPath()
|
|
vr.addRect(view.boundingRect())
|
|
paths = vr.intersected(p).toSubpathPolygons(QtGui.QTransform())
|
|
if len(paths) > 0:
|
|
l = list(paths[0])
|
|
pt1 = self.line.mapFromItem(view, l[0])
|
|
pt2 = self.line.mapFromItem(view, l[1])
|
|
self._endpoints = (pt1, pt2)
|
|
return self._endpoints
|
|
|
|
def updatePosition(self):
|
|
# update text position to relative view location along line
|
|
self._endpoints = (None, None)
|
|
pt1, pt2 = self.getEndpoints()
|
|
if pt1 is None:
|
|
return
|
|
pt = pt2 * self.orthoPos + pt1 * (1-self.orthoPos)
|
|
self.setPos(pt)
|
|
|
|
# update anchor to keep text visible as it nears the view box edge
|
|
vr = self.line.viewRect()
|
|
if vr is not None:
|
|
self.setAnchor(self.anchors[0 if vr.center().y() < 0 else 1])
|
|
|
|
def setVisible(self, v):
|
|
TextItem.setVisible(self, v)
|
|
if v:
|
|
self.valueChanged()
|
|
|
|
def setMovable(self, m):
|
|
"""Set whether this label is movable by dragging along the line.
|
|
"""
|
|
self.movable = m
|
|
self.setAcceptHoverEvents(m)
|
|
|
|
def setPosition(self, p):
|
|
"""Set the relative position (0.0-1.0) of this label within the view box
|
|
and along the line.
|
|
|
|
For horizontal (angle=0) and vertical (angle=90) lines, a value of 0.0
|
|
places the text at the bottom or left of the view, respectively.
|
|
"""
|
|
self.orthoPos = p
|
|
self.updatePosition()
|
|
|
|
def setFormat(self, text):
|
|
"""Set the text format string for this label.
|
|
|
|
May optionally contain "{value}" to include the lines current value
|
|
(the text will be reformatted whenever the line is moved).
|
|
"""
|
|
self.format = text
|
|
self.valueChanged()
|
|
|
|
def mouseDragEvent(self, ev):
|
|
if self.movable and ev.button() == QtCore.Qt.LeftButton:
|
|
if ev.isStart():
|
|
self._moving = True
|
|
self._cursorOffset = self._posToRel(ev.buttonDownPos())
|
|
self._startPosition = self.orthoPos
|
|
ev.accept()
|
|
|
|
if not self._moving:
|
|
return
|
|
|
|
rel = self._posToRel(ev.pos())
|
|
self.orthoPos = fn.clip_scalar(self._startPosition + rel - self._cursorOffset, 0., 1.)
|
|
self.updatePosition()
|
|
if ev.isFinish():
|
|
self._moving = False
|
|
|
|
def mouseClickEvent(self, ev):
|
|
if self.moving and ev.button() == QtCore.Qt.RightButton:
|
|
ev.accept()
|
|
self.orthoPos = self._startPosition
|
|
self.moving = False
|
|
|
|
def hoverEvent(self, ev):
|
|
if not ev.isExit() and self.movable:
|
|
ev.acceptDrags(QtCore.Qt.LeftButton)
|
|
|
|
def viewTransformChanged(self):
|
|
GraphicsItem.viewTransformChanged(self)
|
|
self.updatePosition()
|
|
TextItem.viewTransformChanged(self)
|
|
|
|
def _posToRel(self, pos):
|
|
# convert local position to relative position along line between view bounds
|
|
pt1, pt2 = self.getEndpoints()
|
|
if pt1 is None:
|
|
return 0
|
|
view = self.getViewBox()
|
|
pos = self.mapToParent(pos)
|
|
return (pos.x() - pt1.x()) / (pt2.x()-pt1.x())
|