def __init__(self, qseries_list, title):
super(QuarterlyLineDiagram, self).__init__()
# Setup quarterly axis
self.x_axis = QCategoryAxis()
self.y_axis = QValueAxis()
self.y_axis.setTickCount(6)
self.x_axis.setMin(1)
self.x_axis.setMax(366)
self.x_axis.append("Q1", 91)
self.x_axis.append("Q2", 182)
self.x_axis.append("Q3", 274)
self.x_axis.append("Q4", 365)
# Setup chart
self.setTitle(title)
for series in qseries_list:
self.addSeries(series)
self.createDefaultAxes() # autoscale y-axis
self.setAxisX(self.x_axis) # use predefined quarterly x-axis
self.setAnimationOptions(QChart.SeriesAnimations)
self.legend().setVisible(True)
self.legend().setAlignment(Qt.AlignBottom)
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 __iniChart(self): ##图表初始化
self.chart = QChart() #创建 chart
self.chart.setTitle("二阶系统频率特性")
self.chart.legend().setVisible(True)
self.ui.chartView.setChart(self.chart) #chart添加到chartView
##2. 创建坐标轴
## bottom 轴是 QLogValueAxis
self.__axisFreq = QLogValueAxis()
self.__axisFreq.setLabelFormat("%.1f") #标签格式
self.__axisFreq.setTitleText("角频率(rad/sec)")
self.__axisFreq.setRange(0.1, 100)
self.__axisFreq.setMinorTickCount(9)
self.chart.addAxis(self.__axisFreq, Qt.AlignBottom)
## left 轴是 QValueAxis
self.__axisMag = QValueAxis()
self.__axisMag.setTitleText("幅度(dB)")
self.__axisMag.setRange(-40, 10)
self.__axisMag.setTickCount(6)
self.__axisMag.setLabelFormat("%.1f") #标签格式
self.chart.addAxis(self.__axisMag, Qt.AlignLeft)
## right 轴是 QValueAxis
self.__axisPhase = QValueAxis()
self.__axisPhase.setTitleText("相位(度)")
self.__axisPhase.setRange(-200, 0)
self.__axisPhase.setTickCount(6)
self.__axisPhase.setLabelFormat("%.0f") #标签格式
self.chart.addAxis(self.__axisPhase, Qt.AlignRight)
def __init__(self, parent=None, ticker="BTCUSDT"):
super().__init__(parent)
uic.loadUi("resource/chart.ui", self)
self.ticker = ticker
self.viewLimit = 10
self.tm = []
self.priceData = QCandlestickSeries()
self.priceData.setDecreasingColor(Qt.red)
self.priceData.setIncreasingColor(Qt.green)
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)
self.pw = PriceWorker(ticker)
self.pw.dataSent.connect(self.appendData)
self.pw.start()
def __init__(self):
super().__init__()
self.m_step = 0
self.m_x = 5
self.m_y = 1
# 初始化图像
self.series = QSplineSeries(self)
green_pen = QPen(Qt.red)
green_pen.setWidth(3)
self.series.setPen(green_pen)
self.axisX = QValueAxis()
self.axisY = QValueAxis()
self.series.append(self.m_x, self.m_y)
self.addSeries(self.series)
self.addAxis(self.axisX, Qt.AlignBottom)
self.addAxis(self.axisY, Qt.AlignLeft)
self.series.attachAxis(self.axisX)
self.series.attachAxis(self.axisY)
self.axisX.setTickCount(5)
self.axisX.setRange(0, 10)
self.axisY.setRange(-5, 10)
self.timer = QTimer(self)
self.timer.setInterval(1000)
self.timer.timeout.connect(self.handleTimeout)
self.timer.start()
def chart_init(self):
self.chart = QChart()
self.series = QSplineSeries()
#设置曲线名称
self.series.setName("实时数据")
#把曲线添加到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("量程")
#设置网格不显示
self.vlaxisY.setGridLineVisible(False)
#把坐标轴添加到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 __init__(self, spec):
super().__init__(None)
self.spec = spec
self.chart = QChart()
self.chart.setTitle(str(self.spec.variable))
self.chart.legend().hide()
self.setMinimumWidth(400)
self.setMinimumHeight(230)
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self.chart.createDefaultAxes()
self.autoscale_y_axis = True
if self.spec.min_y and self.spec.max_y:
self.autoscale_y_axis = False
self.chart.axes()[1].setRange(self.spec.min_y, self.spec.max_y)
self.axis_x = QValueAxis()
self.axis_y = QValueAxis()
self.chart.addAxis(self.axis_x, Qt.AlignBottom)
self.chart.addAxis(self.axis_y, Qt.AlignLeft)
self._updates_per_second = 60
self._data = []
self._min = 0
self._max = 0
def __init__(self, parent=None):
super(QChart, self).__init__(parent)
self.setAnimationOptions(QChart.SeriesAnimations)
self.axisX = QValueAxis()
self.axisY = QValueAxis()
self.axisX.setTickCount(10)
self.axisY.setTickCount(10)
self.axisX.setMin(0)
self.axisX.setMax(1)
self.axisY.setMin(0)
self.axisY.setMax(1)
series = []
#Temporay Test Data
for i in range(0, 10):
x = np.random.rand(10)
y = np.random.rand(10)
#self.series = XScatterSeries(tooltips = True)
#self.series.addXY(x,y)
#self.addSeries(self.series)
#self.setAxisX(self.axisX, self.series); self.setAxisY(self.axisY, self.series)
serset = XScatterSet() # many options not supported with openGl
serset.setChart(self)
serset.addXY(x, y)
serset.setAxisX(self.axisX)
serset.setAxisY(self.axisY)
series.append(serset)
def _get_processor_chart(self): # type: (Display) -> QChartView
# Create pen
pen = QLineSeries().pen()
pen.setColor(Qt.red)
pen.setWidthF(1)
# Series
self._processor_series = QLineSeries()
self._processor_series.setPen(pen)
self._processor_series.useOpenGL()
# Chart
self._processor_chart = QChart()
self._processor_chart.legend().hide()
self._processor_chart.addSeries(self._processor_series)
self._processor_chart.createDefaultAxes()
self._processor_chart.axisX().setMax(100)
self._processor_chart.axisX().setMin(0)
self._processor_chart.axisY().setMax(5000)
self._processor_chart.axisY().setMin(0)
self._processor_x_axis = QValueAxis()
self._processor_x_axis.setLabelFormat('%i')
self._processor_chart.setAxisX(self._processor_x_axis,
self._processor_series)
self._processor_y_axis = QLogValueAxis()
self._processor_y_axis.setLabelFormat('%g')
self._processor_y_axis.setBase(8)
# Chart View
view = QChartView(self._processor_chart)
view.setRenderHint(QPainter.Antialiasing)
view.setStyleSheet('margin: 0px; height: 250%; width: 400%;')
return view
def __init__(self):
QChartView.__init__(self)
#self.resize(300, 300)
self.setRenderHint(QPainter.Antialiasing) # 抗锯齿
self.chart = QChart()
self.seriesAcc = QLineSeries()
self.seriesAcc.setName(CONF.leftUpNames[0])
self.chart.addSeries(self.seriesAcc)
#声明并初始化X轴，Y轴
self.dtaxisX = QValueAxis()
self.vlaxisY = QValueAxis()
#设置坐标轴显示范围
self.dtaxisX.setMin(0)
#self.dtaxisX.setMax(100)
self.vlaxisY.setMin(0)
#self.vlaxisY.setMax(100)
self.dtaxisX.setTickCount(3)
self.vlaxisY.setTickCount(3)
#设置坐标轴名称
self.dtaxisX.setTitleText(CONF.leftUpNames[1])
self.vlaxisY.setTitleText(CONF.leftUpNames[2])
#设置网格不显示
self.vlaxisY.setGridLineVisible(False)
#把坐标轴添加到chart中
self.chart.addAxis(self.dtaxisX, Qt.AlignBottom)
self.chart.addAxis(self.vlaxisY, Qt.AlignLeft)
self.seriesAcc.attachAxis(self.dtaxisX)
self.seriesAcc.attachAxis(self.vlaxisY)
self.initUI()
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 __iniChart(self):
self.chart = QChart() #创建 Chart
self.chart.setTitle("股票日线图")
self.chart.setTheme(
QChart.ChartThemeBlueCerulean
) #ChartThemeBlueCerulean, ChartThemeQt,ChartThemeBlueNcs,ChartThemeDark
self.ui.chartView.setChart(self.chart) #Chart添加到ChartView
## X 轴是QDateTimeAxis
self.__axisX = QDateTimeAxis()
dateFormat = self.ui.comboDateFormat.currentText() #如"MM-dd"
self.__axisX.setFormat(dateFormat) #标签格式
self.__axisX.setTickCount(10) #主分隔个数
self.__axisX.setTitleText("日期") #标题
dateMin = QDateTime.fromString("2018-01-01", "yyyy-MM-dd")
self.__axisX.setMin(dateMin)
dateMax = dateMin.addDays(150)
self.__axisX.setMax(dateMax)
self.chart.addAxis(self.__axisX, Qt.AlignBottom)
## Y 轴是 QValueAxis
self.__axisY = QValueAxis()
self.__axisY.setTitleText("Value")
self.__axisY.setRange(0, 20)
self.__axisY.setTickCount(5)
self.__axisY.setLabelFormat("%.2f") #标签格式
self.chart.addAxis(self.__axisY, Qt.AlignLeft)
def __init__(self, parent=None):
super(Plot, self).__init__(parent)
self.setFixedSize(PLOT_WIDTH, PLOT_HEIGHT)
self.xMax = None
self.yMin = None
self.yMax = None
self.xAutoRescale = True
self.yMinAutoRescale = True
self.yMaxAutoRescale = True
self.seriesList = []
self.chart = QChart()
self.xAxis = QValueAxis()
self.chart.addAxis(self.xAxis, Qt.AlignBottom)
self.yAxis = QValueAxis()
self.chart.addAxis(self.yAxis, Qt.AlignLeft)
self.setSubplots(1)
self.chart.legend().setVisible(False)
self.chart.legend().setAlignment(Qt.AlignBottom)
self.setChart(self.chart)
def clear(self):
VCTemporalSeriesAlone.clear(self)
self.axisY2 = QValueAxis()
self.maxy2 = None
self.miny2 = None
self.series2 = []
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 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 __init__(self):
super(QChart, self).__init__()
self.m_timer = QTimer()
self.m_series = None
self.m_titles = []
self.m_axis = QValueAxis()
self.m_step = None
self.m_x = 5
self.m_y = 1
random.seed(QTime.currentTime().msec())
self.m_timer.timeout.connect(self.handleTimeout)
self.m_timer.setInterval(1000)
self.m_series = QSplineSeries(self)
green = QPen(Qt.green)
green.setWidth(3)
self.m_series.setPen(green)
self.m_series.append(self.m_x, self.m_y)
self.addSeries(self.m_series)
self.createDefaultAxes()
self.setAxisX(self.m_axis, self.m_series)
self.m_axis.setTickCount(5)
self.axisX().setRange(0, 10)
self.axisY().setRange(-5, 10)
self.m_timer.start()
def auto_adjust_axis(axis: QValueAxis,
bar_sets: [QBarSet],
padding: float = 2):
# Adjust the range so that everything is visible and add some gaps
set_count = len(bar_sets)
minimums = []
maximums = []
for i in range(set_count):
minimums.append(sys.maxsize)
maximums.append(-sys.maxsize)
for set_index in range(set_count):
bar_set = bar_sets[set_index]
for i in range(bar_set.count()):
minimums[set_index] = min(minimums[set_index], bar_set.at(i))
maximums[set_index] = max(maximums[set_index], bar_set.at(i))
minimums.append(0)
axis_min = min(minimums) - padding
maximums.append(0)
axis_max = max(maximums) + padding
print("axis min = {}, axis max = {}".format(axis_min, axis_max))
axis.setMin(axis_min)
axis.setMax(axis_max)
def __init__(self, spec):
super().__init__(None)
self.spec = spec
self.chart = QChart()
# self.chart.setTitle(str(self.spec.variables))
self.chart.legend().hide()
self.mainset = QBarSet("")
self.mainset.append([0 for i in range(len(spec.variables))])
self.mainset.setColor(
QColor(spec.color[0], spec.color[1], spec.color[2]))
self.series = QBarSeries()
self.series.append(self.mainset)
self.setMinimumWidth(400)
self.setMinimumHeight(230)
self.axis_x = QBarCategoryAxis()
self.axis_y = QValueAxis()
self.axis_x.append(spec.variables)
self.chart.addSeries(self.series)
self.chart.setAxisX(self.axis_x, self.series)
self.chart.setAxisY(self.axis_y, self.series)
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self._updates_per_second = 10
self._dataset = []
def __init__(self, parent=None):
super(TestChart, self).__init__(parent)
self.xRange = 800
self.sampleRate = 5
self.counter = 0
self.seriesList = []
self.legend().show()
self.axisX = QValueAxis()
self.axisX.setRange(0, self.xRange)
self.addAxis(self.axisX, Qt.AlignBottom)
# self.setAxisX(self.axisX, series)
self.axisY = QValueAxis()
self.axisY.setRange(-1, 1)
self.addAxis(self.axisY, Qt.AlignLeft)
# self.setAxisY(self.axisY, series)
for i in range(24):
series = QLineSeries()
series.setName("Series" + str(i))
series.setUseOpenGL(True)
self.addSeries(series)
self.seriesList.append(series)
series.attachAxis(self.axisX)
series.attachAxis(self.axisY)
def __init__(self):
super().__init__()
self.m_step = 0
self.m_x = 2
self.m_y = 1
# Инициализировать изображение
self.series = QSplineSeries(self)
red_pen = QPen(Qt.red)
red_pen.setWidth(2)
self.series.setPen(red_pen)
self.axisX = QValueAxis()
self.axisY = QValueAxis()
self.series.append(self.m_x, self.m_y)
self.addSeries(self.series)
self.addAxis(self.axisX, Qt.AlignBottom)
self.addAxis(self.axisY, Qt.AlignLeft)
self.series.attachAxis(self.axisX)
self.series.attachAxis(self.axisY)
self.axisX.setTickCount(5)
self.axisX.setRange(0, 10)
self.axisY.setRange(0, 100)
self.timer = QTimer(self)
self.timer.setInterval(1000)
self.timer.timeout.connect(self.handleTimeout)
self.timer.start()
def __iniChart(self): #图表初始化
self.chart = QPolarChart() ##极坐标图
self.chart.legend().setVisible(False)
self.ui.chartView.setChart(self.chart)
self.ui.chartView.setRenderHint(QPainter.Antialiasing)
self.ui.chartView.setCursor(Qt.CrossCursor)
self.__axisAngle = QValueAxis() #角度坐标轴
self.__axisAngle.setRange(0, 360) #角度范围
self.__axisAngle.setLabelFormat("NE %.0f")
self.__axisAngle.setTickCount(9)
self.chart.addAxis(self.__axisAngle,
QPolarChart.PolarOrientationAngular)
self.__axisRadial = QValueAxis() #径向坐标轴
self.__axisRadial.setTickCount(6)
self.__axisRadial.setLabelFormat("%.1f") #标签格式
self.chart.addAxis(self.__axisRadial,
QPolarChart.PolarOrientationRadial)
pen = QPen(Qt.blue)
pen.setWidth(2)
seriesSpLine = QSplineSeries()
seriesSpLine.setPen(pen)
seriesSpLine.setPointsVisible(True) #数据点可见
seriesSpLine.hovered.connect(self.do_series_hovered)
self.chart.addSeries(seriesSpLine)
seriesSpLine.attachAxis(self.__axisAngle)
seriesSpLine.attachAxis(self.__axisRadial)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
try:
self.maxVal = float(list(data.values())[0])
if self.maxVal * 60 < 1:
self.set0 = QBarSet('Seconds')
self.set0.append(
[round(float(x) * 60 * 60, 1) for x in data.values()])
self.maxVal = round(self.maxVal * 60 * 60, 1)
elif self.maxVal < 1:
self.set0 = QBarSet('Minutes')
self.set0.append(
[round(float(x) * 60, 1) for x in data.values()])
self.maxVal = round(self.maxVal * 60, 1)
else:
self.set0 = QBarSet('Hours')
self.set0.append([round(float(x), 1) for x in data.values()])
self.maxVal = round(self.maxVal, 1)
except:
self.set0 = QBarSet('NotEnoughData')
self.series = QBarSeries()
self.series.append(self.set0)
self.chart = QChart()
self.chart.setTheme(QChart.ChartThemeHighContrast)
self.chart.addSeries(self.series)
self.chart.setTitle(header)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
months = (data.keys())
self.axisX = QBarCategoryAxis()
self.axisX.append(months)
self.axisY = QValueAxis()
try:
self.axisY.setRange(0, self.maxVal)
if self.maxVal > 19:
self.axisY.setTickCount(15)
elif self.maxVal > 10:
self.axisY.setTickCount(10)
else:
self.axisY.setTickCount(5)
#axisY.setTickInterval(1)
#axisY.applyNiceNumbers()
except:
self.chart.setTitle("No Data")
self.chart.addAxis(self.axisX, Qt.AlignBottom)
self.chart.addAxis(self.axisY, Qt.AlignLeft)
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignBottom)
self.chartView = QChartView(self.chart)
self.vert_l = QVBoxLayout()
self.vert_l.addWidget(self.chartView)
self.setLayout(self.vert_l)
def __init__(self, *args, **kwargs):
super(CpuLineChart, self).__init__(*args, **kwargs)
self.m_count = 10
# 隐藏图例
self.legend().hide()
self.m_series = QSplineSeries(self)
# 设置画笔
self.m_series.setPen(QPen(QColor('#3B8CFF'), 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.addSeries(self.m_series)
# x轴
self.m_axisX = QDateTimeAxis(self)
self.m_axisX.setTickCount(self.m_count + 1) # 设置刻度数量
self.m_axisX.setFormat('hh:mm:ss') # 设置时间显示格式
now = QDateTime.currentDateTime() # 前10秒到现在
self.m_axisX.setRange(now.addSecs(-self.m_count), now)
self.addAxis(self.m_axisX, Qt.AlignBottom)
self.m_series.attachAxis(self.m_axisX)
# y轴
self.m_axisY = QValueAxis(self)
self.m_axisY.setLabelFormat('%d') # 设置文本格式
self.m_axisY.setMinorTickCount(4) # 设置小刻度线的数目
self.m_axisY.setTickCount(self.m_count + 1)
self.m_axisY.setRange(0, 100)
self.addAxis(self.m_axisY, Qt.AlignLeft)
self.m_series.attachAxis(self.m_axisY)
# 填充11个初始点，注意x轴 需要转为秒的时间戳
self.m_series.append(
[QPointF(now.addSecs(-i).toMSecsSinceEpoch(), 0) for i in range(self.m_count, -1, -1)])
# 定时器获取数据
self.m_timer = QTimer()
self.m_timer.timeout.connect(self.update_data)
self.m_timer.start(1000)
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 initChart(self, xAxis):
self._chart = QChart()
# 调整边距
self._chart.layout().setContentsMargins(0, 0, 0, 0) # 外界
self._chart.setMargins(QMargins(3, 0, 3, 0)) # 内界
self._chart.setBackgroundRoundness(0)
self._chart.setBackgroundVisible(False)
# 设置主题
self._chart.setTheme(QChart.ChartThemeBlueIcy)
# 抗锯齿
self.setRenderHint(QPainter.Antialiasing)
# 开启动画效果
self._chart.setAnimationOptions(QChart.SeriesAnimations)
self.categories = xAxis
self._series = QBarSeries(self._chart)
self._chart.addSeries(self._series)
self._chart.createDefaultAxes() # 创建默认的轴
self._axis_x = QBarCategoryAxis(self._chart)
self._axis_x.append(self.categories)
self._axis_y = QValueAxis(self._chart)
self._axis_y.setTitleText("任务数")
self._axis_y.setRange(0, 10)
self._chart.setAxisX(self._axis_x, self._series)
self._chart.setAxisY(self._axis_y, self._series)
# chart的图例
legend = self._chart.legend()
legend.setVisible(True)
self.setChart(self._chart)
def __init__(self, parent=None):
super().__init__(parent=parent)
self.setRenderHint(QPainter.Antialiasing)
self._chart = self.chart()
self._axis_x = QValueAxis()
self._axis_y = QValueAxis()
self.series = QLineSeries(self)
self._chart.addSeries(self.series)
self._chart.addAxis(self._axis_x, Qt.AlignBottom)
self._chart.addAxis(self._axis_y, Qt.AlignLeft)
self.series.attachAxis(self._axis_x)
self.series.attachAxis(self._axis_y)
self._axis_x.setTickCount(5)
self._axis_x.setRange(0, 10)
self._axis_y.setTickCount(5)
self._axis_y.setRange(0, 10)
self._chart.legend().hide()
def __init__(self, theme='day', 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 __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 __init__(self, parent=None):
super(QChart, self).__init__(parent)
# Class Vars
self.activeDistr = 'lognorm'
self.knowndistr = distr._distrnames()
self.data = dict()
# Axis Setup
self.axisX = QValueAxis()
self.axisY = QValueAxis()
self.axisX.setLabelsVisible(False)
self.axisX.setTickCount(2)
self.axisX.setTitleText("Series Fractional Probability")
self.axisY.setTitleText("Value")
self.setAxesMinMax(-3, 3, 0.01, 1.5)
self.axisX.setMinorGridLineVisible(False)
self.axisX.setGridLineVisible(False)
# define the default grid colour to grey
self.setGridColor(110, 110, 110)
self.setActiveProbit(self.activeDistr)
self.plotAreaChanged.connect(self.onPlotSizeChanged)
def __init__(
self, _name: str,
_wizard: "ParadoxTrading.Chart.Wizard",
_adaptive: bool,
_view_stretch: int,
_chart_stretch: int,
_index: int,
):
self.name = _name
self.wizard = _wizard
self.adaptive = _adaptive
self.view_stretch = _view_stretch
self.chart_stretch = _chart_stretch
self.index = _index
self.series_table: typing.Dict[str, SeriesAbstract] = {}
self.axis_x = QValueAxis()
# show x will slow down chart
self.axis_x.setVisible(False)
self.axis_y = QValueAxis()
# set name to axis_y, price for price, volume for volume, etc
self.axis_y.setTitleText(self.name)
self.begin_y: float = None
self.end_y: float = None
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)
class View:
def __init__(
self, _name: str,
_wizard: "ParadoxTrading.Chart.Wizard",
_adaptive: bool,
_view_stretch: int,
_chart_stretch: int,
_index: int,
):
self.name = _name
self.wizard = _wizard
self.adaptive = _adaptive
self.view_stretch = _view_stretch
self.chart_stretch = _chart_stretch
self.index = _index
self.series_table: typing.Dict[str, SeriesAbstract] = {}
self.axis_x = QValueAxis()
# show x will slow down chart
self.axis_x.setVisible(False)
self.axis_y = QValueAxis()
# set name to axis_y, price for price, volume for volume, etc
self.axis_y.setTitleText(self.name)
self.begin_y: float = None
self.end_y: float = None
def addBar(
self, _name: str,
_x_list: typing.Sequence, _y_list: typing.Sequence,
_color: typing.Any = None, _show_value: bool = False,
):
assert _name not in self.series_table.keys()
self.series_table[_name] = BarSeries(
_name, _x_list, _y_list, _color, _show_value
)
def addLine(
self, _name: str,
_x_list: typing.Sequence, _y_list: typing.Sequence,
_color: typing.Any = None, _show_value: bool = False,
):
assert _name not in self.series_table.keys()
self.series_table[_name] = LineSeries(
_name, _x_list, _y_list, _color, _show_value
)
def addScatter(
self, _name: str,
_x_list: typing.Sequence, _y_list: typing.Sequence,
_color: typing.Any = None, _show_value: bool = False
):
assert _name not in self.series_table.keys()
self.series_table[_name] = ScatterSeries(
_name, _x_list, _y_list, _color, _show_value
)
def addCandle(
self, _name: str,
_x_list: typing.Sequence,
_y_list: typing.Sequence[typing.Sequence],
_inc_color: typing.Any = None,
_dec_color: typing.Any = None,
_show_value: bool = False
):
assert _name not in self.series_table.keys()
self.series_table[_name] = CandleSeries(
_name, _x_list, _y_list, _inc_color, _dec_color, _show_value
)
def calcSetX(self) -> typing.Set:
"""
get the set of x, to get x range for wizard
:return: the set of all x value
"""
tmp = set()
for v in self.series_table.values():
tmp |= set(v.calcSetX())
return tmp
def calcRangeY(self, _begin_x=None, _end_x=None):
"""
get range of y for this view
:return: (min, max)
"""
tmp_min_list = []
tmp_max_list = []
for v in self.series_table.values():
min_y, max_y = v.calcRangeY(_begin_x, _end_x)
if min_y is not None and max_y is not None:
tmp_min_list.append(min_y)
tmp_max_list.append(max_y)
if tmp_min_list:
self.begin_y = min(tmp_min_list)
if tmp_max_list:
self.end_y = max(tmp_max_list)
def setAxisX(self, _begin: float, _end: float):
self.axis_x.setRange(_begin, _end)
def setAxisY(self, _begin: float, _end: float):
self.axis_y.setRange(_begin, _end)
def createChartView(
self, _x2idx: dict, _idx2x: list
) -> QHBoxLayout:
chart = QChart()
# assign y range
self.calcRangeY()
self.setAxisY(self.begin_y, self.end_y)
value_layout = QFormLayout()
# add each series
for v in self.series_table.values():
v.addSeries(_x2idx, _idx2x, chart, self.axis_x, self.axis_y)
if v.show_value:
value_layout.addWidget(v.show_group)
# create chartview and layout for view and value
chartview = ChartView(chart, self.wizard)
chartview.setRenderHint(QPainter.Antialiasing)
global_layout = QHBoxLayout()
global_layout.addWidget(chartview, self.chart_stretch)
global_layout.addLayout(value_layout)
return global_layout
def updateValue(self, _x):
for v in self.series_table.values():
if v.show_value:
v.updateValue(_x)
