def paint(self, p, opt, widget):
UIGraphicsItem.paint(self, p, opt, widget)
rect = self.boundingRect()
unit = self.pixelSize()
y = rect.bottom() + (rect.top()-rect.bottom()) * 0.02
y1 = y + unit[1]*self._width
x = rect.right() + (rect.left()-rect.right()) * 0.02
x1 = x - self.size
p.setPen(self.pen)
p.setBrush(self.brush)
rect = QtCore.QRectF(
QtCore.QPointF(x1, y1),
QtCore.QPointF(x, y)
)
p.translate(x1, y1)
p.scale(rect.width(), rect.height())
p.drawRect(0, 0, 1, 1)
alpha = np.clip(((self.size/unit[0]) - 40.) * 255. / 80., 0, 255)
p.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0, alpha)))
for i in range(1, 10):
#x2 = x + (x1-x) * 0.1 * i
x2 = 0.1 * i
p.drawLine(QtCore.QPointF(x2, 0), QtCore.QPointF(x2, 1))
def __init__(self, clock):
pg.ItemGroup.__init__(self)
self.size = clock.size
self.item = QtWidgets.QGraphicsEllipseItem(QtCore.QRectF(0, 0, self.size, self.size))
self.item.moveBy(-self.size*0.5, -self.size*0.5)
self.item.setPen(pg.mkPen(100,100,100))
self.item.setBrush(clock.brush)
self.hand = QtWidgets.QGraphicsLineItem(0, 0, 0, self.size*0.5)
self.hand.setPen(pg.mkPen('w'))
self.hand.setZValue(10)
self.flare = QtWidgets.QGraphicsPolygonItem(QtGui.QPolygonF([
QtCore.QPointF(0, -self.size*0.25),
QtCore.QPointF(0, self.size*0.25),
QtCore.QPointF(self.size*1.5, 0),
QtCore.QPointF(0, -self.size*0.25),
]))
self.flare.setPen(pg.mkPen('y'))
self.flare.setBrush(pg.mkBrush(255,150,0))
self.flare.setZValue(-10)
self.addItem(self.hand)
self.addItem(self.item)
self.addItem(self.flare)
self.clock = clock
self.i = 1
self._spaceline = None
def render(self):
#Convert data to QImage for display.
#profile = debug.Profiler()
if self.image is None or self.image.size == 0:
return
if isinstance(self.lut, collections.Callable):
lut = self.lut(self.image)
else:
lut = self.lut
if False:#self.autoDownsample:
# reduce dimensions of image based on screen resolution
o = self.mapToDevice(QtCore.QPointF(0,0))
x = self.mapToDevice(QtCore.QPointF(1,0))
y = self.mapToDevice(QtCore.QPointF(0,1))
w = Point(x-o).length()
h = Point(y-o).length()
xds = int(1/max(1, w))
yds = int(1/max(1, h))
image = pg.downsample(self.image, xds, axis=0)
image = pg.downsample(image, yds, axis=1)
else:
image = self.image
imageRGBA = makeRGBAImage(image,self.cppLut)
imageNew = imageRGBA
argb, alpha = pg.makeARGB(imageNew.transpose((1, 0, 2)[:imageNew.ndim]), lut=None, levels=None)
self.qimage = pg.makeQImage(argb, alpha, transpose=False)
def paint(self, p, *args):
opts = self.opts
if opts.get('antialias', True):
p.setRenderHint(p.Antialiasing)
if opts.get('fillLevel', None) is not None and opts.get(
'fillBrush', None) is not None:
p.setBrush(fn.mkBrush(opts['fillBrush']))
p.setPen(fn.mkPen(None))
p.drawPolygon(
QtGui.QPolygonF([
QtCore.QPointF(2, 18),
QtCore.QPointF(18, 2),
QtCore.QPointF(18, 18)
]))
if opts.get('pen', None) is not None:
p.setPen(fn.mkPen(opts['pen']))
p.drawLine(2, 18, 18, 2)
symbol = opts.get('symbol', None)
if symbol is not None:
pen = fn.mkPen(opts.get('symbolPen', None))
brush = fn.mkBrush(opts.get('symbolBrush', None))
size = opts.get('symbolSize', 10)
p.translate(10, 10)
path = drawSymbol(p, symbol, size, pen, brush)
def getGradient(self, p1=None, p2=None):
"""Return a QLinearGradient object spanning from QPoints p1 to p2."""
if p1 == None:
p1 = QtCore.QPointF(0,0)
if p2 == None:
p2 = QtCore.QPointF(self.pos.max()-self.pos.min(),0)
g = QtGui.QLinearGradient(p1, p2)
pos, color = self.getStops(mode=self.BYTE)
color = [QtGui.QColor(*x) for x in color]
g.setStops(zip(pos, color))
#if self.colorMode == 'rgb':
#ticks = self.listTicks()
#g.setStops([(x, QtGui.QColor(t.color)) for t,x in ticks])
#elif self.colorMode == 'hsv': ## HSV mode is approximated for display by interpolating 10 points between each stop
#ticks = self.listTicks()
#stops = []
#stops.append((ticks[0][1], ticks[0][0].color))
#for i in range(1,len(ticks)):
#x1 = ticks[i-1][1]
#x2 = ticks[i][1]
#dx = (x2-x1) / 10.
#for j in range(1,10):
#x = x1 + dx*j
#stops.append((x, self.getColor(x)))
#stops.append((x2, self.getColor(x2)))
#g.setStops(stops)
return g
def __init__(self, pose, radius):
pg.GraphicsObject.__init__(self)
self.pose = QtCore.QPointF(*pose[:2])
self.R = radius
pt = pose[:2] + np.array([np.cos(pose[2]), np.sin(pose[2])]) * self.R
self.pt = QtCore.QPointF(*(pose[:2] + pt))
self.generatePicture()
def copyROI(self, offset=0.0):
""" Copy current ROI. Offset from original for visibility """
if self.currentROIindex != None:
osFract = 0.05
roi = self.rois[self.currentROIindex]
# For rectangular ROI, offset by a fraction of the rotated size
if type(roi) == RectROIcustom:
roiState = roi.getState()
pos = roiState['pos']
size = roiState['size']
angle = roiState['angle']
dx, dy = np.array(size) * osFract
ang = np.radians(angle)
cosa = np.cos(ang)
sina = np.sin(ang)
dxt = dx * cosa - dy * sina
dyt = dx * sina + dy * cosa
offset = QtCore.QPointF(dxt, dyt)
self.addROI(pos + offset, size, angle)
# For a polyline ROI, offset by a fraction of the bounding rectangle
if type(roi) == PolyLineROIcustom:
br = roi.shape().boundingRect()
size = np.array([br.width(), br.height()])
osx, osy = size * osFract
offset = QtCore.QPointF(osx, osy)
hps = [i[-1] for i in roi.getSceneHandlePositions(index=None)]
hpsOffset = [self.mapSceneToView(hp) + offset for hp in hps]
self.addPolyLineROI(hpsOffset)
def setStyle(self, **opts):
self.opts = opts
if opts['style'] == 'tri':
if opts['width'] is None:
width = opts['size'] / 2.
else:
width = opts['width']
points = [
QtCore.QPointF(0,0),
QtCore.QPointF(opts['size'],-width/2.),
QtCore.QPointF(opts['size'],width/2.),
]
poly = QtGui.QPolygonF(points)
else:
raise Exception("Unrecognized arrow style '%s'" % opts['style'])
self.setPolygon(poly)
if opts['pxMode']:
self.setFlags(self.flags() | self.ItemIgnoresTransformations)
else:
self.setFlags(self.flags() & ~self.ItemIgnoresTransformations)
def paint(self, p, *args):
#p.setRenderHint(p.Antialiasing) # only if the data is antialiased.
opts = self.item.opts
if opts.get('fillLevel', None) is not None and opts.get(
'fillBrush', None) is not None:
p.setBrush(fn.mkBrush(opts['fillBrush']))
p.setPen(fn.mkPen(None))
p.drawPolygon(
QtGui.QPolygonF([
QtCore.QPointF(2, 18),
QtCore.QPointF(18, 2),
QtCore.QPointF(18, 18)
]))
if not isinstance(self.item, ScatterPlotItem):
p.setPen(fn.mkPen(opts['pen']))
p.drawLine(2, 18, 18, 2)
symbol = opts.get('symbol', None)
if symbol is not None:
if isinstance(self.item, PlotDataItem):
opts = self.item.scatter.opts
pen = fn.mkPen(opts['pen'])
brush = fn.mkBrush(opts['brush'])
size = opts['size']
p.translate(10, 10)
path = drawSymbol(p, symbol, size, pen, brush)
def __init__(self, clock, ref):
pg.ItemGroup.__init__(self)
self.size = 0.4
self.item = QtGui.QGraphicsEllipseItem(
QtCore.QRectF(0, 0, self.size, self.size))
self.item.translate(-self.size * 0.5, -self.size * 0.5)
self.item.setPen(clock.pen)
self.item.setBrush(clock.brush)
self.hand = QtGui.QGraphicsLineItem(0, 0, 0, self.size * 0.5)
self.hand.setPen(pg.mkPen('w'))
self.hand.setZValue(10)
self.flare = QtGui.QGraphicsPolygonItem(
QtGui.QPolygonF([
QtCore.QPointF(0, -self.size * 0.25),
QtCore.QPointF(0, self.size * 0.25),
QtCore.QPointF(1, 0),
QtCore.QPointF(0, -self.size * 0.25),
]))
self.flare.setPen(pg.mkPen('y'))
self.flare.setBrush(pg.mkBrush(100, 100, 0))
self.flare.setZValue(-10)
self.addItem(self.hand)
self.addItem(self.item)
self.addItem(self.flare)
self.clock = clock
self.ref = ref
self.i = 1
def paint(self, painter, option, widget=None):
if (self.p1 == self.p2):
return
myPen = self.pen()
myPen.setColor(self.myColor)
arrowSize = self.myArrowHeadSize
painter.setPen(myPen)
painter.setBrush(self.myColor)
line = QtCore.QLineF(self.p1, self.p2)
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = (math.pi * 2.0) - angle
arrowP1 = line.p2() - QtCore.QPointF(
math.sin(angle + math.pi / 3.0) * arrowSize,
math.cos(angle + math.pi / 3) * arrowSize)
arrowP2 = line.p2() - QtCore.QPointF(
math.sin(angle + math.pi - math.pi / 3.0) * arrowSize,
math.cos(angle + math.pi - math.pi / 3.0) * arrowSize)
self.arrowHead.clear()
for point in [line.p2(), arrowP1, arrowP2]:
self.arrowHead.append(point)
painter.drawLine(line)
painter.drawPolygon(self.arrowHead)
def pixelHeight(self):
vt = self.deviceTransform()
if vt is None:
return 0
vt = vt.inverted()[0]
return Point(
vt.map(QtCore.QPointF(0, 1)) -
vt.map(QtCore.QPointF(0, 0))).length()
def __init__(self, origin, direction):
pg.GraphicsObject.__init__(self)
points = ArrowItem.pts(direction) + origin.reshape(2, 1)
self.p1 = QtCore.QPointF(*points[:, 0])
self.p2 = QtCore.QPointF(*points[:, 1])
self.p3 = QtCore.QPointF(*points[:, 2])
self.p4 = QtCore.QPointF(*points[:, 3])
self.generatePicture()
def plotVolue(self,xAxis,yAxis):
if self.xData:
if int(round(xAxis)) <=len(self.xData)-1:
xValue =self.xData[int(round(xAxis))]
elif int(xAxis)>len(self.xData)-1:
xValue=self.xData[len(self.xData)-1]
else:
xValue = self.xData[int(xAxis)]
if (isinstance(xValue, dt.datetime)):
xValueText = dt.datetime.strftime(xValue, '%Y-%m-%d %H:%M:%S')
elif (isinstance(xValue, (str))):
xValueText = xValue
elif (isinstance(xValue, (int))):
xValueText = xValue
else:
xValueText = ""
else:
xValueText=xAxis
self.__textDate.setHtml(
'<div style="text-align: center">\
<span style="color: yellow; font-size: 20px;">x=%s</span>\
</div>' \
% (xValueText))
self.__textSig.setHtml(
'<div style="text-align: right">\
<span style="color: yellow; font-size: 20px;">y=%0.2f</span>\
</div>' \
% (yAxis))
# y，右上角显示
rightAxis = self.__view.getAxis('right')
rightAxisWidth = rightAxis.width()
rectTextsig = self.__textDate.boundingRect()
rectTextsigwidth = rectTextsig.width()
topRight = self.__view.vb.mapSceneToView(
QtCore.QPointF(self.rects[0].width() - (rightAxisWidth+rectTextsigwidth), self.rects[0].top()))
if yAxis<self.rects[0].top():
self.__textSig.anchor=Point((1,1));
else:
self.__textSig.anchor = Point((1, 0));
self.__textSig.setPos(topRight.x(), yAxis)
# X坐标时间显示
rectTextDate = self.__textDate.boundingRect()
rectTextDateHeight = rectTextDate.height()
bottomAxis = self.__view.getAxis('bottom')
bottomAxisHeight = bottomAxis.height()
bottomRight = self.__view.vb.mapSceneToView(QtCore.QPointF(self.rects[0].width(), \
self.rects[0].bottom() - (
bottomAxisHeight + rectTextDateHeight)))
# # 修改对称方式防止遮挡
if xAxis >self.rects[0].width():
self.__textDate.anchor = Point((1, 0))
else:
self.__textDate.anchor = Point((0, 0))
self.__textDate.setPos(xAxis, bottomRight.y())
def generatePicture(self):
self.picture = QtGui.QPicture()
p = QtGui.QPainter(self.picture)
p.setPen(pg.mkPen(self.color))
for spike in self.spike_position_list:
if spike != -1:
p.drawLine(QtCore.QPointF(self.t[spike], self.start_point),
QtCore.QPointF(self.t[spike], self.end_point))
p.end()
def pixelVectors(self):
"""Return vectors in local coordinates representing the width and height of a view pixel."""
vt = self.deviceTransform()
if vt is None:
return None
vt = vt.inverted()[0]
orig = vt.map(QtCore.QPointF(0, 0))
return vt.map(QtCore.QPointF(1, 0)) - orig, vt.map(QtCore.QPointF(
0, 1)) - orig
def updateBar(self):
view = self.parentItem()
if view is None:
return
p1 = view.mapFromViewToItem(self, QtCore.QPointF(0, 0))
p2 = view.mapFromViewToItem(self, QtCore.QPointF(0, self.size))
w = (p2 - p1).y()
self.bar.setRect(QtCore.QRectF(0, 0, self._width, w))
self.text.setPos(0, w / 2.)
def setDragPoint(self, dragPoint):
topLeft = QtCore.QPointF(self.__mouseDownPos)
bottomRight = QtCore.QPointF(dragPoint)
if dragPoint.x() < self.__mouseDownPos.x():
topLeft.setX(dragPoint.x())
bottomRight.setX(self.__mouseDownPos.x())
if dragPoint.y() < self.__mouseDownPos.y():
topLeft.setY(dragPoint.y())
bottomRight.setY(self.__mouseDownPos.y())
self.setPos(topLeft)
self.resize(max(bottomRight.x() - topLeft.x(), 100),
max(bottomRight.y() - topLeft.y(), 100))
def generatePicture(self):
self.picture = QtGui.QPicture()
p = QtGui.QPainter(self.picture)
# Make this a checkbox in GUI
regionTypesOfInterest = (Region.ALIGNMENT_REGION,
Region.ADAPTER_REGION)
for region in self.traceRegions:
if region.regionType in regionTypesOfInterest:
p.setPen(self.pens[region.regionType])
y = self.regionOverlayY(region.regionType)
p.drawLine(QtCore.QPointF(region.start, y),
QtCore.QPointF(region.end, y))
def setRB(self, ev = None, pen = None, brush = None):
if pen is not None and brush is not None:
if self.RB is not None:
self.RB.hide()
self.RB = None
if self.RB is None:
if pen is None: pen = self.defRbPen
if brush is None: brush = self.defRbBrush
self.RB = QtGui.QGraphicsRectItem(0, 0, 1, 1)
self.RB.setPen(pen)
self.RB.setBrush(brush)
self.RB.hide()
if ev is None: self.view.addItem(self.RB, ignoreBounds=True)
return
elif ev is None: # release mouse button
self.RB.hide()
return
if type(ev) is QtGuiQGraphicsMouseEvent:
self.XY1 = ev.pos()
self.keymod = ev.keymod
x0, y0 = self.XY0.x(), self.XY0.y()
x1, y1 = self.XY1.x(), self.XY1.y()
xY, yX = False, False
xr, yr = x0 > x1, y0 > y1 # Note: y are pixel values from top(left)
if self.keymod not in self.keyMod:
xY, yX = xr, yr
else:
xY = self.keymod == self.xyKeyMod[0]
yX = self.keymod == self.xyKeyMod[1]
if xY:
x0 = 0.
x1 = self.width()
if yX:
y0 = 0.
y1 = self.height()
X0, Y0 = self.mapxy(x0, y0, False) # bypasses axis
X1, Y1 = self.mapxy(x1, y1, False) # transformation
XY0 = QtCore.QPoint(X0, Y0)
XY1 = QtCore.QPoint(X1, Y1)
try: # to cope with old Qt4 versions.
rb = QtCore.QRectF(XY0, XY1)
except TypeError:
XY0 = QtCore.QPointF(X0, Y0)
XY1 = QtCore.QPointF(X1, Y1)
rb = QtCore.QRectF(XY0, XY1)
rb = self.childGroup.mapRectFromParent(rb)
self.RB.setPos(rb.topLeft())
self.RB.resetTransform()
self.RB.scale(rb.width(), rb.height())
self.RB.show()
def paint(self, p, opt, widget):
super(GradientLegend, self).paint(p, opt, widget)
pen = QtGui.QPen(QtGui.QColor(0, 0, 0))
rect = self.boundingRect()
unit = self.pixelSize()
offset = 10, 10
size = widget.width() / 10, widget.height() / 3
padding = 10
x1 = rect.left() + unit[0] * offset[0]
x2 = x1 + unit[0] * size[0]
y1 = rect.bottom() - unit[1] * offset[1]
y2 = y1 - unit[1] * size[1]
# Draw background
p.setPen(pen)
p.setBrush(QtGui.QBrush(QtGui.QColor(255, 255, 255, 100)))
rect = QtCore.QRectF(
QtCore.QPointF(x1 - padding * unit[0], y1 + padding * unit[1]),
QtCore.QPointF(x2 + padding * unit[0], y2 - padding * unit[1]))
p.drawRect(rect)
p.scale(unit[0], unit[1])
# Draw color bar
gradient = QtGui.QLinearGradient()
i = 0.0
while i < 1:
color = plt.get_cmap(self.cm_type)(i)
color = [x * 255 for x in color]
gradient.setColorAt(i, QtGui.QColor(*color))
i += 0.1
gradient.setStart(0, y1 / unit[1])
gradient.setFinalStop(0, y2 / unit[1])
p.setBrush(gradient)
rect = QtCore.QRectF(QtCore.QPointF(x1 / unit[0], y1 / unit[1]),
QtCore.QPointF(x2 / unit[0], y2 / unit[1]))
p.drawRect(rect)
# Draw labels
self.labelsize = self.maximumLabelSize(p)
lh = self.labelsize.height()
p.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0)))
for label in self.labels:
y = y1 + self.labels[label] * (y2 - y1)
p.drawText(
QtCore.QRectF(x1 + widget.width() / 20, y - lh / 2.0, 1000,
lh), QtCore.Qt.AlignVCenter, str(label))
def generatePicture(self):
''' pre-computing a QPicture object allows paint() to run
much more quickly, rather than re-drawing the shapes every time.'''
self.picture = QtGui.QPicture()
p = QtGui.QPainter(self.picture)
p.setPen(pg.mkPen('w'))
w = (self.data[1][0] - self.data[0][0]) / 3.
for (t, opn, high, low, close) in self.data:
p.drawLine(QtCore.QPointF(t, low), QtCore.QPointF(t, high))
if opn > close:
p.setBrush(pg.mkBrush('r'))
else:
p.setBrush(pg.mkBrush('g'))
p.drawRect(QtCore.QRectF(t - w, opn, w * 2, close - opn))
p.end()
def __init__(self, data: RegularDataArray, parent=None, layout=0):
"""data is the RegularSpacedData to examine
layout is an integer. 0 is a simple layout, 1 is a complete layout, and 2 is a special layout for 4D data"""
super().__init__(parent)
self.data: RegularDataArray = data
self.parent = parent
self.tool_layout: int = layout
self.cursor: Cursor = Cursor(data)
self.lineplots: Dict[str, Tuple[pg.PlotItem, str]] = {} # dict of (PlotItem, orient), orient = 'h' or 'v'
self.lineplots_data: Dict[str, Tuple[pg.PlotDataItem, str]] = {} # dict of PlotDataItems, orient = 'h' or 'v'
self.cursor_lines: Dict[str, List[InfiniteLineBinning]] = {} # dict of cursor lines for 'x', 'y', 'z', etc.
# self.bin_widths: List[SingleValueModel] = \
# [SingleValueModel(1.0) for i in range(data.ndim)] # each dimension has a bin width
self.imgs: Dict[str, ImageSlice] = {} # a dictionary of ImageItems
self.img_tr: Dict[str, QtGui.QTransform] = {} # a dictionary of transforms going from index to coordinates
self.img_tr_inv: Dict[str, QtGui.QTransform] = {} # a dictionary of transforms going from coordinates to index
self._signal_proxies: List[pg.SignalProxy] = [] # a list of created signal proxies to be held in memory
# Properties for color map
self.ct: np.array = np.array([])
self.ct_name: str = 'viridis'
# Properties for tracking the mouse
self.mouse_pos: QtCore.QPointF = QtCore.QPointF(0, 0)
self.mouse_panel: str = ''
# Keyboard
self.shift_down = False
self.status_bar: str = '' # string representing current mouse location
self.load_ct(self.ct_name)
self.build_layout() # add plots according to chosen layout which populates self.lineplots and self.img_axes
self.create_items() # now that axes are ready, make ImageItems, PlotDataItems, and Cursor lines
self.init_data() # set data for each ImageItem, PlotDataItem, and connect cursors to data
def drawObjects(self, view_manager):
geom = view_manager._geometry
for view in view_manager.getViewPorts():
# # get the showers from the process:
self._drawnObjects.append([])
tracks = self._process.getDataByPlane(view.plane())
offset = geom.offset(view.plane()) / geom.time2cm()
for i in xrange(len(tracks)):
track = tracks[i]
# construct a polygon for this track:
points = []
# Remeber - everything is in cm, but the display is in
# wire/time!
for pair in track.track():
x = pair.first / geom.wire2cm()
y = pair.second / geom.time2cm() + offset
points.append(QtCore.QPointF(x, y))
# self._drawnObjects[view.plane()].append(thisPoly)
thisPoly = polyLine(points)
pen = pg.mkPen((130, 0, 0), width=2)
thisPoly.setPen(pen)
# polyLine.draw(view._view)
view._view.addItem(thisPoly)
self._drawnObjects[view.plane()].append(thisPoly)
def paintEvent(self, ev):
if self.opts is None:
return
if self.image is None:
argb, alpha = fn.makeARGB(self.opts[0], *self.opts[1],
**self.opts[2])
self.image = fn.makeQImage(argb, alpha)
self.opts = ()
#if self.pixmap is None:
#self.pixmap = QtGui.QPixmap.fromImage(self.image)
p = QtGui.QPainter(self)
if self.scaled:
rect = self.rect()
ar = rect.width() / float(rect.height())
imar = self.image.width() / float(self.image.height())
if ar > imar:
rect.setWidth(int(rect.width() * imar / ar))
else:
rect.setHeight(int(rect.height() * ar / imar))
p.drawImage(rect, self.image)
else:
p.drawImage(QtCore.QPointF(), self.image)
#p.drawPixmap(self.rect(), self.pixmap)
p.end()
def Summary(self):
self.distance = 0
self.raw_time_open = 0
self.raw_time_close = 0
roiShape = self.roi.mapToView(self.roi.shape())
roi_2Shape = self.roi.mapToView(self.roi_2.shape())
roi_3Shape = self.roi.mapToView(self.roi_3.shape())
roi_4Shape = self.roi.mapToView(self.roi_4.shape())
pt = QtCore.QPointF()
for i, v in enumerate(self.valueNframe):
if i < len(self.valueNframe) - 1:
dist = math.sqrt((self.valueX[i + 1] - self.valueX[i])**2 +
(self.valueY[i + 1] - self.valueY[i])**2)
self.distance = self.distance + dist
pt.setX(self.valueX[i])
pt.setY(self.valueY[i])
if roiShape.contains(pt) or roi_3Shape.contains(pt):
self.raw_time_close = self.raw_time_close + 10
if roi_2Shape.contains(pt) or roi_4Shape.contains(pt):
self.raw_time_open = self.raw_time_open + 10
print(f"raw_open: {self.raw_time_open}")
print(f"raw_close: {self.raw_time_close}")
print(f"fps: {self.fps}")
self.time_open = self.raw_time_open / self.fps
self.time_close = self.raw_time_close / self.fps
def resizeEvent(self, ev):
#c1 = self.boundingRect().center()
#c2 = self.item.mapToParent(self.item.boundingRect().center()) # + self.item.pos()
#dif = c1 - c2
#self.item.moveBy(dif.x(), dif.y())
#print c1, c2, dif, self.item.pos()
self.item.setPos(0,0)
bounds = self.itemRect()
left = self.mapFromItem(self.item, QtCore.QPointF(0,0)) - self.mapFromItem(self.item, QtCore.QPointF(1,0))
rect = self.rect()
if self.opts['justify'] == 'left':
if left.x() != 0:
bounds.moveLeft(rect.left())
if left.y() < 0:
bounds.moveTop(rect.top())
elif left.y() > 0:
bounds.moveBottom(rect.bottom())
elif self.opts['justify'] == 'center':
bounds.moveCenter(rect.center())
#bounds = self.itemRect()
#self.item.setPos(self.width()/2. - bounds.width()/2., 0)
elif self.opts['justify'] == 'right':
if left.x() != 0:
bounds.moveRight(rect.right())
if left.y() < 0:
bounds.moveBottom(rect.bottom())
elif left.y() > 0:
bounds.moveTop(rect.top())
#bounds = self.itemRect()
#self.item.setPos(self.width() - bounds.width(), 0)
self.item.setPos(bounds.topLeft() - self.itemRect().topLeft())
self.updateMin()
def pasteSelectedNodes(self):
# TODO figure out right positions and preserve topology?
pos = self.mapToView(self.paste_pos)
for node in self.selected_nodes:
self.widget.chart.createNode(type(node).__name__, pos=pos, prompt=False)
pos += QtCore.QPointF(200, 0)
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 test_mouseInteraction():
# disable delay of mouse move events because events is called immediately in test
pg.setConfigOption('mouseRateLimit', -1)
plt = pg.plot()
plt.scene().minDragTime = 0 # let us simulate mouse drags very quickly.
vline = plt.addLine(x=0, movable=True)
hline = plt.addLine(y=0, movable=True)
hline2 = plt.addLine(y=-1, movable=False)
plt.setXRange(-10, 10)
plt.setYRange(-10, 10)
# test horizontal drag
pos = plt.plotItem.vb.mapViewToScene(pg.Point(0, 5))
pos2 = pos - QtCore.QPointF(200, 200)
mouseMove(plt, pos)
assert vline.mouseHovering is True and hline.mouseHovering is False
mouseDrag(plt, pos, pos2, QtCore.Qt.MouseButton.LeftButton)
px = vline.pixelLength(pg.Point(1, 0), ortho=True)
assert abs(vline.value() - plt.plotItem.vb.mapSceneToView(pos2).x()) <= px
# test missed drag
pos = plt.plotItem.vb.mapViewToScene(pg.Point(5, 0))
pos = pos + QtCore.QPointF(0, 6)
pos2 = pos + QtCore.QPointF(-20, -20)
mouseMove(plt, pos)
assert vline.mouseHovering is False and hline.mouseHovering is False
mouseDrag(plt, pos, pos2, QtCore.Qt.MouseButton.LeftButton)
assert hline.value() == 0
# test vertical drag
pos = plt.plotItem.vb.mapViewToScene(pg.Point(5, 0))
pos2 = pos - QtCore.QPointF(50, 50)
mouseMove(plt, pos)
assert vline.mouseHovering is False and hline.mouseHovering is True
mouseDrag(plt, pos, pos2, QtCore.Qt.MouseButton.LeftButton)
px = hline.pixelLength(pg.Point(1, 0), ortho=True)
assert abs(hline.value() - plt.plotItem.vb.mapSceneToView(pos2).y()) <= px
# test non-interactive line
pos = plt.plotItem.vb.mapViewToScene(pg.Point(5, -1))
pos2 = pos - QtCore.QPointF(50, 50)
mouseMove(plt, pos)
assert hline2.mouseHovering == False
mouseDrag(plt, pos, pos2, QtCore.Qt.MouseButton.LeftButton)
assert hline2.value() == -1
plt.close()
