def test_TextItem_setAngle():
plt = pg.plot()
plt.setXRange(-10, 10)
plt.setYRange(-20, 20)
item = pg.TextItem(text="test")
plt.addItem(item)
t1 = item.transform()
item.setAngle(30)
app.processEvents()
t2 = item.transform()
assert t1 != t2
assert not t1.isRotating()
assert t2.isRotating()
def addEventPlot(self, event_name, event_id):
if (event_name == "TID"):
color = (255,0,0)
elif (event_name == "KEY"):
color = (0, 255, 0)
elif (event_name == "LPT"):
color = (0,0,255)
else:
color = (255, 255, 255)
self.events_detected.append(self.data_plot.shape[0]-1)
self.events_detected.append(event_id)
self.events_curves.append(self.plot_handler.plot(pen=color, x=np.array([self.x_ticks[-1], self.x_ticks[-1]]), y=np.array([+1.5*self.scale, -1.5*self.scale*self.config['eeg_channels']])))
text = pg.TextItem(event_name + "(" + str(self.events_detected[-1]) + ")", anchor=(1.1,0), fill=(0,0,0), color=color)
text.setPos(self.x_ticks[-1], +1.5*self.scale)
self.events_text.append(text)
self.plot_handler.addItem(self.events_text[-1])
def setVoltages(self):
self.spot_plot_list = []
#=======================================================================
# for i in range(0,37):
# self.voltageIndicators[i].setText("{:.2f}".format(self.voltageSliders[i].value()))
# #spots.append({'pos': self.electrodeCoordinates[i,:], 'data': 1, 'brush':pq.intColor(np.round(self.voltageSliders[i].value())), 'symbol': 'o', 'size': 50})
# spot = {'pos': self.electrodeCoordinates[i,:],'data':1,'brush':pq.hsvColor(self.voltageSliders[i].value()/(self.maxVoltage*5.5),sat=1.0,val=1.0, alpha=1.0),'symbol':'o','size': 40,'pen':0}
# #spots.append(spot)
# #spots.append({'pos': self.electrodeCoordinates[i,:], 'data': 1, 'brush':self.map.map(self.voltageSliders[i].value(),mode='qcolor'), 'symbol': 'o', 'size': 40})
# plot = pq.ScatterPlotItem(size=50, pxMode=True, symbol='o', name=str(i))
# plot.addPoints([spot])
# self.spot_plot_list.append(plot)
# self.plotWidget1.addItem(plot)
#=======================================================================
self.plot11 = self.plotWidget1.addPlot()
#self.scatterPlotItem1 = pq.ScatterPlotItem(size=30, pen=pq.mkPen(None), brush=pq.mkBrush(0, 0, 125+self.voltages[0]/2, 250))
self.scatterPlotItem1 = pq.ScatterPlotItem(size=30, pen=pq.mkPen(None))
self.scatterPlotItem1.addPoints(x=self.electrodeCoordinates[:, 0],
y=self.electrodeCoordinates[:, 1])
brushes = []
for i in range(0, self.noChannels):
chName = 'channel' + str(self.channelsList[i])
self.adDevice.write_attribute(chName,
self.voltages[i] / self.ampFactor)
if i <= 36:
brushes.append(
QtGui.QColor(255, self.voltages[i] / self.maxVoltage * 255,
0, 220))
#self.labelItem1 = pq.LabelItem()
#self.labelItem1.setPos(self.electrodeCoordinates[0][0],self.electrodeCoordinates[0][1])
#self.labelItem1.setPos(0,0)
#self.labelItem1.setText('A', size = '8pt')
#self.plotWidget1.addItem(self.labelItem1)
#self.plot11.addItem(self.labelItem1)
#for i in range(0,37)
#print type(brushes)
self.scatterPlotItem1.setBrush(brushes)
self.plot11.addItem(self.scatterPlotItem1)
self.scatterPlotItem1.sigClicked.connect(self.clicked)
self.textItem = pq.TextItem()
self.plot11.addItem(self.textItem)
def __init__(self, parent=None, line=None, label=None, **kwargs):
super().__init__(parent, **kwargs)
self.setFlag(pg.GraphicsObject.ItemHasNoContents)
if line is None:
line = QtCore.QLineF(0, 0, 1, 0)
self._spine = QtGui.QGraphicsLineItem(line, self)
angle = line.angle()
self._arrow = pg.ArrowItem(parent=self, angle=0)
self._arrow.setPos(self._spine.line().p2())
self._arrow.setRotation(angle)
self._label = pg.TextItem(text=label, color=(10, 10, 10))
self._label.setParentItem(self)
self._label.setPos(self._spine.line().p2())
def plot_k(self):
""" 绘制K线 """
axis_date = pg.AxisItem(orientation='bottom')
axis_date.setTicks([self._axis_date])
self._pw.setAxisItems({'bottom': axis_date})
self._pw.showAxis('left', True)
self._pw.showAxis('right', True)
self._pw.showAxis('bottom', False)
self._k_item = CandlestickItem(self._data)
self._pw.addItem(self._k_item)
# 添加第二个图形, 收盘价走势线
self._pw.plot(x=list(self._xdict.keys()),
y=self._data['close'].values,
pen='r',
name='close')
self._label_info = pg.TextItem()
self._pw.addItem(self._label_info)
self._pw.showGrid(x=True, y=True, alpha=0.5)
self._v_line = pg.InfiniteLine(angle=90, movable=False)
self._h_line = pg.InfiniteLine(angle=0, movable=False)
self._pw.addItem(self._v_line, ignoreBounds=True)
self._pw.addItem(self._h_line, ignoreBounds=True)
self._view_box = self._pw.getPlotItem().getViewBox()
# 显示部分数据
_tmp_data = self._data.iloc[-120:]
_x_left = _tmp_data.index[0]
_x_right = _tmp_data.index[-1]
_y_max = _tmp_data['high'].max()
_y_min = _tmp_data['low'].min()
self._y_min = _y_min * 0.99
self._y_max = _y_max * 1.01
top_left = QPointF(_x_left * 0.99, _y_max * 1.01)
bottom_right = QPointF(_x_right * 1.01, _y_min * 0.99)
self._view_box.setRange(rect=QRectF(top_left, bottom_right))
# 设置Y轴的值范围和左右的padding
self._view_box.setYRange(self._y_min, self._y_max, padding=0.1)
# self._proxy 代理必须存在，不能用局部变量
self._proxy = pg.SignalProxy(self._pw.scene().sigMouseMoved,
rateLimit=30,
slot=self.mouse_moved)
def __init__(self):
super().__init__()
self.curve = None
self.classif_region_curve = None
self.combo_box_curve = None
self.num = pg.TextItem(anchor=(0, 0), fill=(0, 0, 0, 0))
self.classif_type = 0
# os.chdir('..')
# project_base_path = os.getcwd()
avg_emg_path = 'machine_learning/avg_emg_class_type.npy'
self.avg_emg_class_type = np.load(
os.path.join(os.getcwd(), avg_emg_path))
self.classified_data = None
self.combo_classif = self.add_classif_num_combobox()
def __init__(self, parent=None):
super(crossCutWindow, self).__init__(parent=parent)
self.cc = pg.PlotWidget()
self.setCentralWidget(self.cc)
self.parent = parent
y = np.random.random(100)
self.p = self.cc.plot()
changingLabel = QtGui.QLabel()
font = changingLabel.font()
font.setPointSize(16)
self.text = pg.TextItem(text='',
color=(200, 200, 200),
border='w',
fill=(0, 0, 255, 100))
self.text.setFont(font)
self.cc.addItem(self.text)
self.cc.setRange(xRange=(0, 100), yRange=(-20, 500))
def add_to_viewwidget(self, viewwidget=None):
if viewwidget is not None:
self.viewwidget = viewwidget
self.viewwidget.addItem(self)
# Removing the handle from this CricleROI
self.removeHandle(0)
# create a new free handle for the name tag, positioned at "east" on the circle.
self.my_handle = self.addRotateHandle([1, 0.5], [0.5, 0.5])
self.sigRegionChangeFinished.connect(self._redraw_label)
self.label = pg.TextItem(text=self.poi.get_name(),
anchor=(0, 1),
color=self.color)
self.setAngle(30)
self.setPos(self.position + self.get_marker_offset())
def _setup_plot(self):
self.plot.clear()
points = self.ca
variables = self.selected_vars()
colors = colorpalette.ColorPaletteGenerator(len(variables))
p_axes = self._p_axes()
if len(variables) == 2:
row_points = self.ca.row_factors[:, p_axes]
col_points = self.ca.col_factors[:, p_axes]
points = [row_points, col_points]
else:
points = self.ca.row_factors[:, p_axes]
counts = [len(var.values) for var in variables]
range_indices = numpy.cumsum([0] + counts)
ranges = zip(range_indices, range_indices[1:])
points = [points[s:e] for s, e in ranges]
for i, (v, points) in enumerate(zip(variables, points)):
color_outline = colors[i]
color_outline.setAlpha(200)
color = QColor(color_outline)
color.setAlpha(120)
item = ScatterPlotItem(
x=points[:, 0], y=points[:, 1], brush=QBrush(color),
pen=pg.mkPen(color_outline.darker(120), width=1.5),
size=numpy.full((points.shape[0],), 10.1),
)
self.plot.addItem(item)
for name, point in zip(v.values, points):
item = pg.TextItem(name, anchor=(0.5, 0))
self.plot.addItem(item)
item.setPos(point[0], point[1])
inertia = self.ca.inertia_of_axis()
inertia = 100 * inertia / numpy.sum(inertia)
ax = self.plot.getAxis("bottom")
ax.setLabel("Component {} ({:.1f}%)"
.format(p_axes[0] + 1, inertia[p_axes[0]]))
ax = self.plot.getAxis("left")
ax.setLabel("Component {} ({:.1f}%)"
.format(p_axes[1] + 1, inertia[p_axes[1]]))
def addLabelTrace(self, waveItem, plotItem):
'Add station label for each trace'
fillBrush = self.opts.colorwaves[int(waveItem.sacdh.selected)]
self.getLabelTrace(waveItem)
sacdh = waveItem.sacdh
waveLabel = pg.TextItem(waveItem.waveLabelText,
color=fillBrush[:3],
anchor=(0, 0.5))
font = QtGui.QFontDatabase.systemFont(QtGui.QFontDatabase.FixedFont)
waveLabel.setFont(font)
plotItem.addItem(waveLabel)
yy = sacdh.datbase
xx = sacdh.time[0] - sacdh.gethdr(self.opts.qcpara.ichdrs[0])
ip = int(self.opts.qcpara.ichdrs[0][1])
xx = sacdh.b - sacdh.thdrs[ip]
waveLabel.setPos(xx, yy)
waveItem.waveLabel = waveLabel
def __init__(self, dataForCandle=None):
super(pgCandleWidget, self).__init__()
# 0) adds candle
self.candleData = dataForCandle
self.item01 = CandlestickItem(dataForCandle)
self.addItem(self.item01)
# 1)cross hair
self.vLine = pg.InfiniteLine(angle=90, movable=False)
self.hLine = pg.InfiniteLine(angle=0, movable=False)
self.addItem(self.vLine, ignoreBounds=True)
self.addItem(self.hLine, ignoreBounds=True)
# 2) adds textInfo
self.textInfo = pg.TextItem("test")
self.addItem(self.textInfo, ignoreBounds=True)
self.item01.sigClicked.connect(self.mouseClicked)
self.proxy = pg.SignalProxy(self.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved)
def calc(self):
if (self.inputError):
self.uResult.setText(self.tr('Invalid Input in some field'))
return
try:
print("Inside calc")
C = float(self.uCap.text()) * 1e-6
R = float(self.uRes.text())
intervals = float(self.intervals.text())
start = int(self.sFreq.text())
end = int(self.eFreq.text())
print(C, R, intervals, start, end)
#mStep = self.updateStep()
mStep = 10
print("mStep: " + str(mStep))
output = []
#self.p.set_sine_amp(2)
for i in range(start, end, mStep):
#print(i)
#print(self.p)
f = self.p.set_sine(i)
time.sleep(0.2)
#print("set sine")
volt = self.p.get_voltage('A1')
current = volt / R
data = (f, current, volt)
plot = pg.TextItem(text=str(current), color='y')
plot.setPos(f, current)
self.legends.append(plot)
self.pwin.addItem(plot)
print((f, volt))
output.append(data)
#print(output)
except:
print("Error")
print(traceback.format_exc())
self.uResult.setText(self.tr('Invalid Input in some field'))
def __init__(self, parent=None):
pyqtgraph.setConfigOption('background', 'w') #before loading widget
super(ExampleApp, self).__init__(parent)
self.setupUi(self)
self.grECG.plotItem.showGrid(True, True, 0.7)
self.btnSave.clicked.connect(self.saveFig)
self.btnSite.clicked.connect(self.website)
stamp = "DIY ECG by Scott Harden"
self.stamp = pyqtgraph.TextItem(stamp,
anchor=(-.01, 1),
color=(150, 150, 150),
fill=pyqtgraph.mkBrush('w'))
self.ear = swhear.Ear(chunk=int(100)) # determines refresh rate
if len(self.ear.valid_input_devices()):
self.ear.stream_start()
self.lblDevice.setText(self.ear.msg)
self.update()
def __init__(self, shape, vb, pos, size, handlePos, handleCenter, *args,
**kwargs):
self.mainShape = shape
pg.ROI.__init__(self, pos, size, pen='m', *args, **kwargs)
self.addScaleHandle(handlePos, handleCenter, lockAspect=True)
vb.addItem(self)
self.label = pg.TextItem()
self.label.setPos(self.pos()[0] + self.size()[0],
self.pos()[1] + self.size()[1])
self.label.setText('100x100')
self.sigRegionChanged.connect(self.updateText)
vb.addItem(self.label)
def length_warning(self):
self.xy_plot.clear()
self.hist_plot.clear()
text = "⚠️ dataset lengths mismatch:\n\n"
if self.mismatch['bins']:
text = ''.join([
text, "bin boundaries should have the same length\n"
"as the first dimension of histogram counts."
])
if self.mismatch['bins'] and self.mismatch['xs']:
text = ''.join([text, '\n\n'])
if self.mismatch['xs']:
text = ''.join([
text, "point abscissas should have the same length\n"
"as the second dimension of histogram counts."
])
self.xy_plot.addItem(pyqtgraph.TextItem(text))
def __init__(self, parent=None):
super(MapWidget, self).__init__(parent)
# Add the map to the view, and turn off some of the automatic interactive properties
self.map = self.addPlot()
self.map.setMenuEnabled(enableMenu=False)
self.map.hideButtons()
self.stas = [] # The station names for the station spot items
self.staItem = None # The station scatter item
self.selectSta = None # Which station is currently selected
self.curEveItem = None # The current event scatter item
self.prevEveItem = None # The previous event scatter item
# Add in the hovered over station label
self.hoverStaItem = pg.TextItem(text='', anchor=(0.5, 1))
self.hoverStaItem.hide()
self.map.addItem(self.hoverStaItem)
# Show station text when hovering over the station symbol
self.scene().sigMouseMoved.connect(self.onHover)
def __init__(self, task_dict):
super().__init__()
self.task_dict = task_dict # taskdict=dict(name= ,idnumber= ,task_type=int(0 to 12), time_start=, time_end=)
qc = cmap.mapToQColor(task_dict['task_type'] / 12)
qc.setAlpha(self.alpha)
self.roi_item = GanttROI(task_dict['name'],
task_dict['idnumber'],
start=task_dict['time_start'],
stop=task_dict['time_end'],
brush=qc)
self.roi_item.sigRegionChangeFinished.connect(
self.show_hide_move_text())
self.roi_item.setZValue(-1000)
self.text_item = pg.TextItem(task_dict['name'])
self.text_item.setPos(task_dict['time_start'], task_dict['idnumber'])
self.roi_item.setZValue(-500)
def AnnotationAdd(self, x, y, color='yellow', text=''):
"""
Adds new annotation to plot scene.
Parameters
----------
x : float
x position
y : float
y position
color :
'yellow', 'red', 'green' or 'blue'
text : str
Annotation text
"""
if color == 'yellow':
bgcolor = pg.mkBrush(250, 250, 150, 200)
elif color == 'red':
bgcolor = pg.mkBrush(250, 0, 0, 200)
elif color == 'green':
bgcolor = pg.mkBrush(0, 255, 0, 200)
elif color == 'blue':
bgcolor = pg.mkBrush(0, 0, 255, 200)
c = pg.TextItem(anchor=(.5, .5), border=pg.mkPen(100, 100, 100), fill=bgcolor)
c.setText(text=text, color=(0, 0, 0))
# Y coordinate transformed to variance_units (for plot control)
y_va = np.round(y / self.scaleVec[0]).astype('int')
c.setPos(x, y_va)
# create annotation object and add it to the list
obj = CustomAnnotation()
obj.pg_item = c
obj.x = x
obj.y_va = y_va
obj.y_off = self.firstCh
obj.color = color
obj.text = text
obj.session = self.parent.current_session
self.AnnotationsList = np.append(self.AnnotationsList, obj)
# List of positions (to calculate distances)
if len(self.AnnotationsPosAV) > 0:
self.AnnotationsPosAV = np.concatenate((self.AnnotationsPosAV,
np.array([x, y_va, self.firstCh]).reshape(1, 3)))
else:
self.AnnotationsPosAV = np.array([x, y_va, self.firstCh]).reshape(1, 3)
self.refreshScreen()
self.unsaved_changes_annotation = True
def on_data_ready(self, t_start, t_stop, visibles, data):
self.plot.clear()
self.graphicsview.setBackground(self.params['background_color'])
for e, chan in enumerate(visibles):
if len(data[chan]) == 3:
times, durations, labels = data[chan]
elif len(data[chan]) == 4:
times, durations, labels, _ = data[chan]
else:
raise ValueError("data has unexpected dimensions")
color = self.by_channel_params.children()[e].param('color').value()
color2 = QT.QColor(color)
color2.setAlpha(130)
ypos = visibles.size - e - 1
for i in range(times.size):
item = RectItem([times[i], ypos, durations[i], .9],
border=color,
fill=color2)
item.setPos(times[i], visibles.size - e - 1)
self.plot.addItem(item)
if self.params['display_labels']:
label_name = '{}: {}'.format(
chan, self.source.get_channel_name(chan=chan))
label = pg.TextItem(label_name,
color=color,
anchor=(0, 0.5),
border=None,
fill=self.params['label_fill_color'])
self.plot.addItem(label)
label.setPos(t_start, ypos + 0.45)
self.vline = pg.InfiniteLine(angle=90,
movable=False,
pen=self.params['vline_color'])
self.vline.setZValue(1) # ensure vline is above plot elements
self.plot.addItem(self.vline)
self.vline.setPos(self.t)
self.plot.setXRange(t_start, t_stop, padding=0.0)
self.plot.setYRange(0, visibles.size)
def drawFinished(self):
self.path.closeSubpath()
self.path_item.setPath(self.path)
self.ti = pg.TextItem(text='%d' % self.id,
fill=self.color,
color=(0, 0, 0))
self.ti.setParentItem(self)
self.ti.setPos(*self.getPoints()[0])
self.sigChanged.emit(self)
try:
if getArea(self.getPoints()) < .2:
raise Exception(
'ROI is too small, must have minimum area of .2')
except:
self.delete()
return False
return True
def displayWaiting(self):
if self.showIndexedPeaks:
if self.numIndexedPeaksFound == 0: # indexing proceeding
xMargin = 5 # pixels
maxX = np.max(self.parent.det.indexes_x(self.parent.evt)) + xMargin
maxY = np.max(self.parent.det.indexes_y(self.parent.evt))
# Draw a big triangle
cenX = np.array((self.parent.cx,)) + 0.5
cenY = np.array((self.parent.cy,)) + 0.5
diameter = 256 # self.peakRadius*2+1
self.parent.img.indexedPeak_feature.setData(cenY, cenX, symbol='t', \
size=diameter, brush=(255, 255, 255, 0), \
pen=pg.mkPen({'color': "#FF00FF", 'width': 3}),
pxMode=False)
self.parent.img.abc_text = pg.TextItem(html='', anchor=(0, 0))
self.parent.img.win.getView().addItem(self.parent.img.abc_text)
self.parent.img.abc_text.setPos(maxY, maxX)
def proc_ROI(self, parent):
stat0 = []
if self.extracted:
for t, s in zip(self.scatter, self.tlabel):
self.p0.removeItem(s)
self.p0.removeItem(t)
self.scatter = []
self.tlabel = []
for n in range(self.nROIs):
ellipse = self.ROIs[n].ellipse
yrange = self.ROIs[n].yrange
xrange = self.ROIs[n].xrange
x, y = np.meshgrid(xrange, yrange)
ypix = y[ellipse].flatten()
xpix = x[ellipse].flatten()
lam = np.ones(ypix.shape)
stat0.append({
'ypix': ypix,
'xpix': xpix,
'lam': lam,
'npix': ypix.size
})
self.tlabel.append(
pg.TextItem(str(n), self.ROIs[n].color, anchor=(0, 0)))
self.tlabel[-1].setPos(xpix.mean(), ypix.mean())
self.p0.addItem(self.tlabel[-1])
self.scatter.append(
pg.ScatterPlotItem([xpix.mean()], [ypix.mean()],
pen=self.ROIs[n].color,
symbol='+'))
self.p0.addItem(self.scatter[-1])
if not os.path.isfile(parent.ops['reg_file']):
parent.ops['reg_file'] = os.path.join(parent.basename, 'data.bin')
F, Fneu, F_chan2, Fneu_chan2, spks, ops, stat = masks_and_traces(
parent.ops, stat0, parent.stat)
print(spks.shape)
# print('After', stat[0].keys())
# print('Orig', parent.stat[0].keys())
self.Fcell = F
self.Fneu = Fneu
self.Spks = spks
self.plot_trace()
self.extracted = True
self.new_stat = stat
self.closeGUI.setEnabled(True)
def __init__(self,parent,master):
"""Constructor"""
self.__view = parent
self.master = master
super(Crosshair, self).__init__()
self.xAxis = 0
self.yAxis = 0
self.datas = None
self.yAxises = [0 for i in range(3)]
self.leftX = [0 for i in range(3)]
self.showHLine = [False for i in range(3)]
self.textPrices = [pg.TextItem('',anchor=(1,1)) for i in range(3)]
self.views = [parent.centralWidget.getItem(i+1,0) for i in range(3)]
self.rects = [self.views[i].sceneBoundingRect() for i in range(3)]
self.vLines = [pg.InfiniteLine(angle=90, movable=False) for i in range(3)]
self.hLines = [pg.InfiniteLine(angle=0, movable=False) for i in range(3)]
#mid 在y轴动态跟随最新价显示最新价和最新时间
self.__textDate = pg.TextItem('date',anchor=(1,1))
self.__textInfo = pg.TextItem('lastBarInfo')
self.__textSig = pg.TextItem('lastSigInfo',anchor=(1,0))
self.__textSubSig = pg.TextItem('lastSubSigInfo',anchor=(1,0))
self.__textVolume = pg.TextItem('lastBarVolume',anchor=(1,0))
self.__textDate.setZValue(2)
self.__textInfo.setZValue(2)
self.__textSig.setZValue(2)
self.__textSubSig.setZValue(2)
self.__textVolume.setZValue(2)
self.__textInfo.border = pg.mkPen(color=(230, 255, 0, 255), width=1.2)
for i in range(3):
self.textPrices[i].setZValue(2)
self.vLines[i].setPos(0)
self.hLines[i].setPos(0)
self.vLines[i].setZValue(0)
self.hLines[i].setZValue(0)
self.views[i].addItem(self.vLines[i])
self.views[i].addItem(self.hLines[i])
self.views[i].addItem(self.textPrices[i])
self.views[0].addItem(self.__textInfo, ignoreBounds=True)
self.views[0].addItem(self.__textSig, ignoreBounds=True)
self.views[1].addItem(self.__textVolume, ignoreBounds=True)
self.views[2].addItem(self.__textDate, ignoreBounds=True)
self.views[2].addItem(self.__textSubSig, ignoreBounds=True)
self.proxy = pg.SignalProxy(self.__view.scene().sigMouseMoved, rateLimit=360, slot=self.__mouseMoved)
# 跨线程刷新界面支持
self.signal.connect(self.update)
self.signalInfo.connect(self.plotInfo)
def setup(self, win):
self.td_plot = win.addPlot(row=0, col=0, title="PSD input data")
self.td_plot.setMenuEnabled(False)
self.td_plot.addLegend()
self.td_curves = []
for i, depth in enumerate(self.depths):
name = "{:.0f} cm".format(depth * 100)
curve = self.td_plot.plot(pen=utils.pg_pen_cycler(i), name=name)
self.td_curves.append(curve)
self.collapsed_plot = win.addPlot(row=1,
col=0,
title="Collapsed sqrt(PSD)")
self.collapsed_plot.setMenuEnabled(False)
self.collapsed_plot.setXRange(0, 1)
self.collapsed_curve = self.collapsed_plot.plot(
pen=utils.pg_pen_cycler())
self.collapsed_vline = pg.InfiniteLine(pen=utils.pg_pen_cycler())
self.collapsed_vline.hide()
self.collapsed_plot.addItem(self.collapsed_vline)
bg = pg.mkColor(0xFF, 0xFF, 0xFF, 150)
self.collapsed_text = pg.TextItem(anchor=(0, 1), color="k", fill=bg)
self.collapsed_text.setPos(0, 0)
self.collapsed_text.setZValue(100)
self.collapsed_plot.addItem(self.collapsed_text)
self.collapsed_history_plot = win.addPlot(
row=2, col=0, title="Collapsed sqrt(PSD) history")
self.collapsed_history_plot.setMenuEnabled(False)
self.collapsed_history_im = pg.ImageItem()
self.collapsed_history_im.setLookupTable(utils.pg_mpl_cmap("viridis"))
self.collapsed_history_plot.addItem(self.collapsed_history_im)
self.dw_plot = win.addPlot(row=3, col=0, title="Depthwise PSD")
self.dw_plot.setMenuEnabled(False)
self.dw_im = pg.ImageItem()
self.dw_im.setLookupTable(utils.pg_mpl_cmap("viridis"))
self.dw_plot.addItem(self.dw_im)
self.dw_plot.setLabel("bottom", "Depth (cm)")
self.dw_plot.getAxis("bottom").setTickSpacing(
6 * self.downsampling_factor, 6)
self.setup_is_done = True
self.update_processing_config()
def __init__(
self,
widget: ChartWidget,
manager: BarManager,
plots: Dict[str, pg.GraphicsObject],
item_plot_map: Dict[ChartItem, pg.GraphicsObject],
event_engine: EventEngine,
#items: Dict[str, pg.GraphicsObject],
):
""""""
super().__init__()
self._widget: ChartWidget = widget
self._manager: BarManager = manager
self._plots: Dict[str, pg.GraphicsObject] = plots
self._item_plot_map: Dict[ChartItem, pg.GraphicsObject] = item_plot_map
self._x: int = 0
self._y: int = 0
self._plot_name: str = ""
self.current_interval = "1m"
self.event_engine = event_engine
self._init_ui()
self._connect_signal()
# 2019-12-15 lwh
#self.items = items
self.dt_ix = {}
self.info_item = Dict[str, pg.TextItem]
for plot_name, plot in self._plots.items():
#print(plot_name)
self.inf = pg.TextItem(
"info",
color=CURSOR_COLOR,
border=CURSOR_COLOR,
fill=BLACK_COLOR
)
self.inf.hide()
self.inf.setZValue(2)
self.inf.setFont(NORMAL_FONT)
plot.addItem(self.inf) # , ignoreBounds=True)
def _plot_ladder_annotations(self):
try:
self._ladder_visible
except (AttributeError, NameError):
return
try:
self.currMaxY
except (AttributeError, NameError):
self.currMaxY = self._getMaxIntensityInRange(
self.getAxis('bottom').range)
xlimit = [self._mzs[0], self._mzs[-1]]
for ladder_key, lastruct in self._ladder_visible.items():
if ladder_key in self._ladder_anno_lines.keys(): # update
self._ladder_anno_lines[ladder_key][0].setData(
[xlimit[0], xlimit[1]],
[self.currMaxY, self.currMaxY]) # horizontal line
cntr = 0
for x in lastruct.mz_list:
self._ladder_anno_lines[ladder_key][cntr + 1].setData(
[x, x], [0, self.currMaxY])
self._ladder_anno_labels[ladder_key][cntr].setPos(
x, self.currMaxY) # horizon line doesn't have label
cntr += 1
else: # plot
pen = pg.mkPen(lastruct.color, width=2, style=Qt.DotLine)
self._ladder_anno_lines[ladder_key] = []
self._ladder_anno_labels[ladder_key] = []
self._ladder_anno_lines[
ladder_key].append( # horizon line. index 0
self.plot([xlimit[0], xlimit[1]],
[self.currMaxY, self.currMaxY],
pen=pen))
for x, txt_label in zip(lastruct.mz_list,
lastruct.text_label_list):
self._ladder_anno_lines[ladder_key].append(
self.plot([x, x], [0, self.currMaxY], pen=pen))
label = pg.TextItem(text=txt_label,
color=lastruct.color,
anchor=(1, -1))
label.setPos(x, self.currMaxY)
label.setParentItem(
self._ladder_anno_lines[ladder_key][-1])
self._ladder_anno_labels[ladder_key].append(label)
def _initialize(self):
BaseOscilloscope._initialize(self)
#create a trigger
self.trigger.configure()
self.trigger.input.connect(self.proxy_input.params)
self.trigger.output.configure(protocol='inproc',
transfermode='plaindata')
self.trigger.initialize()
#create a triggeraccumulator
self.triggeraccumulator.configure(max_stack_size=np.inf)
self.triggeraccumulator.inputs['signals'].connect(
self.proxy_input.params)
self.triggeraccumulator.inputs['events'].connect(self.trigger.output)
self.triggeraccumulator.initialize()
self.trigger.params.sigTreeStateChanged.connect(self.on_param_change)
self.triggeraccumulator.params.sigTreeStateChanged.connect(
self.on_param_change)
self.curves = []
self.channel_labels = []
for i in range(self.nb_channel):
color = '#7FFF00' # TODO
curve = pg.PlotCurveItem(pen=color)
self.plot.addItem(curve)
self.curves.append(curve)
label = pg.TextItem('TODO name{}'.format(i),
color=color,
anchor=(0.5, 0.5),
border=None,
fill=pg.mkColor((128, 128, 128, 200)))
self.plot.addItem(label)
self.channel_labels.append(label)
self.vline = pg.InfiniteLine(pos=0, angle=90, pen='r')
self.plot.addItem(self.vline)
self.list_curves = [[] for i in range(self.nb_channel)]
self.recreate_stack()
self.reset_curves_data()
def setup(self):
self.settings.New('spec_index', dtype=int, initial=0)
self.settings.spec_index.add_listener(self.on_spec_index_change)
self.ui = QtWidgets.QGroupBox()
self.ui.setLayout(QtWidgets.QVBoxLayout())
self.ui.spec_index_doubleSpinBox = QtWidgets.QDoubleSpinBox()
self.settings.spec_index.connect_bidir_to_widget(
self.ui.spec_index_doubleSpinBox)
self.ui.layout().addWidget(self.ui.spec_index_doubleSpinBox)
self.graph_layout = pg.GraphicsLayoutWidget()
self.ui.layout().addWidget(self.graph_layout)
self.power_plot = self.graph_layout.addPlot()
self.power_plot.setLogMode(x=True, y=True)
self.power_plotcurve = self.power_plot.plot([1], [1], name='Data')
self.power_fit_plotcurve = self.power_plot.plot([1], [1],
pen='r',
name='Fit')
self.power_plot_arrow = pg.ArrowItem()
self.power_plot_arrow.setPos(0, 0)
self.power_plot.addItem(self.power_plot_arrow)
self.power_plot_lr = pg.LinearRegionItem([1, 2])
self.power_plot_lr.setZValue(-10)
self.power_plot.addItem(self.power_plot_lr)
self.power_plot_lr.sigRegionChanged.connect(self.redo_fit)
#self.power_plot_legend = pg.LegendItem()
#self.power_plot.addItem(self.power_plot_legend)
#self.power_plot_legend.addItem(self.power_plotcurve)
#self.power_plot_legend.addItem(self.power_fit_plotcurve)
self.fit_text = pg.TextItem("fit")
self.fit_text.setParentItem(self.power_plot_lr, )
self.graph_layout.nextRow()
self.spec_plot = self.graph_layout.addPlot()
self.spec_plotcurve = self.spec_plot.plot([0])
def set_data(self, in_array_data):
items = self.view.allChildren()
for i in range(len(items)):
if i >= self.item_number - 1:
self.view.removeItem(items[i])
frame = abs(in_array_data)
self.item.setImage(frame, autoLevels=True)
self.item.setRect(
QRectF(self.Vmin, self.Rmin, self.VRange, self.RRange))
frame = (abs(in_array_data) - 2 * self.noize) * np.heaviside(
(abs(in_array_data) - 2 * self.noize), 0)
#frame = frame.astype(int)
frame = ndimage.binary_opening(frame, structure=np.ones(
(3, 3))).astype(int)
labeled_array, lab_num = ndimage.label(frame)
pos = []
symbols = []
sizes = []
rects = []
texts = []
for i in range(lab_num):
(xcm,
ycm) = (ndimage.measurements.center_of_mass(labeled_array == i +
1))
xcm = xcm * (self.VRange / self.xdim) + self.Vmin
ycm = ycm * (self.RRange / self.ydim) + self.Rmin
slices = ndimage.find_objects(labeled_array == i + 1)
pos.append([xcm, ycm])
rect = self.rect_from_tuple(slices[0])
rect = QtGui.QGraphicsRectItem(rect)
rect.setPen(pg.mkPen(100, 200, 100))
self.view.addItem(rect)
text = 'target %s\n V=%3d R=%3d' % (i, xcm, ycm)
text = pg.TextItem(text)
self.view.addItem(text)
text.setPos(xcm, slices[0][1].start * (self.RRange / self.ydim))
#symbols.append('s')
#sizes.append(self.val_from_slice(slices[0]))
#texts.append('target %s\n V=%3d R=%3d' % (i, xcm, ycm))
pos = np.asarray(pos)
self.mass_centers.setData(pos=pos,
symbolPen=(255, 0, 0, 255),
symbolBrush=(255, 0, 0, 255),
size=20,
symbol='x')
def scatterAddition(self, x, y):
"""
此处将clicked定义为内部函数，是为了将传入参数pgPlot与其绑定
每个通过scatterAddition加入scatter的pgPlot都会保存一份自己的clicked函数
而clicked处理的是传入的参数pgPlot
"""
scatterPrice = pg.ScatterPlotItem(size=5,
pen=pg.mkPen(None),
pxMode=True,
brush=pg.mkBrush(255, 255, 255, 120))
spots = [{'pos': (x, price)} for x, price in zip(x, y)]
scatterPrice.addPoints(spots)
self.addItem(scatterPrice)
self.scatterInfo = pg.TextItem("test") ## Make all plots clickable
self.addItem(self.scatterInfo)
self.lastClicked = []
def clicked(plot, points):
if (len(points) > 0):
mousePoint = points[0].pos()
self.scatterInfo.setHtml(
'<div style="text-align: center">\
<span style="color: red; font-size: 10pt;">\
%s\
</span>\
<br>\
<span style="color: red; font-size: 10pt;">\
%.3f\
</span>\
</div>'\
% (dt.datetime.strftime(mpd.num2date(mousePoint.x()).astimezone(pytz.timezone('utc')),'%Y-%m-%d %H:%M:%S%Z'),
mousePoint.y()
))
xAxis = mousePoint.x()
yAxis = mousePoint.y()
self.scatterInfo.setPos(xAxis, yAxis)
for p in self.lastClicked:
p.resetPen()
for p in points:
p.setPen('b', width=2)
self.lastClicked = points
scatterPrice.sigClicked.connect(clicked)
