def initChart(self, common):
self.categories = [item[0] for item in common]
series = QBarSeries(self._chart)
bar = QBarSet("")
# 随机数据
for item in common:
bar.append(item[1])
series.append(bar)
bar.hovered.connect(self.handleBarHoverd) # 鼠标悬停
self._chart.addSeries(series)
self._chart.createDefaultAxes() # 创建默认的轴
# x轴
axis_x = QBarCategoryAxis(self._chart)
axis_x.append(self.categories)
self._chart.setAxisX(axis_x, series)
# chart的图例
legend = self._chart.legend()
legend.setVisible(True)
# 遍历图例上的标记并绑定信号
for marker in legend.markers():
# 点击事件
marker.clicked.connect(self.handleMarkerClicked)
# 鼠标悬停事件
marker.hovered.connect(self.handleMarkerHovered)
# 一些固定计算，减少mouseMoveEvent中的计算量
# 获取x和y轴的最小最大值
axisX, axisY = self._chart.axisX(), self._chart.axisY()
self.category_len = len(axisX.categories())
self.min_x, self.max_x = -0.5, self.category_len - 0.5
self.min_y, self.max_y = axisY.min(), axisY.max()
# 坐标系中左上角顶点
self.point_top = self._chart.mapToPosition(
QPointF(self.min_x, self.max_y))
self.setChart(self._chart)
def make_bar_chart(self):
chart = QChart()
chart.setTitle("현재 재고 현황")
chart.setAnimationOptions(QChart.SeriesAnimations)
item_statistics_dict = self.statistics_manager.get_item_statistics_dict(
)
categories = ["2020년"]
series = QBarSeries()
for key, value in item_statistics_dict.items():
set = QBarSet(key)
set << value[REMAIN_COUNT]
series.append(set)
chart.addSeries(series)
axis = QBarCategoryAxis()
axis.append(categories)
chart.createDefaultAxes()
chart.setAxisX(axis, series)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
self.barChartView = QChartView(chart)
self.barChartView.setRenderHint(QPainter.Antialiasing)
self.statisticsWidget.setWidget(self.barChartView)
def handler(self):
'''
Processes Data
'''
barset = QBarSet('Attacks')
countdata = self.data.agg('count')
self.max = countdata.max()
now = time.localtime()
past12months = [
time.localtime(
time.mktime(
(now.tm_year, now.tm_mon - n, 1, 0, 0, 0, 0, 0, 0)))[:2]
for n in range(12)
] # get the past 12 months from current date
datadict = {}
for key in past12months:
for k, v in countdata.items():
if k == key:
datadict[k] = v
# set value to 0 if no attacks in a key (month)
for k in past12months:
if k not in datadict.keys():
datadict[k] = 0
self.sorteddict = OrderedDict(sorted(datadict.items()))
setlist = [
value for key, value in self.sorteddict.items()
] # list of attack counts over the past 12 months to append to barset
barset.append(setlist)
self.series = QBarSeries()
self.series.setLabelsVisible(True)
self.series.append(barset)
def initChart(self):
self._chart = QChart(title="柱状图堆叠")
self._chart.setAcceptHoverEvents(True)
# Series动画
self._chart.setAnimationOptions(QChart.SeriesAnimations)
self.categories = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"]
# names = ["邮件营销", "联盟广告", "视频广告", "直接访问", "搜索引擎"]
names = ["邮件营销", ]
series = QBarSeries(self._chart)
for name in names:
bar = QBarSet(name)
# 随机数据
for _ in range(7):
bar.append(randint(0, 10))
series.append(bar)
bar.hovered.connect(self.handleBarHoverd) # 鼠标悬停
self._chart.addSeries(series)
self._chart.createDefaultAxes() # 创建默认的轴
# x轴
axis_x = QBarCategoryAxis(self._chart)
axis_x.append(self.categories)
self._chart.setAxisX(axis_x, series)
# chart的图例
legend = self._chart.legend()
legend.setVisible(True)
# 遍历图例上的标记并绑定信号
for marker in legend.markers():
# 点击事件
marker.clicked.connect(self.handleMarkerClicked)
# 鼠标悬停事件
marker.hovered.connect(self.handleMarkerHovered)
self.setChart(self._chart)
def __init__(self, barCount: int):
super().__init__()
self.chart = QChart()
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.chart.setBackgroundVisible(True)
self.chart.legend().setVisible(False)
self.series = QBarSeries()
self.chart.addSeries(self.series)
self.barValues = QBarSet('')
self.series.append(self.barValues)
for i in range(barCount):
self.barValues << 0.
self.xAxis = QBarCategoryAxis()
self.chart.addAxis(self.xAxis, Qt.AlignBottom)
self.series.attachAxis(self.xAxis)
self.xAxis.setTitleText('yPlus ranges')
self.yAxis = QValueAxis()
self.chart.addAxis(self.yAxis, Qt.AlignLeft)
self.series.attachAxis(self.yAxis)
self.yAxis.setTitleText('% of surface area')
self.yAxis.setRange(0, 100)
def __init__(self, track, parent=None):
QChartView.__init__(self, parent)
self.track = track
self.points = jump_analysis(list(track.time_position_map.values()))
self.bar_set = QBarSet("Time Points")
for p in self.points:
self.bar_set.append(p)
self.bar_set.clicked.connect(self.__bar_clicked)
self.bar_series = QBarSeries()
self.bar_series.append(self.bar_set)
self.chart = QChart()
self.chart.addSeries(self.bar_series)
self.chart.setTitle(f'Jump Analysis for {track.name}')
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.axis = QBarCategoryAxis()
self.axis.append([str(i) for i in range(1, len(self.points)+1)])
self.chart.createDefaultAxes()
self.chart.setAxisX(self.axis, self.bar_series)
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(QtCore.Qt.AlignBottom)
self.setChart(self.chart)
self.setRenderHint(QtGui.QPainter.Antialiasing)
def create_chart(self):
self.chart.setTitle(
'Grafiek aantal externe werken per status - opnameweek ' +
jrwk)
font = QFont("Sans Serif", 10)
font.setWeight(QFont.Bold)
self.chart.setTitleFont(font)
set0 = QBarSet('Aantal externe werken per status')
set0 << rpr[0][2] << rpr[1][2] << rpr[2][2] << rpr[3][2] << rpr[4][
2] << rpr[5][2] << rpr[6][2] << rpr[7][2]
barseries = QBarSeries()
barseries.append(set0)
barseries.append
categories = [
"Status A", "Status B", "Status C", "Status D", "Status E",
"Status F", "Status G", "Status H"
]
self.chart.addSeries(barseries)
self.chart.axisX()
self.chart.createDefaultAxes()
axisX = QBarCategoryAxis()
axisX.append(categories)
self.chart.setAxisX(axisX, barseries)
axisX.setRange(str("Status A"), str("Status H"))
def __actualizar_grafico_barras(self):
self.grafico.legend().setVisible(True)
medias = [
math.floor(np.mean(datos)) if len(datos) > 0 else 0
for datos in self.datos.values()
]
mejores = [
np.min(datos) if len(datos) > 0 else 0
for datos in self.datos.values()
]
peores = [
np.max(datos) if len(datos) > 0 else 0
for datos in self.datos.values()
]
self.eje_y.setRange(1, max(max(medias), max(peores)))
barset_media = QBarSet('Media')
barset_media.append(medias)
barset_mejor = QBarSet('Mejor')
barset_mejor.append(mejores)
barset_peor = QBarSet('Peor')
barset_peor.append(peores)
series = QBarSeries()
series.append(barset_media)
series.append(barset_mejor)
series.append(barset_peor)
series.setLabelsVisible(True)
self.grafico.addSeries(series)
series.attachAxis(self.eje_y)
self.init_grafico()
def addSeries(
self,
_x2idx: typing.Dict,
_idx2x: list,
_chart: QChart,
_axis_x: QValueAxis,
_axis_y: QValueAxis,
):
bar_set = QBarSet(self.name)
tmp_dict = dict(zip(self.x_list, self.y_list))
for k in _idx2x:
try:
bar_set.append(tmp_dict[k])
except KeyError:
bar_set.append(0)
if self.color is not None:
bar_set.setColor(self.color)
bar_series = QBarSeries()
bar_series.append(bar_set)
_chart.addSeries(bar_series)
_chart.setAxisX(_axis_x, bar_series)
_chart.setAxisY(_axis_y, bar_series)
if self.show_value:
self.createShow()
def __init__(self, spec):
super().__init__(None)
self.spec = spec
self.chart = QChart()
# self.chart.setTitle(str(self.spec.variables))
self.chart.legend().hide()
self.mainset = QBarSet("")
self.mainset.append([0 for i in range(len(spec.variables))])
self.mainset.setColor(
QColor(spec.color[0], spec.color[1], spec.color[2]))
self.series = QBarSeries()
self.series.append(self.mainset)
self.setMinimumWidth(400)
self.setMinimumHeight(230)
self.axis_x = QBarCategoryAxis()
self.axis_y = QValueAxis()
self.axis_x.append(spec.variables)
self.chart.addSeries(self.series)
self.chart.setAxisX(self.axis_x, self.series)
self.chart.setAxisY(self.axis_y, self.series)
self.setChart(self.chart)
self.setRenderHint(QPainter.Antialiasing)
self._updates_per_second = 10
self._dataset = []
class BarView(QChartView):
def __init__(self):
QChartView.__init__(self)
#self.resize(700,700)
self.initUI()
def initUI(self):
self.backend = BackendThread()
self.backend.update_bar.connect(self.handleBar)
self.backend.start()
def handleBar(self, data):
self.series = QBarSeries()
self.series.clear()
self.chart = QChart()
self.chart.setTitle(CONF.leftDownNames[0])
set0 = QBarSet(CONF.leftDownNames[1])
for i in range(len(data)):
set0 << data[i][1]
self.series.append(set0)
self.chart.addSeries(self.series)
categories = [data[i][0][-5:] for i in range(len(data))]
print(categories)
axis = QBarCategoryAxis()
axis.append(categories)
self.chart.createDefaultAxes()
self.chart.setAxisX(axis, self.series)
self.setChart(self.chart)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
try:
self.maxVal = float(list(data.values())[0])
if self.maxVal * 60 < 1:
self.set0 = QBarSet('Seconds')
self.set0.append(
[round(float(x) * 60 * 60, 1) for x in data.values()])
self.maxVal = round(self.maxVal * 60 * 60, 1)
elif self.maxVal < 1:
self.set0 = QBarSet('Minutes')
self.set0.append(
[round(float(x) * 60, 1) for x in data.values()])
self.maxVal = round(self.maxVal * 60, 1)
else:
self.set0 = QBarSet('Hours')
self.set0.append([round(float(x), 1) for x in data.values()])
self.maxVal = round(self.maxVal, 1)
except:
self.set0 = QBarSet('NotEnoughData')
self.series = QBarSeries()
self.series.append(self.set0)
self.chart = QChart()
self.chart.setTheme(QChart.ChartThemeHighContrast)
self.chart.addSeries(self.series)
self.chart.setTitle(header)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
months = (data.keys())
self.axisX = QBarCategoryAxis()
self.axisX.append(months)
self.axisY = QValueAxis()
try:
self.axisY.setRange(0, self.maxVal)
if self.maxVal > 19:
self.axisY.setTickCount(15)
elif self.maxVal > 10:
self.axisY.setTickCount(10)
else:
self.axisY.setTickCount(5)
#axisY.setTickInterval(1)
#axisY.applyNiceNumbers()
except:
self.chart.setTitle("No Data")
self.chart.addAxis(self.axisX, Qt.AlignBottom)
self.chart.addAxis(self.axisY, Qt.AlignLeft)
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignBottom)
self.chartView = QChartView(self.chart)
self.vert_l = QVBoxLayout()
self.vert_l.addWidget(self.chartView)
self.setLayout(self.vert_l)
def create_initialize_histogram(self):
bar_set = QBarSet('x')
bar_set.append([0] * 10)
max_val = 100
series = QBarSeries()
series.append(bar_set)
return series, max_val
def __init__(self, predictions, probabilities):
# calls the parent (QMainWindow) constructor
super().__init__()
# Size of the window
self.resize(800, 600)
# The title of the window
self.setWindowTitle("Flower Confidence score graph")
# The array to hold flower sets
self.flowerSets = []
# A Q bar series object
self.flowerSeries = QBarSeries()
# The for loop add Q bar sets and probabilities to the Q bsr series object.
for i in range(5):
self.flowerSets.append(
QBarSet(predictions[i] +
" ({0:.3f}%)".format(probabilities[i])))
self.flowerSets[i].append(probabilities[i])
self.flowerSeries.append(self.flowerSets[i])
# creates the char that will be the bar graph chart (also the base class of all qt charts)
flowerChart = QChart()
# added the series object to the chart object
flowerChart.addSeries(self.flowerSeries)
# Adds a title to the graph
flowerChart.setTitle('Confidence score percentages by flower type')
# Gives the graph a nice animation when opened
flowerChart.setAnimationOptions(QChart.SeriesAnimations)
# The next two line label the x axis
axisX = QBarCategoryAxis()
axisX.append(["Flower Types"])
# Gives the y axis its values
axisY = QValueAxis()
axisY.setRange(0, probabilities[0])
# added the axises to the chart
flowerChart.addAxis(axisX, Qt.AlignBottom)
flowerChart.addAxis(axisY, Qt.AlignLeft)
# Makes sure teh legend is visible
flowerChart.legend().setVisible(True)
# Places the legend to the bottom of the chart
flowerChart.legend().setAlignment(Qt.AlignBottom)
# places the chart in a chart view
flowerChartView = QChartView(flowerChart)
# Adds the chart to the main widget
self.setCentralWidget(flowerChartView)
def create_predict_histogram(self):
bar_set = QBarSet('x')
hist_val, _ = self.predictor.get_hist_values()
max_val = max(hist_val)
bar_set.append(hist_val)
series = QBarSeries()
series.append(bar_set)
return series, max_val
def build(self):
self.setWindowTitle("Histogram - " + self.name)
self.setMinimumSize(400, 300)
# Close when ctrl+w is triggered
QShortcut(QKeySequence("Ctrl+W"), self, self.close)
# 2D array -> 1D array
img = self.image.ravel()
# Process histogram
histogram, bin_edges = np.histogram(img, bins='auto')
bar_series = QBarSeries()
bar_ = QBarSet("")
# Append values
for val in histogram:
bar_.append(val)
pen = bar_.pen()
pen.setColor(Qt.black)
pen.setWidth(0.1)
bar_.setPen(pen)
# Append bar to the bar series
bar_series.append(bar_)
# Chart object
chart = QChart()
chart.addSeries(bar_series)
# Active animation
chart.setAnimationOptions(QChart.SeriesAnimations)
# Do not show title
chart.legend().setVisible(False)
# Draw Axes, with [min, max]
# Y axis
h_max = histogram.max()
axis_y = QValueAxis()
axis_y.setRange(0, h_max)
# X axis
be_max = bin_edges.max()
be_min = bin_edges.min()
axis_x = QValueAxis()
axis_x.setRange(be_min, be_max)
# Add axis to chart + rendering
chart.addAxis(axis_x, Qt.AlignBottom)
chart.addAxis(axis_y, Qt.AlignLeft)
view = QChartView(chart)
view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(view)
def createBar(self):
min_num, max_num = 0, 100
linked_bag_list = []
try:
df = self.linked['Beam Diff'].dropna()
linked_bag_list = df.values.tolist()
min_num = int(min(linked_bag_list))
if min_num > 0: # check if greater than 0, set to 0
min_num = 0
max_num = int(max(linked_bag_list))
except AttributeError:
self.statusbar.showMessage('Data not ready')
count = [0] * (max_num + 1) # choose the largest num as length of count
for num in linked_bag_list:
count[int(num)] += 1 # update every number's count
max_count = max(count)
setBar = QBarSet('Beam Difference Occurrence')
setBar.append(count)
brush = QBrush(QColor(0x57B1FD))
pen = QPen(QColor(0x57B1FD))
pen.setWidth(2)
setBar.setPen(pen)
setBar.setBrush(brush)
series = QBarSeries()
series.append(setBar)
chart = QChart()
chart.setTheme(QChart.ChartThemeBlueIcy)
font = QFont()
font.setPixelSize(18)
chart.setTitleFont(font)
chart.setTitle('Linked Bins Histogram')
chart.addSeries(series)
chart.setAnimationOptions(QChart.SeriesAnimations)
axisX = QValueAxis()
axisX.setTitleText("Attenuation Window")
axisX.setRange(min_num, max_num+20)
chart.setAxisX(axisX, series)
axisY = QValueAxis()
axisY.setTitleText("Frequency")
axisY.setRange(0, max_count+20)
chart.setAxisY(axisY, series)
chart.legend().hide()
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
return chartView
def __init__(self, parent=None):
super(QChartView, self).__init__(parent=parent)
self.chart = QChart()
self.setChart(self.chart)
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignBottom)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
self.series = QBarSeries(self)
self.categoryAxis = QBarCategoryAxis(self)
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 load_glycation(self, filename: Optional[str] = None) -> None:
"""
Load glycation data from a CSV file and display it
in the corresponding chart view.
:param str filename: directly load this file
:return: nothing, sets self.se_glycation
:rtype: None
"""
# load and clean glycation data
if filename is None:
filename, self.last_path = get_filename(
self, "open", self.tr("Load glycation data ..."),
self.last_path, FileTypes(["csv"]))
if filename is None:
return
logging.info(
self.tr("Loading glycation data in '{}'").format(filename))
try:
self.glycation = read_clean_datasets(filename)
except (OSError, ValueError) as e:
logging.error(str(e))
QMessageBox.critical(self, self.tr("Error"), str(e))
return
# extract x- and y-values from series
x_values = [str(i) for i in self.glycation.index]
y_values = [a.nominal_value for a in self.glycation]
# assemble the chart
bar_set = QBarSet("glycation abundance")
bar_set.append(y_values)
bar_set.setColor(QColor("#a1dab4"))
bar_set.hovered.connect(self.update_glycation_label)
bar_series = QBarSeries()
bar_series.append(bar_set)
x_axis = QBarCategoryAxis()
x_axis.append(x_values)
x_axis.setTitleText(self.tr("count"))
y_axis = QValueAxis()
y_axis.setRange(0, 100)
y_axis.setTitleText(self.tr("abundance"))
y_axis.setLabelFormat("%d")
chart = QChart()
chart.addSeries(bar_series)
chart.setAxisX(x_axis, bar_series)
chart.setAxisY(y_axis, bar_series)
chart.legend().setVisible(False)
chart.setBackgroundRoundness(0)
chart.layout().setContentsMargins(0, 0, 0, 0)
chart.setMargins(QMargins(5, 5, 5, 5))
self.cvGlycation.setChart(chart)
def __init__(self, parent=None):
super().__init__(parent=parent)
self.chart = QChart()
self.setChart(self.chart)
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignBottom)
self.series = QBarSeries(self)
self.categoryAxis = QBarCategoryAxis(self)
self.build_style()
def __init__(self, parent=None):
super(TableWidget, self).__init__(parent)
# Create a simple model for storing data.
model = CustomTableModel()
# Create the table view and add the model to it.
tableView = QTableView()
tableView.setModel(model)
tableView.setMinimumWidth(300)
tableView.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
tableView.verticalHeader().setSectionResizeMode(QHeaderView.Stretch)
chart = QChart()
chart.setAnimationOptions(QChart.AllAnimations)
# Series 1.
series = QBarSeries()
first = 3
count = 5
mapper = QVBarModelMapper(self)
mapper.setFirstBarSetColumn(1)
mapper.setLastBarSetColumn(4)
mapper.setFirstRow(first)
mapper.setRowCount(count)
mapper.setSeries(series)
mapper.setModel(model)
chart.addSeries(series)
# Get the color of the series and use it for showing the mapped area.
for i, barset in enumerate(series.barSets()):
seriesColorHex = hex(barset.brush().color().rgb()).upper()
if seriesColorHex.endswith('L'):
seriesColorHex = seriesColorHex[:-1]
seriesColorHex = '#' + seriesColorHex[-6:]
model.addMapping(seriesColorHex,
QRect(1 + i, first, 1, barset.count()))
categories = ["April", "May", "June", "July", "August"]
axis = QBarCategoryAxis(chart)
axis.append(categories)
chart.createDefaultAxes()
chart.setAxisX(axis, series)
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
chartView.setMinimumSize(640, 480)
# Create the main layout.
mainLayout = QGridLayout()
mainLayout.addWidget(tableView, 1, 0)
mainLayout.addWidget(chartView, 1, 1)
mainLayout.setColumnStretch(1, 1)
mainLayout.setColumnStretch(0, 0)
self.setLayout(mainLayout)
def __init__(self):
super(initial, self).__init__()
loadUi("main.ui", self)
# definir elementos de la UI y acciones/funciones asociadas
# creamos sets para mostrar resultados en el barchart
self.setRecall = QBarSet("Recalls")
self.setRecall.append([0, 0, 0])
self.setAccurracy = QBarSet("Accurracy")
self.setAccurracy.append([0, 0, 0])
self.series = QBarSeries()
# Elementos Tab Entrenamiento:
# ===========================
# Btn Insertar primeros datos entrenamiento
self.trainingAddFilesBtn.clicked.connect(
self.insertarNoticiasEntrenamientoDespoblacion)
# Btn Insertar segundos datos entrenamiento
self.trainingAddFilesBtn2.clicked.connect(
self.insertarNoticiasEntrenamientoNoDespoblacion)
# Btn Preprocesamiento de texto
self.procesarTextoBtn.clicked.connect(self.procesarTextoEntrenamiento)
# ComboBox selector de Modelo a entrenar
# self.chooseModelComboBox.activated.connect(self.elegirModeloEntrenamiento)
# añadir elementos al comboBox y sus valores asociados
self.chooseModelComboBox.addItem("KNN", 1)
self.chooseModelComboBox.addItem("Naive Bayes", 2)
self.chooseModelComboBox.addItem("Decision Tree", 3)
# Btn para entrenar el modelo seleccionado
self.trainModelBtn.clicked.connect(self.entrenarModelo)
# Elementos Tab Testeo:
# ====================
# Btn Insertar Datos Testeo
self.testingFilesBtn.clicked.connect(self.insertarNoticiasTesteo)
# Btn Seleccionar Modelo
self.selectTestModelBtn.clicked.connect(self.elegirModeloTesteo)
# Btn Mostrar Resultados
self.testBtn.clicked.connect(self.mostrarResultados)
# Tab Testeo
#self.tabTest.clicked.connect(self.abrirTabTesteo)
# nombre excel
self.nombreresultadoexcel = ':)'
def beforeDelay(self):
print("in before delay bar")
min_num, max_num = 0, 100
max_count = 0
total_stopped_time = []
try:
total_stopped_time = self.tm.total_stopped_time
max_num = max(total_stopped_time)
except AttributeError:
self.statusbar.showMessage('Data not ready')
count = total_stopped_time
count = [0] * (int(max_num) + 1
) # choose the largest num as length of count
for num in total_stopped_time:
count[int(num)] += 1 # update every number's count
max_count = max(count)
print(len(total_stopped_time), max_count)
setBar = QBarSet('stop time')
setBar.append(count)
brush = QBrush(QColor(0x57B1FD))
pen = QPen(QColor(0x57B1FD))
pen.setWidth(2)
setBar.setPen(pen)
setBar.setBrush(brush)
series = QBarSeries()
series.append(setBar)
chart = QChart()
font = QFont()
font.setPixelSize(18)
chart.setTitleFont(font)
chart.setTitle('Stop time Histogram (before)')
chart.addSeries(series)
chart.setAnimationOptions(QChart.SeriesAnimations)
axisX = QValueAxis()
axisX.setRange(min_num, max_num + 20)
chart.setAxisX(axisX, series)
axisY = QValueAxis()
axisY.setRange(0, max_count + 20)
chart.setAxisY(axisY, series)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
# MainWindow.setCentralWidget(chartView)
return chartView
def afterDelay(self):
# print("in after delay bar")
min_num, max_num = 0, 100
max_count = 0
total_stopped_after_delay = []
count = [0] * (int(max_num) + 1) # choose the largest num as length of count
try:
total_stopped_after_delay = self.tm.total_stopped_after_delay
max_num = max(total_stopped_after_delay)
count = [0] * (int(max_num) + 1) # choose the largest num as length of count
for num in total_stopped_after_delay:
count[int(num)] += 1 # update every number's count
max_count = max(count)
except (AttributeError, ValueError):
self.statusbar.showMessage('Data not ready')
setBar = QBarSet('Stop Time Occurrence')
setBar.append(count)
brush = QBrush(QColor(0xA6E22E)) # Green
pen = QPen(QColor(0xA6E22E)) # Green
pen.setWidth(2)
setBar.setPen(pen)
setBar.setBrush(brush)
series = QBarSeries()
series.append(setBar)
chart = QChart()
font = QFont()
font.setPixelSize(18)
chart.setTitleFont(font)
chart.setTitle('Stop time Occurrence (after)')
chart.addSeries(series)
chart.setAnimationOptions(QChart.SeriesAnimations)
axisX = QValueAxis()
axisX.setRange(min_num, max_num+20)
chart.setAxisX(axisX, series)
axisY = QValueAxis()
axisY.setRange(0, max_count+20)
chart.setAxisY(axisY, series)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
# MainWindow.setCentralWidget(chartView)
return chartView
def agg_glycoforms(self) -> None:
"""
Display glycoform data in the corresponding chart view.
:return: nothing
:rtype: None
"""
# aggregate "other" abundances
if self.cbAggGlycoforms.isChecked():
agg_abundance = (
self.glycoforms.iloc[self.sbAggGlycoforms.value():].sum())
self.glycoforms_agg = (
self.glycoforms.iloc[:self.sbAggGlycoforms.value()].append(
pd.Series(agg_abundance, index=[self.tr("other")])))
else:
self.glycoforms_agg = self.glycoforms
# extract x- and y-values from series
x_values = [str(i) for i in self.glycoforms_agg.index]
y_values = [a.nominal_value for a in self.glycoforms_agg]
# assemble the chart
bar_set = QBarSet("glycoform abundance")
bar_set.append(y_values)
bar_set.setColor(QColor("#2c7fb8"))
bar_set.hovered.connect(self.update_glycoform_label)
bar_series = QBarSeries()
bar_series.append(bar_set)
x_axis = QBarCategoryAxis()
x_axis.append(x_values)
x_axis.setTitleVisible(False)
x_axis.setLabelsAngle(270)
range_max = max(self.glycoforms_agg).nominal_value
range_max = math.ceil(range_max / 20) * 20
tick_count = range_max // 20 + 1
y_axis = QValueAxis()
y_axis.setRange(0, range_max)
y_axis.setTickCount(tick_count)
y_axis.setTitleText(self.tr("abundance"))
y_axis.setLabelFormat("%d")
chart = QChart()
chart.addSeries(bar_series)
chart.setAxisX(x_axis, bar_series)
chart.setAxisY(y_axis, bar_series)
chart.legend().setVisible(False)
chart.setBackgroundRoundness(0)
chart.layout().setContentsMargins(0, 0, 0, 0)
chart.setMargins(QMargins(5, 5, 5, 5))
self.cvGlycoforms.setChart(chart)
def _init_chart(self) -> None:
series = QBarSeries()
axis_x = QBarCategoryAxis()
axis_y = QValueAxis()
data_set = defaultdict(int)
for title, money in self.base:
data_set[title] += money
for title, money in data_set.items():
bar = QBarSet(title)
axis_x.append(title)
bar.append(money)
series.append(bar)
#
self.chart = QChart()
self.chart.addSeries(series)
self.chart.setAnimationOptions(QChart.SeriesAnimations)
#
series.attachAxis(axis_x)
self.chart.addAxis(axis_x, Qt.AlignBottom)
axis_y.setRange(0, max(data_set.values()))
axis_y.setTickCount(11)
self.chart.addAxis(axis_y, Qt.AlignLeft)
series.attachAxis(axis_y)
#
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignBottom)
def beforeDelayDistribution(self):
min_num, max_num = 0, 100
max_count = 0
total_stopped_time = []
count = [0]
try:
total_stopped_time = self.tm.total_stopped_time
max_num = len(total_stopped_time) # change from max() to len() 2/12 11:11
count = total_stopped_time
max_count = max(count)
except (AttributeError, ValueError):
self.statusbar.showMessage('Data not ready')
setBar = QBarSet('stop time')
setBar.append(count)
brush = QBrush(QColor(0x57B1FD))
pen = QPen(QColor(0x57B1FD))
pen.setWidth(2)
setBar.setPen(pen)
setBar.setBrush(brush)
series = QBarSeries()
series.append(setBar)
chart = QChart()
font = QFont()
font.setPixelSize(18)
chart.setTitleFont(font)
chart.setTitle('Stop time Distribution (before)')
chart.addSeries(series)
chart.setAnimationOptions(QChart.SeriesAnimations)
axisX = QValueAxis()
axisX.setRange(min_num, max_num)
chart.setAxisX(axisX, series)
axisY = QValueAxis()
axisY.setRange(0, max_count+20)
chart.setAxisY(axisY, series)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
# MainWindow.setCentralWidget(chartView)
return chartView
def initChart(self, xAxis):
self._chart = QChart()
# 调整边距
self._chart.layout().setContentsMargins(0, 0, 0, 0) # 外界
self._chart.setMargins(QMargins(3, 0, 3, 0)) # 内界
self._chart.setBackgroundRoundness(0)
self._chart.setBackgroundVisible(False)
# 设置主题
self._chart.setTheme(QChart.ChartThemeBlueIcy)
# 抗锯齿
self.setRenderHint(QPainter.Antialiasing)
# 开启动画效果
self._chart.setAnimationOptions(QChart.SeriesAnimations)
self.categories = xAxis
self._series = QBarSeries(self._chart)
self._chart.addSeries(self._series)
self._chart.createDefaultAxes() # 创建默认的轴
self._axis_x = QBarCategoryAxis(self._chart)
self._axis_x.append(self.categories)
self._axis_y = QValueAxis(self._chart)
self._axis_y.setTitleText("任务数")
self._axis_y.setRange(0, 10)
self._chart.setAxisX(self._axis_x, self._series)
self._chart.setAxisY(self._axis_y, self._series)
# chart的图例
legend = self._chart.legend()
legend.setVisible(True)
self.setChart(self._chart)
def XDictSet(data_dict, chart_type='bar', key_order=None):
known_chart_types = ['bar', 'hbar', 'box', 'candlestick']
if chart_type in known_chart_types:
if key_order == None:
key_order = data_dict.keys()
def dictloop(data, ko, QSeries, QSet):
for key in ko:
set = QSet(key)
for item in data[key]:
try:
set << float(item)
except (ValueError, TypeError):
set << 0.0
QSeries.append(set)
return QSeries
if chart_type == 'bar':
series = dictloop(data_dict, key_order, QBarSeries(), QBarSet)
if chart_type == 'hbar':
series = dictloop(data_dict, key_order, QHorizontalBarSeries(), QBarSet)
elif chart_type == 'box':
series = dictloop(data_dict, key_order, QBoxPlotSeries(), QBoxSet)
elif chart_type == 'candlestick':
series = dictloop(data_dict, key_order, QCandlestickSeries(), QCandlestickSet)
else:
raise ValueError('chart_type is unknown')
pass
return series
def addSeries(
self, _x2idx: typing.Dict, _idx2x: list, _chart: QChart,
_axis_x: QValueAxis, _axis_y: QValueAxis
):
bar_set = QBarSet(self.name)
tmp_dict = dict(zip(self.x_list, self.y_list))
for k in _idx2x:
if k in tmp_dict.keys():
bar_set.append(tmp_dict[k])
else:
bar_set.append(0)
if self.color is not None:
bar_set.setColor(self.color)
bar_series = QBarSeries()
bar_series.append(bar_set)
_chart.addSeries(bar_series)
_chart.setAxisX(_axis_x, bar_series)
_chart.setAxisY(_axis_y, bar_series)
if self.show_value:
self.createShow()
