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()
class StatsTab(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.seriesmap = {} # map items to series
# create widgets
self.stat_list = QListWidget(self)
chart = QChart()
self.chart_view = QChartView(chart, self)
for i in range(30):
series = QLineSeries(self)
for j in range(20):
series.append(j, i * 3 + j)
item = QListWidgetItem()
item.setData(Qt.DisplayRole, str(i))
item.setData(Qt.UserRole, i)
if i < 10:
item.setData(Qt.CheckStateRole, Qt.Checked)
else:
item.setData(Qt.CheckStateRole, Qt.Unchecked)
series.hide()
chart.addSeries(series)
self.stat_list.addItem(item)
self.seriesmap[i] = series
# create layout
layout = QHBoxLayout(self)
layout.addWidget(self.stat_list)
layout.addWidget(self.chart_view)
layout.setStretchFactor(self.chart_view, 3)
# configure widgets
chart.legend().hide()
chart.createDefaultAxes()
chart.setTitle("Daily aggregated stats of your school")
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.retranslateUi()
# connect signals
self.stat_list.itemClicked.connect(self.on_stat_clicked)
def retranslateUi(self):
chart = self.chart_view.chart()
chart.setTitle(
QApplication.translate("StatsTab",
"Daily aggregated stats of your school"))
@pyqtSlot(QListWidgetItem)
def on_stat_clicked(self, item):
key = item.data(Qt.UserRole)
series = self.seriesmap[key]
series.setVisible(not series.isVisible())
def __init__(self, config: Config, chart_view: QChartView) -> None:
self.chart_view = chart_view
self.config = config
self.initialized = False
chart_view.setRenderHint(QPainter.Antialiasing)
self.chart: QChart = chart_view.chart()
legend: QLegend = self.chart.legend()
legend.hide()
self.chart_view.repaint()
def __init__(self):
super(SpeedFigure, self).__init__()
self.layout = QVBoxLayout()
self.chart_view = []
self.line_series = [[], []]
self.y_axis = []
self.default_max_y_value = 3000
self.colors = [Qt.red, Qt.blue, Qt.green, Qt.magenta]
for i in range(2):
cv = QChartView()
for j in range(4):
ls = QLineSeries()
p = ls.pen()
p.setColor(self.colors[j])
ls.setPen(p)
self.line_series[i].append(ls)
cv.chart().addSeries(ls)
cv.chart().legend().hide()
cv.chart().layout().setContentsMargins(0, 0, 0, 0)
cv.setRenderHint(QPainter.Antialiasing)
self.chart_view.append(cv)
self.layout.addWidget(cv)
self.last_timestamp = None
self.setLayout(self.layout)
class PieChart(QDialog):
def __init__(self, title: str, project_data, parent=None):
super(PieChart, self).__init__(parent)
self.setWindowTitle(title)
self._layout = QVBoxLayout(self)
self.setMinimumWidth(600)
self.setMinimumHeight(500)
self._create_pie_chart(project_data)
'''定义饼状图并获取各区间信息'''
def get_data(self, mark_data):
pie_series = QPieSeries() # 定义PieSeries
total_area = 0
for j in range(len(mark_data)):
total_area += mark_data[j][1]
for j in range(len(mark_data)):
percentage = mark_data[j][1] / total_area * 100
str1 = "{:.1f}%".format(percentage) + mark_data[j][0]
pie_series.append(str1, mark_data[j][1])
return pie_series
'''绘制饼状图各区间'''
def set_slice(self, pie_series: QPieSeries, mark_data) -> QPieSeries:
for i in range(len(mark_data)):
slice_ = pie_series.slices()[i] # 地道饼图的某一个元素切片
slice_.setLabelVisible() # 设置各区域文本标签
slice_.setPen(QPen(Qt.darkGreen, 0)) # 设置画笔类型——边界线颜色
slice_.setBrush(mark_data[i][2]) # 设置笔刷——区域颜色
return pie_series
'''绘制饼状图并显示'''
def _create_pie_chart(self, project_data: tuple):
font = QFont("黑体")
point_size = font.pointSize()
font.setPixelSize(point_size * 90 / 72)
self.char_view = QChartView(self) # 将父窗体设置为空，设置为独立窗口
self.char_view.setFont(font)
self.char_view.setGeometry(100, 100, 800, 600) # 设置窗口位置和大小
self.char_view.setRenderHint(QPainter.Antialiasing) # 消除锯齿
pie = self.get_data(project_data) # 获取区域种类及占比信息
pie_series = self.set_slice(pie, project_data) # 绘制饼状图各区间
self.char_view.chart().addSeries(pie_series) # 将饼状图添加至charView中
self.char_view.chart().setTitle("各类型地物占比") # 设置标题
self.char_view.chart().legend().hide()
self._layout.addWidget(self.char_view)
def closeEvent(self, QCloseEvent):
del self._layout
del self.char_view
del self
class PriceFigure(QWidget):
def __init__(self):
super(PriceFigure, self).__init__()
self.layout = QHBoxLayout()
self.chart_view = QChartView()
self.price_series = QLineSeries()
self.chart_view.chart().addSeries(self.price_series)
self.chart_view.chart().legend().hide()
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.layout.addWidget(self.chart_view)
self.setLayout(self.layout)
self.prices = []
self.volumes = []
self.graph_time = None
self.last_timestamp = None
def set_bound(self, dt, low, high):
axisX = QDateTimeAxis()
axisX.setFormat('h:mm')
start_time = QDateTime()
finish_time = QDateTime()
start_time.setDate(QDate(dt.year, dt.month, dt.day))
start_time.setTime(QTime(9, 0))
finish_time.setDate(QDate(dt.year, dt.month, dt.day))
finish_time.setTime(QTime(15, 30))
axisX.setRange(start_time, finish_time)
axisY = QValueAxis()
axisY.setRange(low, high)
self.chart_view.chart().setAxisX(axisX, self.price_series)
self.chart_view.chart().setAxisY(axisY, self.price_series)
def add_trade(self, timestamp, price, volume, is_buy):
if self.last_timestamp is None:
self.set_bound(timestamp, price + price * (-30 / 100.), price + price * (30 / 100.))
self.last_timestamp = timestamp
self.graph_time = timestamp
else:
if timestamp < self.last_timestamp:
return
else:
self.last_timestamp = timestamp
if timestamp - self.graph_time < timedelta(seconds=60):
self.prices.append(price)
self.volumes.append(volume)
else:
price_mean = np.mean(self.prices)
self.prices = []
self.price_series.append(int(timestamp.timestamp() * 1000), price_mean)
self.graph_time = timestamp
def test_run(self):
r = random.random()
if random.random() < 0.5:
r = -r
v = random.randint(100, 1000)
self.current = self.current + self.current * (r / 100.)
self.add_trade(datetime.now() - timedelta(hours=5), self.current, v, True)
def start_test(self):
self.set_bound(datetime.now(), 1000, 2000)
self.timer = QTimer()
self.timer.timeout.connect(self.test_run)
self.timer.start(100)
self.current = 1500
class MainChartWidget(QDialog):
# w_type_charts = None
# w_chart_line = None
# w_chart_pie = None
# w_chart_bar = None
# w_chart = None
#
# v_layout_main = None
# h_layout_middle = None
#
# selector = None
signal_confirm_chart = pyqtSignal(QChart)
def __init__(self):
super(MainChartWidget, self).__init__()
self.w_type_charts = None
self.w_chart_line = None
self.w_chart_pie = None
self.w_chart_bar = None
self.w_chart = None
self.v_layout_main = None
self.h_layout_middle = None
self.selector = None
self.init_ui()
def init_ui(self):
self.setFixedSize(700, 600)
self.assemble()
self.set_styles()
self.aux = QPoint(200, 300)
self.setWindowFlags(Qt.FramelessWindowHint)
# self.setAttribute(Qt.WA_TranslucentBackground)
def mousePressEvent(self, event):
self.oldPos = event.globalPos()
self._from_x = event.pos().x()
self._from_y = event.pos().y()
# self.start = event.pos()
def mouseMoveEvent(self, event):
delta = QPoint(event.globalPos() - self.oldPos)
self.aux = QPoint(self.x() + delta.x(), self.y() + delta.y())
self.move(self.aux)
self.oldPos = event.globalPos()
self._to_x = event.pos().x()
self._to_y = event.pos().y()
self.global_pos = event.globalPos()
self._from_x = self._to_x
self._from_y = self._to_y
def set_styles(self):
self.setStyleSheet("""
MainChartWidget{
border-radius: 4px;
background:rgb(37,43,52,220);
color: white;
}
QScrollArea{
background-color:transparent;
border-radius: 4px;
border: 0px solid ;
border-color: rgb(0,0,0,100)
}
QScrollBar:vertical{
border:1px solid;
border-color: rgb(197,197,199,100);
width: 7px;
margin: 0px 0px 0px 0px;
background: rgb(234,234,234,100);
}
QScrollBar::handle:vertical {
background: rgba(14,65,148,100);
}
QScrollBar::add-line:vertical{
height: 0px;
}
QScrollBar::sub-line:vertical{
height: 0px;
}
""")
def assemble(self):
self.w_type_charts = TopBar(self)
self.w_type_charts.signal_send_chart_selected.connect(
self.set_chart_type)
self.w_type_charts.setMinimumSize(650, 50)
self.w_type_charts.setMaximumHeight(50)
self.w_chart_line = LeftBarLineChart(self)
self.w_chart_line.setMinimumSize(200, 300)
self.w_chart_line.setMaximumWidth(200)
self.w_chart_pie = LeftBarPieChart(self)
self.w_chart_pie.hide()
self.w_chart_pie.setMinimumSize(200, 300)
self.w_chart_pie.setMaximumWidth(200)
self.w_chart_bar = LeftBarBarChart(self)
self.w_chart_bar.hide()
self.w_chart_bar.setMinimumSize(200, 300)
self.w_chart_bar.setMaximumWidth(200)
self.w_chart = QChartView()
self.w_chart.setChart(self.w_chart_line.chart)
self.w_chart.setMinimumSize(400, 300)
self.v_layout_main = QVBoxLayout()
self.v_layout_main.setContentsMargins(20, 20, 20, 20)
self.h_layout_middle = QHBoxLayout()
self.v_layout_main.addWidget(self.w_type_charts)
self.v_layout_main.addLayout(self.h_layout_middle)
self.h_layout_middle.addWidget(self.w_chart_line)
self.h_layout_middle.addWidget(self.w_chart_pie)
self.h_layout_middle.addWidget(self.w_chart_bar)
self.h_layout_middle.addWidget(self.w_chart)
self.setLayout(self.v_layout_main)
self.w_type_charts.btn_chart_line_clicked()
@pyqtSlot(int)
def set_chart_type(self, type):
self.w_chart_line.hide()
self.w_chart_pie.hide()
self.w_chart_bar.hide()
self.selector = type
if type == EChart.LINE:
self.w_chart_line.show()
self.w_chart.setChart(self.w_chart_line.chart)
elif type == EChart.PIE:
self.w_chart_pie.show()
self.w_chart.setChart(self.w_chart_pie.chart)
elif type == EChart.BAR:
self.w_chart_bar.show()
self.w_chart.setChart(self.w_chart_bar.chart)
def confirm_chart(self):
self.signal_confirm_chart.emit(self.w_chart.chart())
# KEYBOARD.close()
def hide(self):
# KEYBOARD.close()
super(MainChartWidget, self).hide()
class PolygonalChart(QDialog):
def __init__(self, title: str, project_data, parent=None):
super(PolygonalChart, self).__init__(parent)
self.setWindowTitle(title)
self.setMinimumWidth(700)
self.setMinimumHeight(500)
self._layout = QVBoxLayout(self)
self._create_polygonal_chart(project_data)
'''定义x轴及其相关属性'''
def set_x_aix(self, years: []) -> QValueAxis: # x轴坐标——年份
x_aix = QValueAxis()
x_aix.setRange(years[0], years[-1])
x_aix.setLabelFormat('%d')
x_aix.setGridLineVisible(True)
x_aix.setTickCount(len(years))
x_aix.setMinorTickCount(5) # 每两个月一个小分级
return x_aix
'''定义y轴及其相关属性'''
def set_y_aix(self, areas: []) -> QValueAxis: # y轴坐标——面积
ma = []
for i in range(0, len(areas)):
m = max(areas[i])
ma.append(m)
bound = max(ma)
y_aix = QValueAxis()
y_aix.setRange(0, int(bound))
y_aix.setLabelFormat('%d')
y_aix.setGridLineVisible(True)
y_aix.setTickCount(11)
y_aix.setMinorTickCount(4)
return y_aix
'''创建折线：确定各折点坐标并连接'''
def create_lines(self, series: QLineSeries, years: [],
areas: []) -> QLineSeries: #
# 创建曲线 series
point_dict_list = {}
for i in range(0, len(years)): # 定义折线坐标点
x = years[i]
y = areas[i]
points = "point_" + str(i)
point_dict_list[points] = QPoint(x, y)
point_list = []
for point in point_dict_list: # 定义折线点清单
point_list.append(point_dict_list[point])
series.append(point_list)
return series
'''根据不同类型创建不同折线'''
def create_lines_to_types(self, types: []) -> dict:
dict1 = {}
for i in range(0, len(types)):
lines = "series_" + str(i)
dict1[lines] = QLineSeries() # 实例化QLineSeries,创建曲线
dict1[lines].setName(types[i])
return dict1
'''创建折线图'''
def _create_polygonal_chart(self, mark_data):
self.char_view = QChartView(self)
self.char_view.setRenderHint(QPainter.Antialiasing)
types = [a[0] for a in mark_data]
# t = mark_data[0]
years = [b[2] for b in mark_data]
# y = mark_data[2]
areas = [c[1] for c in mark_data]
# a = mark_data[1]
dict1 = self.create_lines_to_types(types)
for i in range(0, len(types)):
lines = "series_" + str(i)
series = self.create_lines(dict1[lines], years[i], areas[i])
series.setUseOpenGL(True)
type_ = dict1[lines].name()
for type_ in types:
self.char_view.chart().addSeries(series)
self.char_view.chart().createDefaultAxes()
self.char_view.chart().setAxisX(self.set_x_aix(years[0])) # 设置x,y轴属性
self.char_view.chart().setAxisY(self.set_y_aix(areas))
self.char_view.chart().setTitle("各地物类型面积变化折线图")
self._layout.addWidget(self.char_view)
# self.char_view.show()
def closeEvent(self, QCloseEvent):
del self._layout
del self.char_view
del self
class Widget(QWidget):
def __init__(self):
super().__init__()
self.setMinimumSize(800, 600)
self.setWindowTitle("Rectifier")
self.chartView = QChartView()
self.chart = self.chartView.chart()
self.series = QLineSeries()
self.series2 = QLineSeries()
self.series2.setColor(QColor('red'))
# for i in range(-90, 90): # rectifier
# x = i * pi / 50
# print('x', x)
# y = sin(x)
# print('y', abs(y))
# self.series.append(x, abs(y))
x = [None] * 400
for n in range(-200, 200):
t = n / 100
if t >= -2 and t <= -1:
x[n] = 0
elif t >= -1 and t <= 1:
x[n] = 1
elif t >= 1 and t <= 2:
x[n] = 0
self.series2.append(t, x[n])
self.chart.addSeries(self.series)
self.chart.addSeries(self.series2)
self.chart.legend().hide()
def format_axis(axis, min_value, max_value, step):
for s in axis.categoriesLabels():
axis.remove(s)
axis.setStartValue(min_value)
for i in range(ceil(min_value / step),
floor(max_value / step) + 1):
v = i * step
axis.append('%s' % v, v)
axis.setRange(min_value, max_value)
grid_pen = QPen(QColor('silver'))
grid_pen.setDashPattern([1, 1, 1, 1, 0, 0, 0, 0])
#grid_pen.setDashPattern([1, 1, 0, 0])
axis.setGridLinePen(grid_pen)
self.chart.createDefaultAxes()
self.chart.axisX().setRange(-5, 5)
self.chart.axisX().setGridLineVisible(False)
self.chartAxisX = QCategoryAxis(
labelsPosition=QCategoryAxis.AxisLabelsPositionOnValue,
startValue=0.0)
self.chart.setAxisX(self.chartAxisX)
format_axis(self.chartAxisX, -5, 5, 1)
self.chart.axisY().setRange(-0.1, 1.3)
self.chartAxisY = QCategoryAxis(
labelsPosition=QCategoryAxis.AxisLabelsPositionOnValue,
startValue=0.0)
self.chart.setAxisY(self.chartAxisY)
format_axis(self.chartAxisY, -0.1, 1.3, 1)
self.layout = QGridLayout(self)
self.layout.addWidget(self.chartView, 1, 1)
self.chartView.show()
self.setLayout(self.layout)
class CTViewPair(QWidget):
def __init__(self,
CTMain=None,
exchange='',
base_code='',
curr_code='',
chart_lookback='',
chart_interval='',
order_book_depth=5):
super().__init__()
self._CTMain = CTMain
self._exchange = exchange
self._base_curr = base_code
self._curr_curr = curr_code
self._chart_lookback = chart_lookback
self._chart_interval = chart_interval
self._order_book_depth = order_book_depth
if 'Fusion' in QStyleFactory.keys():
self.change_style('Fusion')
self._layout = QGridLayout()
self.setLayout(self._layout)
self.draw_view()
self.show()
def refresh_dropdown_exchange_change(self,
exchange,
default_base=None,
default_curr=None):
self._exchange = exchange
if default_base is None:
default_base = self._dropdown_base_curr.currentText
if default_curr is None:
default_curr = self._dropdown_curr_curr.currentText
base_codes = sorted(
list(self._CTMain._Crypto_Trader.trader[exchange]._active_markets))
self._dropdown_base_curr.clear()
self._dropdown_base_curr.addItems(base_codes)
if default_base not in base_codes:
default_base = base_codes[0]
self._dropdown_base_curr.setCurrentText(default_base)
self.refresh_dropdown_base_change(default_base, default_curr)
def refresh_dropdown_base_change(self, base_curr, default_curr=None):
self._base_curr = base_curr
if default_curr is None:
default_curr = self._dropdown_curr_curr.currentText
curr_codes = sorted(
list(self._CTMain._Crypto_Trader.trader[
self._exchange]._active_markets[base_curr]))
self._dropdown_curr_curr.clear()
self._dropdown_curr_curr.addItems(curr_codes)
if default_curr not in curr_codes:
default_curr = curr_codes[0]
self._dropdown_curr_curr.setCurrentText(default_curr)
self.refresh_dropdown_curr_change(default_curr)
def refresh_dropdown_curr_change(self, curr_curr):
self._curr_curr = curr_curr
self._market_symbol = self._CTMain._Crypto_Trader.get_market_symbol(
self._exchange, self._base_curr, curr_curr)
self.initiate_widgets()
def draw_view(self):
self._order_book_widget = CTOrderBook(self._CTMain, None, None, None,
None, self._order_book_depth)
self.CandlestickSeries = QCandlestickSeries()
self.CandlestickSeries.setIncreasingColor(Qt.green)
self.CandlestickSeries.setDecreasingColor(Qt.red)
self.VolumeBarSeries = QCandlestickSeries()
self.VolumeBarSeries.setBodyWidth(1.0)
self.VolumeBarSeries.setIncreasingColor(Qt.green)
self.VolumeBarSeries.setDecreasingColor(Qt.red)
self._chart_view = CTChartView(self)
self._chart_view_volume = QChartView(self)
self._chart_view_volume.chart().legend().setVisible(False)
exchanges = self._CTMain._Crypto_Trader.trader.keys()
self._dropdown_exchange = Dropdown(exchanges, self._exchange)
self._dropdown_exchange.activated[str].connect(
self.refresh_dropdown_exchange_change)
base_codes = sorted(self._CTMain._Crypto_Trader.trader[
self._exchange]._active_markets.keys())
self._dropdown_base_curr = Dropdown(base_codes, self._base_curr)
self._dropdown_base_curr.activated[str].connect(
self.refresh_dropdown_base_change)
curr_codes = sorted(self._CTMain._Crypto_Trader.trader[
self._exchange]._active_markets[self._base_curr].keys())
self._dropdown_curr_curr = Dropdown(curr_codes, self._curr_curr)
self._dropdown_curr_curr.activated[str].connect(
self.refresh_dropdown_curr_change)
label_lookback = QLabel("Lookback:")
self._chart_dropdown_lookback = Dropdown(
list(self._CTMain._settings['Chart Lookback Window']),
self._chart_lookback)
self._chart_dropdown_lookback.currentTextChanged.connect(
self.draw_chart)
label_interval = QLabel("Interval:")
self._chart_dropdown_interval = Dropdown(
list(self._CTMain._settings['Chart Interval']),
self._chart_interval)
self._chart_dropdown_interval.currentTextChanged.connect(
self.draw_chart)
self._market_symbol = self._CTMain._Crypto_Trader.get_market_symbol(
self._exchange, self._base_curr, self._curr_curr)
self._trade_widget = CTTradeWidget(self._CTMain, self._exchange,
self._base_curr, self._curr_curr,
self._market_symbol)
self._open_orders_widget = CTOpenOrdersWidget(self._CTMain,
self._exchange,
self._market_symbol)
self._recent_trades_widget = CTRecentTradesWidget(
self._CTMain, self._exchange, self._base_curr, self._curr_curr,
self._market_symbol)
self.refresh_dropdown_exchange_change(self._exchange, self._base_curr,
self._curr_curr)
label_exchange = QLabel("&Exchange:")
label_exchange.setBuddy(self._dropdown_exchange)
label_base_curr = QLabel("&Base:")
label_base_curr.setBuddy(self._dropdown_base_curr)
label_curr_curr = QLabel("&Currency:")
label_curr_curr.setBuddy(self._dropdown_curr_curr)
self._debug_button = QPushButton()
self._debug_button.setText("Debug")
self._debug_button.clicked.connect(self.debug)
top_layout = QHBoxLayout()
top_layout.addWidget(label_exchange)
top_layout.addWidget(self._dropdown_exchange)
top_layout.addWidget(label_base_curr)
top_layout.addWidget(self._dropdown_base_curr)
top_layout.addWidget(label_curr_curr)
top_layout.addWidget(self._dropdown_curr_curr)
top_layout.addWidget(label_lookback)
top_layout.addWidget(self._chart_dropdown_lookback)
top_layout.addWidget(label_interval)
top_layout.addWidget(self._chart_dropdown_interval)
top_layout.addWidget(self._debug_button)
top_layout.addStretch(1)
self._layout.addLayout(top_layout, 0, 0, 1, 10)
self._splitter_top = QSplitter(Qt.Horizontal)
self._splitter_left = QSplitter(Qt.Vertical)
self._splitter_left.addWidget(self._order_book_widget)
self._splitter_left.addWidget(self._recent_trades_widget)
self._splitter_left.addWidget(self._trade_widget)
self._splitter_left.setSizes([500, 100, 100])
self._splitter_right = QSplitter(Qt.Vertical)
self._splitter_right.addWidget(self._chart_view)
self._splitter_right.addWidget(self._chart_view_volume)
self._splitter_right.addWidget(self._open_orders_widget)
self._splitter_right.setSizes([500, 100, 100])
self._splitter_top.addWidget(self._splitter_left)
self._splitter_top.addWidget(self._splitter_right)
window_width = self._CTMain.frameGeometry().width()
self._splitter_top.setSizes(
[round(0.3 * window_width),
round(0.7 * window_width)])
self._layout.addWidget(self._splitter_top, 1, 0, 9, 10)
@staticmethod
def change_style(style_name):
QApplication.setStyle(QStyleFactory.create(style_name))
def debug(self):
import ipdb
ipdb.set_trace()
# def refresh(self):
# t = threading.Thread(target = self.refresh_widgets)
# t.start()
# t.join(1)
def initiate_widgets(self):
self._order_book_widget.refresh_order_book(self._exchange,
self._market_symbol,
self._base_curr,
self._curr_curr)
self._trade_widget.update_currencies(self._exchange, self._base_curr,
self._curr_curr,
self._market_symbol)
self._open_orders_widget.update_market(self._exchange,
self._market_symbol)
self._recent_trades_widget.update_market(self._exchange,
self._base_curr,
self._curr_curr,
self._market_symbol)
self.draw_chart()
def draw_chart(self):
exchange = self._exchange
market_symbol = self._market_symbol
interval_name = self._chart_dropdown_interval.currentText()
lookback_name = self._chart_dropdown_lookback.currentText()
interval = self._CTMain._settings['Chart Interval'][interval_name]
lookback = self._CTMain._settings['Chart Lookback Window'][
lookback_name]
load_chart = self._CTMain._Crypto_Trader.trader[
exchange].load_chart_data(market_symbol, interval, lookback)
self.CandlestickSeries.clear()
self.VolumeBarSeries.clear()
ch_min = load_chart[0][3]
ch_max = load_chart[0][2]
t_min = load_chart[0][0]
t_max = load_chart[0][0]
v_max = load_chart[0][6]
for point in load_chart:
candle = CTCandlestickSet(point[0] * 1000, point[1], point[2],
point[3], point[4], point[5], point[6],
self)
self.CandlestickSeries.append(candle)
ch_min = min(ch_min, point[3])
ch_max = max(ch_max, point[2])
t_min = min(t_min, point[0])
t_max = max(t_max, point[0])
v_max = max(v_max, point[6])
min_y = max(0, ch_min - 0.15 * (ch_max - ch_min))
max_y = ch_max + 0.1 * (ch_max - ch_min)
max_volume = 0
for point in load_chart:
# high = min_y + 0.1 * (max_y - min_y) * point[6] / v_max
# low = min_y
v_low = 0
v_high = point[6]
max_volume = max(max_volume, point[6])
if point[4] >= point[1]:
v_open = v_low
v_close = v_high
else:
v_open = v_high
v_close = v_low
volume_candle = QCandlestickSet(v_open, v_high, v_low, v_close,
point[0] * 1000, self)
self.VolumeBarSeries.append(volume_candle)
if not self._chart_view._chart_loaded:
self._chart_view.chart.addSeries(self.CandlestickSeries)
self._chart_view_volume.chart().addSeries(self.VolumeBarSeries)
self._chart_view._chart_loaded = True
axis_x = QDateTimeAxis()
axis_x.setFormat("dd-MM-yyyy h:mm")
axis_x.setRange(datetime.fromtimestamp(int(t_min) - 30 * interval),
datetime.fromtimestamp(int(t_max) + 30 * interval))
self._chart_view.chart.setAxisX(axis_x, self.CandlestickSeries)
axis_y = QValueAxis()
axis_y.setRange(min_y, max_y)
self._chart_view.chart.setAxisY(axis_y, self.CandlestickSeries)
axis_x2 = QDateTimeAxis()
axis_x2.setFormat("dd-MM-yyyy h:mm")
axis_x2.setRange(datetime.fromtimestamp(int(t_min) - 30 * interval),
datetime.fromtimestamp(int(t_max) + 30 * interval))
self._chart_view_volume.chart().setAxisX(axis_x2, self.VolumeBarSeries)
axis_y2 = QValueAxis()
axis_y2.setRange(0, max_volume)
self._chart_view_volume.chart().setAxisY(axis_y2, self.VolumeBarSeries)
class VolumeFigure:
def __init__(self, name):
self.chart_volume_view = QChartView()
self.chart_volume_view.chart().setLocalizeNumbers(True)
self.volume_series = QCandlestickSeries()
self.volume_time_axis = QDateTimeAxis()
self.volume_time_axis.setFormat('h:mm')
self.volume_axis = QValueAxis()
self.volume_average_series = QLineSeries()
self.chart_volume_view.chart().addSeries(self.volume_series)
self.chart_volume_view.chart().addSeries(self.volume_average_series)
self.chart_volume_view.chart().addAxis(self.volume_time_axis,
Qt.AlignBottom)
self.chart_volume_view.chart().addAxis(self.volume_axis, Qt.AlignLeft)
self.chart_volume_view.chart().legend().hide()
self.chart_volume_view.setRenderHint(QPainter.Antialiasing)
def in_datetime_range(self, q):
return self.datetime_range[0] < q < self.datetime_range[1]
def get_chart_view(self):
return self.chart_volume_view
def clear_series_data(self):
self.volume_series.clear()
self.volume_average_series.clear()
def set_volume_average(self, vol):
self.volume_average_series.append(self.datetime_range[0], vol)
self.volume_average_series.append(self.datetime_range[1], vol)
def set_datetime(self, d):
self.chart_datetime = d
self.datetime_range = (d.timestamp() * 1000,
d.replace(hour=23, minute=59).timestamp() *
1000)
start_time = QDateTime()
until_time = QDateTime()
start_time.setDate(QDate(d.year, d.month, d.day))
until_time.setDate(QDate(d.year, d.month, d.day))
start_time.setTime(QTime(9, 0))
until_time.setTime(QTime(16, 0))
self.volume_time_axis.setRange(start_time, until_time)
def add_volume_data(self, q, volume):
if self.in_datetime_range(q):
self.volume_series.append(QCandlestickSet(0, volume, 0, volume, q))
def attach(self):
self.volume_time_axis.setTickCount(7)
self.volume_average_series.attachAxis(self.volume_axis)
self.volume_average_series.attachAxis(self.volume_time_axis)
self.volume_series.attachAxis(self.volume_axis)
self.volume_series.attachAxis(self.volume_time_axis)
def set_max(self, vol):
self.volume_axis.setRange(0, vol)
class Example(QMainWindow):
def __init__(self, ):
super().__init__()
self.bijiao = [0, 0, 0]
self.res = ""
self.queue = []
self.k = -1
self.flag = -1
try:
self.initUI()
self.chart_init(10)
except:
traceback.print_exc()
def initUI(self):
icon = QtGui.QIcon()
icon.addPixmap(
QtGui.QPixmap("D:\\Sysytem\\Desktop\\zhong\\data\\ico.ico"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.setWindowIcon(icon)
self.resize(1000, 700)
self.setWindowTitle('Icon')
self.setObjectName("清华大学得不到的学生")
self.setWindowTitle("一枚小乖乖~")
self.label = QLabel(self)
self.label.setWindowTitle("清华大学得不到的学生")
self.setWindowFlags(Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.label.setGeometry(QtCore.QRect(15, 15, 970, self.height() - 30))
self.label.setText("")
palette = QtGui.QPalette()
self.label.setStyleSheet("background-color: #fff;border-radius: 15px;")
self.labelshadow = QGraphicsDropShadowEffect(self)
self.labelshadow.setBlurRadius(15)
self.labelshadow.setOffset(1, 1)
self.label.setGraphicsEffect(self.labelshadow)
self.label.setScaledContents(True)
self.label.setObjectName("label")
self.pushButton_12 = QtWidgets.QPushButton(self)
self.pushButton_12.setGeometry(
QtCore.QRect(self.width() - 55, 29, 20, 20))
self.pushButton_12.setStyleSheet(
"QPushButton{\n"
" background:#fc625d;\n"
" color:white;\n"
" box-shadow: 1px 1px 3px rgba(0,0,0,0.3);font-size:20px;border-radius: 10px;font-family: 微软雅黑;\n"
"}\n"
"QPushButton:hover{ \n"
" background:#FF2D2D;\n"
"}\n"
"QPushButton:pressed{\n"
" border: 1px solid #3C3C3C!important;\n"
" background:#AE0000;\n"
"}")
self.pushButton_12.clicked.connect(self.close)
self.pushButton_14 = QtWidgets.QPushButton(self)
self.pushButton_14.setGeometry(
QtCore.QRect(self.width() - 55 - 35, 29, 20, 20))
self.pushButton_14.setStyleSheet(
"QPushButton{\n"
" background:#35cd4b;\n"
" color:white;\n"
" box-shadow: 1px 1px 3px rgba(0,0,0,0.3);font-size:20px;border-radius: 10px;font-family: 微软雅黑;\n"
"}\n"
"QPushButton:hover{ \n"
" background:#00CC00;\n"
"}\n"
"QPushButton:pressed{\n"
" border: 1px solid #3C3C3C!important;\n"
" background:#009900;\n"
"}")
self.pushButton_14.clicked.connect(self.showMinimized)
self.color = ["#e89291", "#c4b98b", "#81a8e1", "#8cc9c4", "#83bde2"]
# -----------------------------------------------------------------测试数量------------------------
error = QtWidgets.QLineEdit(self)
error.setGeometry(QtCore.QRect(70, 70, 150, 50))
error.setStyleSheet(
"text-align: center;background-color: " + self.color[0] +
";border-radius: 7px;border: 0px solid #000;color:#ffffff;font-size:20px;font-family: 微软雅黑;"
)
errorshadow = QGraphicsDropShadowEffect(self)
error.setPlaceholderText("测试数量")
errorshadow.setBlurRadius(30)
cl = QColor("#cacaca")
errorshadow.setColor(cl)
error.setAlignment(Qt.AlignCenter)
errorshadow.setOffset(0, 0)
error.textChanged.connect(self.set_suliang)
# error.setGraphicsEffect(errorshadow)
# -----------------------------------------------------------------随机范围------------------------
fan = QtWidgets.QLineEdit(self)
fan.setGeometry(QtCore.QRect(240, 70, 150, 50))
fan.setStyleSheet(
"text-align: center;background-color: " + self.color[2] +
";border-radius: 7px;border: 0px solid #000;color:#ffffff;font-size:20px;font-family: 微软雅黑;"
)
fanshadow = QGraphicsDropShadowEffect(self)
fanshadow.setBlurRadius(30)
fancl = QColor("#cacaca")
fan.setPlaceholderText("随机范围")
fanshadow.setColor(fancl)
fan.setAlignment(Qt.AlignCenter)
fanshadow.setOffset(0, 0)
fan.textChanged.connect(self.set_fanwei)
# fan.setGraphicsEffect(fanshadow)
# -----------------------------------------------------------------内存块数-----------------------
kuai = QtWidgets.QLineEdit(self)
kuai.setGeometry(QtCore.QRect(410, 70, 150, 50))
kuai.setStyleSheet(
"text-align: center;background-color: " + self.color[3] +
";border-radius: 7px;border: 0px solid #000;color:#ffffff;font-size:20px;font-family: 微软雅黑;"
)
kuaishadow = QGraphicsDropShadowEffect(self)
kuaishadow.setBlurRadius(30)
kuaicl = QColor("#cacaca")
kuai.setPlaceholderText("内存块数")
kuaishadow.setColor(kuaicl)
kuai.setAlignment(Qt.AlignCenter)
kuaishadow.setOffset(0, 0)
kuai.textChanged.connect(self.set_kuai)
# kuai.setGraphicsEffect(kuaishadow)
self.Button = QtWidgets.QPushButton(self)
self.Button.setGeometry(QtCore.QRect(580, 70, 150, 50))
self.Button.setStyleSheet(
"QPushButton{text-align: center;background-color: #83bde2;"
"border-radius: 7px;border: 0px solid #000;color:#ffffff;"
"font-size:20px;font-family: 微软雅黑;}" + "QPushButton:hover{ " +
" background-color: #9ad0d0;color: white;" + "}")
Buttonshadow = QGraphicsDropShadowEffect(self)
Buttonshadow.setBlurRadius(30)
Buttoncl = QColor("#cacaca")
self.Button.setText("执行")
Buttonshadow.setColor(Buttoncl)
Buttonshadow.setOffset(0, 0)
# Button.setGraphicsEffect(Buttonshadow)
self.Button.clicked.connect(self.on_click_start)
self.avgflag = 0
self.qq = QtWidgets.QPushButton(self)
self.qq.setGeometry(QtCore.QRect(750, 70, 180, 50))
self.qq.setStyleSheet(
"color: #000;text-align: center;background-color: #f0f0f0;border-radius: 7px;border: 0px solid #000;font-size:14px;font-family: 微软雅黑;"
)
self.qq.clicked.connect(self.on_avg)
self.show()
def on_avg(self):
if self.avgflag == 0:
self.series.hide()
self.serieslru.hide()
self.seriesopt.hide()
self.seriesfifoavg.show()
self.serieslruavg.show()
self.seriesoptavg.show()
self.avgflag = 1
else:
self.series.show()
self.serieslru.show()
self.seriesopt.show()
self.seriesfifoavg.hide()
self.serieslruavg.hide()
self.seriesoptavg.hide()
self.avgflag = 0
def set_kuai(self, text):
self.kuai = text
def set_fanwei(self, text):
self.fan = text
def set_suliang(self, text):
self.su = text
def hideerror(self):
self.error.hide()
def set_kuaishu(self, text):
self.kuaishu = text
def set_yemian(self, text):
self.yemian = text
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
def mousePressEvent(self, e):
if e.button() == Qt.LeftButton:
self.m_drag = True
self.m_DragPosition = e.globalPos() - self.pos()
e.accept()
def mouseReleaseEvent(self, e):
if e.button() == Qt.LeftButton:
self.m_drag = False
def mouseMoveEvent(self, e):
try:
if Qt.LeftButton and self.m_drag:
self.move(e.globalPos() - self.m_DragPosition)
e.accept()
except:
print("错误代码:000x0")
def on_click_start(self):
try:
self.jishu = 0
self.thread = MyThread()
self.thread.set_su(self.su)
self.thread.set_kuai(self.kuai)
self.thread.set_x(self.dtaxisX)
self.thread.set_fan(self.fan)
self.thread.det_bijiao(self.bijiao)
self.dailist = []
self.avg = []
self.avg1 = []
self.avg2 = []
self.dailistlru = []
self.dailistopt = []
self.thread.sinOut.connect(self.change)
self.thread.start()
# self.qq.setText("FIFO:%0.2f LRU:%0.2f \n OPT:%0.2f" % (self.bijiao[0], self.bijiao[1], self.bijiao[2]))
except:
traceback.print_exc()
# self.sinOut.emit(self.dailist)
# self.sinOut2.emit(self.dailistlru)
# self.sinOut3.emit(self.dailistopt)
def change(self, dailist):
try:
# print(dailist)
# arr = str.split(dailist)
# print(arr)
flag = 0
start = 0
flag = dailist.find(" ", flag)
flag = dailist.find(" ", flag + 1)
end = flag
arr = str.split(dailist[start:end])
start = flag
flag = dailist.find(" ", flag + 1)
flag = dailist.find(" ", flag + 1)
end = flag
arr1 = str.split(dailist[start:end])
start = flag
flag = dailist.find(" ", flag + 1)
flag = dailist.find(" ", flag + 1)
end = flag
arr2 = str.split(dailist[start:end])
self.dailist.append(QPointF(float(arr[0]), float(arr[1])))
self.dailistlru.append(QPointF(float(arr1[0]), float(arr1[1])))
self.dailistopt.append(QPointF(float(arr2[0]), float(arr2[1])))
#
self.series.replace(self.dailist)
self.serieslru.replace(self.dailistlru)
self.seriesopt.replace(self.dailistopt)
if self.jishu == 0:
self.bijiao[0] = float(arr[1])
self.bijiao[1] = float(arr1[1])
self.bijiao[2] = float(arr2[1])
self.jishu = 1
else:
self.bijiao[0] = (float(arr[1]) + self.bijiao[0]) / 2.0
self.bijiao[1] = (float(arr1[1]) + self.bijiao[1]) / 2.0
self.bijiao[2] = (float(arr2[1]) + self.bijiao[2]) / 2.0
self.jishu = self.jishu + 1
self.avg.append(QPointF(float(arr[0]), self.bijiao[0]))
self.avg1.append(QPointF(float(arr[0]), self.bijiao[1]))
self.avg2.append(QPointF(float(arr[0]), self.bijiao[2]))
# print(self.avg)
self.seriesfifoavg.replace(self.avg)
self.serieslruavg.replace(self.avg1)
self.seriesoptavg.replace(self.avg2)
self.qq.setText("FIFO:%0.2f LRU:%0.2f \n OPT:%0.2f" %
(self.bijiao[0], self.bijiao[1], self.bijiao[2]))
except:
traceback.print_exc()
def drawLine(self):
self.series.replace(self.dailist)
# print("uiy")
def chart_init(self, su):
self.start_num = 0
self.chart = QChartView(self)
self.chart.setGeometry(50, 150,
self.width() - 100,
self.height() - 150 - 50) # 设置charView位置、大小
self.series = QSplineSeries()
self.series.setName("FIFO")
self.chart.chart().addSeries(self.series)
pen = QPen(Qt.gray)
pen.setWidth(2)
self.serieslru = QSplineSeries()
self.serieslru.setPen(pen)
self.serieslru.setName("LRU")
self.serieslru.setColor(QColor("#e89291"))
self.chart.chart().addSeries(self.serieslru)
pen2 = QPen(Qt.gray)
pen2.setWidth(2)
self.seriesopt = QSplineSeries()
self.seriesopt.setPen(pen2)
self.seriesopt.setColor(QColor("#3ea54f"))
self.seriesopt.setName("OPT")
self.chart.chart().addSeries(self.seriesopt)
penfifo = QPen(Qt.gray)
penfifo.setWidth(2)
self.seriesfifoavg = QSplineSeries()
self.seriesfifoavg.setPen(penfifo)
self.seriesfifoavg.setName("FIFO-avg")
self.seriesfifoavg.setColor(QColor("#209fdf"))
self.chart.chart().addSeries(self.seriesfifoavg)
self.seriesfifoavg.hide()
penavg = QPen(Qt.gray)
penavg.setWidth(2)
self.serieslruavg = QSplineSeries()
self.serieslruavg.setPen(penavg)
self.serieslruavg.setName("LRU-avg")
self.serieslruavg.setColor(QColor("#e89291"))
self.chart.chart().addSeries(self.serieslruavg)
self.serieslruavg.hide()
pen2avg = QPen(Qt.gray)
pen2avg.setWidth(2)
self.seriesoptavg = QSplineSeries()
self.seriesoptavg.setPen(pen2avg)
self.seriesoptavg.setColor(QColor("#3ea54f"))
self.seriesoptavg.setName("OPT-avg")
self.chart.chart().addSeries(self.seriesoptavg)
self.seriesoptavg.hide()
self.dtaxisX = QValueAxis()
self.vlaxisY = QValueAxis()
self.dtaxisX.setMin(10)
self.dtaxisX.setMax(100)
self.vlaxisY.setMin(0)
self.vlaxisY.setMax(100)
self.dtaxisX.setTickCount(6)
self.vlaxisY.setTickCount(11)
self.dtaxisX.setTitleText("页数")
self.vlaxisY.setTitleText("缺页率")
self.vlaxisY.setGridLineVisible(False)
self.chart.chart().addAxis(self.dtaxisX, Qt.AlignBottom)
self.chart.chart().addAxis(self.vlaxisY, Qt.AlignLeft)
self.series.attachAxis(self.dtaxisX)
self.series.attachAxis(self.vlaxisY)
self.serieslru.attachAxis(self.dtaxisX)
self.serieslru.attachAxis(self.vlaxisY)
self.seriesopt.attachAxis(self.dtaxisX)
self.seriesopt.attachAxis(self.vlaxisY)
self.seriesoptavg.attachAxis(self.dtaxisX)
self.seriesoptavg.attachAxis(self.vlaxisY)
self.serieslruavg.attachAxis(self.dtaxisX)
self.serieslruavg.attachAxis(self.vlaxisY)
self.seriesfifoavg.attachAxis(self.dtaxisX)
self.seriesfifoavg.attachAxis(self.vlaxisY)
self.chart.chart().setTitleBrush(QBrush(Qt.cyan))
cc = QColor("#f0f0f0")
self.chart.setBackgroundBrush(cc)
self.chart.setStyleSheet(
"QChartView{ background-color: #83bde2;border-radius: 20px;}")
self.chart.show()
class My_Main_window(Ui_MainWindow, QWidget
): # 这里继承 QWidget 是因为 QFileDialog 必须要有 QWidget 才能运行，没有会出错
def setupBusi(self, MainWindow):
# # 设置布局
# self.verticalLayout.addWidget(self.label)
# self.verticalLayout.addWidget(self.pushButton)
# 设置连接事件
self.pushButton.clicked.connect(self.plot_)
self.pushButton_2.clicked.connect(self.pixSave)
self.chart = QChart()
self.view = QChartView(self.chart)
self.series = QLineSeries(self.chart) # 在QChart上实例化曲线
self.verticalLayout.addWidget(self.view)
self.view.show()
def plot_(self):
# 设置图片背景颜色，默认是白色背景；比如，还可以设置为：QChart.ChartThemeDark，QChart.ChartThemeLight，QChart.ChartThemeBlueCerulean
# QChart.ChartThemeBrownSand，QChart.ChartThemeBlueNcs，QChart.ChartThemeHighContrast，QChart.ChartThemeBlueIcy等
self.view.chart().setTheme(QChart.ChartThemeBlueCerulean)
self.chart.setTitle("曲线图") # 设置图题
self.chart.setTitleFont(QFont('SansSerif', 20)) # 设置图题字体的类型和大小
# self.view.chart().legend().hide() # 隐藏图例
self.chart.removeSeries(self.series) # 清除QChart上的指定曲线
self.series.append(0, 6)
self.series.append(1, 7)
self.series.append(2, 4)
self.series.setName('单井生产数据') # 设置每条数据曲线的名称
self.view.chart().legend().setFont(QFont("Arial",
17)) # 设置数据曲线名称的字体类型和大小
self.chart.addSeries(self.series)
self.chart.createDefaultAxes() # 创建默认轴
self.chart.axisX().setTitleText('时间') # 设置横坐标标题
self.chart.axisX().setLabelsFont(QFont('SansSerif',
13)) # 设置横坐标刻度的字体类型和大小
self.chart.axisX().setTitleFont(QFont('SansSerif',
15)) # 设置横坐标标题字体的类型和大小
self.chart.axisY().setTitleText('产量') # 设置横坐标标题
self.chart.axisY().setLabelsFont(QFont('SansSerif',
13)) # 设置横坐标刻度的字体类型和大小
self.chart.axisY().setTitleFont(QFont('SansSerif',
15)) # 设置横坐标标题字体的类型和大小
# self.series.remove(0) # 清除数据，但坐标框架等还在。
# self.series.clear() # 清除数据，但坐标框架等还在。
self.view.setRenderHint(QPainter.Antialiasing) # 抗锯齿
# self.view.show()
def pixSave(self):
# 用 QFileDialog 获取保存文件的全部路径（包括文件名和后缀名）
fileName2, ok2 = QFileDialog.getSaveFileName(self, "文件保存", "/",
"图片文件 (*.png);;(*.jpeg)")
"""
下面用 Pyqt5 的截屏方法，截取指定 QChartView 上显示的东西；缺点，若显示的图像变形，
则截图也会变形！
"""
screen = QApplication.primaryScreen()
pix = screen.grabWindow(self.view.winId())
pix.save(fileName2)
class graficoBarras(QWidget):
def __init__(self, parent=None):
super(graficoBarras, self).__init__(parent)
self.initUI()
def initUI(self):
comboBoxColor = QComboBox()
comboBoxColor.addItems([
"Color del fondo del CharView", "Color del fondo del Chart",
"Color del título del Chart", "Color de las etiquetas del eje X",
"Color de las etiquetas del eje Y",
"Color de las etiquetas de la leyenda"
])
checkBoxVisibilidadFondoChart = QCheckBox("Visibilidad fondo (chart)")
checkBoxMargenesChart = QCheckBox("Margenes del chart")
checkBoxEsquinasChart = QCheckBox("Esquinas del chart")
buttonGuardar = QPushButton("Guardar gráfico")
# Crear gráficos.
self.vistaGrafico = QChartView(self.crearGraficoBarras())
self.vistaGrafico.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.vistaGrafico.setRenderHint(QPainter.Antialiasing, True)
# ========================== DISEÑO ==========================
disenioConfiguracion = QVBoxLayout()
disenioConfiguracion.addWidget(QLabel("Cambiar colores:"))
disenioConfiguracion.addWidget(comboBoxColor)
disenioConfiguracion.addWidget(checkBoxVisibilidadFondoChart)
disenioConfiguracion.addWidget(checkBoxMargenesChart)
disenioConfiguracion.addWidget(checkBoxEsquinasChart)
disenioConfiguracion.setSpacing(4)
disenioConfiguracion.addStretch()
disenioConfiguracion.addWidget(buttonGuardar)
baseDisenio = QGridLayout()
baseDisenio.addLayout(disenioConfiguracion, 0, 0, 0, 1)
baseDisenio.addWidget(self.vistaGrafico, 0, 1, 0, 4)
baseDisenio.setSpacing(10)
baseDisenio.setContentsMargins(10, 10, 10, 10)
self.setLayout(baseDisenio)
# ===================== CONECTAR SEÑALES =====================
comboBoxColor.activated.connect(self.Color)
checkBoxVisibilidadFondoChart.toggled.connect(
self.visibilidadFondoChart)
checkBoxMargenesChart.toggled.connect(self.margenesChart)
checkBoxEsquinasChart.toggled.connect(self.esquinasChart)
buttonGuardar.clicked.connect(self.Guardar)
# Establecer los valores predeterminados
comboBoxColor.setCurrentIndex(-1)
checkBoxVisibilidadFondoChart.setChecked(True)
checkBoxMargenesChart.setChecked(True)
checkBoxEsquinasChart.setChecked(True)
# ========================== FUNCIONES ===========================
def crearGraficoBarras(self):
paises = [
"EEUU", "China", "Japon", "Alemania", "Reino Unido",
"Resto del mundo"
]
valores = [24.32, 14.85, 8.91, 12.54, 7.85, 31.53]
colores = [
Qt.blue, Qt.red, Qt.darkYellow, Qt.gray, Qt.black, Qt.darkCyan
]
grafico = QChart()
grafico.setMargins(QMargins(30, 30, 30, 30))
grafico.setTheme(QChart.ChartThemeLight)
grafico.setTitle("% Distribución del PIB global")
grafico.setAnimationOptions(QChart.SeriesAnimations)
for i in range(len(paises)):
series = QBarSeries()
barSet = QBarSet(paises[i])
barSet.setColor(colores[i])
barSet.setLabelColor(Qt.yellow)
barSet.append(valores[i])
series.append(barSet)
series.setLabelsVisible(True)
series.setLabelsAngle(-90)
# series.setLabelsPrecision(2)
series.setLabelsFormat("@value %")
series.setLabelsPosition(QAbstractBarSeries.LabelsCenter)
grafico.addSeries(series)
axisX = QBarCategoryAxis()
axisX.append(paises)
axisY = QValueAxis()
axisY.setRange(0, 31.53)
axisY.setTickCount(10)
axisY.setLabelFormat("%.2f %")
grafico.createDefaultAxes()
grafico.setAxisX(axisX, None)
grafico.setAxisY(axisY, None)
grafico.legend().setVisible(True)
grafico.legend().setAlignment(Qt.AlignBottom)
return grafico
def Color(self, item):
if item == 0:
color = (self.vistaGrafico.backgroundBrush().color()
if self.vistaGrafico.backgroundBrush().color().isValid()
else QColor(Qt.white))
elif item == 1:
color = (
self.vistaGrafico.chart().backgroundBrush().color() if
self.vistaGrafico.chart().backgroundBrush().color().isValid()
else QColor(Qt.white))
elif item == 2:
color = (self.vistaGrafico.chart().titleBrush().color() if
self.vistaGrafico.chart().titleBrush().color().isValid()
else QColor(Qt.black))
elif item == 3:
color = (self.vistaGrafico.chart().axisX().labelsBrush().color()
if self.vistaGrafico.chart().axisX().labelsBrush().color(
).isValid() else QColor(Qt.black))
elif item == 4:
color = (self.vistaGrafico.chart().axisY().labelsBrush().color()
if self.vistaGrafico.chart().axisY().labelsBrush().color(
).isValid() else QColor(Qt.black))
elif item == 5:
color = (self.vistaGrafico.chart().legend().labelColor() if
self.vistaGrafico.chart().legend().labelColor().isValid()
else QColor(Qt.black))
color = QColorDialog.getColor(color, self)
if color.isValid():
if item == 0:
self.vistaGrafico.setBackgroundBrush(color)
elif item == 1:
self.vistaGrafico.chart().setBackgroundBrush(color)
elif item == 2:
self.vistaGrafico.chart().setTitleBrush(color)
elif item == 3:
self.vistaGrafico.chart().axisX().setLabelsBrush(color)
elif item == 4:
self.vistaGrafico.chart().axisY().setLabelsBrush(color)
elif item == 5:
self.vistaGrafico.chart().legend().setLabelColor(color)
def visibilidadFondoChart(self, bool):
self.vistaGrafico.chart().setBackgroundVisible(bool)
def margenesChart(self, bool):
if bool:
self.vistaGrafico.chart().layout().setContentsMargins(9, 9, 9, 9)
else:
self.vistaGrafico.chart().layout().setContentsMargins(0, 0, 0, 0)
def esquinasChart(self, bool):
if bool:
self.vistaGrafico.chart().setBackgroundRoundness(5)
else:
self.vistaGrafico.chart().setBackgroundRoundness(0)
def Guardar(self):
nombre, extension = QFileDialog.getSaveFileName(
self,
"Guardar como",
"Gráfico de barras",
"JPG (*.jpg);;PNG (*.png)",
options=QFileDialog.Options())
if nombre:
guardar = QPixmap(self.vistaGrafico.grab())
guardar.save(nombre, quality=100)
if guardar:
QMessageBox.information(self, "Guardar gráfico",
"Gráfico guardado con éxito.",
QMessageBox.Ok)
else:
QMessageBox.critical(self, "Guardar gráfico",
"Error al guardar el gráfico.",
QMessageBox.Ok)
class anaxcelhandler(QtWidgets.QMainWindow, anaxcelgui.Ui_MainWindow):
def __init__(self, parent=None):
super(anaxcelhandler, self).__init__(parent)
if getattr(sys, 'frozen', False):
self.frozen = 'ever so'
self.bundle_dir = sys._MEIPASS
else:
self.bundle_dir = os.path.dirname(os.path.abspath(__file__))
self.setupUi(self)
self.setWindowIcon(QtGui.QIcon(self.bundle_dir + '/icons/icon.png'))
self.setStyleSheet(open("Dark/darkstyle.qss", "r").read())
self.listWidget.setSelectionMode(
QtWidgets.QAbstractItemView.ExtendedSelection)
self.pushButtonbrowse.clicked.connect(self.openFileNamesDialog)
self.pushButtonclear.clicked.connect(self.clearwidget)
self.pushButtonselall.clicked.connect(self.selectall)
self.pushButtonload.clicked.connect(self.LoadProcess)
self.statusbar.showMessage('V 0.1')
self.actionExit.setShortcut('Ctrl+Q')
self.actionExit.triggered.connect(self.close_application)
self.actionExit.setStatusTip('Exit ')
self.pixmaplab = QPixmap('icons/excel48.png')
self.labelicon.setPixmap(self.pixmaplab)
self.labelicon.show()
self.label.setText("Loaded Excel File")
self.comboBoxfiletype.addItems(['xls', ' xlsx'])
self.pushButton_5.clicked.connect(self.analyseProcess)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
layoutx = QVBoxLayout()
layoutx.addWidget(self.toolbar)
layoutx.addWidget(self.canvas)
self.tab_6.setLayout(layoutx)
self.layoutdout = QGridLayout()
self.tab_4.setLayout(self.layoutdout)
self.chartView3 = QChartView()
self.layoutdout.addWidget(self.chartView3)
self.actionAdd_File.setShortcut('Ctrl+A')
self.actionAdd_File.triggered.connect(self.openFileNamesDialog)
self.actionAdd_File.setStatusTip('Add File ')
self.actionClear.setShortcut('Ctrl+C')
self.actionClear.triggered.connect(self.clearwidget)
self.actionClear.setStatusTip('Clear ')
self.actionSelect_All.setShortcut('Ctrl+S')
self.actionSelect_All.triggered.connect(self.selectall)
self.actionSelect_All.setStatusTip('Sellect All ')
self.actionLoad.setShortcut('Ctrl+L')
self.actionLoad.triggered.connect(self.LoadProcess)
self.actionLoad.setStatusTip('Load ')
self.actionAbout.setShortcut('Ctrl+I')
self.actionAbout.triggered.connect(self.showAbout)
self.actionAbout.setStatusTip('About ')
def showAbout(self):
self.window = aboutmain.abouthandel()
self.window.show()
def close_application(self):
choice = QtWidgets.QMessageBox.question(
self, ' Confirm Exit ', "Are You Sure You want To Close Anaxcel ?",
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if choice == QtWidgets.QMessageBox.Yes:
self.saveSettingstofilepackage()
sys.exit()
else:
pass
def openFileNamesDialog(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
filterxls = "XLS (*.xls *.XLS)"
filterxlsx = "XLSX (*.xlsx *.XLSX)"
if self.comboBoxfiletype.currentIndex() == 0:
files, _ = QFileDialog.getOpenFileNames(self,
"Select XLS Files",
filter=filterxls,
options=options)
if files:
for file in files:
self.listWidget.addItem(file)
elif self.comboBoxfiletype.currentIndex() == 1:
files, _ = QFileDialog.getOpenFileNames(self,
"Select XLSX Files",
filter=filterxlsx,
options=options)
if files:
for file in files:
self.listWidget.addItem(file)
def clearwidget(self):
self.listWidget.clear()
self.tableWidget.clear()
self.label.setText("Loaded Excel File")
def selectall(self):
self.listWidget.selectAll()
# def CsvProcess(self):
# # merge csv files
# fout = open("combined.csv", "a")
# items = self.listWidget.selectedItems()
# xlsfiles = []
# for i in list(items):
# xlsfiles.append(str(i.text()))
# for line in open(xlsfiles[0]):
# fout.write(line)
# for index in xlsfiles[1:]:
# print(index)
# # now the rest:
# f = open(index)
# f.__next__() # skip the header
# for line in f:
# fout.write(line)
# f.close() # not really needed
# fout.close()
# f = open("folder/02-08-2017.CSV")
# for line in f:
# for x in line:
# if x == ';'
# line.split(';')
# print(line)
#
# f.close() # not really needed
def xlsProcess(self):
self.tableWidget.clear()
items = self.listWidget.selectedItems()
xlsfiles = []
for i in list(items):
xlsfiles.append(i.text())
wkbk = xlwt.Workbook()
outsheet = wkbk.add_sheet('Sheet1')
outrow_idx = 0
for f in xlsfiles:
insheet = xlrd.open_workbook(f).sheets()[0]
for row_idx in range(insheet.nrows):
for col_idx in range(insheet.ncols):
outsheet.write(outrow_idx, col_idx,
insheet.cell_value(row_idx, col_idx))
outrow_idx += 1
wkbk.save(r'combined.xls')
# use on_demand=True to avoid loading worksheet data into memory
book = xlrd.open_workbook("combined.xls", on_demand=True)
sheet = book.sheet_by_index(0)
num_rows = sheet.nrows
num_col = sheet.ncols
self.tableWidget.setRowCount(num_rows)
self.tableWidget.setColumnCount(num_col)
for col in range(num_col):
for row in range(num_rows):
cell = sheet.cell(row, col)
if (not cell.value == "") and (not cell.value == " "):
self.tableWidget.setItem(row, col,
QTableWidgetItem(str(cell.value)))
self.tableWidget.resizeColumnsToContents()
self.tableWidget.resizeRowsToContents()
def xlsxprocess(self):
self.tableWidget.clear()
items = self.listWidget.selectedItems()
xlsfiles = []
xlsoutput = []
c = 0
for i in list(items):
xlsfiles.append(str(i.text()))
for xlsx_item in xlsfiles:
wb = openpyxl.load_workbook(xlsx_item)
pathname = "file" + str(c) + ".xls"
wb.save(pathname)
c += 1
xlsoutput.append(str(pathname))
wkbk = xlwt.Workbook()
outsheet = wkbk.add_sheet('Sheet1')
outrow_idx = 0
for f in xlsoutput:
print(f)
insheet = xlrd.open_workbook(f).sheets()[0]
for row_idx in range(insheet.nrows):
for col_idx in range(insheet.ncols):
outsheet.write(outrow_idx, col_idx,
insheet.cell_value(row_idx, col_idx))
outrow_idx += 1
wkbk.save(r'combined.xls')
df = pd.read_excel('combined.xls',
header=0) # read file and set header row
self.tableWidget.setColumnCount(len(df.columns))
self.tableWidget.setRowCount(len(df.index))
for i in range(len(df.index)):
for j in range(len(df.columns)):
self.tableWidget.setItem(i, j,
QTableWidgetItem(str(df.iat[i, j])))
self.tableWidget.resizeColumnsToContents()
self.tableWidget.resizeRowsToContents()
def LoadProcess(self):
if self.comboBoxfiletype.currentIndex() == 0: # xls
self.xlsProcess()
for colindex in range(self.tableWidget.columnCount()):
self.comboBoxabsc.addItem(str(colindex))
self.comboBoxordo.addItem(str(colindex))
elif self.comboBoxfiletype.currentIndex() == 1: # xlsx
self.xlsxprocess()
for colindex in range(self.tableWidget.columnCount()):
self.comboBoxabsc.addItem(str(colindex))
self.comboBoxordo.addItem(str(colindex))
def analyseProcess(self):
absc = []
ordo = []
absc.clear()
ordo.clear()
for tabrow in range(self.tableWidget.rowCount()):
abscitem = self.tableWidget.item(tabrow,
self.comboBoxabsc.currentIndex())
ordoitem = self.tableWidget.item(tabrow,
self.comboBoxordo.currentIndex())
absc.append(int(abscitem.text()))
ordo.append(str(ordoitem.text()))
df = pd.DataFrame({'data': absc})
df.index = ordo
df = df.sort_values(by='data', ascending=False)
df["cumpercentage"] = df["data"].cumsum() / df["data"].sum() * 100
self.figure.clear()
plt.ion()
ax = self.figure.add_subplot()
ax.bar(df.index, df["data"], color="C0")
ax2 = ax.twinx()
ax2.plot(df.index, df["cumpercentage"], color="C1", marker="D", ms=7)
ax2.yaxis.set_major_formatter(PercentFormatter())
ax.tick_params(axis="y", colors="C0")
ax2.tick_params(axis="y", colors="C1")
self.canvas.draw()
# donutchart***********************************
self.m_donuts = []
self.chartView3.setRenderHint(QPainter.Antialiasing)
self.chart3 = self.chartView3.chart()
self.chart3.legend().setVisible(True)
self.chart3.setTitle("Nested donuts Chart")
self.chart3.setAnimationOptions(QChart.AllAnimations)
minSize3 = 0.1
maxSize3 = 0.9
donutCount3 = 5
for i in range(donutCount3):
donut = QPieSeries()
sliceCount = random.randrange(3, 6)
# print(sliceCount)
for j in range(sliceCount):
value3 = random.randrange(0, 50)
slice_ = QPieSlice(str(value3), value3)
slice_.setLabelVisible(True)
slice_.setLabelColor(Qt.white)
slice_.setLabelPosition(QPieSlice.LabelInsideTangential)
slice_.hovered[bool].connect(
functools.partial(self.explodeSlice, slice_=slice_))
donut.append(slice_)
donut.setHoleSize(minSize3 + i *
(maxSize3 - minSize3) / donutCount3)
donut.setPieSize(minSize3 + (i + 1) *
(maxSize3 - minSize3) / donutCount3)
self.m_donuts.append(donut)
self.chartView3.chart().addSeries(donut)
self.updateTimer = QTimer(self)
self.updateTimer.timeout.connect(self.updateRotation)
self.updateTimer.start(1250)
self.tabWidget.setCurrentIndex(2)
def updateRotation(self):
for donut in self.m_donuts:
phaseShift = random.randrange(-50, 100)
donut.setPieStartAngle(donut.pieStartAngle() + phaseShift)
donut.setPieEndAngle(donut.pieEndAngle() + phaseShift)
def explodeSlice(self, exploded, slice_):
if exploded:
self.updateTimer.stop()
sliceStartAngle = slice_.startAngle()
sliceEndAngle = slice_.startAngle() + slice_.angleSpan()
donut = slice_.series()
seriesIndex = self.m_donuts.index(donut)
for i in range(seriesIndex + 1, len(self.m_donuts)):
self.m_donuts[i].setPieStartAngle(sliceEndAngle)
self.m_donuts[i].setPieEndAngle(360 + sliceStartAngle)
else:
for donut in self.m_donuts:
donut.setPieStartAngle(0)
donut.setPieEndAngle(360)
self.updateTimer.start()
slice_.setExploded(exploded)
class Ui_SmainWindow(object):
def setupUi(self, SmainWindow):
width = QDesktopWidget().screenGeometry().width()
height = QDesktopWidget().screenGeometry().height()
'''screen_resolution = app.desktop().screenGeometry()
width, height = screen_resolution.width(), screen_resolution.height()'''
SmainWindow.setObjectName("SmainWindow")
SmainWindow.resize((3400/3840)*width,(1700/2160)*height)
SmainWindow.setMaximumSize(QtCore.QSize((3400/3840)*width,(1700/2160)*height))
SmainWindow.setMinimumSize(QtCore.QSize((3400/3840)*width,(1700/2160)*height))
self.centralwidget = QtWidgets.QWidget(SmainWindow)
self.centralwidget.setObjectName("centralwidget")
self.line = QtWidgets.QFrame(self.centralwidget)
self.line.setGeometry(QtCore.QRect((20/3840)*width, (1070/2160)*height ,(3300/3840)*width, (30/2160)*height))
self.line.setFrameShape(QtWidgets.QFrame.HLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setLineWidth(5)
self.line.setObjectName("line")
self.line2 = QtWidgets.QFrame(self.centralwidget)
self.line2.setGeometry(QtCore.QRect((1440/3840)*width, (290/2160)*height ,(30/3840)*width, (700/2160)*height))
self.line2.setFrameShape(QtWidgets.QFrame.VLine)
self.line2.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line2.setLineWidth(5)
self.line2.setObjectName("line2")
self.line3 = QtWidgets.QFrame(self.centralwidget)
self.line3.setGeometry(QtCore.QRect((2290/3840)*width, (290/2160)*height ,(30/3840)*width, (700/2160)*height))
self.line3.setFrameShape(QtWidgets.QFrame.VLine)
self.line3.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line3.setLineWidth(5)
self.line3.setObjectName("line3")
self.layout = QVBoxLayout(self.centralwidget)
self.fig = Figure(figsize=((8/3840)*width, (6.5/2160)*height ))
self.canvas = FigureCanvas(self.fig)
self.layout.addWidget(self.canvas)
self.widget = QWidget(self.centralwidget)
#self.toolbar = NavigationToolbar(self.canvas, self.widget)
self.layout.setMenuBar(NavigationToolbar(self.canvas,self.widget))
self.widget.setLayout(self.layout)
self.widget.setGeometry((1480/3840)*width,(290/2160)*height,(800/3840)*width,(600/2160)*height)
#layout.addWidget(self.canvas)
'''
self.graphicsView = PlotWidget(self.centralwidget)
self.graphicsView.setGeometry(QtCore.QRect(700, 150, 700, 700))
self.graphicsView.setObjectName("graphicsView")
'''
self.chartView = QChartView(self.centralwidget)
self.chartView.setGeometry(QtCore.QRect((200/3840)*width, (1090/2160)*height, (1700/3840)*width, (500/2160)*height))
self.chartView.setObjectName("graphicsView")
self.browseFile = QtWidgets.QPushButton(self.centralwidget)
self.browseFile.setGeometry(QtCore.QRect((200/3840)*width, (50/2160)*height, (350/3840)*width, (50/2160)*height))
self.browseFile.setObjectName("browseFile")
self.filenameLabel = QtWidgets.QLabel(self.centralwidget)
self.filenameLabel.setGeometry(QtCore.QRect((700/3840)*width, (55/2160)*height, (350/3840)*width, (70/2160)*height))
self.filenameLabel.setObjectName("filenameLabel")
self.datasize = QtWidgets.QLabel(self.centralwidget)
self.datasize.setGeometry(QtCore.QRect((20/3840)*width, (105/2160)*height, (350/3840)*width, (70/2160)*height))
self.datasize.setObjectName("datasize")
self.datasize.setText("Data Shape :")
self.datasize.setStyleSheet(
"""QLabel {
font: bold;
font-size: 10pt;
font-family: Typograf;}""")
self.datashape = QtWidgets.QLabel(self.centralwidget)
self.datashape.setGeometry(QtCore.QRect((250/3840)*width, (105/2160)*height, (350/3840)*width, (70/2160)*height))
self.datashape.setObjectName("datashape")
self.datashape.setStyleSheet(
"""QLabel {
font: bold;
font-size: 12pt;
font-family: Typograf;}""")
self.atributelabe = QtWidgets.QLabel(self.centralwidget)
self.atributelabe.setGeometry(QtCore.QRect((295/3840)*width, (200/2160)*height, (350/3840)*width, (70/2160)*height))
self.atributelabe.setObjectName("atributelabe")
self.atributelabe.setText("Variables")
self.atributelabe.setStyleSheet(
"""QLabel {
font: bold;
font-size: 10pt;
font-family: Typograf;}""")
self.statisticlabel = QtWidgets.QLabel(self.centralwidget)
self.statisticlabel.setGeometry(QtCore.QRect((1020/3840)*width, (200/2160)*height, (350/3840)*width, (70/2160)*height))
self.statisticlabel.setObjectName("statisticlabel")
self.statisticlabel.setText("Statistics")
self.statisticlabel.setStyleSheet(
"""QLabel {
font: bold;
font-size: 10pt;
font-family: Typograf;}""")
self.textBrowser = QtWidgets.QTextBrowser(self.centralwidget)
self.textBrowser.setGeometry(QtCore.QRect((740/3840)*width, (290/2160)*height, (700/3840)*width, (700/2160)*height))
self.textBrowser.setObjectName("textBrowser")
self.textBrowser.setStyleSheet(
"""QTextBrowser {
font: bold;
font-size: 12pt;
font-family: Courier;}""")
self.missingvalulabel = QtWidgets.QLabel(self.centralwidget)
self.missingvalulabel.setGeometry(QtCore.QRect((2330/3840)*width, (500/2160)*height, (250/3840)*width, (100/2160)*height))
self.missingvalulabel.setObjectName("missingvalulabel")
self.missingvalulabel.setText("Show Missing \nValues")
self.missingvalulabel.setStyleSheet(
"""QLabel {
font: bold;
font-size: 10pt;
font-family: Courier;}""")
self.resetbtn = QtWidgets.QPushButton(self.centralwidget)
self.resetbtn.setGeometry(QtCore.QRect((2330/3840)*width, (300/2160)*height, (250/3840)*width, (50/2160)*height))
self.resetbtn.setObjectName("resetbtn")
self.resetbtn.setText("Reset")
self.resetbtn.setEnabled(False)
self.perclm = QtWidgets.QPushButton(self.centralwidget)
self.perclm.setGeometry(QtCore.QRect((2330/3840)*width, (600/2160)*height, (250/3840)*width, (50/2160)*height))
self.perclm.setObjectName("perclm")
self.perclm.setText("PerColumn")
self.perclm.setEnabled(False)
self.perrow = QtWidgets.QPushButton(self.centralwidget)
self.perrow.setGeometry(QtCore.QRect((2330/3840)*width, (670/2160)*height, (250/3840)*width, (50/2160)*height))
self.perrow.setObjectName("perrow")
self.perrow.setText("PerRow")
self.perrow.setEnabled(False)
self.datainfo = QtWidgets.QLabel(self.centralwidget)
self.datainfo.setGeometry(QtCore.QRect((2850/3840)*width, (200/2160)*height, (350/3840)*width, (70/2160)*height))
self.datainfo.setObjectName("statisticlabel")
self.datainfo.setText("Data Info")
self.datainfo.setStyleSheet(
"""QLabel {
font: bold;
font-size: 10pt;
font-family: Typograf;}""")
self.infor = QtWidgets.QTextBrowser(self.centralwidget)
self.infor.setGeometry(QtCore.QRect((2600/3840)*width, (290/2160)*height, (700/3840)*width, (700/2160)*height))
self.infor.setObjectName("infor")
self.infor.setStyleSheet(
"""QTextBrowser {
font: bold;
font-family: Courier;}""")
self.calstatistics = QtWidgets.QPushButton(self.centralwidget)
self.calstatistics.setGeometry(QtCore.QRect((200/3840)*width, (1020/2160)*height, (350/3840)*width, (50/2160)*height))
self.calstatistics.setObjectName("calstatistics")
self.listWidget = QtWidgets.QListWidget(self.centralwidget)
self.listWidget.setGeometry(QtCore.QRect((20/3840)*width, (290/2160)*height, (700/3840)*width, (700/2160)*height))
self.listWidget.setObjectName("listWidget")
self.listWidget.setAlternatingRowColors(True)
self.comboBox = QtWidgets.QComboBox(self.centralwidget)
self.comboBox.setGeometry(QtCore.QRect((1480/3840)*width,(120/2160)*height,(800/3840)*width,(50/2160)*height))
self.comboBox.setObjectName("comboBox")
self.comboBox2 = QtWidgets.QComboBox(self.centralwidget)
self.comboBox2.setGeometry(QtCore.QRect((1480/3840)*width,(200/2160)*height,(800/3840)*width,(50/2160)*height))
self.comboBox2.setObjectName("comboBox2")
self.report = QtWidgets.QPushButton(self.centralwidget)
self.report.setGeometry(QtCore.QRect((1700/3840)*width, (1020/2160)*height, (300/3840)*width, (50/2160)*height))
self.report.setObjectName("report")
self.report.setText("Generate Report")
self.back = QtWidgets.QPushButton(self.centralwidget)
self.back.setGeometry(QtCore.QRect((5/3840)*width, (1600/2160)*height, (300/3840)*width, (50/2160)*height))
self.back.setObjectName("back")
self.back.setText("Back")
self.back.setStyleSheet(
"""QPushButton {
border-radius:0;
border:0;
text-align:left;
padding-left:70px;
qproperty-icon:url('back.png');
qproperty-iconSize: 40px 40px;}""")
SmainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(SmainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, (469/3840)*width, (22/2160)*height))
self.menubar.setObjectName("menubar")
SmainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(SmainWindow)
self.statusbar.setObjectName("statusbar")
SmainWindow.setStatusBar(self.statusbar)
self.retranslateUi(SmainWindow)
QtCore.QMetaObject.connectSlotsByName(SmainWindow)
def retranslateUi(self, SmainWindow):
_translate = QtCore.QCoreApplication.translate
SmainWindow.setWindowTitle(_translate("SmainWindow", "Data Statistical Analysis"))
self.browseFile.setText(_translate("SmainWindow", "Open File"))
self.browseFile.clicked.connect(self.pushButton_handler)
self.filenameLabel.setText(_translate("SmainWindow", ""))
self.calstatistics.setText(_translate("SmainWindow", "Calculate Statistics"))
self.calstatistics.clicked.connect(self.cal)
self.listWidget.clicked.connect(self.listview_clicked)
self.resetbtn.clicked.connect(self.information)
self.perclm.clicked.connect(self.num_missing)
self.perrow.clicked.connect(self.row_missing)
self.report.clicked.connect(self.generatereport)
def pushButton_handler(self):
self.open_dialog_box()
def open_dialog_box(self):
filename = QFileDialog.getOpenFileName(None, 'Open File', r"~/Desktop", '*.csv')
path = filename[0]
with open(path, "r") as fpath:
self.infor.clear()
self.comboBox.clear()
self.comboBox2.clear()
self.datasetheaders=[]
self.filenameLabel.setText(str(path))
self.filenameLabel.adjustSize()
pandas.set_option('display.max_rows', None)
self.dataset=pandas.read_csv(fpath)
buf = io.StringIO()
self.dataset.info(verbose=True, null_counts=True,buf=buf)
s = buf.getvalue()
self.perclm.setDisabled(False)
self.perrow.setDisabled(False)
self.infor.append(s)
SIZE=self.dataset.shape
self.datashape.setText(str(SIZE))
self.create_piechart()
#headers=self.dataset.columns
self.datasetheaders=self.dataset.columns.to_numpy()
self.listWidget.clear()
for i in range(len(self.datasetheaders)-1):
self.listWidget.insertItem(i,self.datasetheaders[i])
for i in range(len(self.datasetheaders)-1):
self.comboBox.addItem(self.datasetheaders[i])
for i in range(len(self.datasetheaders)-1):
self.comboBox2.addItem(self.datasetheaders[i])
self.setup()
self.comboBox.currentIndexChanged.connect(self.setup)
self.comboBox2.currentIndexChanged.connect(self.setup)
#print(unique_headers)
'''print ("Missing values per column:")
print(self.dataset.apply(lambda x: sum(x.isnull())))
'''
def generatereport(self):
try:
profile = ProfileReport(self.dataset)
profile.to_file(output_file="AnalysisReport.html")
print("yes")
except Exception as e:
print(repr(e))
def information(self):
self.infor.clear()
self.resetbtn.setEnabled(False)
self.perrow.setDisabled(False)
self.perclm.setDisabled(False)
buf = io.StringIO()
self.dataset.info(verbose=True, null_counts=True,buf=buf)
s = buf.getvalue()
self.infor.append(s)
def row_missing(self):
self.perrow.setEnabled(False)
self.perclm.setDisabled(False)
self.resetbtn.setDisabled(False)
self.infor.clear()
#self.infor.append(str(self.dataset.apply(lambda x: sum(x.isnull()))))
self.infor.append(str(self.dataset.apply(self.missing, axis=1)))
def num_missing(self):
self.perclm.setEnabled(False)
self.perrow.setDisabled(False)
self.resetbtn.setDisabled(False)
self.infor.clear()
#self.infor.append(str(self.dataset.apply(lambda x: sum(x.isnull()))))
self.infor.append(str(self.dataset.apply(self.missing, axis=0)))
def missing(self,x):
return sum(x.isnull())
def setup(self):
try:
print("fig")
iris=self.dataset
x_index = 0
y_index = 1
w=iris.iloc[:,self.comboBox.currentIndex()]
z=iris.iloc[:,self.comboBox2.currentIndex()]
y=iris.iloc[:,-1].values
# this formatter will label the colorbar with the correct target names
#formatter = plt.FuncFormatter(y)
#plt.figure(figsize=(5, 4))
ax = self.fig.add_subplot(111)
ax.clear()
scatter=ax.scatter(w, z, c=y)
#self.figure.colorbar(ticks=y)
#ax.xlabel("iris.feature_names[x_index]")
#ax.ylabel("iris.feature_names[y_index]")
ax.set_xlabel(self.comboBox.currentText(), fontsize=25)
ax.set_ylabel(self.comboBox2.currentText(), fontsize=25)
ax.set_title('Scatter Plot',fontsize=25)
legend1 = ax.legend(*scatter.legend_elements(),
loc="lower left", title="Classes")
ax.add_artist(legend1)
self.widget.adjustSize()
print("fig123456789")
except Exception as e:
print(repr(e))
def cal(self):
#self.graphicsView.clear()
z=self.dataset
w=z.iloc[:,self.a]
self.textBrowser.setText("Mean:\n"+str(np.mean(w))+"\nMedian:\n"+str(np.median(w))+"\nMode:\n"+str(stats.mode(w))+"\nvariance:\n"+str(np.var(w))+"\nStdev:\n"+str(np.std(w)))
#self.textBrowser.adjustSize()
'''
pen = pg.mkPen(color=(255, 0, 0),width=8)
self.graphicsView.setBackground('w')
self.graphicsView.plot(w,symbol='+',symbolSize=30, pen=pen)
'''
def listview_clicked(self):
item=self.listWidget.currentRow()
self.a=item
def create_piechart(self):
z=self.dataset
w=z.iloc[:,-1]
r=w.value_counts()
p=r.to_numpy()
y=w.nunique()
df_val_counts = pandas.DataFrame(r)
df_val_counts = df_val_counts.reset_index()
df_val_counts.columns = ['unique_values', 'counts']
w=df_val_counts.iloc[:,0].to_numpy()
k=df_val_counts.iloc[:,1].to_numpy()
res = w.astype(str)
series = QPieSeries()
for i in range(y):
series.append(res[i], k[i])
chart = self.chartView.chart()
chart.removeAllSeries()
chart.legend().hide()
chart.addSeries(series)
chart.createDefaultAxes()
chart.setAnimationOptions(QChart.AllAnimations)
chart.setTitle("Pie Chart")
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
#self.chartView = QChartView(chart)
self.chartView.setRenderHint(QPainter.Antialiasing)
class PriceFigure:
def __init__(self, name):
self.name = name
self.chart_view = QChartView()
self.price_time_axis = QDateTimeAxis()
self.price_time_axis.setFormat('h:mm')
self.price_axis = QValueAxis()
self.candle_stick_series = QCandlestickSeries()
self.candle_stick_series.setIncreasingColor(Qt.red)
self.candle_stick_series.setDecreasingColor(Qt.blue)
self.moving_average_series = QLineSeries()
self.top_edge_series = QScatterSeries()
self.bottom_edge_series = QScatterSeries()
self.trend_lines = []
self.short_top_trend_series = QLineSeries()
self.short_bottom_trend_series = QLineSeries()
self.long_top_trend_series = QLineSeries()
self.long_bottom_trend_series = QLineSeries()
self.trend_lines.append(self.short_top_trend_series)
self.trend_lines.append(self.short_bottom_trend_series)
self.trend_lines.append(self.long_top_trend_series)
self.trend_lines.append(self.long_bottom_trend_series)
self.chart_view.chart().addSeries(self.candle_stick_series)
self.chart_view.chart().addSeries(self.moving_average_series)
self.chart_view.chart().addSeries(self.top_edge_series)
self.chart_view.chart().addSeries(self.bottom_edge_series)
self.chart_view.chart().addSeries(self.short_top_trend_series)
self.chart_view.chart().addSeries(self.long_top_trend_series)
self.chart_view.chart().addSeries(self.short_bottom_trend_series)
self.chart_view.chart().addSeries(self.long_bottom_trend_series)
self.chart_view.chart().addAxis(self.price_time_axis, Qt.AlignBottom)
self.chart_view.chart().addAxis(self.price_axis, Qt.AlignLeft)
self.chart_view.chart().legend().hide()
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.set_marker_color()
self.set_trend_line_pen()
def set_trend_line_pen(self):
brushes = [
QBrush(QColor(255, 0, 0, 90)),
QBrush(QColor(0, 0, 255, 90)),
QBrush(QColor(205, 56, 47, 255)),
QBrush(QColor(0, 153, 213, 255))
]
for i, tl in enumerate(self.trend_lines):
tl.setPen(QPen(brushes[i], 4, Qt.DotLine))
def set_marker_color(self):
self.top_edge_series.setPen(Qt.black)
self.top_edge_series.setBrush(QBrush(QColor(255, 0, 255, 90)))
self.bottom_edge_series.setPen(Qt.black)
self.bottom_edge_series.setBrush(QBrush(QColor(0, 255, 255, 90)))
def set_datetime(self, d):
self.chart_datetime = d
self.datetime_range = (d.timestamp() * 1000,
d.replace(hour=23, minute=59).timestamp() *
1000)
start_time = QDateTime()
until_time = QDateTime()
start_time.setDate(QDate(d.year, d.month, d.day))
until_time.setDate(QDate(d.year, d.month, d.day))
start_time.setTime(QTime(9, 0))
until_time.setTime(QTime(16, 0))
self.price_time_axis.setRange(start_time, until_time)
def attach(self):
self.price_time_axis.setTickCount(7)
self.candle_stick_series.attachAxis(self.price_time_axis)
self.candle_stick_series.attachAxis(self.price_axis)
self.moving_average_series.attachAxis(self.price_time_axis)
self.moving_average_series.attachAxis(self.price_axis)
self.top_edge_series.attachAxis(self.price_time_axis)
self.top_edge_series.attachAxis(self.price_axis)
self.bottom_edge_series.attachAxis(self.price_time_axis)
self.bottom_edge_series.attachAxis(self.price_axis)
self.short_top_trend_series.attachAxis(self.price_time_axis)
self.short_top_trend_series.attachAxis(self.price_axis)
self.long_top_trend_series.attachAxis(self.price_time_axis)
self.long_top_trend_series.attachAxis(self.price_axis)
self.short_bottom_trend_series.attachAxis(self.price_time_axis)
self.short_bottom_trend_series.attachAxis(self.price_axis)
self.long_bottom_trend_series.attachAxis(self.price_time_axis)
self.long_bottom_trend_series.attachAxis(self.price_axis)
def in_datetime_range(self, q):
return self.datetime_range[0] < q < self.datetime_range[1]
def clear_series_data(self):
self.candle_stick_series.clear()
self.moving_average_series.clear()
self.top_edge_series.clear()
self.bottom_edge_series.clear()
self.short_top_trend_series.clear()
self.long_top_trend_series.clear()
self.short_bottom_trend_series.clear()
self.long_bottom_trend_series.clear()
def get_chart_view(self):
return self.chart_view
def add_moving_average(self, q, price):
if self.in_datetime_range(q):
self.moving_average_series.append(q, price)
def add_candle_stick(self, q, o, h, l, c):
if self.in_datetime_range(q):
self.candle_stick_series.append(QCandlestickSet(o, h, l, c, q))
def set_price_range(self, price_min, price_max):
self.price_axis.setRange(price_min, price_max)
tick_count = int(
math.ceil((price_max - price_min) / price_min * 100. / 2.0))
self.price_axis.setTickCount(tick_count if tick_count + 1 > 2 else 2)
def add_top_edge(self, q, price):
if self.in_datetime_range(q):
self.top_edge_series.append(q, price)
def add_bottom_edge(self, q, price):
if self.in_datetime_range(q):
self.bottom_edge_series.append(q, price)
def add_short_top_trend(self, q, price, draw_horizontal=False):
if self.in_datetime_range(q):
if draw_horizontal:
self.short_top_trend_series.append(q, price)
if self.name == 'yesterday':
self.short_top_trend_series.append(self.datetime_range[1],
price)
else:
self.short_top_trend_series.append(self.datetime_range[0],
price)
else:
self.short_top_trend_series.append(q, price)
def add_long_top_trend(self, q, price, draw_horizontal=False):
if self.in_datetime_range(q):
if draw_horizontal:
self.long_top_trend_series.append(q, price)
if self.name == 'yesterday':
self.long_top_trend_series.append(self.datetime_range[1],
price)
else:
self.long_top_trend_series.append(self.datetime_range[0],
price)
else:
self.long_top_trend_series.append(q, price)
def add_short_bottom_trend(self, q, price, draw_horizontal=False):
if self.in_datetime_range(q):
if draw_horizontal:
self.short_bottom_trend_series.append(q, price)
if self.name == 'yesterday':
self.short_bottom_trend_series.append(
self.datetime_range[1], price)
else:
self.short_bottom_trend_series.append(
self.datetime_range[0], price)
else:
self.short_bottom_trend_series.append(q, price)
def add_long_bottom_trend(self, q, price, draw_horizontal=False):
if self.in_datetime_range(q):
if draw_horizontal:
self.long_bottom_trend_series.append(q, price)
if self.name == 'yesterday':
self.long_bottom_trend_series.append(
self.datetime_range[1], price)
else:
self.long_bottom_trend_series.append(
self.datetime_range[0], price)
else:
self.long_bottom_trend_series.append(q, price)
