def make_bar_chart(self):
chart = QChart()
chart.setTitle("현재 재고 현황")
chart.setAnimationOptions(QChart.SeriesAnimations)
item_statistics_dict = self.statistics_manager.get_item_statistics_dict(
)
categories = ["2020년"]
series = QBarSeries()
for key, value in item_statistics_dict.items():
set = QBarSet(key)
set << value[REMAIN_COUNT]
series.append(set)
chart.addSeries(series)
axis = QBarCategoryAxis()
axis.append(categories)
chart.createDefaultAxes()
chart.setAxisX(axis, series)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
self.barChartView = QChartView(chart)
self.barChartView.setRenderHint(QPainter.Antialiasing)
self.statisticsWidget.setWidget(self.barChartView)
class Chart(QWidget):
def __init__(self, chartKey, data, frame, parent=None):
super(Chart, self).__init__(parent)
self.frame = frame
self.data = data
self.create_chart(chartKey)
def create_chart(self, chartKey):
self.series = QPieSeries()
self.series.setHoleSize(0.35)
self.chart = QChart()
#Add series to the chart
self.addSeries(chartKey)
# for the background and title
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.chart.setTitle("Code Size Visualizer")
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignRight)
self.chart.setTheme(QChart.ChartThemeBlueCerulean)
self.chartview = QChartView(self.chart)
self.chartview.setRenderHint(QPainter.Antialiasing)
#each section of the pie chart
def addSeries(self, key):
self.chart.removeAllSeries()
self.series = QPieSeries()
self.series.setHoleSize(0.35)
#Show chartview only if the content length is less than 6. Otherwise show a table view
if len(self.data[key]) < 6:
#print('length',self.data, key)
for key, value in self.data[key].items():
print('key, value', key, value)
slice_ = QPieSlice(str(key), value)
self.series.append(slice_)
self.series.setLabelsVisible()
self.series.setLabelsPosition(QPieSlice.LabelInsideHorizontal)
for slice in self.series.slices():
#slice.setLabel(slice.label())
slice.setLabel(slice.label() + ' - ' + str(slice.value()) +
' B ')
self.chart.addSeries(self.series)
self.frame.frame.hide()
self.chart.show()
else:
self.table = TableView(self.data[key], len(self.data[key]), 1)
if self.frame.ly.count() > 0:
self.frame.ly.itemAt(0).widget().setParent(None)
self.frame.ly.addWidget(self.table)
self.frame.frame.show()
self.chart.hide()
def drawD2(self):
if self.vtkViewer.reader == None:
return
num = self.inputD2.text()
try:
num = list(map(int, num.split(' ')))
except Exception:
return
if len(num) != 2 or num[0] <= 1 or num[1] <= 1:
return
self.clear()
histogram, scale = self.vtkViewer.d2Sample(num[0], num[1])
d2Chart = QChart()
d2Chart.legend().hide()
polyline = QPolygonF(num[0])
pointer = polyline.data()
dtype, tinfo = np.float, np.finfo
pointer.setsize(2*polyline.size()*tinfo(dtype).dtype.itemsize)
memory = np.frombuffer(pointer, dtype)
memory[:(num[0]-1)*2+1:2] = scale
memory[1:(num[0]-1)*2+2:2] = histogram
curve = QLineSeries()
curve.append(polyline)
d2Chart.addSeries(curve)
d2Chart.createDefaultAxes()
ChartView = QChartView(d2Chart)
self.d2ChartLayout.addWidget(ChartView)
def __init__(self):
super(MainWindow, self).__init__()
''' Load the UI file from disk (UI file was created in QT Designer) '''
uic.loadUi("mainwindow.ui", self)
''' Create an instance of the database class '''
self.dbase = db.database(
) # Create an instance of the database as self.dbase
'''call the Connect method on our new database object (Creates a database connection) '''
self.dbase.Connect()
self.conn = self.dbase.getConn()
''' Set up the menubar '''
self.createMenus()
self.carsModel = cars.carsModel()
setupUI.doSetup(self)
self.dbase.populateView(self, "select * from car order by make asc",
self.carsModel)
mySeries = QPieSeries()
mySeries.append("jane", 2)
mySeries.append("joe", 8)
chart = QChart()
chart.addSeries(mySeries)
chart.setTitle("Simple piechart example")
chart.legend().hide()
def setupChart(self):
"""Set up the GUI's series and chart."""
# Collect x and y data values from the CSV file
x_values, y_values = self.loadCSVFile()
# Get the largest x and y values; Used for setting the chart's axes
x_max, y_max = max(x_values), max(y_values)
# Create numpy arrays from the x and y values
x_values = np.array(x_values)
y_values = np.array(y_values)
# Calculate the regression line
coefficients = linearRegression(x_values, y_values)
# Create chart object
chart = QChart()
chart.setTitle("Auto Insurance for Geographical Zones in Sweden")
chart.legend().hide()
# Create scatter series and add points to the series
scatter_series = QScatterSeries()
scatter_series.setName("DataPoints")
scatter_series.setMarkerSize(9.0)
scatter_series.hovered.connect(self.displayPointInfo)
for value in range(0, self.row_count - 1):
scatter_series.append(x_values[value], y_values[value])
scatter_series.setBorderColor(QColor('#000000'))
# Create line series and add points to the series
line_series = QLineSeries()
line_series.setName("RegressionLine")
# Calculate the regression line
for x in x_values:
y_pred = coefficients[0] + coefficients[1] * x
line_series.append(x, y_pred)
# Add both series to the chart and create x and y axes
chart.addSeries(scatter_series)
chart.addSeries(line_series)
chart.createDefaultAxes()
axis_x = chart.axes(Qt.Horizontal)
axis_x[0].setTitleText("Number of Claims")
axis_x[0].setRange(0, x_max)
axis_x[0].setLabelFormat("%i")
axis_y = chart.axes(Qt.Vertical)
axis_y[0].setTitleText(
"Total Payment in Swedish Kronor (in thousands)")
axis_y[0].setRange(0, y_max + 20)
# Create QChartView object for displaying the chart
chart_view = QChartView(chart)
v_box = QVBoxLayout()
v_box.addWidget(chart_view)
self.setLayout(v_box)
def build_plot(self,
data,
title,
is_legend_visible=False,
series_name=None):
axis_x, axis_y = self.make_axis()
chart = QChart()
if self.no_margins:
chart.setMargins(QMargins(0, 0, 0, 0))
self.clean()
if data != None:
self.lineSeries = self.fill_series(data)
self.lineSeries.setName(series_name)
chart.addSeries(self.lineSeries)
chart.legend().setVisible(is_legend_visible)
chart.setTitle(title)
chart.addAxis(axis_x, Qt.AlignBottom)
chart.addAxis(axis_y, Qt.AlignLeft)
self.lineSeries.attachAxis(axis_x)
self.lineSeries.attachAxis(axis_y)
self.setChart(chart)
def create_linechart(self):
series = QLineSeries(self)
series.append(0, 6)
series.append(2, 4)
series.append(3, 8)
series.append(7, 4)
series.append(10, 5)
series << QPointF(11, 1) << QPointF(13, 3) << QPointF(
17, 6) << QPointF(18, 3) << QPointF(20, 2)
chart = QChart()
chart.addSeries(series)
chart.createDefaultAxes()
chart.setAnimationOptions(QChart.SeriesAnimations)
chart.setTitle("Line Chart Example")
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chartview = QChartView(chart)
chartview.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(chartview)
def create_donutchart(self, chartKey):
series = QPieSeries()
series.setHoleSize(0.35)
for key, value in sample[chartKey].items():
series.append(key, value)
slice = QPieSlice()
chart = QChart()
#chart.legend().hide()
chart.addSeries(series)
# for the background and title
chart.setAnimationOptions(QChart.SeriesAnimations)
chart.setTitle("DonutChart Example")
chart.setTheme(QChart.ChartThemeBlueCerulean)
chartview = QChartView(chart)
chartview.setRenderHint(QPainter.Antialiasing)
# creating a widget object
widget = QWidget()
# Creating a grid layout
layout = QGridLayout()
# setting this layout to the widget
widget.setLayout(layout)
self.setCentralWidget(chartview)
series.doubleClicked.connect(self.handle_double_clicked)
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("Demo12_1, QChart 基本绘图")
self.resize(580, 420)
chart = QChart()
chart.setTitle("简单函数曲线")
chartView = QChartView(self)
chartView.setChart(chart)
self.setCentralWidget(chartView)
series0 = QLineSeries()
series1 = QLineSeries()
series0.setName("sin曲线")
series1.setName("cos曲线")
chart.addSeries(series0)
chart.addSeries(series1)
t = 0
intv = 0.1
pointCount = 100
for i in range(pointCount):
y1 = math.cos(t)
series0.append(t, y1)
y2 = 1.5 * math.sin(t + 20)
series1.append(t, y2)
t = t + intv
axisX = QValueAxis()
axisX.setRange(0, 10)
axisX.setTitleText("time(secs)")
axisY = QValueAxis()
axisY.setRange(-2, 2)
axisY.setTitleText("value")
chart.setAxisX(axisX, series0)
chart.setAxisY(axisY, series0)
chart.setAxisX(axisX, series1)
chart.setAxisY(axisY, series1)
def __init__(self):
super().__init__()
# window size
self.setMinimumSize(600, 400)
# data
raw_data = [
(0, 6),
(2, 4),
(3, 8),
(7, 4),
(10, 5),
(11, 1),
(13, 3),
(17, 6),
(18, 3),
(20, 2)
]
series = QLineSeries()
for d in raw_data:
series.append(*d)
# chart object
chart = QChart()
chart.legend().hide()
chart.addSeries(series) # data feeding
chart.createDefaultAxes()
# displaying chart
chart_view = QChartView(chart)
chart_view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(chart_view)
class ChartWidget:
def __init__(self):
self.model = QChart()
self.view = QChartView()
self.view.setChart(self.model)
self.model.legend().setAlignment(Qt.AlignBottom)
self.view.setRenderHint(QPainter.Antialiasing)
def show(self):
self.view.show()
def exit(self):
self.view.close()
@property
def title(self):
return self.model.title()
@title.setter
def title(self, title):
self.model.setTitle(title)
def add_series(self, x_list, y_list, name):
series = QLineSeries()
series.setName(name)
for x, y in zip(x_list, y_list):
series.append(x, y)
self.model.addSeries(series)
self.model.createDefaultAxes()
class TestWindow(QMainWindow):
def __init__(self, parent=None):
super(TestWindow, self).__init__(parent=parent)
self.ncurves = 0
self.timer = QTimer(self)
self.chart = QChart()
self.chart.legend().hide()
self.view = QChartView(self.chart)
self.view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(self.view)
self.count = 0.
#self.timer.timeout.connect(functools.partial(self.update, a=1))
#self.timer.start(100)
#def update(self, a):
#print(self.chart.series)
def set_title(self, title):
self.chart.setTitle(title)
def add_data(self, xdata, ydata, color=None):
curve = QLineSeries()
pen = curve.pen()
if color is not None:
pen.setColor(color)
pen.setWidthF(.6)
curve.setPen(pen)
curve.setUseOpenGL(True)
curve.append(series_to_polyline(xdata, ydata))
self.chart.addSeries(curve)
self.chart.createDefaultAxes()
self.ncurves += 1
class TestWindow(QMainWindow):
def __init__(self, parent=None):
super(TestWindow, self).__init__(parent=parent)
self.ncurves = 0
self.chart = QChart()
self.chart.legend().hide()
self.view = QChartView(self.chart)
self.view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(self.view)
def set_title(self, title):
self.chart.setTitle(title)
def add_data(self, xdata, ydata, color=None):
curve = QLineSeries()
#pen = curve.pen()
#if color is not None:
# pen.setColor(color)
#pen.setWidthF(1)
#curve.setPen(pen)
curve.setUseOpenGL(True)
curve.append(series_to_polyline(xdata, ydata))
self.chart.addSeries(curve)
self.chart.createDefaultAxes()
self.ncurves += 1
class MainWindow(ChartViewToolTips):
def __init__(self):
super().__init__()
series = QLineSeries()
series.setPointsVisible(True)
series.setPointLabelsVisible(True)
series.setPointLabelsFormat("(@xPoint, @yPoint)")
series.hovered.connect(self.show_series_tooltip)
series.append(0, 6)
series.append(2, 4)
series.append(3, 8)
series.append(7, 4)
series.append(10, 5)
self._chart = QChart()
self._chart.setMinimumSize(640, 480)
self._chart.setTitle("Line Chart Example")
self._chart.setAnimationOptions(QChart.SeriesAnimations)
self._chart.legend().hide()
self._chart.addSeries(series)
self._chart.createDefaultAxes()
self.setChart(self._chart)
def __init__(self, *args, **kwargs):
super(Window, self).__init__(*args, **kwargs)
self.resize(400, 300)
# 抗锯齿
self.setRenderHint(QPainter.Antialiasing)
# 图表
chart = QChart()
self.setChart(chart)
# 设置标题
chart.setTitle('Simple barchart example')
# 开启动画效果
chart.setAnimationOptions(QChart.SeriesAnimations)
# 添加Series
series = self.getSeries()
chart.addSeries(series)
# 分类
categories = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
# 分类x轴
axis = QBarCategoryAxis()
axis.append(categories)
# 创建默认轴线
chart.createDefaultAxes()
# 替换默认x轴
chart.setAxisX(axis, series)
# 显示图例
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
def build_multiple_plot(self, first_data, second_data, title):
axis_x, axis_y = self.make_axis()
chart = QChart()
if self.no_margins:
chart.setMargins(QMargins(0, 0, 0, 0))
self.clean()
first_lineseries = self.fill_series(first_data)
second_lineseries = self.fill_series(second_data)
chart.addSeries(first_lineseries)
chart.addSeries(second_lineseries)
chart.addAxis(axis_x, Qt.AlignBottom)
chart.addAxis(axis_y, Qt.AlignLeft)
chart.legend().setVisible(False)
chart.setTitle(title)
first_lineseries.attachAxis(axis_x)
first_lineseries.attachAxis(axis_y)
second_lineseries.attachAxis(axis_x)
second_lineseries.attachAxis(axis_y)
first_lineseries.setPointsVisible(True)
second_lineseries.setPointsVisible(True)
self.setChart(chart)
class ChartView(QChartView,QChart):
def __init__(self, *args, **kwargs):
super(ChartView, self).__init__(*args, **kwargs)
self.resize(800, 600)
self.setRenderHint(QPainter.Antialiasing) # 抗锯齿
self.chart_init()
self.timer_init()
def timer_init(self):
#使用QTimer，2秒触发一次，更新数据
self.timer = QTimer(self)
self.timer.timeout.connect(self.drawLine)
self.timer.start(100)
def chart_init(self):
self.chart = QChart()
self.series = QScatterSeries()
#设置曲线名称
self.series.setName("实时数据")
self.series.setColor(QColor(255,0,0))
self.series.setMarkerSize(20.0)
self.series.setPen(QPen(QtCore.Qt.PenStyle.NoPen))
#把曲线添加到QChart的实例中
self.chart.addSeries(self.series)
#声明并初始化X轴，Y轴
self.dtaxisX = QDateTimeAxis()
self.vlaxisY = QValueAxis()
#设置坐标轴显示范围
self.dtaxisX.setMin(QDateTime.currentDateTime().addSecs(-300*1))
self.dtaxisX.setMax(QDateTime.currentDateTime().addSecs(0))
self.vlaxisY.setMin(0)
self.vlaxisY.setMax(1500)
#设置X轴时间样式
self.dtaxisX.setFormat("MM月dd hh:mm:ss")
#设置坐标轴上的格点
self.dtaxisX.setTickCount(6)
self.vlaxisY.setTickCount(11)
#设置坐标轴名称
self.dtaxisX.setTitleText("时间")
self.vlaxisY.setTitleText("量程")
#设置网格不显示`
#把坐标轴添加到chart中
self.chart.addAxis(self.dtaxisX,Qt.AlignBottom)
self.chart.addAxis(self.vlaxisY,Qt.AlignLeft)
#把曲线关联到坐标轴
self.series.attachAxis(self.dtaxisX)
self.series.attachAxis(self.vlaxisY)
self.setChart(self.chart)
def drawLine(self):
#获取当前时间
bjtime = QDateTime.currentDateTime()
#更新X轴坐标
self.dtaxisX.setMin(QDateTime.currentDateTime().addSecs(-300*1))
self.dtaxisX.setMax(QDateTime.currentDateTime().addSecs(0))
#当曲线上的点超出X轴的范围时，移除最早的点
if(self.series.count()>149):
self.series.removePoints(0,self.series.count()-149)
#产生随即数
yint = random.randint(0,1500)
#添加数据到曲线末端
self.series.append(bjtime.toMSecsSinceEpoch(),yint)
def addSeries(
self,
_x2idx: typing.Dict,
_idx2x: list,
_chart: QChart,
_axis_x: QValueAxis,
_axis_y: QValueAxis,
):
bar_set = QBarSet(self.name)
tmp_dict = dict(zip(self.x_list, self.y_list))
for k in _idx2x:
try:
bar_set.append(tmp_dict[k])
except KeyError:
bar_set.append(0)
if self.color is not None:
bar_set.setColor(self.color)
bar_series = QBarSeries()
bar_series.append(bar_set)
_chart.addSeries(bar_series)
_chart.setAxisX(_axis_x, bar_series)
_chart.setAxisY(_axis_y, bar_series)
if self.show_value:
self.createShow()
def __init__(self):
super().__init__()
series = QLineSeries()
for date, value in DATA:
date_value = QDateTime(*date, 0, 0).toMSecsSinceEpoch()
series.append(date_value, value)
chart = QChart()
chart.setTheme(QChart.ChartThemeDark)
chart.setTitle("Line Chart with Date Example")
chart.setAnimationOptions(QChart.SeriesAnimations)
chart.addSeries(series)
chart.legend().hide()
axisX = QDateTimeAxis()
axisX.setFormat("dd/MM/yyyy")
axisX.setTitleText('Date')
chart.addAxis(axisX, Qt.AlignBottom)
series.attachAxis(axisX)
axisY = QValueAxis()
axisY.setTitleText('Value')
chart.addAxis(axisY, Qt.AlignLeft)
series.attachAxis(axisY)
chart_view = QChartView()
chart_view.setChart(chart)
chart_view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(chart_view)
def __init__(self):
super().__init__()
series = QLineSeries()
series.setPointsVisible(True)
series.setPointLabelsVisible(True)
series.setPointLabelsFormat("(@xPoint, @yPoint)")
series.append(0, 6)
series.append(2, 4)
series.append(3, 8)
series.append(7, 4)
series.append(10, 5)
chart = QChart()
chart.setTitle("Line Chart Example")
chart.setAnimationOptions(QChart.SeriesAnimations)
chart.legend().hide()
chart.addSeries(series)
chart.createDefaultAxes()
chart_view = QChartView()
chart_view.setChart(chart)
chart_view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(chart_view)
def create_piechart(self, series, animation=True):
if animation:
animation_type = QChart.AllAnimations
else:
animation_type = QChart.NoAnimation
font_title = QFont()
font_title.setBold(True)
font_title.setPointSize(13)
# define the chart properties
chart = QChart()
chart.addSeries(series)
chart.createDefaultAxes()
chart.setAnimationOptions(animation_type)
chart.setBackgroundVisible(False)
chart.setMargins(QMargins())
chart.setTitle("Prediction Distribution")
chart.setTitleFont(font_title)
font_legend = QFont()
font_legend.setBold(True)
# define legend properties
chart.legend().show()
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chart.legend().setFont(font_legend)
self.ui.piechart.setChart(chart)
self.ui.piechart.setRenderHint(QPainter.Antialiasing)
QApplication.processEvents()
class ChartWidget(QWidget):
def __init__(self, parent=None, ticker="BTC"):
super().__init__(parent)
uic.loadUi("resource/chart.ui", self)
self.ticker = ticker
self.viewLimit = 128
self.priceData = QLineSeries()
self.priceChart = QChart()
self.priceChart.addSeries(self.priceData)
self.priceChart.legend().hide()
# ----------------- 추 가 ------------------
axisX = QDateTimeAxis()
axisX.setFormat("hh:mm:ss")
axisX.setTickCount(4)
dt = QDateTime.currentDateTime()
axisX.setRange(dt, dt.addSecs(self.viewLimit))
axisY = QValueAxis()
axisY.setVisible(False)
self.priceChart.addAxis(axisX, Qt.AlignBottom)
self.priceChart.addAxis(axisY, Qt.AlignRight)
self.priceData.attachAxis(axisX)
self.priceData.attachAxis(axisY)
self.priceChart.layout().setContentsMargins(0, 0, 0, 0)
# ------------------------------------------
self.priceView.setChart(self.priceChart)
self.priceView.setRenderHints(QPainter.Antialiasing)
def createAreaChart(self):
chart = QChart()
chart.setTitle("Area chart")
# The lower series is initialized to zero values.
lowerSeries = None
y_points = []
for i, data_list in enumerate(self.m_dataTable):
upperSeries = QLineSeries(chart)
for j, (value, _) in enumerate(data_list):
y = value.y()
if lowerSeries is None:
upperSeries.append(QPointF(j, y))
y_points.append(y)
else:
new_y = y_points[i] + y
upperSeries.append(QPointF(j, new_y))
y_points[j] += new_y
area = QAreaSeries(upperSeries, lowerSeries)
area.setName("Series " + str(i))
chart.addSeries(area)
lowerSeries = upperSeries
chart.createDefaultAxes()
return chart
def bargraph(self):
'''
Processes and Creates Bar Graph.
'''
self.barchart = self.findChild(QChartView, "attackgraph")
bardata = self.data.getBar()
chartobj = Barchart(bardata)
chartseries = chartobj.getSeries()
# create QChart object and add data
chart = QChart()
chart.addSeries(chartseries)
chart.setTitle("Attacks Over the Past 12 Months")
chart.setAnimationOptions(QChart.SeriesAnimations)
axisX = QBarCategoryAxis()
axisX.append(chartobj.getKeys())
chart.addAxis(axisX, Qt.AlignBottom)
axisY = QValueAxis()
axisY.setRange(0, chartobj.getMax())
chart.addAxis(axisY, Qt.AlignLeft)
chart.legend().setVisible(False)
self.barchart.setChart(chart)
def show_diagram(self):
self.student_diagram_ui.label_4.setText(self.label_2.text())
self.student_diagram_ui.label_7.setText(self.label_8.text())
self.student_diagram_ui.label_8.setText(self.label_6.text())
self.student_diagram_ui.label_10.setText(self.label_4.text())
max_value = 0
series = QBarSeries()
for i in self.result:
set0 = QBarSet(i[0])
set0.append(float(i[1]))
series.append(set0)
if max_value < (float(i[1])):
max_value = float(i[1])
axisY = QValueAxis()
axisY.setRange(0, max_value)
chart = QChart()
series.attachAxis(axisY)
chart.addSeries(series)
chart.setAnimationOptions(QChart.SeriesAnimations)
chart.addAxis(axisY, Qt.AlignLeft)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
centralwidget = self.student_diagram_ui.centralwidget
self.student_diagram_ui.chartview = QChartView(chart, centralwidget)
self.student_diagram_ui.chartview.setGeometry(QtCore.QRect(10, 110, 880, 371))
self.student_diagram_ui.pushButton_3.show()
self.student_diagram_ui.update(self.dark_theme)
self.student_diagram_window.show()
def createAreaChart(self):
chart = QChart()
chart.setTitle("Area chart")
# The lower series is initialized to zero values.
lowerSeries = None
y_points = []
for i, data_list in enumerate(self.m_dataTable):
upperSeries = QLineSeries(chart)
for j, (value, _) in enumerate(data_list):
y = value.y()
if lowerSeries is None:
upperSeries.append(QPointF(j, y))
y_points.append(y)
else:
new_y = y_points[i] + y
upperSeries.append(QPointF(j, new_y))
y_points[j] += new_y
area = QAreaSeries(upperSeries, lowerSeries)
area.setName("Series " + str(i))
chart.addSeries(area)
lowerSeries = upperSeries
chart.createDefaultAxes()
return chart
def addSeries(
self,
_x2idx: typing.Dict,
_idx2x: list,
_chart: QChart,
_axis_x: QValueAxis,
_axis_y: QValueAxis,
):
series = QCandlestickSeries()
series.setName(self.name)
for x, y in zip(self.x_list, self.y_list):
series.append(QCandlestickSet(*y, _x2idx[x]))
if self.inc_color is not None:
series.setIncreasingColor(self.inc_color)
else:
series.setIncreasingColor(QColor("#c41919"))
if self.dec_color is not None:
series.setDecreasingColor(self.dec_color)
else:
series.setDecreasingColor(QColor("#009f9f"))
_chart.addSeries(series)
_chart.setAxisX(_axis_x, series)
_chart.setAxisY(_axis_y, series)
if self.show_value:
self.createShow()
class BarView(QChartView):
def __init__(self):
QChartView.__init__(self)
#self.resize(700,700)
self.initUI()
def initUI(self):
self.backend = BackendThread()
self.backend.update_bar.connect(self.handleBar)
self.backend.start()
def handleBar(self, data):
self.series = QBarSeries()
self.series.clear()
self.chart = QChart()
self.chart.setTitle(CONF.leftDownNames[0])
set0 = QBarSet(CONF.leftDownNames[1])
for i in range(len(data)):
set0 << data[i][1]
self.series.append(set0)
self.chart.addSeries(self.series)
categories = [data[i][0][-5:] for i in range(len(data))]
print(categories)
axis = QBarCategoryAxis()
axis.append(categories)
self.chart.createDefaultAxes()
self.chart.setAxisX(axis, self.series)
self.setChart(self.chart)
def addSeries(
self,
_x2idx: typing.Dict,
_idx2x: list,
_chart: QChart,
_axis_x: QValueAxis,
_axis_y: QValueAxis,
):
series = QBoxPlotSeries()
series.setName(self.name)
if self.color is not None:
series.setBrush(self.color)
tmp_dict = dict(zip(self.x_list, self.y_list))
for k in _idx2x:
try:
series.append(QBoxSet(*tmp_dict[k]))
except KeyError:
series.append(QBoxSet())
_chart.addSeries(series)
_chart.setAxisX(_axis_x, series)
_chart.setAxisY(_axis_y, series)
if self.show_value:
self.createShow()
class ChartWidget(QWidget):
def __init__(self, number: int, parent=None):
super(QWidget, self).__init__(parent)
self.layout = QVBoxLayout(self)
self.chart = QChart()
self.chartView = QChartView(self.chart)
self.chartView.setRenderHint(QPainter.Antialiasing) # 抗锯齿
self.layout.addWidget(self.chartView)
self.channelNumber = number
for index in range(self.channelNumber):
tmp = QLineSeries()
tmp.setName("channel "+str(index))
self.chart.addSeries(tmp)
self.chart.createDefaultAxes()
self.chart.axisX().setRange(0, 25)
self.chart.axisX().setTitleText("AAA")
self.chart.axisY().setRange(0, 25)
self.chart.axisY().setTitleText("BBB")
# 标题
self.chart.setTitle("XXX XXX XXX")
# 指示颜色所代表的内容
# self.chart.legend().hide()
# 动画效果
self.chart.setAnimationOptions(QChart.AllAnimations)
def set_line(self, *lines):
for index in range(len(lines)):
self.chart.series()[index].clear()
for v1, v2 in enumerate(lines[index]):
self.chart.series()[index].append(v1, v2)
def update_particles(particles):
animation_chart = QChart()
reals = QScatterSeries()
pen_reals = reals.pen()
pen_reals.setBrush(QtGui.QColor("white"))
reals.setMarkerSize(5)
reals.setColor(QtGui.QColor("red"))
reals.setPen(pen_reals)
for particle in particles:
reals.append(particle, 0)
animation_chart.addSeries(reals)
animation_chart.setBackgroundBrush(QtGui.QColor(41, 43, 47))
animation_chart.createDefaultAxes()
animation_chart.legend().hide()
animation_chart.setContentsMargins(-10, -10, -10, -10)
animation_chart.layout().setContentsMargins(0, 0, 0, 0)
animation_chart.axisX().setTickCount(17)
animation_chart.axisY().setTickCount(3)
animation_chart.axisX().setLabelsColor(QtGui.QColor("white"))
animation_chart.axisX().setGridLineColor(QtGui.QColor("grey"))
animation_chart.axisX().setRange(-4, 12)
animation_chart.axisY().setRange(-1, 1)
animation_chart.axisY().setLabelsColor(QtGui.QColor("white"))
animation_chart.axisY().setGridLineColor(QtGui.QColor("grey"))
form.widget_animation.setChart(animation_chart)
def createScatterChart(self):
chart = QChart()
chart.setTitle("Scatter chart")
for i, data_list in enumerate(self.m_dataTable):
series = QScatterSeries(chart)
for value, _ in data_list:
series.append(value)
series.setName("Series " + str(i))
chart.addSeries(series)
chart.createDefaultAxes()
return chart
def addSeries(
self, _x2idx: typing.Dict, _idx2x: list, _chart: QChart,
_axis_x: QValueAxis, _axis_y: QValueAxis
):
series = QLineSeries()
series.setName(self.name)
for x, y in zip(self.x_list, self.y_list):
series.append(_x2idx[x], y)
if self.color is not None:
series.setColor(self.color)
_chart.addSeries(series)
_chart.setAxisX(_axis_x, series)
_chart.setAxisY(_axis_y, series)
if self.show_value:
self.createShow()
def createBarChart(self, valueCount):
chart = QChart()
chart.setTitle("Bar chart")
series = QStackedBarSeries(chart)
for i, data_list in enumerate(self.m_dataTable):
set = QBarSet("Bar set " + str(i))
for value, _ in data_list:
set << value.y()
series.append(set)
chart.addSeries(series)
chart.createDefaultAxes()
return chart
def createPieChart(self):
chart = QChart()
chart.setTitle("Pie chart")
pieSize = 1.0 / len(self.m_dataTable)
for i, data_list in enumerate(self.m_dataTable):
series = QPieSeries(chart)
for value, label in data_list:
slice = series.append(label, value.y())
if len(series) == 1:
slice.setLabelVisible()
slice.setExploded()
hPos = (pieSize / 2) + (i / float(len(self.m_dataTable)))
series.setPieSize(pieSize)
series.setHorizontalPosition(hPos)
series.setVerticalPosition(0.5)
chart.addSeries(series)
return chart
def addSeries(
self, _x2idx: typing.Dict, _idx2x: list, _chart: QChart,
_axis_x: QValueAxis, _axis_y: QValueAxis
):
bar_set = QBarSet(self.name)
tmp_dict = dict(zip(self.x_list, self.y_list))
for k in _idx2x:
if k in tmp_dict.keys():
bar_set.append(tmp_dict[k])
else:
bar_set.append(0)
if self.color is not None:
bar_set.setColor(self.color)
bar_series = QBarSeries()
bar_series.append(bar_set)
_chart.addSeries(bar_series)
_chart.setAxisX(_axis_x, bar_series)
_chart.setAxisY(_axis_y, bar_series)
if self.show_value:
self.createShow()
def addSeries(
self, _x2idx: typing.Dict, _idx2x: list, _chart: QChart,
_axis_x: QValueAxis, _axis_y: QValueAxis
):
series = QCandlestickSeries()
series.setName(self.name)
for x, y in zip(self.x_list, self.y_list):
series.append(QCandlestickSet(*y, _x2idx[x]))
if self.inc_color is not None:
series.setIncreasingColor(self.inc_color)
else:
series.setIncreasingColor(QColor('#c41919'))
if self.dec_color is not None:
series.setDecreasingColor(self.dec_color)
else:
series.setDecreasingColor(QColor('#009f9f'))
_chart.addSeries(series)
_chart.setAxisX(_axis_x, series)
_chart.setAxisY(_axis_y, series)
if self.show_value:
self.createShow()
class PlotterPane(QChartView):
"""
This plotter widget makes viewing sensor data easy!
This widget represents a chart that will look for tuple data from
the MicroPython REPL, Python 3 REPL or Python 3 code runner and will
auto-generate a graph.
"""
data_flood = pyqtSignal()
def __init__(self, parent=None):
super().__init__(parent)
# Holds the raw input to be checked for actionable data to display.
self.input_buffer = []
# Holds the raw actionable data detected while plotting.
self.raw_data = []
self.setObjectName('plotterpane')
self.max_x = 100 # Maximum value along x axis
self.max_y = 1000 # Maximum value +/- along y axis
self.flooded = False # Flag to indicate if data flooding is happening.
# Holds deques for each slot of incoming data (assumes 1 to start with)
self.data = [deque([0] * self.max_x), ]
# Holds line series for each slot of incoming data (assumes 1 to start
# with).
self.series = [QLineSeries(), ]
# Ranges used for the Y axis (up to 1000, after which we just double
# the range).
self.y_ranges = [1, 5, 10, 25, 50, 100, 250, 500, 1000]
# Set up the chart with sensible defaults.
self.chart = QChart()
self.chart.legend().hide()
self.chart.addSeries(self.series[0])
self.axis_x = QValueAxis()
self.axis_y = QValueAxis()
self.axis_x.setRange(0, self.max_x)
self.axis_y.setRange(-self.max_y, self.max_y)
self.axis_x.setLabelFormat("time")
self.axis_y.setLabelFormat("%d")
self.chart.setAxisX(self.axis_x, self.series[0])
self.chart.setAxisY(self.axis_y, self.series[0])
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
def process_bytes(self, data):
"""
Takes raw bytes and, if a valid tuple is detected, adds the data to
the plotter.
The the length of the bytes data > 1024 then a data_flood signal is
emitted to ensure Mu can take action to remain responsive.
"""
# Data flooding guards.
if self.flooded:
return
if len(data) > 1024:
self.flooded = True
self.data_flood.emit()
return
data = data.replace(b'\r\n', b'\n')
self.input_buffer.append(data)
# Check if the data contains a Python tuple, containing numbers, on a
# single line (i.e. ends with \n).
input_bytes = b''.join(self.input_buffer)
lines = input_bytes.split(b'\n')
for line in lines:
if line.startswith(b'(') and line.endswith(b')'):
# Candidate tuple. Extract the raw bytes into a numeric tuple.
raw_values = [val.strip() for val in line[1:-1].split(b',')]
numeric_values = []
for raw in raw_values:
try:
numeric_values.append(int(raw))
# It worked, so move onto the next value.
continue
except ValueError:
# Try again as a float.
pass
try:
numeric_values.append(float(raw))
except ValueError:
# Not an int or float, so ignore this value.
continue
if numeric_values:
# There were numeric values in the tuple, so use them!
self.add_data(tuple(numeric_values))
# Reset the input buffer.
self.input_buffer = []
if lines[-1]:
# Append any bytes that are not yet at the end of a line, for
# processing next time we read data from self.serial.
self.input_buffer.append(lines[-1])
def add_data(self, values):
"""
Given a tuple of values, ensures there are the required number of line
series, add the data to the line series, update the range of the chart
so the chart displays nicely.
"""
# Store incoming data to dump as CSV at the end of the session.
self.raw_data.append(values)
# Check the number of incoming values.
if len(values) != len(self.series):
# Adjust the number of line series.
value_len = len(values)
series_len = len(self.series)
if value_len > series_len:
# Add new line series.
for i in range(value_len - series_len):
new_series = QLineSeries()
self.chart.addSeries(new_series)
self.chart.setAxisX(self.axis_x, new_series)
self.chart.setAxisY(self.axis_y, new_series)
self.series.append(new_series)
self.data.append(deque([0] * self.max_x))
else:
# Remove old line series.
for old_series in self.series[value_len:]:
self.chart.removeSeries(old_series)
self.series = self.series[:value_len]
self.data = self.data[:value_len]
# Add the incoming values to the data to be displayed, and compute
# max range.
max_ranges = []
for i, value in enumerate(values):
self.data[i].appendleft(value)
max_ranges.append(max([max(self.data[i]), abs(min(self.data[i]))]))
if len(self.data[i]) > self.max_x:
self.data[i].pop()
# Re-scale y-axis.
max_y_range = max(max_ranges)
y_range = bisect.bisect_left(self.y_ranges, max_y_range)
if y_range < len(self.y_ranges):
self.max_y = self.y_ranges[y_range]
elif max_y_range > self.max_y:
self.max_y += self.max_y
elif max_y_range < self.max_y / 2:
self.max_y = self.max_y / 2
self.axis_y.setRange(-self.max_y, self.max_y)
# Ensure floats are used to label y axis if the range is small.
if self.max_y <= 5:
self.axis_y.setLabelFormat("%2.2f")
else:
self.axis_y.setLabelFormat("%d")
# Update the line series with the data.
for i, line_series in enumerate(self.series):
line_series.clear()
xy_vals = []
for j in range(self.max_x):
val = self.data[i][self.max_x - 1 - j]
xy_vals.append((j, val))
for point in xy_vals:
line_series.append(*point)
def set_theme(self, theme):
"""
Sets the theme / look for the plotter pane.
"""
if theme == 'day':
self.chart.setTheme(QChart.ChartThemeLight)
elif theme == 'night':
self.chart.setTheme(QChart.ChartThemeDark)
else:
self.chart.setTheme(QChart.ChartThemeHighContrast)
