b78662c33e
- curves enable antialiasing when exporting to image - plotitems hide button during export
506 lines
19 KiB
Python
506 lines
19 KiB
Python
from pyqtgraph.Qt import QtGui, QtCore
|
|
import numpy as np
|
|
from pyqtgraph.Point import Point
|
|
import pyqtgraph.debug as debug
|
|
import weakref
|
|
import pyqtgraph.functions as fn
|
|
from GraphicsWidget import GraphicsWidget
|
|
|
|
__all__ = ['AxisItem']
|
|
class AxisItem(GraphicsWidget):
|
|
def __init__(self, orientation, pen=None, linkView=None, parent=None, maxTickLength=-5, showValues=True):
|
|
"""
|
|
GraphicsItem showing a single plot axis with ticks, values, and label.
|
|
Can be configured to fit on any side of a plot, and can automatically synchronize its displayed scale with ViewBox items.
|
|
Ticks can be extended to make a grid.
|
|
"""
|
|
|
|
|
|
GraphicsWidget.__init__(self, parent)
|
|
self.label = QtGui.QGraphicsTextItem(self)
|
|
self.showValues = showValues
|
|
self.picture = None
|
|
self.orientation = orientation
|
|
if orientation not in ['left', 'right', 'top', 'bottom']:
|
|
raise Exception("Orientation argument must be one of 'left', 'right', 'top', or 'bottom'.")
|
|
if orientation in ['left', 'right']:
|
|
#self.setMinimumWidth(25)
|
|
#self.setSizePolicy(QtGui.QSizePolicy(
|
|
#QtGui.QSizePolicy.Minimum,
|
|
#QtGui.QSizePolicy.Expanding
|
|
#))
|
|
self.label.rotate(-90)
|
|
#else:
|
|
#self.setMinimumHeight(50)
|
|
#self.setSizePolicy(QtGui.QSizePolicy(
|
|
#QtGui.QSizePolicy.Expanding,
|
|
#QtGui.QSizePolicy.Minimum
|
|
#))
|
|
#self.drawLabel = False
|
|
|
|
self.labelText = ''
|
|
self.labelUnits = ''
|
|
self.labelUnitPrefix=''
|
|
self.labelStyle = {'color': '#CCC'}
|
|
|
|
self.textHeight = 18
|
|
self.tickLength = maxTickLength
|
|
self.scale = 1.0
|
|
self.autoScale = True
|
|
|
|
self.setRange(0, 1)
|
|
|
|
if pen is None:
|
|
pen = QtGui.QPen(QtGui.QColor(100, 100, 100))
|
|
self.setPen(pen)
|
|
|
|
self._linkedView = None
|
|
if linkView is not None:
|
|
self.linkToView(linkView)
|
|
|
|
self.showLabel(False)
|
|
|
|
self.grid = False
|
|
#self.setCacheMode(self.DeviceCoordinateCache)
|
|
|
|
def close(self):
|
|
self.scene().removeItem(self.label)
|
|
self.label = None
|
|
self.scene().removeItem(self)
|
|
|
|
def setGrid(self, grid):
|
|
"""Set the alpha value for the grid, or False to disable."""
|
|
self.grid = grid
|
|
self.picture = None
|
|
self.prepareGeometryChange()
|
|
self.update()
|
|
|
|
|
|
def resizeEvent(self, ev=None):
|
|
#s = self.size()
|
|
|
|
## Set the position of the label
|
|
nudge = 5
|
|
br = self.label.boundingRect()
|
|
p = QtCore.QPointF(0, 0)
|
|
if self.orientation == 'left':
|
|
p.setY(int(self.size().height()/2 + br.width()/2))
|
|
p.setX(-nudge)
|
|
#s.setWidth(10)
|
|
elif self.orientation == 'right':
|
|
#s.setWidth(10)
|
|
p.setY(int(self.size().height()/2 + br.width()/2))
|
|
p.setX(int(self.size().width()-br.height()+nudge))
|
|
elif self.orientation == 'top':
|
|
#s.setHeight(10)
|
|
p.setY(-nudge)
|
|
p.setX(int(self.size().width()/2. - br.width()/2.))
|
|
elif self.orientation == 'bottom':
|
|
p.setX(int(self.size().width()/2. - br.width()/2.))
|
|
#s.setHeight(10)
|
|
p.setY(int(self.size().height()-br.height()+nudge))
|
|
#self.label.resize(s)
|
|
self.label.setPos(p)
|
|
self.picture = None
|
|
|
|
def showLabel(self, show=True):
|
|
#self.drawLabel = show
|
|
self.label.setVisible(show)
|
|
if self.orientation in ['left', 'right']:
|
|
self.setWidth()
|
|
else:
|
|
self.setHeight()
|
|
if self.autoScale:
|
|
self.setScale()
|
|
|
|
def setLabel(self, text=None, units=None, unitPrefix=None, **args):
|
|
if text is not None:
|
|
self.labelText = text
|
|
self.showLabel()
|
|
if units is not None:
|
|
self.labelUnits = units
|
|
self.showLabel()
|
|
if unitPrefix is not None:
|
|
self.labelUnitPrefix = unitPrefix
|
|
if len(args) > 0:
|
|
self.labelStyle = args
|
|
self.label.setHtml(self.labelString())
|
|
self.resizeEvent()
|
|
self.picture = None
|
|
self.update()
|
|
|
|
def labelString(self):
|
|
if self.labelUnits == '':
|
|
if self.scale == 1.0:
|
|
units = ''
|
|
else:
|
|
units = u'(x%g)' % (1.0/self.scale)
|
|
else:
|
|
#print repr(self.labelUnitPrefix), repr(self.labelUnits)
|
|
units = u'(%s%s)' % (self.labelUnitPrefix, self.labelUnits)
|
|
|
|
s = u'%s %s' % (self.labelText, units)
|
|
|
|
style = ';'.join(['%s: "%s"' % (k, self.labelStyle[k]) for k in self.labelStyle])
|
|
|
|
return u"<span style='%s'>%s</span>" % (style, s)
|
|
|
|
def setHeight(self, h=None):
|
|
if h is None:
|
|
h = self.textHeight + max(0, self.tickLength)
|
|
if self.label.isVisible():
|
|
h += self.textHeight
|
|
self.setMaximumHeight(h)
|
|
self.setMinimumHeight(h)
|
|
self.picture = None
|
|
|
|
|
|
def setWidth(self, w=None):
|
|
if w is None:
|
|
w = max(0, self.tickLength) + 40
|
|
if self.label.isVisible():
|
|
w += self.textHeight
|
|
self.setMaximumWidth(w)
|
|
self.setMinimumWidth(w)
|
|
|
|
def setPen(self, pen):
|
|
self.pen = pen
|
|
self.picture = None
|
|
self.update()
|
|
|
|
def setScale(self, scale=None):
|
|
"""
|
|
Set the value scaling for this axis.
|
|
The scaling value 1) multiplies the values displayed along the axis
|
|
and 2) changes the way units are displayed in the label.
|
|
For example:
|
|
If the axis spans values from -0.1 to 0.1 and has units set to 'V'
|
|
then a scale of 1000 would cause the axis to display values -100 to 100
|
|
and the units would appear as 'mV'
|
|
If scale is None, then it will be determined automatically based on the current
|
|
range displayed by the axis.
|
|
"""
|
|
if scale is None:
|
|
#if self.drawLabel: ## If there is a label, then we are free to rescale the values
|
|
if self.label.isVisible():
|
|
d = self.range[1] - self.range[0]
|
|
#(scale, prefix) = fn.siScale(d / 2.)
|
|
(scale, prefix) = fn.siScale(max(abs(self.range[0]), abs(self.range[1])))
|
|
if self.labelUnits == '' and prefix in ['k', 'm']: ## If we are not showing units, wait until 1e6 before scaling.
|
|
scale = 1.0
|
|
prefix = ''
|
|
self.setLabel(unitPrefix=prefix)
|
|
else:
|
|
scale = 1.0
|
|
|
|
|
|
if scale != self.scale:
|
|
self.scale = scale
|
|
self.setLabel()
|
|
self.picture = None
|
|
self.update()
|
|
|
|
def setRange(self, mn, mx):
|
|
if mn in [np.nan, np.inf, -np.inf] or mx in [np.nan, np.inf, -np.inf]:
|
|
raise Exception("Not setting range to [%s, %s]" % (str(mn), str(mx)))
|
|
self.range = [mn, mx]
|
|
if self.autoScale:
|
|
self.setScale()
|
|
self.picture = None
|
|
self.update()
|
|
|
|
def linkedView(self):
|
|
"""Return the ViewBox this axis is linked to"""
|
|
if self._linkedView is None:
|
|
return None
|
|
else:
|
|
return self._linkedView()
|
|
|
|
def linkToView(self, view):
|
|
oldView = self.linkedView()
|
|
self._linkedView = weakref.ref(view)
|
|
if self.orientation in ['right', 'left']:
|
|
if oldView is not None:
|
|
oldView.sigYRangeChanged.disconnect(self.linkedViewChanged)
|
|
view.sigYRangeChanged.connect(self.linkedViewChanged)
|
|
else:
|
|
if oldView is not None:
|
|
oldView.sigXRangeChanged.disconnect(self.linkedViewChanged)
|
|
view.sigXRangeChanged.connect(self.linkedViewChanged)
|
|
|
|
def linkedViewChanged(self, view, newRange):
|
|
self.setRange(*newRange)
|
|
|
|
def boundingRect(self):
|
|
linkedView = self.linkedView()
|
|
if linkedView is None or self.grid is False:
|
|
rect = self.mapRectFromParent(self.geometry())
|
|
## extend rect if ticks go in negative direction
|
|
if self.orientation == 'left':
|
|
rect.setRight(rect.right() - min(0,self.tickLength))
|
|
elif self.orientation == 'right':
|
|
rect.setLeft(rect.left() + min(0,self.tickLength))
|
|
elif self.orientation == 'top':
|
|
rect.setBottom(rect.bottom() - min(0,self.tickLength))
|
|
elif self.orientation == 'bottom':
|
|
rect.setTop(rect.top() + min(0,self.tickLength))
|
|
return rect
|
|
else:
|
|
return self.mapRectFromParent(self.geometry()) | linkedView.mapRectToItem(self, linkedView.boundingRect())
|
|
|
|
def paint(self, p, opt, widget):
|
|
if self.picture is None:
|
|
self.picture = QtGui.QPicture()
|
|
painter = QtGui.QPainter(self.picture)
|
|
try:
|
|
self.drawPicture(painter)
|
|
finally:
|
|
painter.end()
|
|
self.picture.play(p)
|
|
|
|
|
|
def drawPicture(self, p):
|
|
|
|
p.setRenderHint(p.Antialiasing, False)
|
|
p.setRenderHint(p.TextAntialiasing, True)
|
|
|
|
prof = debug.Profiler("AxisItem.paint", disabled=True)
|
|
p.setPen(self.pen)
|
|
|
|
#bounds = self.boundingRect()
|
|
bounds = self.mapRectFromParent(self.geometry())
|
|
|
|
linkedView = self.linkedView()
|
|
if linkedView is None or self.grid is False:
|
|
tbounds = bounds
|
|
else:
|
|
tbounds = linkedView.mapRectToItem(self, linkedView.boundingRect())
|
|
|
|
if self.orientation == 'left':
|
|
span = (bounds.topRight(), bounds.bottomRight())
|
|
tickStart = tbounds.right()
|
|
tickStop = bounds.right()
|
|
tickDir = -1
|
|
axis = 0
|
|
elif self.orientation == 'right':
|
|
span = (bounds.topLeft(), bounds.bottomLeft())
|
|
tickStart = tbounds.left()
|
|
tickStop = bounds.left()
|
|
tickDir = 1
|
|
axis = 0
|
|
elif self.orientation == 'top':
|
|
span = (bounds.bottomLeft(), bounds.bottomRight())
|
|
tickStart = tbounds.bottom()
|
|
tickStop = bounds.bottom()
|
|
tickDir = -1
|
|
axis = 1
|
|
elif self.orientation == 'bottom':
|
|
span = (bounds.topLeft(), bounds.topRight())
|
|
tickStart = tbounds.top()
|
|
tickStop = bounds.top()
|
|
tickDir = 1
|
|
axis = 1
|
|
|
|
## draw long line along axis
|
|
p.drawLine(*span)
|
|
|
|
## determine size of this item in pixels
|
|
points = map(self.mapToDevice, span)
|
|
lengthInPixels = Point(points[1] - points[0]).length()
|
|
|
|
## decide optimal tick spacing in pixels
|
|
pixelSpacing = np.log(lengthInPixels+10) * 2
|
|
optimalTickCount = lengthInPixels / pixelSpacing
|
|
|
|
## Determine optimal tick spacing
|
|
#intervals = [1., 2., 5., 10., 20., 50.]
|
|
#intervals = [1., 2.5, 5., 10., 25., 50.]
|
|
intervals = np.array([0.1, 0.2, 1., 2., 10., 20., 100., 200.])
|
|
dif = abs(self.range[1] - self.range[0])
|
|
if dif == 0.0:
|
|
return
|
|
pw = 10 ** (np.floor(np.log10(dif))-1)
|
|
scaledIntervals = intervals * pw
|
|
scaledTickCounts = dif / scaledIntervals
|
|
try:
|
|
i1 = np.argwhere(scaledTickCounts < optimalTickCount)[0,0]
|
|
except:
|
|
print "AxisItem can't determine tick spacing:"
|
|
print "scaledTickCounts", scaledTickCounts
|
|
print "optimalTickCount", optimalTickCount
|
|
print "dif", dif
|
|
print "scaledIntervals", scaledIntervals
|
|
print "intervals", intervals
|
|
print "pw", pw
|
|
print "pixelSpacing", pixelSpacing
|
|
i1 = 1
|
|
|
|
distBetweenIntervals = (optimalTickCount-scaledTickCounts[i1]) / (scaledTickCounts[i1-1]-scaledTickCounts[i1])
|
|
|
|
#print optimalTickCount, i1, scaledIntervals, distBetweenIntervals
|
|
|
|
#for i in range(len(intervals)):
|
|
#i1 = i
|
|
#if dif / (pw*intervals[i]) < 10:
|
|
#break
|
|
|
|
textLevel = 1 ## draw text at this scale level
|
|
|
|
#print "range: %s dif: %f power: %f interval: %f spacing: %f" % (str(self.range), dif, pw, intervals[i1], sp)
|
|
|
|
#print " start at %f, %d ticks" % (start, num)
|
|
|
|
|
|
if axis == 0:
|
|
xs = -bounds.height() / dif
|
|
else:
|
|
xs = bounds.width() / dif
|
|
|
|
prof.mark('init')
|
|
|
|
tickPositions = set() # remembers positions of previously drawn ticks
|
|
## draw ticks and generate list of texts to draw
|
|
## (to improve performance, we do not interleave line and text drawing, since this causes unnecessary pipeline switching)
|
|
## draw three different intervals, long ticks first
|
|
texts = []
|
|
for i in [2,1,0]:
|
|
if i1+i >= len(intervals) or i1+i < 0:
|
|
print "AxisItem.paint error: i1=%d, i=%d, len(intervals)=%d" % (i1, i, len(intervals))
|
|
continue
|
|
|
|
## spacing for this interval
|
|
sp = pw*intervals[i1+i]
|
|
|
|
## determine starting tick
|
|
start = np.ceil(self.range[0] / sp) * sp
|
|
|
|
## determine number of ticks
|
|
num = int(dif / sp) + 1
|
|
|
|
## last tick value
|
|
last = start + sp * num
|
|
|
|
## Number of decimal places to print
|
|
maxVal = max(abs(start), abs(last))
|
|
places = max(0, np.ceil(-np.log10(sp*self.scale)))
|
|
#print i, sp, sp*self.scale, np.log10(sp*self.scale), places
|
|
|
|
## length of tick
|
|
#h = np.clip((self.tickLength*3 / num) - 1., min(0, self.tickLength), max(0, self.tickLength))
|
|
if i == 0:
|
|
h = self.tickLength * distBetweenIntervals / 2.
|
|
else:
|
|
h = self.tickLength*i/2.
|
|
|
|
## alpha
|
|
if i == 0:
|
|
#a = min(255, (765. / num) - 1.)
|
|
a = 255 * distBetweenIntervals
|
|
else:
|
|
a = 255
|
|
|
|
lineAlpha = a
|
|
textAlpha = a
|
|
|
|
if self.grid is not False:
|
|
lineAlpha = int(lineAlpha * self.grid / 255.)
|
|
|
|
if axis == 0:
|
|
offset = self.range[0] * xs - bounds.height()
|
|
else:
|
|
offset = self.range[0] * xs
|
|
|
|
for j in range(num):
|
|
v = start + sp * j
|
|
x = (v * xs) - offset
|
|
p1 = [0, 0]
|
|
p2 = [0, 0]
|
|
p1[axis] = tickStart
|
|
p2[axis] = tickStop
|
|
if self.grid is False:
|
|
p2[axis] += h*tickDir
|
|
p1[1-axis] = p2[1-axis] = x
|
|
|
|
if p1[1-axis] > [bounds.width(), bounds.height()][1-axis]:
|
|
continue
|
|
if p1[1-axis] < 0:
|
|
continue
|
|
p.setPen(QtGui.QPen(QtGui.QColor(150, 150, 150, lineAlpha)))
|
|
|
|
# draw tick only if there is none
|
|
tickPos = p1[1-axis]
|
|
|
|
#if tickPos not in tickPositions:
|
|
p.drawLine(Point(p1), Point(p2))
|
|
#tickPositions.add(tickPos)
|
|
if i == textLevel:
|
|
if abs(v*self.scale) < .001 or abs(v*self.scale) >= 10000:
|
|
vstr = "%g" % (v * self.scale)
|
|
else:
|
|
vstr = ("%%0.%df" % places) % (v * self.scale)
|
|
#print " ", v*self.scale, places, vstr
|
|
|
|
textRect = p.boundingRect(QtCore.QRectF(0, 0, 100, 100), QtCore.Qt.AlignCenter, vstr)
|
|
height = textRect.height()
|
|
self.textHeight = height
|
|
if self.orientation == 'left':
|
|
textFlags = QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter
|
|
rect = QtCore.QRectF(tickStop-100, x-(height/2), 99-max(0,self.tickLength), height)
|
|
elif self.orientation == 'right':
|
|
textFlags = QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter
|
|
rect = QtCore.QRectF(tickStop+max(0,self.tickLength)+1, x-(height/2), 100-max(0,self.tickLength), height)
|
|
elif self.orientation == 'top':
|
|
textFlags = QtCore.Qt.AlignCenter|QtCore.Qt.AlignBottom
|
|
rect = QtCore.QRectF(x-100, tickStop-max(0,self.tickLength)-height, 200, height)
|
|
elif self.orientation == 'bottom':
|
|
textFlags = QtCore.Qt.AlignCenter|QtCore.Qt.AlignTop
|
|
rect = QtCore.QRectF(x-100, tickStop+max(0,self.tickLength), 200, height)
|
|
|
|
#p.setPen(QtGui.QPen(QtGui.QColor(150, 150, 150, a)))
|
|
#p.drawText(rect, textFlags, vstr)
|
|
texts.append((rect, textFlags, vstr, textAlpha))
|
|
|
|
prof.mark('draw ticks')
|
|
for args in texts:
|
|
p.setPen(QtGui.QPen(QtGui.QColor(150, 150, 150, args[3])))
|
|
p.drawText(*args[:3])
|
|
prof.mark('draw text')
|
|
prof.finish()
|
|
|
|
def show(self):
|
|
|
|
if self.orientation in ['left', 'right']:
|
|
self.setWidth()
|
|
else:
|
|
self.setHeight()
|
|
GraphicsWidget.show(self)
|
|
|
|
def hide(self):
|
|
if self.orientation in ['left', 'right']:
|
|
self.setWidth(0)
|
|
else:
|
|
self.setHeight(0)
|
|
GraphicsWidget.hide(self)
|
|
|
|
def wheelEvent(self, ev):
|
|
if self.linkedView() is None:
|
|
return
|
|
if self.orientation in ['left', 'right']:
|
|
self.linkedView().wheelEvent(ev, axis=1)
|
|
else:
|
|
self.linkedView().wheelEvent(ev, axis=0)
|
|
ev.accept()
|
|
|
|
def mouseDragEvent(self, event):
|
|
if self.linkedView() is None:
|
|
return
|
|
if self.orientation in ['left', 'right']:
|
|
return self.linkedView().mouseDragEvent(event, axis=1)
|
|
else:
|
|
return self.linkedView().mouseDragEvent(event, axis=0)
|
|
|
|
def mouseClickEvent(self, event):
|
|
if self.linkedView() is None:
|
|
return
|
|
return self.linkedView().mouseClickEvent(event)
|