Source code for pyqtgraph.graphicsItems.InfiniteLine

from math import atan2, degrees

import numpy as np

from .. import functions as fn
from ..Point import Point
from ..Qt import QtCore, QtGui
from .GraphicsItem import GraphicsItem
from .GraphicsObject import GraphicsObject
from .TextItem import TextItem
from .ViewBox import ViewBox

__all__ = ['InfiniteLine', 'InfLineLabel']

[docs]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)
[docs] 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 <pyqtgraph.graphicsItems.InfiniteLine.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)
[docs] def setMovable(self, m): """Set whether the line is movable by the user.""" self.movable = m self.setAcceptHoverEvents(m)
[docs] def setBounds(self, bounds): """Set the (minimum, maximum) allowable values when dragging.""" self.maxRange = bounds self.setValue(self.value())
[docs] def bounds(self): """Return the (minimum, maximum) values allowed when dragging. """ return self.maxRange[:]
[docs] 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()
[docs] 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()
[docs] 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()
[docs] def clearMarkers(self): """ Remove all markers from this line. """ self.markers = [] self._maxMarkerSize = 0 self.update()
[docs] 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
[docs] 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()
[docs] 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.GraphicsItemChange.ItemScenePositionHasChanged, self.GraphicsItemChange.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() # compute the pixel size orthogonal to the line # this is more complicated than it seems, maybe it can be simplified _, ortho = self.pixelVectors(direction=Point(1, 0)) px = 0 if ortho is None else ortho.y() pw = max(self.pen.width() / 2, self.hoverPen.width() / 2) w = (self._maxMarkerSize + pw + 1) * 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.RenderHint.Antialiasing) left, right = self._endPoints pen = self.currentPen pen.setJoinStyle(QtCore.Qt.PenJoinStyle.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 =, 0)) end =, 0)) up =, 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.MouseButton.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.MouseButton.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.MouseButton.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()
[docs] 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
[docs]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. """
[docs] 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 < 0 else 1]) def setVisible(self, v): TextItem.setVisible(self, v) if v: self.valueChanged()
[docs] def setMovable(self, m): """Set whether this label is movable by dragging along the line. """ self.movable = m self.setAcceptHoverEvents(m)
[docs] 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()
[docs] 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.MouseButton.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.MouseButton.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.MouseButton.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 pos = self.mapToParent(pos) return (pos.x() - pt1.x()) / (pt2.x()-pt1.x())