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 build(self):
self.setWindowTitle('Emoreco')
self.setWindowIcon(QIcon(root + 'Logo.ico'))
oImage = QImage(root + "Background.png")
palette = QPalette()
palette.setBrush(QPalette.Window, QBrush(oImage))
self.setPalette(palette)
oImage = QPixmap(root + "Ok.png")
palette = QPalette()
palette.setBrush(self.OkButton.backgroundRole(), QBrush(oImage))
self.OkButton.setFlat(1)
self.OkButton.setAutoFillBackground(1)
self.OkButton.setPalette(palette)
self.OkButton.clicked.connect(self.closeWindow)
set_list = [
QBarSet('Circulatory'),
QBarSet('Digestive'),
QBarSet('Endocrine'),
QBarSet('Integumentary'),
QBarSet('Lymphatic'),
QBarSet('Muscular'),
QBarSet('Nervous'),
QBarSet('Excretory'),
QBarSet('Reproductive'),
QBarSet('Respiratory'),
QBarSet('Skeletal')
]
categories = ['']
series = QBarSeries()
chart = QChart()
axis = QBarCategoryAxis()
for i in range(sys_n):
set_list[i].append([dis_prediction[i]])
series.append(set_list[i])
chart.addSeries(series)
axis.append(categories)
chart.setTitle('Our prediction (%)')
chart.createDefaultAxes()
chart.setAxisX(axis, series)
chart.legend().setAlignment(Qt.AlignLeft)
chart.setBackgroundBrush(QColor(61, 56, 63, 0))
chartView = QChartView(chart)
chartView.chart().setAnimationOptions(QChart.AllAnimations)
base = self.gridLayout
base.addWidget(chartView)
self.show()
def test_generations():
range_a = float(str(form.input_a_test.text()))
range_b = float(str(form.input_b_test.text()))
precision = int(str(form.input_d_test.text()))
generations = int(str(form.input_generations_test.text()))
app.setOverrideCursor(QtCore.Qt.WaitCursor)
start = time()
result = test_generation(range_a, range_b, precision, generations)
app.restoreOverrideCursor()
chart = QChart()
series = QLineSeries()
form.test_table.setRowCount(0)
form.test_table.insertRow(0)
item = QtWidgets.QTableWidgetItem("iteracje")
item.setTextAlignment(QtCore.Qt.AlignCenter)
form.test_table.setItem(0, 0, item)
item = QtWidgets.QTableWidgetItem("wystąpienia")
item.setTextAlignment(QtCore.Qt.AlignCenter)
form.test_table.setItem(0, 1, item)
item = QtWidgets.QTableWidgetItem("%")
item.setTextAlignment(QtCore.Qt.AlignCenter)
form.test_table.setItem(0, 2, item)
for i in range(0, generations):
percent = sum(result[:i+1])/100000*100
series.append(i+1, percent)
form.test_table.insertRow(i+1)
form.test_table.setItem(i+1, 0, QtWidgets.QTableWidgetItem(str(i+1)))
form.test_table.setItem(i+1, 1, QtWidgets.QTableWidgetItem(str(result[i])))
form.test_table.setItem(i+1, 2, QtWidgets.QTableWidgetItem(str(round(percent, 2))))
chart.addSeries(series)
chart.setBackgroundBrush(QtGui.QColor(41, 43, 47))
chart.createDefaultAxes()
chart.legend().hide()
chart.setContentsMargins(-10, -10, -10, -10)
chart.layout().setContentsMargins(0, 0, 0, 0)
chart.axisX().setTickCount(10)
chart.axisY().setRange(0, 100)
chart.axisY().setTickCount(11)
chart.axisX().setLabelsColor(QtGui.QColor("white"))
chart.axisY().setLabelsColor(QtGui.QColor("white"))
form.widget_test.setChart(chart)
class AccountPieChart(QChartView):
"""
Chart that displays certaing accounts with their
respective balance on a Pie Chart.
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.series = QPieSeries()
self.chart = QChart()
self.chart.setTheme(QChart.ChartThemeDark)
self.chart.legend().hide()
self.chart.addSeries(self.series)
self.chart.createDefaultAxes()
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.chart.setBackgroundBrush(QBrush(QColor('#19232d')))
self.chart.setTitle("")
self.chart.setTitleBrush(QBrush(QColor('white')))
self.chart.legend().setAlignment(Qt.AlignBottom)
self.chart.legend().setLabelColor(QColor('white'))
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self.setStyleSheet("border: 0px")
# self.setMinimumWidth(300)
def updateWithToken(self, token):
""" Updates series with all accounts that have a certain token """
entries_with_token = cbalances.get_entries_with_token(token)
self.series.clear()
for entry in entries_with_token:
account = entry[0]
amount = entry[2]
self.series.append(account, amount)
self.showSliceLabels(token)
def allMode(self):
"""Updates series with all accounts"""
self.series.clear()
data = cbalances.get_all_accounts_with_amount()
for d in data:
account = d[0]
balance = d[1]
self.series.append(account, balance)
self.showSliceLabels("btc")
self.hideLittleSlices()
def showSliceLabels(self, token):
"""
Formats the Slices so that they show the percentage
"""
for slce in self.series.slices():
slce.setLabel("{} {}% ({})".format(
slce.label(), int(100*slce.percentage()), str(prices.to_btc(token, slce.value())) + " BTC"))
slce.setLabelPosition(QPieSlice.LabelInsideNormal)
# slce.setLabelPosition(QPieSlice.LabelOutside)
slce.setLabelColor(QColor('white'))
slce.setLabelVisible(True)
self.hideLittleSlices()
def selectSlice(self, account):
"""
Explodes a certaing slice that corresponds to
an account
"""
for slce in self.series.slices():
if account in slce.label():
# Explode slice
slce.setExploded(True)
font = QFont()
font.setBold(True)
font.setUnderline(True)
slce.setLabelFont(font)
slce.setLabelPosition(QPieSlice.LabelOutside)
else:
slce.setExploded(False)
slce.setLabelFont(QFont())
# slce.setLabelPosition(QPieSlice.LabelInsideTangential)
slce.setLabelPosition(QPieSlice.LabelInsideNormal)
self.hideLittleSlices(selected=account)
def hideLittleSlices(self, selected=''):
"""
If a slice is not big enough for the label to be properly seen,
the label gets hidden
"""
for slce in self.series.slices():
if slce.angleSpan() < 5 and slce.label().split(' ')[0] != selected:
# Slice too little to show, and it's not selected
slce.setLabelVisible(False)
else:
slce.setLabelVisible(True)
def run_statistics(self):
text = self.comp_type_crt_text
x_vals = []
y_vals = []
if text[:5] == "Inter":
data_sets = []
for check_box in self.check_boxes:
if check_box.isChecked():
data_sets.append(self.check_boxes[check_box])
metric = self.select_metric_inter.currentText()
metric_alias = self.dict_metric_inter[metric]
res = ResultsManager.get_results_inter(metric_alias, data_sets)
# self.graphWidget.plot(data_sets, res)
x_vals = data_sets
y_vals = res
elif text[:5] == "Intra":
ds_name = self.intra_ds_current
metric = self.select_metric_intra.currentText()
metric_alias = self.dict_metric_intra[metric]
names, res = ResultsManager.get_results_intra(metric_alias, ds_name)
# self.graphWidget.plot(names, res)
x_vals = names
y_vals = res
#horizontal bar
chart_view = None
if self.select_chart.currentIndex() == 0:
chart = QChart(flags=Qt.WindowFlags())
series = QHorizontalBarSeries()
for i in range(len(x_vals)):
name = x_vals[i]
set0 = QBarSet(name)
set0.append(y_vals[i])
series.append(set0)
chart.addSeries(series)
if text[:5] == "Inter":
chart.setTitle(f"Comparison by {self.select_metric_inter.currentText()}")
else:
chart.setTitle(f"Comparison by {self.select_metric_intra.currentText()}")
chart.setAnimationOptions(QChart.SeriesAnimations)
chart_view = QChartView(chart)
self.graph_layout.replaceWidget(self.crt_chart, chart_view)
self.crt_chart = chart_view
axisX = QValueAxis()
chart.addAxis(axisX, Qt.AlignBottom)
series.attachAxis(axisX)
axisX.applyNiceNumbers()
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chart_view.setRenderHint(QPainter.Antialiasing)
chart_view.setBackgroundBrush(QColor(0, 0, 0, 255))
chart.setBackgroundBrush(QColor(255, 255, 0, 255))
# vertical bar
elif self.select_chart.currentIndex() == 1:
chart = QChart(flags=Qt.WindowFlags())
series = QBarSeries()
for i in range(len(x_vals)):
name = x_vals[i]
set0 = QBarSet(name)
set0.append(y_vals[i])
series.append(set0)
chart.addSeries(series)
if text[:5] == "Inter":
chart.setTitle(f"Comparison by {self.select_metric_inter.currentText()}")
else:
chart.setTitle(f"Comparison by {self.select_metric_intra.currentText()}")
chart.setAnimationOptions(QChart.SeriesAnimations)
chart_view = QChartView(chart)
self.graph_layout.replaceWidget(self.crt_chart, chart_view)
self.crt_chart = chart_view
axisY = QValueAxis()
chart.addAxis(axisY, Qt.AlignLeft)
series.attachAxis(axisY)
axisY.applyNiceNumbers()
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chart_view.setRenderHint(QPainter.Antialiasing)
chart_view.setBackgroundBrush(QColor(0, 0, 0, 255))
chart.setBackgroundBrush(QColor(255, 255, 0, 255))
# pie chart
elif self.select_chart.currentIndex() == 2:
chart = QChart(flags=Qt.WindowFlags())
series = QPieSeries()
for i in range(len(x_vals)):
series.append(x_vals[i], y_vals[i])
chart.addSeries(series)
if text[:5] == "Inter":
chart.setTitle(f"Comparison by {self.select_metric_inter.currentText()}")
else:
chart.setTitle(f"Comparison by {self.select_metric_intra.currentText()}")
chart.setAnimationOptions(QChart.SeriesAnimations)
chart.legend().setAlignment(Qt.AlignBottom)
# chart.legend().setFont(QFont("Arial", 12))
chart_view = QChartView(chart)
self.graph_layout.replaceWidget(self.crt_chart, chart_view)
self.crt_chart = chart_view
chart_view.setRenderHint(QPainter.Antialiasing)
chart_view.setBackgroundBrush(QColor(0, 0, 0, 255))
chart.setBackgroundBrush(QColor(255, 255, 0, 255))
chart_view.setRubberBand(QChartView.HorizontalRubberBand)
chart_view.setRubberBand(QChartView.VerticalRubberBand)
class QtChartCanvas(QWidget):
def __init__(self, parent=None):
super(QtChartCanvas, self).__init__(parent)
self.setStyleSheet("border:0;background-color:#263848")
self.plotChart = QChart()
self.plotChart.legend().hide()
self.verticalLayout = QtWidgets.QVBoxLayout(self)
self.plotView = QChartView(self.plotChart)
self.plotView.setStyleSheet("border:0;background-color:#263848;")
self.plotView.setBackgroundBrush(QBrush(QColor("#263848")))
self.plotChart.setBackgroundBrush(QBrush(QColor("#263848")))
#self.plotChart.setStyle()
self.verticalLayout.addWidget(self.plotView)
self.plotCurve = QSplineSeries()
self.plotCurve.setColor(QColor("#AABFFF"))
self.plotCurve.setUseOpenGL(True)
self.plotCurve.pen().setColor(QColor("#FAF0FF"))
self.plotChart.addSeries(self.plotCurve)
# self.scatter=QScatterSeries()
# self.scatter.setMarkerSize(8)
# self.plotChart.addSeries(self.scatter)
self.plotChart.createDefaultAxes()
self.plotChart.axisY().setGridLineColor(QColor("#5D5C72"))
self.plotChart.axisY().setLinePenColor(QColor("#9D9CA2"))
self.plotChart.axisY().setLabelsColor(QColor("#F8F6F6"))
self.plotChart.axisY().setRange(0, 100)
self.plotChart.axisX().hide()
self.RecvData = [] # 存储接收到的传感器数据
self.RecvIndx = 0
self.setLockY = True
self.isTop = False
self.minY = 0
self.maxY = 100
def update_figure(self, payload):
data = payload["data"]
self.RecvData.append(data)
self.RecvData = self.RecvData[-20:]
plotData = []
if self.isTop:
for i, val in enumerate(self.RecvData):
plotData.append(QPoint(i, val))
self.plotCurve.replace(plotData)
#self.scatter.replace(plotData)
self.plotChart.axisX().setMax(len(plotData))
if not self.setLockY:
self.plotChart.axisY().setRange(
min(self.RecvData) * 0.5,
max(self.RecvData) * 1.3)
else:
self.plotChart.axisY().setRange(self.minY, self.maxY)
def setYLimit(self, miny=0, maxy=100, lockY=True):
self.setLockY = lockY
if self.setLockY:
self.maxY = maxy
self.minY = miny
def changeTop(self, isTop):
self.isTop = isTop
class ChartView(QChartView):
def __init__(self, file, parent=None):
super(ChartView, self).__init__(parent)
self._chart = QChart()
self._chart.setAcceptHoverEvents(True)
self.setChart(self._chart)
self.initUi(file)
def initUi(self, file):
if isinstance(file, dict):
return self.__analysis(file)
if isinstance(file, str):
if not os.path.isfile(file):
return self.__analysis(json.loads(file))
with open(file, "rb") as fp:
data = fp.read()
encoding = chardet.detect(data) or {}
data = data.decode(encoding.get("encoding") or "utf-8")
self.__analysis(json.loads(data))
# def onSeriesHoverd(self, point, state):
# print(point, state)
def mouseMoveEvent(self, event):
super(ChartView, self).mouseMoveEvent(event)
# 获取x和y轴的最小最大值
axisX, axisY = self._chart.axisX(), self._chart.axisY()
min_x, max_x = axisX.min(), axisX.max()
min_y, max_y = axisY.min(), axisY.max()
# 把鼠标位置所在点转换为对应的xy值
x = self._chart.mapToValue(event.pos()).x()
y = self._chart.mapToValue(event.pos()).y()
index = round(x) # 四舍五入
print(x, y, index)
# 得到在坐标系中的所有series的类型和点
points = [(s.type(), s.at(index)) for s in self._chart.series()
if min_x <= x <= max_x and min_y <= y <= max_y]
print(points)
def __getColor(self, color=None, default=Qt.white):
'''
:param color: int|str|[r,g,b]|[r,g,b,a]
'''
if not color:
return QColor(default)
if isinstance(color, QBrush):
return color
# 比如[r,g,b]或[r,g,b,a]
if isinstance(color, list) and 3 <= len(color) <= 4:
return QColor(*color)
else:
return QColor(color)
def __getPen(self,
pen=None,
default=QPen(Qt.white, 1, Qt.SolidLine, Qt.SquareCap,
Qt.BevelJoin)):
'''
:param pen: pen json
'''
if not pen or not isinstance(pen, dict):
return default
return QPen(self.__getColor(pen.get("color", None) or default.color()),
pen.get("width", 1) or 1,
pen.get("style", 0) or 0,
pen.get("capStyle", 16) or 16,
pen.get("joinStyle", 64) or 64)
def __getAlignment(self, alignment):
'''
:param alignment: left|top|right|bottom
'''
try:
return getattr(Qt, "Align" + alignment.capitalize())
except:
return Qt.AlignTop
# if alignment == "left":
# return Qt.AlignLeft
# if alignment == "right":
# return Qt.AlignRight
# if alignment == "bottom":
# return Qt.AlignBottom
# return Qt.AlignTop
def __setTitle(self, title=None):
'''
:param title: title json
'''
if not title or not isinstance(title, dict):
return
# 设置标题
self._chart.setTitle(title.get("text", "") or "")
# 设置标题颜色
self._chart.setTitleBrush(
self.__getColor(
title.get("color", self._chart.titleBrush())
or self._chart.titleBrush()))
# 设置标题字体
font = QFont(title.get("font", "") or self._chart.titleFont())
pointSize = title.get("pointSize", -1) or -1
if pointSize > 0:
font.setPointSize(pointSize)
font.setWeight(title.get("weight", -1) or -1)
font.setItalic(title.get("italic", False) or False)
self._chart.setTitleFont(font)
def __setAnimation(self, animation=None):
'''
:param value: animation json
'''
if not animation or not isinstance(animation, dict):
return
# 动画持续时间
self._chart.setAnimationDuration(
animation.get("duration", 1000) or 1000)
# 设置动画曲线
self._chart.setAnimationEasingCurve(
EasingCurve.get(animation.get("curve", 10) or 10, None)
or QEasingCurve.OutQuart)
# 设置开启何种动画
self._chart.setAnimationOptions(
AnimationOptions.get(animation.get("options", 0) or 0, None)
or QChart.NoAnimation)
def __setBackground(self, background=None):
'''
:param background:background json
'''
if not background or not isinstance(background, dict):
return
# 设置是否背景可用
self._chart.setBackgroundVisible(
background.get("visible", True) or True)
# 设置背景矩形的圆角
self._chart.setBackgroundRoundness(background.get("radius", 0) or 0)
# 设置下拉阴影
self._chart.setDropShadowEnabled(
background.get("dropShadow", True) or True)
# 设置pen
self._chart.setBackgroundPen(
self.__getPen(background.get("pen", None),
self._chart.backgroundPen()))
# 设置背景
image = background.get("image", None)
color = background.get("color", None)
if image:
self._chart.setBackgroundBrush(QBrush(QPixmap(image)))
elif color:
self._chart.setBackgroundBrush(
self.__getColor(color, self._chart.backgroundBrush()))
def __setMargins(self, margins=None):
'''
:param margins: margins json
'''
if not margins or not isinstance(margins, dict):
return
left = margins.get("left", 20) or 20
top = margins.get("top", 20) or 20
right = margins.get("right", 20) or 20
bottom = margins.get("bottom", 20) or 20
self._chart.setMargins(QMargins(left, top, right, bottom))
def __setLegend(self, legend=None):
'''
:param legend: legend json
'''
if not legend or not isinstance(legend, dict):
return
_legend = self._chart.legend()
_legend.setAlignment(self.__getAlignment(legend.get("alignment",
None)))
_legend.setShowToolTips(legend.get("showToolTips", True) or True)
def __getSerie(self, serie=None):
if not serie or not isinstance(serie, dict):
return None
types = serie.get("type", "") or ""
data = serie.get("data", []) or []
if not data or not isinstance(data, list):
return None
if types == "line":
_series = QLineSeries(self._chart)
else:
return None
# 设置series名字
_series.setName(serie.get("name", "") or "")
# 添加数据到series中
for index, value in enumerate(data):
# 保证vlaue必须是数字
_series.append(index, value if type(value) in (int, float) else 0)
return _series
def __setSeries(self, series=None):
if not series or not isinstance(series, list):
return
for serie in series:
_serie = self.__getSerie(serie)
if _serie:
# _serie.hovered.connect(self.onSeriesHoverd)
self._chart.addSeries(_serie)
# 创建默认的xy轴
self._chart.createDefaultAxes()
def __setAxisX(self, axisx=None):
if not axisx or not isinstance(axisx, dict):
return
series = self._chart.series()
if not series:
return
types = axisx.get("type", None)
data = axisx.get("data", []) or []
if not data or not isinstance(data, list):
return None
minx = self._chart.axisX().min()
maxx = self._chart.axisX().max()
if types == "category":
xaxis = QCategoryAxis(
self._chart,
labelsPosition=QCategoryAxis.AxisLabelsPositionOnValue)
# 隐藏网格
xaxis.setGridLineVisible(False)
# 刻度条数
tickc_d = len(data)
tickc = tickc_d if tickc_d > 1 else self._chart.axisX().tickCount()
xaxis.setTickCount(tickc)
# 强制x轴刻度与新刻度条数一致
self._chart.axisX().setTickCount(tickc)
step = (maxx - minx) / (tickc - 1)
for i in range(min(tickc_d, tickc)):
xaxis.append(data[i], minx + i * step)
self._chart.setAxisX(xaxis, series[-1])
def __analysis(self, datas):
'''
analysis json data
:param datas: json data
'''
# 标题
self.__setTitle(datas.get("title", None))
# 抗锯齿
if (datas.get("antialiasing", False) or False):
self.setRenderHint(QPainter.Antialiasing)
# 主题
self._chart.setTheme(datas.get("theme", 0) or 0)
# 动画
self.__setAnimation(datas.get("animation", None))
# 背景设置
self.__setBackground(datas.get("background", None))
# 边距设置
self.__setMargins(datas.get("margins", None))
# 设置图例
self.__setLegend(datas.get("legend", None))
# 设置series
self.__setSeries(datas.get("series", None))
# 自定义的x轴
self.__setAxisX(datas.get("axisx", None))
def initChart(self):
series = QLineSeries()
data = [
QPoint(0, 4),
QPoint(3, 2),
QPoint(7, 7),
QPoint(9, 10),
QPoint(12, 17),
QPoint(17, 9),
QPoint(20, 22),
QPoint(22, 2),
QPoint(28, 13)
]
series.append(data)
# creating chart object
chart = QChart()
chart.legend().hide()
chart.addSeries(series)
pen = QPen(QColor(0, 0, 128))
pen.setWidth(3)
series.setPen(pen)
font = QFont("Open Sans")
font.setPixelSize(40)
font.setBold(True)
chart.setTitleFont(font)
chart.setTitleBrush(QBrush(Qt.yellow))
chart.setTitle("Custom Chart Demo")
backgroundGradient = QLinearGradient()
backgroundGradient.setStart(QPoint(0, 0))
backgroundGradient.setFinalStop(QPoint(0, 1))
backgroundGradient.setColorAt(0.0, QColor(175, 201, 182))
backgroundGradient.setColorAt(1.0, QColor(51, 105, 66))
backgroundGradient.setCoordinateMode(QGradient.ObjectBoundingMode)
chart.setBackgroundBrush(backgroundGradient)
plotAreaGraident = QLinearGradient()
plotAreaGraident.setStart(QPoint(0, 1))
plotAreaGraident.setFinalStop(QPoint(1, 0))
plotAreaGraident.setColorAt(0.0, QColor(222, 222, 222))
plotAreaGraident.setColorAt(1.0, QColor(51, 105, 66))
plotAreaGraident.setCoordinateMode(QGradient.ObjectBoundingMode)
chart.setPlotAreaBackgroundBrush(plotAreaGraident)
chart.setPlotAreaBackgroundVisible(True)
# customize axis
axisX = QCategoryAxis()
axisY = QCategoryAxis()
labelFont = QFont("Open Sans")
labelFont.setPixelSize(25)
axisX.setLabelsFont(labelFont)
axisY.setLabelsFont(labelFont)
axisPen = QPen(Qt.white)
axisPen.setWidth(2)
axisX.setLinePen(axisPen)
axisY.setLinePen(axisPen)
axisBrush = QBrush(Qt.white)
axisX.setLabelsBrush(axisBrush)
axisY.setLabelsBrush(axisBrush)
axisX.setRange(0, 30)
axisX.append("low", 10)
axisX.append("medium", 20)
axisX.append("high", 30)
axisY.setRange(0, 30)
axisY.append("slow", 10)
axisY.append("average", 20)
axisY.append("fast", 30)
axisX.setGridLineVisible(False)
axisY.setGridLineVisible(False)
chart.addAxis(axisX, Qt.AlignBottom)
chart.addAxis(axisY, Qt.AlignLeft)
series.attachAxis(axisX)
series.attachAxis(axisY)
self.chartView = QChartView(chart)
self.chartView.setRenderHint(QPainter.Antialiasing)
class Graph(QChartView):
def __init__(self, parent=None):
super().__init__(parent=parent)
self.setpoint_temperature = None
self.chart = QChart()
self.chart.legend().hide()
self.setChart( self.chart )
self.setRenderHint(QPainter.Antialiasing)
self.chart.setPlotAreaBackgroundBrush( QBrush(Qt.black) )
self.chart.setPlotAreaBackgroundVisible( True )
self.setpointTemperatureSeries = QLineSeries( self.chart )
pen = self.setpointTemperatureSeries.pen()
pen.setWidthF(2.)
pen.setColor( Qt.green )
self.setpointTemperatureSeries.setPen( pen )
#self.setpointTemperatureSeries.setUseOpenGL( True )
self.chart.addSeries( self.setpointTemperatureSeries )
self.temperatureSeries = QLineSeries( self.chart )
pen = self.temperatureSeries.pen()
pen.setWidthF(2.)
pen.setColor( Qt.red )
self.temperatureSeries.setPen( pen )
#self.temperatureSeries.setUseOpenGL( True )
self.chart.addSeries( self.temperatureSeries )
self.number_of_samples_to_keep = 2 * 5 * 60
self.xMin = QDateTime.currentDateTime().toMSecsSinceEpoch()
self.xMax = QDateTime.currentDateTime().toMSecsSinceEpoch()
self.yMin = 400
self.yMax = 0
#self.chart.createDefaultAxes()
#x_axis = QValueAxis()
x_axis = QDateTimeAxis()
x_axis.setTitleText( "Time" )
x_axis.setFormat("HH:mm:ss")
self.chart.addAxis( x_axis, Qt.AlignBottom )
self.temperatureSeries.attachAxis( x_axis )
self.setpointTemperatureSeries.attachAxis( x_axis )
startDate = QDateTime.currentDateTime().addSecs( -5 * 60 )
endDate = QDateTime.currentDateTime().addSecs( 5 * 60 )
#startDate = QDateTime(QDate(2017, 1, 9), QTime(17, 25, 0))
#endDate = QDateTime(QDate(2017, 1, 9), QTime(17, 50, 0))
#self.chart.axisX().setRange( startDate, endDate )
#self.chart.axisX().setRange( 0, 100 )
y_axis = QValueAxis()
y_axis.setTitleText( "Temperature (K)" )
self.chart.addAxis( y_axis, Qt.AlignLeft )
self.temperatureSeries.attachAxis( y_axis )
self.setpointTemperatureSeries.attachAxis( y_axis )
self.chart.axisY().setRange( 0, 400 )
#self.chart.axisY().setRange( 260., 290. )
self.temperatureSeries.pointAdded.connect( self.Rescale_Axes )
#self.setpointTemperatureSeries.pointAdded.connect( self.Rescale_Axes )
self.setRubberBand( QChartView.HorizontalRubberBand )
# Customize chart title
font = QFont()
font.setPixelSize(24);
self.chart.setTitleFont(font);
self.chart.setTitleBrush(QBrush(Qt.white));
## Customize chart background
#backgroundGradient = QLinearGradient()
#backgroundGradient.setStart(QPointF(0, 0));
#backgroundGradient.setFinalStop(QPointF(0, 1));
#backgroundGradient.setColorAt(0.0, QColor(0x000147));
#backgroundGradient.setColorAt(1.0, QColor(0x000117));
#backgroundGradient.setCoordinateMode(QGradient.ObjectBoundingMode);
#self.chart.setBackgroundBrush(backgroundGradient);
transparent_background = QBrush(QColor(0,0,0,0))
self.chart.setBackgroundBrush( transparent_background )
# Customize axis label font
labelsFont = QFont()
labelsFont.setPixelSize(16);
x_axis.setLabelsFont(labelsFont)
y_axis.setLabelsFont(labelsFont)
x_axis.setTitleFont(labelsFont)
y_axis.setTitleFont(labelsFont)
# Customize axis colors
axisPen = QPen(QColor(0xd18952))
axisPen.setWidth(2)
x_axis.setLinePen(axisPen)
y_axis.setLinePen(axisPen)
# Customize axis label colors
axisBrush = QBrush(Qt.white)
x_axis.setLabelsBrush(axisBrush)
y_axis.setLabelsBrush(axisBrush)
x_axis.setTitleBrush(axisBrush)
y_axis.setTitleBrush(axisBrush)
def set_title(self, title):
self.chart.setTitle(title)
def add_new_data_point( self, x, y ):
x_as_millisecs = x.toMSecsSinceEpoch()
self.temperatureSeries.append( x_as_millisecs, y )
if( self.setpoint_temperature ):
self.setpointTemperatureSeries.append( x_as_millisecs, self.setpoint_temperature )
num_of_datapoints = self.temperatureSeries.count()
#if( num_of_datapoints > self.number_of_samples_to_keep ):
# self.number_of_samples_to_keep.
#print( x_as_millisecs, y )
#self.chart.scroll( x_as_millisecs - 5 * 60 * 1000, x_as_millisecs )
#self.temperatureSeries.append( x, float(y) )
#self.repaint()
def Rescale_Axes( self, index ):
x = self.temperatureSeries.at( index ).x()
x_rescaled = False
if( x < self.xMin ):
self.xMin = x
x_rescaled = True
if( x > self.xMax ):
self.xMax = x
x_rescaled = True
if( x_rescaled ):
full_range = min( self.xMax - self.xMin, 5 * 60 * 1000 )
margin = full_range * 0.05
self.chart.axisX().setRange( QDateTime.fromMSecsSinceEpoch(self.xMax - full_range - margin), QDateTime.fromMSecsSinceEpoch(self.xMax + margin) )
y = self.temperatureSeries.at( index ).y()
y_rescaled = False
if( y < self.yMin ):
self.yMin = y
y_rescaled = True
if( y > self.yMax ):
self.yMax = y
y_rescaled = True
if( y_rescaled ):
full_range = self.yMax - self.yMin
margin = full_range * 0.05
self.chart.axisY().setRange( self.yMin - margin, self.yMax + margin )
def run_evolution():
range_a = float(str(form.input_a.text()))
range_b = float(str(form.input_b.text()))
precision = int(str(form.input_d.text()))
generations_number = int(str(form.input_t.text()))
app.setOverrideCursor(QtCore.Qt.WaitCursor)
best_reals, best_binary, best_fxs, local_fxs, _, _ = evolution(range_a, range_b, precision, generations_number, form.checkBox.isChecked())
form.best_table.item(1,0).setText(str(best_reals[len(local_fxs)-1]))
form.best_table.item(1,1).setText(''.join(map(str, best_binary[len(local_fxs)-1])))
form.best_table.item(1,2).setText(str(best_fxs[len(local_fxs)-1]))
chart = QChart()
bests = QLineSeries()
pen_best = bests.pen()
pen_best.setWidth(1)
pen_best.setBrush(QtGui.QColor("red"))
bests.setPen(pen_best)
for i in range(0, len(local_fxs)):
if len(local_fxs[i]) - 1 == 0:
fxs = QScatterSeries()
fxs.append(i + 0.99, local_fxs[i][0])
pen = fxs.pen()
color = QtGui.QColor(random.randint(50,255), random.randint(50,255), random.randint(50,255))
fxs.setColor(color)
pen.setColor(color)
fxs.setPen(pen)
fxs.setMarkerSize(5)
else:
fxs = QLineSeries()
tick = 1 / (len(local_fxs[i]) - 1)
for j in range(len(local_fxs[i])):
fxs.append(i + j * tick, local_fxs[i][j])
pen = fxs.pen()
pen.setWidth(1)
pen.setBrush(QtGui.QColor(random.randint(50,255), random.randint(50,255), random.randint(50,255)))
fxs.setPen(pen)
bests.append(i+1, best_fxs[i])
chart.addSeries(fxs)
chart.addSeries(bests)
chart.setBackgroundBrush(QtGui.QColor(41, 43, 47))
chart.createDefaultAxes()
chart.legend().hide()
chart.setContentsMargins(-10, -10, -10, -10)
chart.layout().setContentsMargins(0, 0, 0, 0)
chart.axisX().setTickCount(11)
chart.axisX().setLabelsColor(QtGui.QColor("white"))
chart.axisX().setGridLineColor(QtGui.QColor("grey"))
chart.axisX().setLabelFormat("%i")
chart.axisY().setRange(-2,2)
chart.axisY().setLabelsColor(QtGui.QColor("white"))
chart.axisY().setGridLineColor(QtGui.QColor("grey"))
form.widget.setChart(chart)
with open('best_history.csv', 'w', newline='', encoding='utf8') as history_csvfile:
history_writer = csv.writer(
history_csvfile, delimiter=';', dialect=csv.excel)
history_writer.writerow(['Parametry'])
history_writer.writerow(['Precyzja: 10^-%d' % precision])
history_writer.writerow(['Iteracje: %d' % generations_number])
history_writer.writerow(['', 'real', 'bin', 'f(real)'])
for index, generation in enumerate(range(generations_number)):
history_writer.writerow([index, best_reals[generation], best_binary[generation], best_fxs[generation]])
app.restoreOverrideCursor()
class LastMonthsHistogram(QChartView):
"""
Chart that displays the balance
from the whole portfolio from the last months
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.chart = QChart()
def setupChartWithData(self):
"""
Chart gets updated displaying the new data.
Data has to be expressed on a dictionary form:
- keys are timestamps
- values are total balance for that timestamp
"""
self.chart = QChart()
self.chart.setTheme(QChart.ChartThemeDark)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.chart.setBackgroundBrush(QBrush(QColor("transparent")))
# Series
self.barseries = QBarSeries()
currentyear, currentmonth = datetime.today().year, datetime.today(
).month
dates, amounts = [], []
# Get 5 previous month numbers
for _ in range(5):
dates.append((currentmonth, currentyear))
currentmonth -= 1
if currentmonth == 0:
currentmonth = 12
currentyear -= 1
# Get amounts for each month
for d in dates:
month, year = d
amounts.append(
dbhandler.get_total_wealth_on_month(month, year=year))
# Iterate months and amount and insert them into the histogram appropiately
barset = QBarSet('Total wealth')
labelsfont = QFont()
labelsfont.setFamily('Inter')
labelsfont.setBold(True)
barset.setLabelFont(labelsfont)
barset.setColor(QColor("#D3EABD"))
x_values = []
for d, a in zip(reversed(dates), reversed(amounts)):
if a > 0:
barset.append(int(a))
x_values.append(calendar.month_name[d[0]])
self.barseries.append(barset)
self.barseries.setName("Last Months")
self.barseries.setLabelsVisible(True)
self.barseries.setBarWidth(0.2)
self.barseries.setLabelsPosition(QAbstractBarSeries.LabelsOutsideEnd)
self.chart.addSeries(self.barseries)
# Axis X (Dates)
self.x_axis = QBarCategoryAxis()
self.x_axis.setTitleText(self.tr('Date'))
labelsfont = QFont()
labelsfont.setFamily('Roboto')
labelsfont.setLetterSpacing(QFont.AbsoluteSpacing, 1)
labelsfont.setWeight(QFont.Light)
labelsfont.setPointSize(9)
self.x_axis.setLabelsFont(labelsfont)
self.x_axis.setGridLineVisible(False)
self.x_axis.setLineVisible(False)
self.x_axis.setLinePenColor(QColor("#D3EABD"))
self.x_axis.setTitleVisible(False)
self.x_axis.append(x_values)
self.chart.addAxis(self.x_axis, Qt.AlignBottom)
# Axis Y (Balances)
self.y_axis = QValueAxis()
self.y_axis.setMax(max(amounts) * 1.3)
self.y_axis.setMin(min(amounts) * 0.95)
self.y_axis.hide()
labelsfont = QFont()
labelsfont.setPointSize(4)
self.y_axis.setLabelsFont(labelsfont)
self.chart.addAxis(self.y_axis, Qt.AlignLeft)
# Attach axis to series
self.barseries.attachAxis(self.x_axis)
self.barseries.attachAxis(self.y_axis)
# Legend
self.chart.legend().hide()
# Set up chart on ChartView
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self.setStyleSheet("border: 0px; background-color: rgba(0,0,0,0)")
def run_evolution():
range_a = float(str(form.input_a.text()))
range_b = float(str(form.input_b.text()))
precision = int(str(form.input_d.text()))
particles_number = int(str(form.input_particles.text()))
iterations = int(str(form.input_iterations.text()))
c1_weight = float(str(form.input_c1.text()))
c2_weight = float(str(form.input_c2.text()))
c3_weight = float(str(form.input_c3.text()))
neighborhood_distance = float(str(form.input_neighborhood.text()))
app.setOverrideCursor(QtCore.Qt.WaitCursor)
best_real, best_fx, best_fxs, avg_fxs, min_fxs, particles = evolution(
range_a, range_b, precision, particles_number, iterations, c1_weight,
c2_weight, c3_weight, neighborhood_distance)
chart = QChart()
bests = QLineSeries()
avg = QLineSeries()
mins = QLineSeries()
pen_best = bests.pen()
pen_best.setWidth(1)
pen_best.setBrush(QtGui.QColor("red"))
pen_avg = avg.pen()
pen_avg.setWidth(1)
pen_avg.setBrush(QtGui.QColor("green"))
pen_min = mins.pen()
pen_min.setWidth(1)
pen_min.setBrush(QtGui.QColor("blue"))
bests.setPen(pen_best)
avg.setPen(pen_avg)
mins.setPen(pen_min)
form.best_table.item(1, 0).setText(str(best_real))
form.best_table.item(1, 1).setText(str(best_fx))
for i in range(len(best_fxs)):
bests.append(i + 1, best_fxs[i])
avg.append(i + 1, avg_fxs[i])
mins.append(i + 1, min_fxs[i])
chart.addSeries(bests)
chart.addSeries(avg)
chart.addSeries(mins)
chart.setBackgroundBrush(QtGui.QColor(41, 43, 47))
chart.createDefaultAxes()
chart.legend().hide()
chart.setContentsMargins(-10, -10, -10, -10)
chart.layout().setContentsMargins(0, 0, 0, 0)
chart.axisX().setTickCount(11)
chart.axisX().setLabelsColor(QtGui.QColor("white"))
chart.axisX().setGridLineColor(QtGui.QColor("grey"))
chart.axisX().setLabelFormat("%i")
chart.axisY().setRange(-2, 2)
chart.axisY().setLabelsColor(QtGui.QColor("white"))
chart.axisY().setGridLineColor(QtGui.QColor("grey"))
form.widget.setChart(chart)
draw_thread.particles_list = particles
draw_thread.start()
app.restoreOverrideCursor()
import time
import numpy
from PyQt5.QtChart import QChart, QLineSeries, QScatterSeries
import csv
import random
path_to_gui = path.abspath(path.join(path.dirname(__file__), 'gui.ui'))
Form, Window = uic.loadUiType(path_to_gui)
app = QtWidgets.QApplication([])
window = Window()
form = Form()
form.setupUi(window)
chart = QChart()
chart.setBackgroundBrush(QtGui.QColor(41, 43, 47))
form.widget.setChart(chart)
form.widget_animation.setChart(chart)
form.tabWidget.setTabText(0, "Algorytm")
form.tabWidget.setTabText(1, "Testy")
window.show()
draw_thread = ThreadClass()
def run_evolution():
range_a = float(str(form.input_a.text()))
range_b = float(str(form.input_b.text()))
precision = int(str(form.input_d.text()))
particles_number = int(str(form.input_particles.text()))
class TotalEquityChartView(QChartView):
"""
Chart that displays the balance between several dates
from an account, token or whole portfolio
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.chart = QChart()
def setupChartWithData(self, data, linecolor='#422F8A'):
"""
Chart gets updated displaying the new data.
Data has to be expressed on a dictionary form:
- keys are timestamps
- values are total balance for that timestamp
"""
self.chart = QChart()
self.chart.setTheme(QChart.ChartThemeDark)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.chart.setBackgroundBrush(QBrush(QColor("transparent")))
# self.chart.setTitle("")
# self.chart.setTitleBrush(QBrush(QColor('white')))
# Axis X (Dates)
self.x_axis = QDateTimeAxis()
self.x_axis.setTickCount(11)
self.x_axis.setLabelsAngle(70)
font = QFont()
font.setFamily('Roboto')
font.setLetterSpacing(QFont.PercentageSpacing, 110)
font.setPointSize(8)
self.x_axis.setLabelsFont(font)
self.x_axis.setFormat("dd-MM-yy")
self.x_axis.setTitleText(self.tr('Date'))
self.x_axis.setTitleVisible(False)
self.x_axis.setLineVisible(False)
self.x_axis.setGridLineVisible(False)
# Axis Y (Balances)
self.y_axis = QValueAxis()
if data != {}:
self.y_axis.setMax(max(data.values()) * 1.05)
self.y_axis.setMin(min(data.values()) * 0.95)
# self.y_axis.setMinorGridLineVisible(False)
self.y_axis.setLineVisible(False)
self.y_axis.setGridLineColor(QColor("#ECE9F1"))
self.chart.addAxis(self.y_axis, Qt.AlignLeft)
self.chart.addAxis(self.x_axis, Qt.AlignBottom)
# Series
self.btcseries = QSplineSeries()
for date in data:
balance = data[date]
date = QDateTime(datetime.fromtimestamp(int(float(date))))
self.btcseries.append(date.toMSecsSinceEpoch(), balance)
self.btcseries.setName("BTC")
pen = QPen(QColor(linecolor))
pen.setWidth(3)
self.btcseries.setPen(pen)
# Series functionality
self.btcseries.hovered.connect(self.selectPoint)
self.chart.addSeries(self.btcseries)
self.btcseries.attachAxis(self.x_axis)
self.btcseries.attachAxis(self.y_axis)
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self.setStyleSheet("border: 0px; background-color: rgba(0,0,0,0); ")
self.chart.legend().hide()
def selectPoint(self, point, state):
""" Shows point where mouse is hovered """
self.chart.setTitle(
f"{int(point.y())} {confighandler.get_fiat_currency().upper()}")
class TokenPieChart(QChartView):
"""
Chart that displays certaing tokens with their
respective balance on a Pie Chart.
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.series = QPieSeries()
self.chart = QChart()
# self.chart.setTheme(QChart.ChartThemeBrownSand)
self.chart.setTheme(QChart.ChartThemeQt)
self.chart.legend().hide()
self.chart.addSeries(self.series)
self.chart.createDefaultAxes()
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.chart.setBackgroundBrush(QBrush(QColor('#19232d')))
self.chart.setTitle("")
self.chart.setTitleBrush(QBrush(QColor('white')))
self.chart.legend().setAlignment(Qt.AlignBottom)
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self.setStyleSheet('border: 0px')
# self.setMinimumWidth(300)
def updateWithAccount(self, account):
"""Changes the series so that only tokens from a certain account are shown"""
entries_with_account = cbalances.get_entries_with_account(account)
self.series.clear()
for entry in entries_with_account:
token = entry[1].upper()
amount = entry[2]
amount_btc = prices.to_btc(token, amount)
self.series.append(token, amount_btc)
self.showSliceLabels()
def allMode(self):
"""Changes the series to show all tokens"""
self.series.clear()
data = cbalances.get_all_tokens_with_amount()
for d in data:
token = d[0].upper()
amount = d[1]
total_in_btc = prices.to_btc(token, amount)
self.series.append(token, total_in_btc)
self.showSliceLabels()
self.hideLittleSlices()
def showSliceLabels(self):
"""
Formats the Slices so that they show the percentage
"""
for slce in self.series.slices():
slce.setLabel("{} {}% ({})".format(
slce.label(), int(100*slce.percentage()), str(round(slce.value(), 4)) + " BTC"))
slce.setLabelPosition(QPieSlice.LabelInsideNormal)
# slce.setLabelPosition(QPieSlice.LabelOutside)
slce.setLabelVisible(True)
self.hideLittleSlices()
def selectSlice(self, account):
"""
Explodes a certaing slice that corresponds to
an account
"""
for slce in self.series.slices():
if slce.label().split(' ')[0] == account:
# Explode slice
slce.setExploded(True)
font = QFont()
font.setBold(True)
font.setWeight(QFont.ExtraBold)
font.setUnderline(True)
slce.setLabelFont(font)
slce.setLabelColor(QColor("white"))
slce.setLabelPosition(QPieSlice.LabelOutside)
else:
slce.setExploded(False)
slce.setLabelFont(QFont())
# # slce.setLabelPosition(QPieSlice.LabelInsideTangential)
font = QFont()
slce.setLabelColor(QColor("#3f3f39"))
slce.setLabelFont(font)
slce.setLabelPosition(QPieSlice.LabelInsideNormal)
self.hideLittleSlices(selected=account)
def hideLittleSlices(self, selected=''):
"""
If a slice is not big enough for the label to be properly seen,
the label gets hidden
"""
for slce in self.series.slices():
if slce.angleSpan() < 5 and slce.label().split(' ')[0] != selected:
# Slice too little to show, and it's not selected
slce.setLabelVisible(False)
else:
slce.setLabelVisible(True)
class BalanceHistoryChartView(QChartView):
"""
Chart that displays the balance between several dates
from an account, token or whole portfolio
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.chart = QChart()
self.FIAT_CURRENCY = confighandler.get_fiat_currency()
def setupChartWithData(self, selectiontype, name=None):
"""
Chart gets updated displaying new data.
The data gets extracted from cbalancehistory, according
to the selection
Parameters:
- selectiontype : in ('account','token','all')
- name: str, corresponds to account/token on cbalancehistory
"""
self.chart = QChart()
self.chart.setTheme(QChart.ChartThemeDark)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.chart.setBackgroundBrush(QBrush(QColor('#19232d')))
# self.chart.setTitle("")
# self.chart.setTitleBrush(QBrush(QColor('white')))
# Data
# Get data
if selectiontype == 'token':
assert(name is not None)
data = chistoricalbalances.get_balances_with_token_tuple(name)
elif selectiontype == 'account':
assert(name is not None)
data = chistoricalbalances.get_balances_with_account_tuple(name)
elif selectiontype == 'all':
data = chistoricalbalances.get_balances_by_day_tuple()
# Separate balance_btc from balance_fiat
dates, balances_btc, balances_fiat = [], [], []
for date in data:
dates.append(int(date))
balances_btc.append(data[date][0])
balances_fiat.append(data[date][1])
# Series
self.btcseries = QSplineSeries()
self.fiatseries = QSplineSeries()
for date, balance_btc, balance_fiat in zip(dates, balances_btc, balances_fiat):
date = datetime.fromtimestamp(date)
date = datetime(date.year, date.month, date.day)
dateQ = QDateTime(date).toMSecsSinceEpoch()
self.btcseries.append(dateQ, balance_btc)
self.fiatseries.append(dateQ, balance_fiat)
# Append current point
currentdate = QDateTime(datetime.today()).toMSecsSinceEpoch()
if selectiontype == "all":
# Append current balances
self.btcseries.append(currentdate,
cbalances.get_total_balance_all_accounts())
self.fiatseries.append(currentdate,
cbalances.get_total_balance_all_accounts_fiat())
elif name != '':
if selectiontype == "account":
# Append current balances
self.btcseries.append(
currentdate, cbalances.get_total_account_balance(name))
self.fiatseries.append(
currentdate, cbalances.get_total_account_balance_fiat(name))
elif selectiontype == "token":
pass
# Axis X (Dates)
self.x_axis = QDateTimeAxis()
self.x_axis.setTickCount(11)
self.x_axis.setLabelsAngle(70)
self.x_axis.setFormat("dd-MM-yy")
self.x_axis.setTitleText(self.tr('Date'))
# Axis Y (Balances)
# BTC
self.y_axis_btc = QValueAxis()
if len(balances_btc) > 0:
self.y_axis_btc.setMax(max(balances_btc)*1.1)
self.y_axis_btc.setMin(min(balances_btc)*0.9)
# Fiat
self.y_axis_fiat = QValueAxis()
if len(balances_fiat) > 0:
self.y_axis_fiat.setMax(max(balances_fiat)*1.1)
self.y_axis_fiat.setMin(min(balances_fiat)*0.9)
self.chart.addAxis(self.y_axis_btc, Qt.AlignLeft)
self.chart.addAxis(self.y_axis_fiat, Qt.AlignRight)
self.chart.addAxis(self.x_axis, Qt.AlignBottom)
# Add series to chart
# BTC
self.btcseries.setName("BTC")
self.chart.addSeries(self.btcseries)
self.btcseries.attachAxis(self.x_axis)
self.btcseries.attachAxis(self.y_axis_btc)
# Fiat
self.fiatseries.setName(self.FIAT_CURRENCY.upper())
self.chart.addSeries(self.fiatseries)
self.fiatseries.attachAxis(self.x_axis)
self.fiatseries.attachAxis(self.y_axis_fiat)
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self.setStyleSheet("border: 0px")
class Chart(QChartView):
def __init__(self):
self.chart = QChart()
QChartView.__init__(self, self.chart)
self.axisX = QValueAxis()
self.axisY = QValueAxis()
self.xRange = [0, 100]
self.yRange = [-100, 100]
self.curve = []
self.scatterCurve = []
self.setBackgroundBrush(QColor('#D8D8D8'))
self.setRenderHint(QPainter.Antialiasing)
self.chart.setAnimationOptions(QChart.NoAnimation)
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignBottom)
self.chart.legend().setLabelColor(Qt.white)
self.chart.legend().setMarkerShape(QLegend.MarkerShapeFromSeries)
self.chart.setBackgroundBrush(QColor('#00004D'))
penAxisGrid = QPen(QColor('#F2F2F2'))
penAxisGrid.setWidthF(0.5)
penAxisMinorGrid = QPen(QColor('#A4A4A4'))
penAxisMinorGrid.setWidthF(0.3)
self.axisX.setGridLinePen(penAxisGrid)
self.axisX.setLinePen(penAxisGrid)
self.axisY.setGridLinePen(penAxisGrid)
self.axisY.setLinePen(penAxisGrid)
self.axisX.setMinorGridLinePen(penAxisMinorGrid)
self.axisY.setMinorGridLinePen(penAxisMinorGrid)
self.axisX.setLabelsColor(Qt.white)
self.axisY.setLabelsColor(Qt.white)
self.axisX.setMinorTickCount(4)
self.axisY.setMinorTickCount(4)
self.axisX.setTitleBrush(Qt.white)
self.axisY.setTitleBrush(Qt.white)
self.axisX.setTitleText('Time')
self.axisY.setTitleText('Signal Amplitude')
self.axisX.setTickCount(11)
self.axisY.setTickCount(11)
self.axisX.setRange(self.xRange[0], self.xRange[1])
self.axisY.setRange(self.yRange[0], self.yRange[1])
def setAddSerie(self, name, color):
self.curve.append(QLineSeries())
pen = self.curve[len(self.curve) - 1].pen()
pen.setColor(QColor(color))
pen.setWidthF(2)
self.curve[len(self.curve) - 1].setPen(pen)
self.curve[len(self.curve) - 1].setName(name)
self.chart.addSeries(self.curve[len(self.curve) - 1])
self.chart.setAxisX(self.axisX, self.curve[len(self.curve) - 1])
self.chart.setAxisY(self.axisY, self.curve[len(self.curve) - 1])
def setAddScatterSerie(self, color):
self.scatterCurve.append(QScatterSeries())
pen = self.scatterCurve[len(self.scatterCurve) - 1].pen()
pen.setColor(QColor(color))
pen.setWidthF(1)
self.scatterCurve[len(self.scatterCurve) - 1].setPen(pen)
self.scatterCurve[len(self.scatterCurve) - 1].setColor(QColor(color))
self.scatterCurve[len(self.scatterCurve) - 1].setMarkerSize(10)
self.chart.addSeries(self.scatterCurve[len(self.scatterCurve) - 1])
self.chart.setAxisX(self.axisX,
self.scatterCurve[len(self.scatterCurve) - 1])
self.chart.setAxisY(self.axisY,
self.scatterCurve[len(self.scatterCurve) - 1])
def setDataChartScatter(self, xData, yData1, yData2):
if xData > self.xRange[1]:
addValue = xData - self.xRange[1]
if self.xRange[0] is not 0:
self.xRange[0] = self.xRange[0] + addValue
self.xRange[1] = self.xRange[1] + addValue
self.axisX.setRange(self.xRange[0], self.xRange[1])
self.curve[0].append(xData, yData1)
self.curve[1].append(xData, yData2)
self.scatterCurve[0].append(xData, yData1)
self.scatterCurve[1].append(xData, yData2)
def setDataChart(self, xData, yData1, yData2):
if xData > self.xRange[1]:
addValue = xData - self.xRange[1]
if self.xRange[0] is not 0:
self.xRange[0] = self.xRange[0] + addValue
self.xRange[1] = self.xRange[1] + addValue
self.axisX.setRange(self.xRange[0], self.xRange[1])
self.curve[0].append(xData, yData1)
self.curve[1].append(xData, yData2)
def setRangeY(self, yRange, autoscale):
if autoscale:
if yRange[0] == 0 and yRange[1] == 0:
yRange[0] = -0.50
yRange[1] = 0.50
elif yRange[0] == 0:
yRange[0] = -0.10
yRange[1] = yRange[1] * 1.10
elif yRange[1] == 0:
yRange[0] = yRange[0] * 1.10
yRange[1] = 0.10
else:
if yRange[0] < 0:
yRange[0] = yRange[0] * 1.10
else:
yRange[0] = yRange[0] - (yRange[0] * 0.10)
if yRange[1] < 0:
yRange[1] = yRange[1] - (yRange[1] * 0.10)
else:
yRange[1] = yRange[1] * 1.10
self.axisY.setRange(yRange[0], yRange[1])
else:
self.axisY.setRange(yRange[0], yRange[1])
def setRangeX(self, xRange):
self.axisX.setRange(xRange[0], xRange[1])
def getRangeX(self):
return self.xRange
def setAxisXName(self, name):
self.axisX.setTitleText(name)
def setAxisYName(self, name):
self.axisY.setTitleText(name)
def setAxisXTickCount(self, tick):
self.axisX.setTickCount(tick)
def setAxisYTickCount(self, tick):
self.axisY.setTickCount(tick)
def initSerie(self):
self.curve.clear()
def initSeries(self):
self.curve[0].clear()
self.curve[1].clear()
