def _replot(self):
def pen(color):
pen = QPen(color, 1)
pen.setCosmetic(True)
return pen
if self._scatter_item is not None:
self.plot.removeItem(self._scatter_item)
self._scatter_item = None
nclasses = len(self.class_model)
pens = [pen(self.colors[i]) for i in range(nclasses)]
self._scatter_item = pg.ScatterPlotItem(
self.data[:, 0],
self.data[:, 1],
symbol="+",
pen=[pens[int(ci)] for ci in self.data[:, 2]])
self.plot.addItem(self._scatter_item)
def _replot(self):
def pen(color):
pen = QPen(color, 1)
pen.setCosmetic(True)
return pen
if self._scatter_item is not None:
self.plot.removeItem(self._scatter_item)
self._scatter_item = None
x = self.__buffer[:, 0].copy()
if self.hasAttr2:
y = self.__buffer[:, 1].copy()
else:
y = np.zeros(self.__buffer.shape[0])
colors = self.colors[self.__buffer[:, 2]]
pens = [pen(c) for c in colors]
self._scatter_item = pg.ScatterPlotItem(x, y, symbol="+", pen=pens)
self.plot.addItem(self._scatter_item)
def test_init_spots():
app = pg.mkQApp()
plot = pg.PlotWidget()
# set view range equal to its bounding rect.
# This causes plots to look the same regardless of pxMode.
plot.setRange(rect=plot.boundingRect())
spots = [
{
'x': 0,
'y': 1
},
{
'pos': (1, 2),
'pen': None,
'brush': None,
'data': 'zzz'
},
]
s = pg.ScatterPlotItem(spots=spots)
# Check we can display without errors
plot.addItem(s)
app.processEvents()
plot.clear()
# check data is correct
spots = s.points()
defPen = pg.mkPen(pg.getConfigOption('foreground'))
assert spots[0].pos().x() == 0
assert spots[0].pos().y() == 1
assert spots[0].pen() == defPen
assert spots[0].data() is None
assert spots[1].pos().x() == 1
assert spots[1].pos().y() == 2
assert spots[1].pen() == pg.mkPen(None)
assert spots[1].brush() == pg.mkBrush(None)
assert spots[1].data() == 'zzz'
plot.close()
def __init__(self, *args, display_size=(1280, 800), roi_params, **kwargs):
super().__init__(*args, **kwargs)
self.roi_params = roi_params
self.view_box = pg.ViewBox(invertY=True,
lockAspect=1,
enableMouse=False)
self.addItem(self.view_box)
self.roi_box = pg.ROI(
maxBounds=QRectF(0, 0, display_size[0], display_size[1]),
size=roi_params["size"],
pos=roi_params["pos"],
)
self.roi_box.addScaleHandle([0, 0], [1, 1])
self.roi_box.addScaleHandle([1, 1], [0, 0])
self.roi_box.sigRegionChanged.connect(self.set_param_val)
self.roi_params.sigTreeStateChanged.connect(self.set_roi)
self.view_box.addItem(self.roi_box)
self.view_box.setRange(
QRectF(0, 0, display_size[0], display_size[1]),
update=True,
disableAutoRange=True,
)
self.view_box.addItem(
pg.ROI(
pos=(1, 1),
size=(display_size[0] - 1, display_size[1] - 1),
movable=False,
pen=(80, 80, 80),
))
self.calibration_points = pg.ScatterPlotItem(pen=None,
brush=(255, 0, 0))
self.calibration_frame = pg.PlotCurveItem(brush=(120, 10, 10),
pen=(200, 10, 10),
fill_level=1)
self.view_box.addItem(self.calibration_points)
self.view_box.addItem(self.calibration_frame)
def generate_scatter_plot(params_dict, feature1, electrode1, feature2,
electrode2):
"""
This function takes the parameters calculated for the waveforms and generates a scatter plot for
selected electrodes and features.
Inputs:
params_dict: Dictionary containing the waveform parameters as generated by the calculate_params
function.
feature1: The feature to be plotted on x axis.
electrode1: From which electrode the parameter will be pulled for the x axis.
feature2: The feature to be plotted on y axis.
electrode2: From which electrode the parameter will be pulled for the y axis.
Outputs:
plt: Scatter plot item containing the scatter plot generated for the selected parameters
"""
y_label = feature2 + ' on Electrode #' + str(electrode2)
x_label = feature1 + ' on Electrode #' + str(electrode1)
plt = pg.PlotItem(labels={'left': y_label, 'bottom': x_label})
s = pg.ScatterPlotItem()
spots = []
for i in range(n_clusters):
feat1_array = params_dict[str(i)][feature1]
feat2_array = params_dict[str(i)][feature2]
pos = np.column_stack(
(feat1_array[:, electrode1], feat2_array[:, electrode2]))
for j in range(len(feat1_array)):
spots.append({
'pos': pos[j, :],
'size': 5,
'symbol': 'o',
'pen': pg.mkPen(None),
'brush': pg.intColor(i, n_clusters)
})
s.addPoints(spots)
plt.addItem(s)
return plt
def minimum_main():
# run()
# app = QtGui.QApplication([])
# win = QtGui.QMainWindow()
# view = GraphicsLayoutWidget()
# win.setCentralWidget(view)
# win.show()
# win.setWindowTitle("win [Test] Window Title")
view: GraphicsView = GraphicsWindow()
view.setWindowTitle("view [Test] Window Title")
fig: GraphicsLayout = view.centralWidget
axes = fig.addPlot()
n = 300
s1 = pg.ScatterPlotItem(size=10,
pen=pg.mkPen(None),
brush=pg.mkBrush(255, 255, 255, 120))
pos = np.random.normal(size=(2, n), scale=1e-5)
spots = [{
'pos': pos[:, i],
'data': 1
} for i in range(n)] + [{
'pos': [0, 0],
'data': 1
}]
s1.addPoints(spots)
axes.addItem(s1)
# p = PlotItem()
# p.titleLabel = "title test"
# p.addLine([1, 2, 3], [4, 5, 6])
# fig.addItem(p)
# fig.addItem(p, row=1, col=1)
print("execute...")
from PyQt5.QtWidgets import QApplication # , QMainWindow
QApplication.instance().exec_()
def getFit(self):
try:
self.fit = getFit(self.data, self.x, self.guess)
checkBounds(self.fit, self.data, self.x)
self.plot.clear()
data = pg.ScatterPlotItem(self.x, self.ampList, symbol='o', size=5)
self.plot.addItem(data)
self.ui.results.append("----------RESULT----------")
self.plotFit(self.fit)
except (RuntimeError, AssertionError):
self.ui.results.append(
"----------OPTIMIZATION NOT FOUND----------")
QtGui.QMessageBox.information(
self, "Unable to Find Optimized Fit",
"Try messing with the guess "
"parameters")
except AttributeError:
QtGui.QMessageBox.information(
self, "Error Getting Fit", "Please upload a Matlab XCor data "
"file to fit")
def showXplot(self):
self.p3.clear()
#
self.p3.setLabel(axis='bottom',
text=str(self.listWidget1.currentItem().text()))
self.p3.setLabel(axis='left',
text=str(self.listWidget2.currentItem().text()))
#
minReg, maxReg = self.lr1.getRegion(
) # returns the depth values associated with the region as a tuple
# use the DataFrame structure of pandas to quickly get the values associated with these depths
dataInRegionDF = self.log_df.loc[minReg:maxReg]
#print dataTEST
xData = dataInRegionDF[str(self.listWidget1.currentItem().text())]
yData = dataInRegionDF[str(self.listWidget2.currentItem().text())]
crossPlot = pg.ScatterPlotItem()
self.p3.addItem(crossPlot)
crossPlot.addPoints(x=xData, y=yData)
# =============== END OF SCRIPT =================
def set_plotdata_2(self, name, data_x, data_y):
data_y = data_y[:64]
brush_default = pg.mkBrush(self.a["colorIndex_x"],
self.a["colorIndex_y"],
self.a["colorIndex_z"], 100)
if name in self.traces:
# update scatter plot content
self.graph.clear()
self.graph.setData(data_x, data_y, brush=brush_default)
else:
self.traces.add(name)
# initial setup of scatter plot
self.graph = pg.ScatterPlotItem(
x=data_x,
y=data_y,
pen=None,
symbol=self.symbol,
size=30,
brush=(100, 100, 255, 100),
)
self.audio_plot.addItem(self.graph)
def __init__(self, parent=None, **kargs):
super(TimeLinePlotWidget, self).__init__(parent, **kargs)
self.plot = None
self.symbol_view = pg.ViewBox()
self.plotItem.scene().addItem(self.symbol_view)
self.symbol_view.setXLink(self.plotItem)
self.symbol_view.setRange(yRange=(0, 1))
self.symbol_view.enableAutoRange(axis=pg.ViewBox.YAxis, enable=False)
fc_brush = pg.mkBrush(0, 255, 0, 255)
self.forecasts_plot = pg.ScatterPlotItem(pen=pg.mkPen(None),
symbol='t',
brush=fc_brush)
self.symbol_view.addItem(self.forecasts_plot)
self.getAxis('left').enableAutoSIPrefix(False)
self.getAxis('bottom').enableAutoSIPrefix(False)
self.getAxis('left').setLabel('N/A')
self.plotItem.vb.sigResized.connect(self._update_views)
self._update_views()
def __init__(self,image=np.zeros((1,1)), nColors=10,parent=None):
QWidget.__init__(self,parent)
self.nColors=nColors
self.view= pg.GraphicsLayoutWidget()
self.l = QVBoxLayout()
self.setLayout(self.l)
self.l.addWidget(self.view)
self.show()
self.w1 = self.view.addPlot()
self.w1.vb.setAspectLocked(True,ratio=1)
self.w1.vb.invertY(True)
self.s1 = pg.ScatterPlotItem(size=5, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 120))
#self.s1.setData(x,y)
self.w1.addItem(pg.ImageItem(image))
self.w1.addItem(self.s1)
self.brush_idx=0
color=np.arange(self.nColors)/self.nColors
color=np.array(cm.RdYlBu(color))*255
color[:,3]=200 # set alpha channel
self.brushes=[pg.mkBrush(QColor(*color[i,:].astype(uint16))) for i in np.arange(self.nColors)]
def drawGrid(self):
try:
self.clearGrid()
except:
pass
height = float(self.polmap_height_l.text())
data = []
h_idx = np.nanargmin(np.abs(height - self.grid_elev))
indicies = np.argwhere(self.grid_array[:, :, h_idx] > 0)
for ii in indicies:
data.append((self.grid_lon[ii[1]], self.grid_lat[ii[0]], self.grid, \
self.grid, self.color_list[int(self.grid_array[ii[0], ii[1], h_idx]) - 1]))
overlap_indicies = np.argwhere(self.grid_array[:, :, h_idx] == -1)
for ii in overlap_indicies:
self.ovlp_marker = pg.ScatterPlotItem()
self.ovlp_marker.setPoints(x=[self.grid_lon[ii[1]]],
y=[self.grid_lat[ii[0]]],
pen=(255, 255, 255),
brush=(255, 255, 255),
symbol='o')
self.polmap_canvas.addItem(self.ovlp_marker)
# try:
self.heat_map_data_squares = RectangleItem(data,
c_map="set",
alpha=255)
self.polmap_canvas.addItem(self.heat_map_data_squares)
# # If there are no squares to draw
# except IndexError:
# pass
self.drawTrajPoint(height)
def plot_curve(curve, pen=None, shadow_pen=None, symbol="+", symbol_size=3, name=None):
"""
Construct a `PlotCurve` for the given `ROCCurve`.
:param ROCCurve curve:
Source curve.
The other parameters are passed to pg.PlotDataItem
:rtype: PlotCurve
"""
def extend_to_origin(points):
"Extend ROCPoints to include coordinate origin if not already present"
if points.tpr.size and (points.tpr[0] > 0 or points.fpr[0] > 0):
points = ROCPoints(
numpy.r_[0, points.fpr],
numpy.r_[0, points.tpr],
numpy.r_[points.thresholds[0] + 1, points.thresholds],
)
return points
points = extend_to_origin(curve.points)
item = pg.PlotCurveItem(
points.fpr, points.tpr, pen=pen, shadowPen=shadow_pen, name=name, antialias=True
)
sp = pg.ScatterPlotItem(
curve.points.fpr,
curve.points.tpr,
symbol=symbol,
size=symbol_size,
pen=shadow_pen,
name=name,
)
sp.setParentItem(item)
hull = extend_to_origin(curve.hull)
hull_item = pg.PlotDataItem(hull.fpr, hull.tpr, pen=pen, antialias=True)
return PlotCurve(curve, item, hull_item)
def initialize_plot(self):
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.curves = []
self.channel_labels = []
self.channel_offsets_line = []
for c in range(self.source.nb_channel):
color = self.by_channel_params['ch{}'.format(c), 'color']
curve = pg.PlotCurveItem(pen='#7FFF00', downsampleMethod='peak', downsample=1,
autoDownsample=False, clipToView=True, antialias=False)#, connect='finite')
self.plot.addItem(curve)
self.curves.append(curve)
ch_name = '{}: {}'.format(c, self.source.get_channel_name(chan=c))
label = TraceLabelItem(text=ch_name, color=color, anchor=(0, 0.5), border=None, fill=self.params['label_fill_color'])
label.setZValue(2) # ensure labels are drawn above scatter
font = label.textItem.font()
font.setPointSize(self.params['label_size'])
label.setFont(font)
label.label_dragged.connect(lambda label_y, chan_index=c: self.params_controller.apply_label_drag(label_y, chan_index))
label.label_ygain_zoom.connect(lambda factor_ratio, chan_index=c: self.params_controller.apply_ygain_zoom(factor_ratio, chan_index))
self.plot.addItem(label)
self.channel_labels.append(label)
offset_line = pg.InfiniteLine(angle = 0, movable = False, pen = '#7FFF00')
self.plot.addItem(offset_line)
self.channel_offsets_line.append(offset_line)
if self.source.with_scatter:
self.scatter = pg.ScatterPlotItem(size=self.params['scatter_size'], pxMode = True)
self.plot.addItem(self.scatter)
self.viewBox.xsize_zoom.connect(self.params_controller.apply_xsize_zoom)
self.viewBox.ygain_zoom.connect(self.params_controller.apply_ygain_zoom)
def __init__(self, dataSource=None, nameList=['Plot1', 'Plot2', 'Plot3']):
#Widget Setting
#pg.setConfigOption('background', 'w')
self.numOfDataToPlot = 200
self.plotViewList = []
self.penStyleList = [(255, 5, 5), (200, 200, 100), (195, 46, 212),
(0, 0, 200), (237, 177, 32)]
self.count = 0
self.curveList = []
self.curveXData = [i for i in range(0, self.numOfDataToPlot)]
self.curveYDataList = []
self.app = QtGui.QApplication([])
self.mainWindow = QtGui.QMainWindow()
self.mainWindow.setWindowTitle('pyqtgraph example: PlotWidget')
self.mainWindow.resize(800, 800 / len(nameList))
self.view = pg.GraphicsLayoutWidget(
) ## GraphicsView with GraphicsLayout inserted by default
self.mainWindow.setCentralWidget(self.view)
# layout = QtGui.QVBoxLayout()
# self.GuiWiget.setLayout(layout)
for i, name in zip(range(0, 3), nameList):
plotView = self.view.addPlot(name=name)
plotView.setRange(xRange=[-600, 600], yRange=[-600, 600])
self.plotViewList.append(plotView)
# plotWidget = pg.PlotWidget(name=name) ## giving the plots names allows us to link their axes together
# plotWidget.setXRange(0, self.numOfDataToPlot)
# plotWidget.setYRange(-1, 1)
# layout.addWidget(plotWidget)
# self.plotWidgetList.append(plotWidget)
# Display the widget as a new window
self.mainWindow.show()
#Draw Setting
for plotView, penStyle in zip(self.plotViewList, self.penStyleList):
curve = pg.ScatterPlotItem(size=1)
curve.setPen(penStyle)
self.curveList.append(curve)
plotView.addItem(curve)
def checkTest(self):
if len(self.traindata) == 0:
return 1
print(self.testData)
self.labeltestdata = classifyKNN(self.traindata, self.testData,
self.spinBoxK.value(),
self.numberofclasses,
self.checkBoxSuspended.isChecked(), 0)
x = sum([
int(self.labeltestdata[i] == self.trueTestDataLabels[i][1])
for i in range(len(self.trueTestDataLabels))
]) / float(len(self.trueTestDataLabels))
classes = []
i = 0
while i < 20:
classes.append([])
i += 1
for i in self.trueTestDataLabels:
classes[i[1]].append(np.asarray(i[0]))
i = 0
for j in classes:
myS = pg.ScatterPlotItem(size=10,
pen=pg.mkPen(colors[i]),
brush=pg.mkBrush(255, 255, 255, 120))
myspots = []
if (len(j)):
for k in j:
myspots.append({'pos': k, 'data': i})
i += 1
myS.addPoints(myspots)
self.w1.addItem(myS)
dialog = QtWidgets.QMessageBox(QtWidgets.QMessageBox.Information,
"Точность классификации ",
str(x),
buttons=QtWidgets.QMessageBox.Ok,
parent=None)
result = dialog.exec_()
def _initialise_series(self):
for s in self.series:
s.remove_items()
self.series.clear()
channels = self.model.get_channel_schemata()
try:
data_names, error_bar_names = extract_scalar_channels(channels)
except ValueError as e:
self.error.emit(str(e))
return
colors = [
SERIES_COLORS[i % len(SERIES_COLORS)]
for i in range(len(data_names))
]
for i, (data_name, color) in enumerate(zip(data_names, colors)):
data_item = pyqtgraph.ScatterPlotItem(pen=None, brush=color)
error_bar_name = error_bar_names.get(data_name, None)
error_bar_item = pyqtgraph.ErrorBarItem(
pen=color) if error_bar_name else None
self.series.append(
_Series(self, data_name, data_item, error_bar_name,
error_bar_item, self._history_length))
def axis_info(i):
# If there is only one series, set label/scaling accordingly.
# TODO: Add multiple y axis for additional channels.
c = channels[data_names[i]]
label = c["description"]
if not label:
label = c["path"].split("/")[-1]
return label, c["path"], colors[i], c
setup_axis_item(self.getAxis("left"),
[axis_info(i) for i in range(len(data_names))])
self.ready.emit()
def __init__(self, time, events, label=None, color=None):
self._kmf = KaplanMeierFitter().fit(time.astype(np.float64), events.astype(np.float64))
self.label: str = label
self.color: List[int] = color
# refactor this
time, survival = self._kmf.survival_function_.reset_index().values.T.tolist()
lower, upper = self._kmf.confidence_interval_.values.T.tolist()
self.x, self.y = self.generate_curve_coordinates(time, survival)
_, self.lower_bound = self.generate_curve_coordinates(time, lower)
_, self.upper_bound = self.generate_curve_coordinates(time, upper)
# Estimated function curve
self.estimated_fun = pg.PlotDataItem(self.x, self.y, pen=self.get_pen())
# Lower and upper confidence intervals
pen = self.get_pen(width=1, alpha=70)
self.lower_conf_limit = pg.PlotDataItem(self.x, self.lower_bound, pen=pen)
self.upper_conf_limit = pg.PlotDataItem(self.x, self.upper_bound, pen=pen)
self.confidence_interval = pg.FillBetweenItem(
self.upper_conf_limit, self.lower_conf_limit, brush=self.get_color(alpha=50)
)
self.selection = pg.PlotDataItem(pen=mkPen(color=QColor(Qt.yellow), width=4))
self.selection.hide()
self.median_survival = median = median_survival_times(self._kmf.survival_function_.astype(np.float32))
self.median_vertical = pg.PlotDataItem(x=(median, median), y=(0, 0.5), pen=MEDIAN_LINE_PEN)
censored_data = self.get_censored_data()
self.censored_data = pg.ScatterPlotItem(
x=censored_data[:, 0],
y=censored_data[:, 1],
brush=QBrush(Qt.black),
pen=self.get_pen(width=1, alpha=255),
# size=np.full((points.shape[0],), 10.1),
)
self.censored_data.setZValue(10)
def __init__(self, emobj):
pg.QtGui.QMainWindow.__init__(self)
self.setWindowTitle('matplotlib and pyqtpgraph integration example')
self.main_widget = pg.QtGui.QWidget(self)
self.layout = pg.QtGui.QHBoxLayout(self.main_widget)
self.persistence_canvas = PersistenceSelector(self.main_widget,
emobj,
width=5,
height=4,
dpi=100)
"""
self.glw = pg.LayoutWidget()
self.b1_b = pg.QtGui.QPushButton('-')
self.b1_b.clicked.connect(self.b1_clicked)
self.b2_b = pg.QtGui.QPushButton('+')
self.b2_b.clicked.connect(self.b2_clicked)
self.glw.addWidget(self.b1_b, row=0, col=0)
self.glw.addWidget(self.b2_b, row=0, col=1)
"""
self.plw = pg.PlotWidget()
s1 = pg.ScatterPlotItem(size=10,
pen=pg.mkPen(None),
brush=pg.mkBrush(255, 255, 255, 120))
pos = np.random.randn(10000, 2)
spots = [{
'pos': pos[i, :],
'data': 1,
'symbol': 'o'
} for i in range(pos.shape[0])]
s1.addPoints(spots)
self.plw.addItem(s1)
self.layout.addWidget(self.persistence_canvas)
#self.layout.addWidget(self.glw)
self.layout.addWidget(self.plw)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
def proc_ROI(self):
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(self.parent.ops['reg_file']):
self.parent.ops['reg_file'] = os.path.join(self.parent.basename, 'data.bin')
F, Fneu, F_chan2, Fneu_chan2, spks, ops, stat = masks_and_traces(self.parent.ops, stat0, self.parent.stat)
print(spks.shape)
# print('After', stat[0].keys())
# print('Orig', self.parent.stat[0].keys())
self.Fcell = F
self.Fneu = Fneu
self.F_chan2 = F_chan2
self.Fneu_chan2 = Fneu_chan2
self.Spks = spks
self.plot_trace()
self.extracted = True
self.new_stat = stat
self.closeGUI.setEnabled(True)
def __init__(self,
type='curve',
name=None,
xaxis=np.arange(2048),
aspectLocked=False):
super().__init__(name=name)
if type == 'curve':
self.item = PyQtG.PlotCurveItem()
elif type == 'scatter':
self.item = PyQtG.ScatterPlotItem()
else:
raise Exception(
'Invalid type for PyQtGraph item. Only "curve" and "scatter" are supported.'
)
self.setTitle(title=name)
self.setAspectLocked(aspectLocked)
self.X = xaxis
self.showGrid(x=1, y=1)
self.addItem(self.item)
def loadEvePoints(self, eveMeta, eveType):
if eveType == 'cur':
item, alpha = self.curEveItem, 200
else:
item, alpha = self.prevEveItem, 160
# Remove the previous item
if item is not None:
self.map.removeItem(item)
# Project the lon,lat into x,y
eveLocProj = self.projFunc(eveMeta[:, 1:4])
# Add in all of the new points, size & color set in different function
scatter = pg.ScatterPlotItem(size=1,
symbol='o',
pen=pg.mkPen(None),
brush=pg.mkBrush(0, 0, 0, alpha))
scatter.addPoints(x=eveLocProj[:, 0], y=eveLocProj[:, 1])
self.map.addItem(scatter)
# Update the scatter item reference
if eveType == 'cur':
self.curEveItem = scatter
else:
self.prevEveItem = scatter
def set_scatter_plot_items(self):
for index_of_instance, each_graphics_instance in enumerate(
self.list_of_graphics_menus_instances):
if not each_graphics_instance.deleted and not each_graphics_instance.table_deleted:
if each_graphics_instance.visible:
for i, v in enumerate(each_graphics_instance.
list_of_lists_of_values_to_show[0]):
s1 = pg.ScatterPlotItem(
size=10,
pen=pg.mkPen(each_graphics_instance.color),
brush=pg.mkBrush(each_graphics_instance.color))
s1.addPoints(
x=each_graphics_instance.
list_of_lists_of_values_to_show[0][i],
y=each_graphics_instance.
list_of_lists_of_values_to_show[1][i],
pen=pg.mkPen(each_graphics_instance.color,
width=2),
)
s1.sigClicked.connect(self._scatter_plot_item_clicked)
self.first_plot.addItem(s1)
self.list_of_scatter_plot_items.append(s1)
def __init__(self, parent):
super().__init__(parent)
self.setWindowTitle('Association rules scatter plot')
scatter = self.scatter = pg.ScatterPlotItem(size=5,
symbol='s',
pen=pg.mkPen(None))
plot = self.plot = self.PlotWidget(background='w',
labels=dict(left='Confidence',
bottom='Support'))
plot.setScatter(scatter)
plot.setLimits(xMin=0,
xMax=1.02,
yMin=0,
yMax=1.02,
minXRange=0.5,
minYRange=0.5)
self.setCentralWidget(plot)
plot.addItem(scatter)
plot.hideButtons()
self.lastClicked = []
scatter.sigClicked.connect(self.clicked)
def __init__(self, pos, prect, color, parent=None):
self.prect = prect
self.pos = pos
#self.slope = (pos[1,1] - pos[0,1]) / (pos[1,0] - pos[0,0])
#self.yint = pos[1,0] - self.slope * pos[0,0]
self.color = color
self.pen = pg.mkPen(pg.mkColor(self.color),
width=3,
style=QtCore.Qt.SolidLine)
self.ROIplot = pg.PlotDataItem(self.prect[:, 0],
self.prect[:, 1],
pen=self.pen)
self.dotplot = pg.ScatterPlotItem(pos=self.pos[0, :][np.newaxis],
pen=self.pen,
symbol='+')
parent.p0.addItem(self.ROIplot)
parent.p0.addItem(self.dotplot)
pts = self.inROI(parent.embedding)
pdist = self.orthproj(parent.embedding[pts, :])
inds = np.argsort(pdist)
self.selected = pts[inds[::-1]]
parent.show()
def __init__(self, scatterplot, parent=None):
super(scatterPlotPlot, self).__init__(parent=parent)
self.parent = parent
self.scatterplot = scatterplot
self.records = self.scatterplot.records
self.doingPlot = False
self.paused = False
self.plotWidget = pg.GraphicsLayoutWidget()
self.plots = {}
self.color = 0
self.paused = False
self.selectionNameX = 0
self.selectionNameY = 0
self.decimateScale = 5000
self.scatterplot.scatterSelectionChanged.connect(
self.setSelectionIndex)
self.plot = self.plotWidget.addPlot(row=0, col=0)
self.scatterPlot = pg.ScatterPlotItem(size=5, pen=pg.mkPen(None))
self.plot.addItem(self.scatterPlot)
self.scatterPlot.sigClicked.connect(self.printPoints)
self.data1 = []
self.data2 = []
def init_ui(self):
""""""
self.setWindowTitle("回测K线图表")
self.resize(1400, 800)
# Create chart widget
self.chart = ChartWidget()
self.chart.add_plot("candle", hide_x_axis=True)
self.chart.add_plot("volume", maximum_height=200)
self.chart.add_item(CandleItem, "candle", "candle")
self.chart.add_item(VolumeItem, "volume", "volume")
self.chart.add_cursor()
# Add scatter item for showing tradings
self.trade_scatter = pg.ScatterPlotItem()
candle_plot = self.chart.get_plot("candle")
candle_plot.addItem(self.trade_scatter)
# Set layout
vbox = QtWidgets.QVBoxLayout()
vbox.addWidget(self.chart)
self.setLayout(vbox)
def plot_data(self, X, y):
self.clear_plot()
# get the simple cross validation score
clf = self.cfg.learner.clf
scores = cross_validation.cross_val_score(clf, X, y, cv=5)
score = np.mean(scores)
self.ui.titleLabel.setText("Accuracy: %.2f" % score)
# project the data for visualization
X_proj = clf.fit(X, y).transform(X)
labels = sorted(np.unique(y))
for i in labels:
if USE_GL:
plot = gl.GLScatterPlotItem(pos=X_proj[y == i, :3],
color=pg.glColor(pg.intColor(i)))
else:
plot = pg.ScatterPlotItem(pos=X_proj[y == i, :2],
brush=pg.mkBrush(pg.intColor(i)))
self.plotWidget.addItem(plot)
self.plot_items.append(plot)
def __init__(self, xlabel, ylabel):
self.fig = pg.PlotWidget(background='w')
self.fig.setLabel('bottom', xlabel)
self.fig.setLabel('left', ylabel)
self.fig.scene().sigMouseMoved.connect(self.on_mouse_hover)
self.scatter = pg.ScatterPlotItem()
self.fig.addItem(self.scatter)
self.fig.plotItem.addLine(x=0, pen=colours['line'])
self.text_popup = pg.TextItem(color=colours['line'])
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(True)
self.text_popup.setFont(font)
self.text_popup.hide()
self.fig.addItem(self.text_popup)
self.region_items = []
self.regions = None
self.region_text = None
def __init__(self, parent=None, widgetSize=(200,200),xlabel='',ylabel=''):
if parent is not None:
set_pg_colors(parent)
super(PsychometricPlot, self).__init__(parent)
self.xLabel = xlabel
self.yLabel = ylabel
self.initialSize = widgetSize
self.mainPlot = pg.ScatterPlotItem(size=8, symbol='o', pxMode=True,
pen='k', brush='k')
self.addItem(self.mainPlot)
# -- Graphical adjustments --
yAxis = self.getAxis('left')
self.setLabel('left', self.yLabel ,units='%')
self.setLabel('bottom', self.xLabel)
#self.setXRange(0, )
self.setYRange(-5, 100)
yAxis.setTicks([[[0,'0'],[50,'50'],[100,'100']],
[[25,'25'],[75,'75']]])
#self.addItem(pg.InfiniteLine(pos=50, angle=0, pen=pg.mkPen('k')))
yAxis.setGrid(20)
