1038 lines
59 KiB
Python
1038 lines
59 KiB
Python
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QLabel, QSpinBox, QSpacerItem, QSizePolicy, \
|
|
QTabWidget, QTableWidget, QPushButton, QLineEdit, QTableView, QCheckBox, \
|
|
QAbstractScrollArea, QTableWidgetItem, QComboBox, QFileDialog, QGridLayout, QMessageBox, \
|
|
QRadioButton
|
|
from PyQt5.QtGui import QIcon, QPixmap
|
|
from PyQt5.QtCore import Qt, QCoreApplication, pyqtSignal, pyqtSlot
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
import matplotlib.pyplot as plt
|
|
from matplotlib.colors import CSS4_COLORS, LogNorm
|
|
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
|
|
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolBar
|
|
from copy import deepcopy
|
|
|
|
from os import path
|
|
|
|
from Model.granulo_loader import GranuloLoader
|
|
|
|
from View.checkable_combobox import CheckableComboBox
|
|
|
|
import Translation.constant_string as cs
|
|
|
|
_translate = QCoreApplication.translate
|
|
|
|
|
|
class SampleDataTab(QWidget):
|
|
|
|
clickedState = pyqtSignal(bool)
|
|
|
|
def __init__(self, widget_tab):
|
|
super().__init__()
|
|
|
|
### --- General layout of widgets ---
|
|
|
|
self.verticalLayout_sampleDataTab = QVBoxLayout(widget_tab)
|
|
|
|
self.horizontalLayoutTop_sampleDataTab = QHBoxLayout()
|
|
self.verticalLayout_sampleDataTab.addLayout(self.horizontalLayoutTop_sampleDataTab, 5)
|
|
|
|
self.horizontalLayoutBottom_sampleDataTab = QHBoxLayout()
|
|
self.verticalLayout_sampleDataTab.addLayout(self.horizontalLayoutBottom_sampleDataTab, 5)
|
|
|
|
# --------------------------------------------------------------------------------------------------------------
|
|
### --- Layout of groupbox in the Top horizontal layout box
|
|
|
|
# Download | Table of values | Sample position
|
|
# Display options
|
|
|
|
self.groupbox_download = QGroupBox()
|
|
self.horizontalLayoutTop_sampleDataTab.addWidget(self.groupbox_download, 3)
|
|
|
|
self.groupbox_table = QGroupBox()
|
|
self.horizontalLayoutTop_sampleDataTab.addWidget(self.groupbox_table, 4)
|
|
|
|
self.verticalLayout_sampleposition_displayoption = QVBoxLayout()
|
|
self.horizontalLayoutTop_sampleDataTab.addLayout(self.verticalLayout_sampleposition_displayoption, 3)
|
|
|
|
self.groupbox_plot_sample_position = QGroupBox()
|
|
self.verticalLayout_sampleposition_displayoption.addWidget(self.groupbox_plot_sample_position, 5)
|
|
|
|
self.groupbox_display_option = QGroupBox()
|
|
self.verticalLayout_sampleposition_displayoption.addWidget(self.groupbox_display_option, 5)
|
|
|
|
path_icon = "./icons/"
|
|
icon_folder = QIcon(path_icon + "folder.png")
|
|
|
|
# ++++++++++++++++++++++++++++++++++++++++
|
|
# +++ --- GroupBox Download Sample --- +++
|
|
# ++++++++++++++++++++++++++++++++++++++++
|
|
|
|
self.verticalLayout_groupbox_download = QVBoxLayout(self.groupbox_download)
|
|
|
|
self.tab_download_experimental_numerical_data = QTabWidget()
|
|
|
|
self.tab_download_experimental_data = QWidget()
|
|
self.tab_download_experimental_numerical_data.addTab(self.tab_download_experimental_data, "Experimental data")
|
|
|
|
self.verticalLayout_experimentalTab_groupbox_download = QVBoxLayout()
|
|
self.tab_download_experimental_data.setLayout(self.verticalLayout_experimentalTab_groupbox_download)
|
|
|
|
self.groupbox_particle_size_file = QGroupBox()
|
|
self.verticalLayout_groupbox_particle_size_file = QVBoxLayout(self.groupbox_particle_size_file)
|
|
|
|
self.groupbox_fine_sediment = QGroupBox()
|
|
self.horizontalLayout_fine_sediment = QHBoxLayout(self.groupbox_fine_sediment)
|
|
self.pushbutton_fine_sediment = QPushButton()
|
|
self.pushbutton_fine_sediment.setIcon(icon_folder)
|
|
self.horizontalLayout_fine_sediment.addWidget(self.pushbutton_fine_sediment)
|
|
self.lineEdit_fine_sediment = QLineEdit()
|
|
self.horizontalLayout_fine_sediment.addWidget(self.lineEdit_fine_sediment)
|
|
self.verticalLayout_groupbox_particle_size_file.addWidget(self.groupbox_fine_sediment)
|
|
|
|
self.pushbutton_fine_sediment.clicked.connect(self.open_dialog_box_fine_sediment)
|
|
|
|
self.groupbox_sand = QGroupBox()
|
|
self.horizontalLayout_sand = QHBoxLayout(self.groupbox_sand)
|
|
self.pushbutton_sand = QPushButton()
|
|
self.pushbutton_sand.setIcon(icon_folder)
|
|
self.horizontalLayout_sand.addWidget(self.pushbutton_sand)
|
|
self.lineEdit_sand = QLineEdit()
|
|
self.horizontalLayout_sand.addWidget(self.lineEdit_sand)
|
|
self.verticalLayout_groupbox_particle_size_file.addWidget(self.groupbox_sand)
|
|
|
|
self.pushbutton_sand.clicked.connect(self.open_dialog_box_sand_sediment)
|
|
|
|
self.verticalLayout_experimentalTab_groupbox_download.addWidget(self.groupbox_particle_size_file)
|
|
|
|
# self.groupbox_total_concentration = QGroupBox()
|
|
# self.horizontalLayout_groupbox_total_concentration = QHBoxLayout(self.groupbox_total_concentration)
|
|
# self.pushbutton_total_concentration = QPushButton()
|
|
# self.pushbutton_total_concentration.setIcon(icon_folder)
|
|
# self.horizontalLayout_groupbox_total_concentration.addWidget(self.pushbutton_total_concentration)
|
|
# self.lineEdit_total_concentration = QLineEdit()
|
|
# self.horizontalLayout_groupbox_total_concentration.addWidget(self.lineEdit_total_concentration)
|
|
#
|
|
# self.pushbutton_total_concentration.clicked.connect(self.open_dialog_box_total_concentration)
|
|
#
|
|
# self.verticalLayout_groupbox_download.addWidget(self.groupbox_total_concentration)
|
|
|
|
# self.verticalLayout_experimentalTab_groupbox_download.addWidget(self.groupbox_total_concentration)
|
|
|
|
self.tab_compute_numerical_data = QWidget()
|
|
self.tab_download_experimental_numerical_data.addTab(self.tab_compute_numerical_data, "Numerical data")
|
|
|
|
self.verticalLayout_groupbox_download.addWidget(self.tab_download_experimental_numerical_data)
|
|
|
|
# ++++++++++++++++++++++++++++++++++++++++
|
|
# +++ --- GroupBox Table of values --- +++
|
|
# ++++++++++++++++++++++++++++++++++++++++
|
|
|
|
self.verticalLayout_groupbox_table = QVBoxLayout(self.groupbox_table)
|
|
|
|
self.horizontalLayout_checkAll_spacer_exportTable = QHBoxLayout()
|
|
|
|
self.pushbutton_fill_table = QPushButton()
|
|
self.horizontalLayout_checkAll_spacer_exportTable.addWidget(self.pushbutton_fill_table)
|
|
|
|
self.horizontalSpacerItem_pushButton_fill_table = QSpacerItem(20, 10, QSizePolicy.Expanding,
|
|
QSizePolicy.Minimum)
|
|
self.horizontalLayout_checkAll_spacer_exportTable.addItem(self.horizontalSpacerItem_pushButton_fill_table)
|
|
|
|
self.allChkBox = QCheckBox()
|
|
self.horizontalLayout_checkAll_spacer_exportTable.addWidget(self.allChkBox)
|
|
|
|
self.horizontalSpacerItem_pushButton_export_table = QSpacerItem(240, 10, QSizePolicy.Expanding,
|
|
QSizePolicy.Minimum)
|
|
self.horizontalLayout_checkAll_spacer_exportTable.addItem(self.horizontalSpacerItem_pushButton_export_table)
|
|
|
|
self.pushButton_export_table = QPushButton()
|
|
self.horizontalLayout_checkAll_spacer_exportTable.addWidget(self.pushButton_export_table)
|
|
|
|
self.verticalLayout_groupbox_table.addLayout(self.horizontalLayout_checkAll_spacer_exportTable)
|
|
|
|
self.tableWidget_sample = QTableWidget()
|
|
|
|
self.row = self.tableWidget_sample.setRowCount(10)
|
|
self.column = self.tableWidget_sample.setColumnCount(10)
|
|
|
|
self.pushbutton_fill_table.clicked.connect(self.fill_table)
|
|
self.pushButton_export_table.clicked.connect(self.export_table)
|
|
|
|
self.verticalLayout_groupbox_table.addWidget(self.tableWidget_sample)
|
|
|
|
# +++++++++++++++++++++++++++++++++++++++++++++
|
|
# +++ --- GroupBox plot sample position --- +++
|
|
# +++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
self.verticalLayout_groupbox_plot_sample_position = QVBoxLayout(self.groupbox_plot_sample_position)
|
|
|
|
self.canvas_transect_sample_position = None
|
|
|
|
# if self.canvas_transect_sample_position
|
|
|
|
# self.figure_sample_position, self.axis_sample_position = plt.subplots(nrows=1, ncols=1, layout="constrained")
|
|
# self.canvas_sample_position = FigureCanvas(self.figure_sample_position)
|
|
# # self.toolbar_sampleposition = NavigationToolBar(self.canvas_sampleposition, self)
|
|
# self.empty_field_for_transect_plot()
|
|
# self.verticalLayout_groupbox_plot_sample_position.addWidget(self.canvas_sample_position)
|
|
|
|
# +++++++++++++++++++++++++++++++++++++++
|
|
# +++ --- GroupBox display option --- +++
|
|
# +++++++++++++++++++++++++++++++++++++++
|
|
|
|
self.verticalLayout_groupbox_display_option = QVBoxLayout(self.groupbox_display_option)
|
|
|
|
# self.pushbutton_plot_transect = QPushButton()
|
|
# self.pushbutton_plot_transect.setText("Plot transect to visualise sample position")
|
|
# self.verticalLayout_groupbox_display_option.addWidget(self.pushbutton_plot_transect)
|
|
|
|
self.horizontalLayout_Ctot_PSD_plot = QHBoxLayout()
|
|
self.verticalLayout_groupbox_display_option.addLayout(self.horizontalLayout_Ctot_PSD_plot)
|
|
|
|
self.groupbox_option_total_concentration_plot = QGroupBox()
|
|
self.groupbox_option_total_concentration_plot.setTitle("Total concentration plot")
|
|
self.horizontalLayout_Ctot_PSD_plot.addWidget(self.groupbox_option_total_concentration_plot)
|
|
|
|
self.gridLayout_groupbox_option_total_concentration_plot = QGridLayout(self.groupbox_option_total_concentration_plot)
|
|
self.label_x_axis = QLabel()
|
|
self.label_x_axis.setText("x axis")
|
|
self.gridLayout_groupbox_option_total_concentration_plot.addWidget(self.label_x_axis, 0, 0)
|
|
|
|
self.combobox_x_axis = QComboBox()
|
|
self.combobox_x_axis.addItems(['Concentration (g/L)', 'Concentration (%)'])
|
|
self.gridLayout_groupbox_option_total_concentration_plot.addWidget(self.combobox_x_axis, 0, 1)
|
|
|
|
self.combobox_x_axis.currentTextChanged.connect(self.update_plot_total_concentration)
|
|
|
|
self.label_y_axis = QLabel()
|
|
self.label_y_axis.setText("y axis")
|
|
self.gridLayout_groupbox_option_total_concentration_plot.addWidget(self.label_y_axis, 1, 0)
|
|
|
|
self.combobox_y_axis = QComboBox()
|
|
self.combobox_y_axis.addItems(['z (m)', 'z / h'])
|
|
self.gridLayout_groupbox_option_total_concentration_plot.addWidget(self.combobox_y_axis, 1, 1)
|
|
|
|
# self.combobox_y_axis.currentTextChanged.connect(self.empty_field_for_total_concentration_plot)
|
|
self.combobox_y_axis.currentTextChanged.connect(self.update_plot_total_concentration)
|
|
|
|
# --- Group box PSD plot ---
|
|
self.groupbox_option_PSD_plot = QGroupBox()
|
|
self.groupbox_option_PSD_plot.setTitle("Particle Size Distribution plot")
|
|
self.horizontalLayout_Ctot_PSD_plot.addWidget(self.groupbox_option_PSD_plot)
|
|
|
|
self.verticalLayout__groupbox_option_PSD_plot = QHBoxLayout(self.groupbox_option_PSD_plot)
|
|
self.combobox_PSD_plot = QComboBox()
|
|
self.combobox_PSD_plot.addItems(["Class PSD", "Cumulative PSD"])
|
|
self.verticalLayout__groupbox_option_PSD_plot.addWidget(self.combobox_PSD_plot)
|
|
|
|
self.combobox_PSD_plot.currentTextChanged.connect(self.update_plot_PSD_fine_and_sand_sediments)
|
|
|
|
# self.horizontalLayout_groupbox_option_PSD_plot = QHBoxLayout(self.groupbox_option_PSD_plot)
|
|
# self.pushbutton_class_PSD = QPushButton()
|
|
# self.pushbutton_class_PSD.setText("Class PSD")
|
|
# self.horizontalLayout_groupbox_option_PSD_plot.addWidget(self.pushbutton_class_PSD)
|
|
|
|
# self.pushbutton_class_PSD.clicked.connect(self.update_plot_fine_and_sand_sediments_PSD_class)
|
|
|
|
# self.pushbutton_class_PSD.clicked_signal[str].connect(self.on_clicked)
|
|
|
|
# if self.tableWidget_sample.columnCount() == 10:
|
|
# self.pushbutton_class_PSD.clicked.connect(self.empty_field_to_plot_fine_sediment_distribution)
|
|
# else:
|
|
# self.pushbutton_class_PSD.clicked.connect(self.update_plot_fine_sediment_PSD_class_cumul)
|
|
|
|
# self.pushbutton_cumulative_PSD = QPushButton()
|
|
# self.pushbutton_cumulative_PSD.setText("Cumulative PSD")
|
|
# self.horizontalLayout_groupbox_option_PSD_plot.addWidget(self.pushbutton_cumulative_PSD)
|
|
|
|
# self.pushbutton_cumulative_PSD.clicked.connect(self.update_plot_fine_and_sand_sediments_PSD_cumul)
|
|
|
|
# if self.tableWidget_sample.columnCount() == 10:
|
|
# self.pushbutton_cumulative_PSD.clicked.connect(self.empty_field_to_plot_fine_sediment_distribution)
|
|
# else:
|
|
# self.pushbutton_cumulative_PSD.clicked.connect(self.update_plot_fine_sediment_PSD_class_cumul)
|
|
|
|
# self.pushbutton_plot_PSD_distribution.setText("Class distribution")
|
|
|
|
# self.horizontalLayout_calibration_sample_vertical_profile = QHBoxLayout()
|
|
# self.verticalLayout_groupbox_displayoption_sampletab.addLayout(
|
|
# self.horizontalLayout_calibration_sample_vertical_profile)
|
|
#
|
|
# self.label_calibration_sample_vertical_profile = QLabel()
|
|
# # self.label_calibration_sample_vertical_profile.setText("Calibration sample vertical profile :")
|
|
# self.horizontalLayout_calibration_sample_vertical_profile.addWidget(
|
|
# self.label_calibration_sample_vertical_profile)
|
|
#
|
|
# self.combobox_calibration_sample_vertical_profile = CheckableComboBox()
|
|
# self.combobox_calibration_sample_vertical_profile.addItems(["S1, S2, S3", "S4, S5, S6, S7", "S8, S9, S10, S11"])
|
|
# self.horizontalLayout_calibration_sample_vertical_profile.addWidget(
|
|
# self.combobox_calibration_sample_vertical_profile)
|
|
|
|
# --------------------------------------------------------------------------------------------------------------
|
|
### --- Layout of groupbox in the Bottom horizontal layout box
|
|
|
|
# Plot Ctot | Plot PSD fine + sand
|
|
|
|
self.groupbox_plot_total_concentration = QGroupBox()
|
|
self.horizontalLayoutBottom_sampleDataTab.addWidget(self.groupbox_plot_total_concentration, 3)
|
|
|
|
self.groupbox_plot_PSD = QGroupBox()
|
|
self.horizontalLayoutBottom_sampleDataTab.addWidget(self.groupbox_plot_PSD, 6)
|
|
|
|
# +++++++++++++++++++++++++++++++++++++++++++++++++
|
|
# +++ --- GroupBox plot total concentration --- +++
|
|
# +++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
self.verticalLayout_plot_total_concentration = QVBoxLayout(self.groupbox_plot_total_concentration)
|
|
self.canvas_total_concentration = None
|
|
|
|
# self.figure_total_concentration, self.axis_total_concentration \
|
|
# = plt.subplots(nrows=1, ncols=1, layout="constrained")
|
|
# self.canvas_total_concentration = FigureCanvas(self.figure_total_concentration)
|
|
# # self.plotToolbar_sample_total_concentration = NavigationToolBar(self.canvas_sample_total_concentration, self)
|
|
# self.empty_field_for_total_concentration_plot()
|
|
# self.verticalLayout_plot_total_concentration.addWidget(self.canvas_total_concentration)
|
|
|
|
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
# +++ --- GroupBox plot particle size distribution --- +++
|
|
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
self.verticalLayout_plot_PSD = QVBoxLayout(self.groupbox_plot_PSD)
|
|
self.canvas_plot_PSD = None
|
|
|
|
# self.figure_plot_PSD, self.axis_plot_PSD = plt.subplots(nrows=1, ncols=2, layout="constrained")
|
|
# self.canvas_plot_PSD = FigureCanvas(self.figure_plot_PSD)
|
|
# # self.plotToolbar_sample_distribution = NavigationToolBar(self.canvas_sample_distribution, self)
|
|
# self.empty_field_for_plot_fine_PSD_class()
|
|
# self.empty_field_for_plot_sand_PSD_class()
|
|
# self.verticalLayout_plot_PSD.addWidget(self.canvas_plot_PSD)
|
|
|
|
self.retranslate_data_sample_tab()
|
|
|
|
# -------------------- Functions for Sample Data Tab --------------------
|
|
|
|
def retranslate_data_sample_tab(self):
|
|
|
|
self.groupbox_download.setTitle(_translate("CONSTANT_STRING", cs.DOWNLOAD))
|
|
self.groupbox_particle_size_file.setTitle(_translate("CONSTANT_STRING", cs.PARTICLE_SIZE_DISTRIBUTION_FILE))
|
|
self.groupbox_fine_sediment.setTitle(_translate("CONSTANT_STRING", cs.FINE_SEDIMENTS))
|
|
self.groupbox_sand.setTitle(_translate("CONSTANT_STRING", cs.SAND_SEDIMENTS))
|
|
# self.groupbox_total_concentration.setTitle(_translate("CONSTANT_STRING", cs.TOTAL_CONCENTRATION))
|
|
|
|
self.groupbox_table.setTitle(_translate("CONSTANT_STRING", cs.TABLE_VALUES))
|
|
self.pushbutton_fill_table.setText(_translate("CONSTANT_STRING", cs.FILL_TABLE))
|
|
self.allChkBox.setText(_translate("CONSTANT_STRING", cs.CHECK_ALL))
|
|
self.pushButton_export_table.setText(_translate("CONSTANT_STRING", cs.EXPORT_TABLE))
|
|
|
|
self.groupbox_plot_sample_position.setTitle(_translate("CONSTANT_STRING", cs.PLOT_SAMPLE_POSITION))
|
|
|
|
self.groupbox_display_option.setTitle(_translate("CONSTANT_STRING", cs.OPTIONS))
|
|
# self.pushbutton_plot_cumulative_distribution.setText(_translate("CONSTANT_STRING", cs.CUMULATIVE_DISTRIBUTION))
|
|
# self.pushbutton_plot_PSD_distribution.setText(_translate("CONSTANT_STRING", cs.CLASS_DISTRIBUTION))
|
|
# self.label_calibration_sample_vertical_profile.setText(_translate("CONSTANT_STRING", cs.VERTICAL_PROFILE_FOR_CALIBRATION))
|
|
|
|
self.groupbox_plot_total_concentration.setTitle(_translate("CONSTANT_STRING", cs.PLOT_TOTAL_CONCENTRATION))
|
|
|
|
self.groupbox_plot_PSD.setTitle(_translate("CONSTANT_STRING", cs.DISTRIBUTION_PLOT))
|
|
|
|
# ------------------------------------------------------------------------------------------------------------------
|
|
# --- Function to select directory and file name of fine sediments sample data ---
|
|
def open_dialog_box_fine_sediment(self):
|
|
filename_fine_sediment = QFileDialog.getOpenFileName(self, "Open file",
|
|
"/home/bmoudjed/Documents/3 SSC acoustic meas project/Graphical interface project/Data/Granulo_data",
|
|
"Fine sediment file (*.xls, *.ods)")
|
|
path_name = path.dirname(filename_fine_sediment[0])
|
|
file_name = path.basename(filename_fine_sediment[0])
|
|
self.lineEdit_fine_sediment.setText(file_name)
|
|
self.lineEdit_fine_sediment.setToolTip(path_name)
|
|
return filename_fine_sediment[0]
|
|
|
|
# --- Function to select directory and file name of sand sediments sample data ---
|
|
def open_dialog_box_sand_sediment(self):
|
|
filename_sand_sediment = QFileDialog.getOpenFileName(self, "Open file",
|
|
"/home/bmoudjed/Documents/3 SSC acoustic meas project/Graphical interface project/Data/Granulo_data",
|
|
"Sand sediment file (*.xls, *.ods)")
|
|
path_name = path.dirname(filename_sand_sediment[0])
|
|
file_name = path.basename(filename_sand_sediment[0])
|
|
self.lineEdit_sand.setText(file_name)
|
|
self.lineEdit_sand.setToolTip(path_name)
|
|
return filename_sand_sediment[0]
|
|
|
|
# ------------------------------------------------------------------------------------------------------------------
|
|
# --- Function to fill table of values ---
|
|
def fill_table(self):
|
|
if self.lineEdit_fine_sediment.text():
|
|
# print("push button", self.pushbutton_fill_table.isChecked())
|
|
# print("self.lineEdit_fine_sediment.text() ", self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text())
|
|
# print("self.lineEdit_sand.text() ", self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text())
|
|
granulo_data = deepcopy(
|
|
GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
self.row = self.tableWidget_sample.setRowCount(granulo_data._data_fine.shape[0])
|
|
self.col = self.tableWidget_sample.setColumnCount(2*granulo_data._data_fine.shape[1])
|
|
|
|
# --- Set horizontal header ---
|
|
horizontal_header = list(map(str, ["Color", "Sample"] + granulo_data._data_fine.columns.values.tolist() +
|
|
granulo_data._data_sand.columns.values.tolist()[2:]))
|
|
# print(len(horizontal_header))
|
|
for horizontal_header_text in horizontal_header:
|
|
# print(horizontal_header_text)
|
|
self.horizontal_header_item = QTableWidgetItem()
|
|
# print(np.where(horizontal_header == horizontal_header_text)[0][0])
|
|
self.tableWidget_sample.setHorizontalHeaderItem(horizontal_header.index(horizontal_header_text),
|
|
self.horizontal_header_item)
|
|
self.horizontal_header_item.setText(horizontal_header_text)
|
|
|
|
# --- Set vertical header (color) ---
|
|
self.tableWidget_sample.verticalHeader().setVisible(False)
|
|
color_list = CSS4_COLORS
|
|
for i in range(self.tableWidget_sample.rowCount()):
|
|
exec("self.comboBox_sample_table" + str(i) + "= QComboBox()")
|
|
exec("self.comboBox_sample_table" + str(i) + ".addItems(color_list)")
|
|
eval(f"self.tableWidget_sample.setCellWidget(i, 0, self.comboBox_sample_table{i})")
|
|
eval(f"self.comboBox_sample_table{i}.currentTextChanged."
|
|
f"connect(self.extract_position_list_and_color_list_from_table_checkboxes)")
|
|
eval(f"self.comboBox_sample_table{i}.currentTextChanged."
|
|
f"connect(self.update_plot_total_concentration)")
|
|
eval(f"self.comboBox_sample_table{i}.currentTextChanged."
|
|
f"connect(self.update_plot_PSD_fine_and_sand_sediments)")
|
|
|
|
# --- Fill Sample column with checkbox ---
|
|
for i in range(self.tableWidget_sample.rowCount()):
|
|
self.item_checkbox = QTableWidgetItem()
|
|
self.item_checkbox.setCheckState(Qt.Unchecked)
|
|
self.tableWidget_sample.setItem(i, 1, self.item_checkbox)
|
|
self.item_checkbox.setText("S " + str(i + 1))
|
|
# print(f"S{i+1} ", self.tableWidget_sample.item(i, 1).checkState())
|
|
|
|
# --- Fill table with data ---
|
|
for i in range(granulo_data._frac_vol_fine.shape[0]):
|
|
for j in range(granulo_data._frac_vol_fine.shape[1]):
|
|
# self.tableWidget_sample.setItem(i, j + 2, QTableWidgetItem(str(granulo_data._data_fine.iloc[i, j])))
|
|
self.tableWidget_sample.setItem(i, 2, QTableWidgetItem(str(granulo_data._y[i])))
|
|
self.tableWidget_sample.setItem(i, 3, QTableWidgetItem(str(granulo_data._z[i])))
|
|
|
|
self.tableWidget_sample.setItem(i, 4, QTableWidgetItem(str(granulo_data._Ctot_fine[i])))
|
|
self.tableWidget_sample.setItem(i, 5, QTableWidgetItem(str(granulo_data._D50_fine[i])))
|
|
self.tableWidget_sample.setItem(i, j + 6, QTableWidgetItem(str(granulo_data._frac_vol_fine[i, j])))
|
|
|
|
self.tableWidget_sample.setItem(i, granulo_data._frac_vol_fine.shape[1] + 6, QTableWidgetItem(str(granulo_data._Ctot_sand[i])))
|
|
self.tableWidget_sample.setItem(i, granulo_data._frac_vol_fine.shape[1] + 7, QTableWidgetItem(str(granulo_data._D50_sand[i])))
|
|
self.tableWidget_sample.setItem(i, granulo_data._frac_vol_fine.shape[1] + 8 + j, QTableWidgetItem(str(granulo_data._frac_vol_sand[i, j])))
|
|
|
|
# --- Connect checkbox to all checkboxes of tableWidget ---
|
|
# self.allChkBox.stateChanged.connect(self.check_allChkBox)
|
|
|
|
# --- Connect checkbox items of tableWidget to update plots ---
|
|
self.tableWidget_sample.itemChanged.connect(
|
|
self.extract_position_list_and_color_list_from_table_checkboxes)
|
|
self.tableWidget_sample.itemChanged.connect(self.update_plot_total_concentration)
|
|
self.tableWidget_sample.itemChanged.connect(self.update_plot_PSD_fine_and_sand_sediments)
|
|
|
|
else:
|
|
# print("PLease download first file")
|
|
msgBox = QMessageBox()
|
|
msgBox.setWindowTitle("Fill table Error")
|
|
msgBox.setIcon(QMessageBox.Warning)
|
|
msgBox.setText("Download files before fill table")
|
|
msgBox.setStandardButtons(QMessageBox.Ok)
|
|
msgBox.exec()
|
|
|
|
# --- Function to extract position of sample from table checkboxes to update plots ---
|
|
def extract_position_list_and_color_list_from_table_checkboxes(self):
|
|
position = []
|
|
color_list = []
|
|
sample_checkbox = np.zeros((1, len(range(self.tableWidget_sample.rowCount()))))
|
|
for i in range(self.tableWidget_sample.rowCount()):
|
|
if self.tableWidget_sample.item(i, 1).checkState() == 2:
|
|
if self.tableWidget_sample.item(i, 1).checkState() == Qt.Checked:
|
|
position.append(i)
|
|
eval(f"color_list.append(self.comboBox_sample_table{i}.currentText())")
|
|
sample_checkbox[0, i] = 2
|
|
|
|
return position, color_list
|
|
|
|
# --- Function to export data of table ---
|
|
def export_table(self):
|
|
if self.tableWidget_sample.columnCount() > 10:
|
|
print("Export table")
|
|
else:
|
|
msgBox = QMessageBox()
|
|
msgBox.setWindowTitle("Export table Error")
|
|
msgBox.setIcon(QMessageBox.Warning)
|
|
msgBox.setText("Fill table before export table")
|
|
msgBox.setStandardButtons(QMessageBox.Ok)
|
|
msgBox.exec()
|
|
|
|
# ------------------------------------------------------------------------------------------------------------------
|
|
# --- Functions to plot samples positions on transect ---
|
|
# def empty_field_for_transect_plot(self):
|
|
# self.axis_sample_position.set_xticks([])
|
|
# self.axis_sample_position.set_yticks([])
|
|
|
|
# def update_plots_from_table_checkboxes(self):
|
|
# # color_value_row = self.tableWidget_sample.currentRow()
|
|
# # exec("color_value = self.comboBox_sample_table{color_value_row}.currentText()")
|
|
# # eval("color_list.append(color_value)")
|
|
# # print(color_list)
|
|
# position = []
|
|
# color_list = []
|
|
# sample_checkbox = np.zeros((1, len(range(self.tableWidget_sample.rowCount()))))
|
|
# # print(sample_checkbox.shape)
|
|
# for i in range(self.tableWidget_sample.rowCount()):
|
|
# # print(f"S{i+1} ", self.tableWidget_sample.item(i, 1).checkState())
|
|
# if self.tableWidget_sample.item(i, 1).checkState() == 2:
|
|
# if self.tableWidget_sample.item(i, 1).checkState() == Qt.Checked:
|
|
# # print(f"S{i} = Checked")
|
|
# position.append(i)
|
|
# eval(f"color_list.append(self.comboBox_sample_table{i}.currentText())")
|
|
# # print("position", position)
|
|
# # print("color_list", color_list)
|
|
# # self.update_plot_transect_bottom_with_sample_position(position, color_list)
|
|
# self.update_plot_total_concentration(position, color_list)
|
|
# # self.update_plot_fine_and_sand_sediments_PSD(position, color_list)
|
|
# if self.pushbutton_cumulative_PSD.sender():
|
|
# self.update_plot_fine_PSD_cumul(position, color_list)
|
|
# self.update_plot_sand_PSD_cumul(position, color_list)
|
|
# else:
|
|
# self.update_plot_fine_PSD_class(position, color_list)
|
|
# self.update_plot_sand_PSD_class(position, color_list)
|
|
# sample_checkbox[0, i] = 2
|
|
# return position, color_list
|
|
|
|
# print("sample_checkbox", np.append(sample_checkbox, self.tableWidget_sample.item(i, 1).checkState()))
|
|
# print(sample_checkbox[0self.tableWidget_sample.item(i, 1).checkState(), i])
|
|
# sample_checkbox[0, i] == self.tableWidget_sample.item(i, 1).checkState()
|
|
# if self.tableWidget_sample.item(i, 1).checkState() == Qt.Unchecked:
|
|
# print(f"S{i} = Unchecked")
|
|
# elif np.sum(sample_checkbox) == 0:
|
|
# self.plot_total_concentration()
|
|
# print("position", position)
|
|
# print("color_list", color_list)
|
|
# print(self.tableWidget_sample.item(i, 1))
|
|
# print("sample_checkbox tot", sample_checkbox)
|
|
# print(np.any(sample_checkbox == 0, axis=0))
|
|
# print(sample_checkbox.all())
|
|
# print(~sample_checkbox.all())
|
|
# if np.sum(sample_checkbox) == 0:
|
|
# print("True")
|
|
# # self.plot_transect_bottom_with_sample_position()
|
|
# # self.plot_total_concentration()
|
|
# else:
|
|
# print("False")
|
|
|
|
# def choice_color_sample_position_point(self):
|
|
# row_value = self.tableWidget_sample.currentRow()
|
|
# print("row = ", row_value)
|
|
# print(eval(f"self.comboBox_sample_table{row_value}.currentText()"))
|
|
# # print("row value", row_value)
|
|
# # print("cell widget ", self.tableWidget_sample.cellWidget(row_value, 0))
|
|
# # print("isinstance(widget, QComboBox)", isinstance(self.tableWidget_sample.cellWidget(row_value, 0), QComboBox))
|
|
# # print("cell item ", self.tableWidget_sample.item(row_value, 0))
|
|
# # print("combobox tablewidget ", self.comboBox_sample_table.currentText())
|
|
# # print("combobox change value")
|
|
|
|
# def plot_transect_bottom_with_sample_position(self):
|
|
# frequency = self.model.Freq[0]
|
|
# val_min = 0 # np.nanmin(self.model.BS_averaged_cross_section_corr.V[:, 0, :])
|
|
# val_max = np.nanmax(self.model.BS_averaged_cross_section_corr.V[:, 0, :])
|
|
# if val_min == 0:
|
|
# val_min = 1e-5
|
|
# # if val_min == 0:
|
|
# # val_min = 1e-5
|
|
# # self.axis_sampleposition.imshow(np.asarray(np.array(self.model.V[:, 0, :2300], dtype=float)), aspect='auto',
|
|
# # extent=[0, 2300, self.model.depth[-1][0], self.model.depth[0][0]],
|
|
# # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
|
|
# self.axis_sampleposition.pcolormesh(self.model.dist_BS_section,
|
|
# np.flipud(self.model.BS_raw_cross_section.r),
|
|
# self.model.BS_averaged_cross_section_corr.V[:, 0, :],
|
|
# cmap='viridis',
|
|
# norm=LogNorm(vmin=val_min, vmax=val_max), shading='gouraud')
|
|
# self.axis_sampleposition.plot(self.model.dist_BS_section,
|
|
# np.max(self.model.r_bottom_cross_section) - self.model.r_bottom_cross_section
|
|
# + np.min(self.model.r_bottom_cross_section),
|
|
# color='k', linewidth=2)
|
|
# self.axis_sampleposition.set_xticks([])
|
|
# self.axis_sampleposition.set_yticks([])
|
|
# self.figure_sampleposition.canvas.draw_idle()
|
|
#
|
|
# def update_plot_transect_bottom_with_sample_position(self, position_value, color_list):
|
|
# frequency = self.model.Freq[0]
|
|
# val_min = 0 # np.nanmin(self.model.BS_averaged_cross_section_corr.V[:, 0, :])
|
|
# val_max = np.nanmax(self.model.BS_averaged_cross_section_corr.V[:, 0, :])
|
|
# if val_min == 0:
|
|
# val_min = 1e-5
|
|
# # if val_min == 0:
|
|
# # val_min = 1e-5
|
|
# # self.axis_sampleposition.imshow(np.asarray(np.array(self.model.V[:, 0, :2300], dtype=float)), aspect='auto',
|
|
# # extent=[0, 2300, self.model.depth[-1][0], self.model.depth[0][0]],
|
|
# # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
|
|
# self.axis_sampleposition.cla()
|
|
# self.plot_transect_bottom_with_sample_position()
|
|
# self.axis_sampleposition.pcolormesh(self.model.dist_BS_section,
|
|
# np.flipud(self.model.BS_raw_cross_section.r),
|
|
# self.model.BS_averaged_cross_section_corr.V[:, 0, :],
|
|
# cmap='viridis',
|
|
# norm=LogNorm(vmin=val_min, vmax=val_max), shading='gouraud')
|
|
# self.axis_sampleposition.plot(self.model.dist_BS_section,
|
|
# np.max(self.model.r_bottom_cross_section) - self.model.r_bottom_cross_section
|
|
# + np.min(self.model.r_bottom_cross_section),
|
|
# color='k', linewidth=2)
|
|
# # marker_color = ["orange", "green"]
|
|
# # for i in range(len(marker_color)):
|
|
# self.axis_sampleposition.scatter(self.model._fine_sediment_file.iloc[position_value]["y"],
|
|
# np.max(self.model.r_bottom_cross_section) - self.model._fine_sediment_file.iloc[position_value]["z"]
|
|
# + np.min(self.model.r_bottom_cross_section),
|
|
# linestyle='None', marker="o", s=14, c=color_list)
|
|
# # markerfacecolor=["orange", "green"], markeredgecolor=["orange", "green"])
|
|
# # self.axis_sampleposition.set_axis_off()
|
|
# self.axis_sampleposition.set_xticks([])
|
|
# self.axis_sampleposition.set_yticks([])
|
|
# self.figure_sampleposition.canvas.draw_idle()
|
|
# # self.figure_sampleposition.tight_layout()
|
|
|
|
# ------------------------------------------------------------------------------------------------------------------
|
|
# --- Functions to plot total concentration ---
|
|
# def empty_field_for_total_concentration_plot(self):
|
|
# self.axis_total_concentration.cla()
|
|
# self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText())
|
|
# self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText())
|
|
# self.canvas_total_concentration.draw()
|
|
|
|
def update_plot_total_concentration(self):
|
|
if self.tableWidget_sample.columnCount() > 15:
|
|
|
|
# --- Read sample data ---
|
|
granulo_data = deepcopy(
|
|
GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
|
|
# --- Read selected samples (checkboxes) ---
|
|
position_list, color_list = self.extract_position_list_and_color_list_from_table_checkboxes()
|
|
|
|
if position_list == []:
|
|
|
|
msgBox = QMessageBox()
|
|
msgBox.setWindowTitle("Axis choice Error")
|
|
msgBox.setIcon(QMessageBox.Warning)
|
|
msgBox.setText("Select sample(s) before changing axis")
|
|
msgBox.setStandardButtons(QMessageBox.Ok)
|
|
msgBox.exec()
|
|
|
|
else:
|
|
|
|
# --- Create canvas of Matplotlib figure ---
|
|
if self.canvas_total_concentration == None:
|
|
self.figure_total_concentration, self.axis_total_concentration \
|
|
= plt.subplots(nrows=1, ncols=1, layout="constrained")
|
|
self.canvas_total_concentration = FigureCanvas(self.figure_total_concentration)
|
|
self.verticalLayout_plot_total_concentration.addWidget(self.canvas_total_concentration)
|
|
else:
|
|
self.axis_total_concentration.cla()
|
|
|
|
# --- Update total concentration plot according to choices of x-axis and y-axis combo-boxes ---
|
|
# if self.combobox_y_axis.currentIndex() == 0:
|
|
# self.axis_total_concentration.scatter(granulo_data._Ctot_fine[position_list],
|
|
# granulo_data._z[position_list],
|
|
# s=100, facecolor=color_list, edgecolor="None", alpha=0.5)
|
|
# self.axis_total_concentration.scatter(granulo_data._Ctot_sand[position_list],
|
|
# granulo_data._z[position_list],
|
|
# s=300, facecolors="None", edgecolors=color_list)
|
|
# self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText())
|
|
# self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText())
|
|
# elif self. combobox_y_axis.currentIndex() == 1:
|
|
# self.axis_total_concentration.scatter(granulo_data._Ctot_fine[position_list],
|
|
# granulo_data._z[position_list] / np.max(granulo_data._z[position_list]),
|
|
# s=100, facecolor=color_list, edgecolor="None", alpha=0.5)
|
|
# self.axis_total_concentration.scatter(granulo_data._Ctot_sand[position_list],
|
|
# granulo_data._z[position_list],
|
|
# s=300, facecolors="None", edgecolors=color_list)
|
|
# self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText())
|
|
# self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText())
|
|
# self.canvas_total_concentration.draw()
|
|
|
|
if (self.combobox_x_axis.currentIndex() == 0) and (self.combobox_y_axis.currentIndex() == 0):
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_fine[position_list],
|
|
granulo_data._z[position_list],
|
|
s=100, facecolor=color_list, edgecolor="None", alpha=0.5)
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_sand[position_list],
|
|
granulo_data._z[position_list],
|
|
s=300, facecolors="None", edgecolors=color_list)
|
|
self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText())
|
|
self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText())
|
|
elif (self.combobox_x_axis.currentIndex() == 0) and (self. combobox_y_axis.currentIndex() == 1):
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_fine[position_list],
|
|
granulo_data._z[position_list] / np.max(granulo_data._z[position_list]),
|
|
s=100, facecolor=color_list, edgecolor="None", alpha=0.5)
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_sand[position_list],
|
|
granulo_data._z[position_list] / np.max(granulo_data._z[position_list]),
|
|
s=300, facecolors="None", edgecolors=color_list)
|
|
self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText())
|
|
self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText())
|
|
elif (self.combobox_x_axis.currentIndex() == 1) and (self. combobox_y_axis.currentIndex() == 0):
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_fine_per_cent[position_list],
|
|
granulo_data._z[position_list],
|
|
s=100, facecolor=color_list, edgecolor="None", alpha=0.5)
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_sand_per_cent[position_list],
|
|
granulo_data._z[position_list],
|
|
s=300, facecolors="None", edgecolors=color_list)
|
|
self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText())
|
|
self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText())
|
|
elif (self.combobox_x_axis.currentIndex() == 1) and (self. combobox_y_axis.currentIndex() == 1):
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_fine_per_cent[position_list],
|
|
granulo_data._z[position_list] / np.max(granulo_data._z[position_list]),
|
|
s=100, facecolor=color_list, edgecolor="None", alpha=0.5)
|
|
self.axis_total_concentration.scatter(granulo_data._Ctot_sand_per_cent[position_list],
|
|
granulo_data._z[position_list] / np.max(granulo_data._z[position_list]),
|
|
s=300, facecolors="None", edgecolors=color_list)
|
|
self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText())
|
|
self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText())
|
|
self.canvas_total_concentration.draw()
|
|
|
|
else:
|
|
msgBox = QMessageBox()
|
|
msgBox.setWindowTitle("Axis choice Error")
|
|
msgBox.setIcon(QMessageBox.Warning)
|
|
msgBox.setText("Fill table and select sample(s) before changing axis")
|
|
msgBox.setStandardButtons(QMessageBox.Ok)
|
|
msgBox.exec()
|
|
|
|
# ------------------------------------------------------------------------------------------------------------------
|
|
|
|
# def empty_field_to_plot_fine_sediment_distribution(self):
|
|
# if self.pushbutton_class_PSD.sender().text() == "Class PSD":
|
|
# print("button Class PSD")
|
|
# elif self.pushbutton_cumulative_PSD.sender().text() == "Cumulative PSD":
|
|
# print("button Cumulative PSD")
|
|
# # print("cumul button push ", self.pushbutton_cumulative_PSD.sender().text())
|
|
# button = self.sender()
|
|
# self.axis_plot_PSD[0].cla()
|
|
# if self.tableWidget_sample.columnCount() == 10:
|
|
# if button.text() == "Class PSD":
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Size class volume fraction')
|
|
# elif button.text() == "Cumulative PSD":
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Cumulated size volume fraction')
|
|
# else:
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Size class volume fraction')
|
|
# else:
|
|
# print("Table size is not equal to 10")
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def update_plot_fine_sediment_PSD_class_cumul(self, sample_position_list, color_list):
|
|
# granulo_data = deepcopy(
|
|
# GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
# self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
#
|
|
# self.figure_plot_PSD, self.axis_plot_PSD = plt.subplots(nrows=1, ncols=2, layout="constrained")
|
|
# self.canvas_plot_PSD = FigureCanvas(self.figure_plot_PSD)
|
|
# self.verticalLayout_plot_PSD.addWidget(self.canvas_plot_PSD)
|
|
#
|
|
# self.axis_plot_PSD[0].cla()
|
|
# if self.pushbutton_class_PSD.sender().text() == "Class PSD":
|
|
# for profil_position_num, color_plot in zip(sample_position_list, color_list):
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[0].plot(granulo_data._r_grain,
|
|
# granulo_data._frac_vol_fine[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Size class volume fraction')
|
|
# elif self.pushbutton_cumulative_PSD.sender().text() == "Cumulative PSD":
|
|
# for profil_position_num, color_plot in zip(sample_position_list, color_list):
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[0].plot(granulo_data._r_grain,
|
|
# granulo_data._frac_vol_fine_cumul[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Cumulated size volume fraction')
|
|
# else:
|
|
# for profil_position_num, color_plot in zip(sample_position_list, color_list):
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[0].plot(granulo_data._r_grain,
|
|
# granulo_data._frac_vol_fine[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Size class volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def on_clicked_pushbutton_PSD_class(self):
|
|
# if self.pushbutton_class_PSD.sender():
|
|
# print("button is clicked")
|
|
# if self.tableWidget_sample.columnCount() > 10:
|
|
# position, color_list = self.update_plots_from_table_checkboxes()
|
|
# self.update_plot_fine_PSD_class(position, color_list)
|
|
# self.update_plot_sand_PSD_class(position, color_list)
|
|
# else:
|
|
# self.empty_field_for_plot_fine_PSD_class()
|
|
# self.empty_field_for_plot_sand_PSD_class()
|
|
|
|
# def on_clicked_pushbutton_PSD_cumul(self):
|
|
# print(self.pushbutton_cumulative_PSD.sender())
|
|
# if self.tableWidget_sample.columnCount() > 10:
|
|
# position, color_list = self.update_plots_from_table_checkboxes()
|
|
# self.update_plot_fine_PSD_cumul(position, color_list)
|
|
# self.update_plot_sand_PSD_cumul(position, color_list)
|
|
# else:
|
|
# self.empty_field_for_plot_fine_PSD_cumul()
|
|
# self.empty_field_for_plot_sand_PSD_cumul()
|
|
|
|
# def empty_field_for_plot_fine_PSD_class(self):
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Size class volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def empty_field_for_plot_fine_sand_PSD_class(self):
|
|
# button = self.sender()
|
|
# print(button.text())
|
|
#
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[1].cla()
|
|
#
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Size class volume fraction')
|
|
#
|
|
# self.axis_plot_PSD[1].set_xscale('log')
|
|
# self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[1].set_ylabel('Size class volume fraction')
|
|
#
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def mouseClickEvent(self, event):
|
|
# super().mousePressEvent(event)
|
|
# if event.button() == Qt.LeftButton:
|
|
# self.pressedState.emit(True)
|
|
# print(self.pressedState.emit(True))
|
|
|
|
def update_plot_PSD_fine_and_sand_sediments(self):
|
|
if self.tableWidget_sample.columnCount() > 15:
|
|
|
|
# --- Read sample data ---
|
|
granulo_data = deepcopy(
|
|
GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
|
|
# --- Read selected samples (checkboxes) ---
|
|
position_list, color_list = self.extract_position_list_and_color_list_from_table_checkboxes()
|
|
|
|
if position_list == []:
|
|
|
|
msgBox = QMessageBox()
|
|
msgBox.setWindowTitle("Axis choice Error")
|
|
msgBox.setIcon(QMessageBox.Warning)
|
|
msgBox.setText("Select sample(s) before changing axis")
|
|
msgBox.setStandardButtons(QMessageBox.Ok)
|
|
msgBox.exec()
|
|
|
|
else:
|
|
|
|
# --- Create canvas of Matplotlib figure ---
|
|
if self.canvas_plot_PSD == None:
|
|
self.figure_plot_PSD, self.axis_plot_PSD = plt.subplots(nrows=1, ncols=2, layout="constrained")
|
|
self.canvas_plot_PSD = FigureCanvas(self.figure_plot_PSD)
|
|
self.verticalLayout_plot_PSD.addWidget(self.canvas_plot_PSD)
|
|
else:
|
|
self.axis_plot_PSD[0].cla()
|
|
self.axis_plot_PSD[1].cla()
|
|
|
|
if self.combobox_PSD_plot.currentIndex() == 0:
|
|
|
|
for profil_position_num, color_plot in zip(position_list, color_list):
|
|
self.axis_plot_PSD[0].plot(granulo_data._r_grain,
|
|
granulo_data._frac_vol_fine[profil_position_num, :],
|
|
color=color_plot)
|
|
self.axis_plot_PSD[0].set_xscale('log')
|
|
self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
self.axis_plot_PSD[0].set_ylabel('Class size volume fraction')
|
|
|
|
self.axis_plot_PSD[1].plot(granulo_data._r_grain,
|
|
granulo_data._frac_vol_sand[profil_position_num, :],
|
|
color=color_plot)
|
|
self.axis_plot_PSD[1].set_xscale('log')
|
|
self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
self.axis_plot_PSD[1].set_ylabel('Class size volume fraction')
|
|
|
|
elif self.combobox_PSD_plot.currentIndex() == 1:
|
|
|
|
for profil_position_num, color_plot in zip(position_list, color_list):
|
|
self.axis_plot_PSD[0].plot(granulo_data._r_grain,
|
|
granulo_data._frac_vol_fine_cumul[profil_position_num, :],
|
|
color=color_plot)
|
|
self.axis_plot_PSD[0].set_xscale('log')
|
|
self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
self.axis_plot_PSD[0].set_ylabel('Cumulative size volume fraction')
|
|
|
|
self.axis_plot_PSD[1].plot(granulo_data._r_grain,
|
|
granulo_data._frac_vol_sand_cumul[profil_position_num, :],
|
|
color=color_plot)
|
|
self.axis_plot_PSD[1].set_xscale('log')
|
|
self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
self.axis_plot_PSD[1].set_ylabel('Cumulative size volume fraction')
|
|
|
|
self.canvas_plot_PSD.draw()
|
|
|
|
else:
|
|
msgBox = QMessageBox()
|
|
msgBox.setWindowTitle("Plot PSD Error")
|
|
msgBox.setIcon(QMessageBox.Warning)
|
|
msgBox.setText("Fill table and select sample(s) before plotting PSD")
|
|
msgBox.setStandardButtons(QMessageBox.Ok)
|
|
msgBox.exec()
|
|
|
|
# def update_plot_fine_and_sand_sediments_PSD_cumul(self):
|
|
# if self.tableWidget_sample.columnCount() > 15:
|
|
#
|
|
# # --- Read sample data ---
|
|
# granulo_data = deepcopy(
|
|
# GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
# self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
#
|
|
# # --- Read selected samples (checkboxes) ---
|
|
# position_list, color_list = self.extract_position_list_and_color_list_from_table_checkboxes()
|
|
#
|
|
# if position_list == []:
|
|
#
|
|
# msgBox = QMessageBox()
|
|
# msgBox.setWindowTitle("Axis choice Error")
|
|
# msgBox.setIcon(QMessageBox.Warning)
|
|
# msgBox.setText("Select sample(s) before changing axis")
|
|
# msgBox.setStandardButtons(QMessageBox.Ok)
|
|
# msgBox.exec()
|
|
#
|
|
# else:
|
|
#
|
|
# # --- Create canvas of Matplotlib figure ---
|
|
# if self.canvas_plot_PSD == None:
|
|
# self.figure_plot_PSD, self.axis_plot_PSD = plt.subplots(nrows=1, ncols=2, layout="constrained")
|
|
# self.canvas_plot_PSD = FigureCanvas(self.figure_plot_PSD)
|
|
# self.verticalLayout_plot_PSD.addWidget(self.canvas_plot_PSD)
|
|
# else:
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[1].cla()
|
|
#
|
|
# for profil_position_num, color_plot in zip(position_list, color_list):
|
|
# self.axis_plot_PSD[0].plot(granulo_data._r_grain,
|
|
# granulo_data._frac_vol_fine_cumul[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Cumulative size volume fraction')
|
|
#
|
|
# self.axis_plot_PSD[1].plot(granulo_data._r_grain,
|
|
# granulo_data._frac_vol_sand_cumul[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[1].set_xscale('log')
|
|
# self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[1].set_ylabel('Cumulative size volume fraction')
|
|
#
|
|
# self.canvas_plot_PSD.draw()
|
|
#
|
|
# else:
|
|
# msgBox = QMessageBox()
|
|
# msgBox.setWindowTitle("Plot PSD Error")
|
|
# msgBox.setIcon(QMessageBox.Warning)
|
|
# msgBox.setText("Fill table and select sample(s) before plotting PSD")
|
|
# msgBox.setStandardButtons(QMessageBox.Ok)
|
|
# msgBox.exec()
|
|
|
|
# def update_plot_fine_PSD_class(self, profil_position, color_list):
|
|
# granulo_data = deepcopy(
|
|
# GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
# self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
# self.axis_plot_PSD[0].cla()
|
|
# for profil_position_num, color_plot in zip(profil_position, color_list):
|
|
# self.axis_plot_PSD[0].plot(granulo_data._r_grain, granulo_data._frac_vol_fine[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Size class volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def empty_field_for_plot_fine_sand_PSD_cumul(self):
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[1].cla()
|
|
#
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Cumulated size volume fraction')
|
|
#
|
|
# self.axis_plot_PSD[1].set_xscale('log')
|
|
# self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[1].set_ylabel('Cumulated size volume fraction')
|
|
#
|
|
# self.canvas_plot_PSD.draw()
|
|
# def empty_field_for_plot_fine_PSD_cumul(self):
|
|
# self.axis_plot_PSD[0].cla()
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Cumulated size volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def update_plot_fine_PSD_cumul(self, profil_position, color_list):
|
|
# granulo_data = deepcopy(
|
|
# GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
# self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
# self.axis_plot_PSD[0].cla()
|
|
# for profil_position_num, color_plot in zip(profil_position, color_list):
|
|
# self.axis_plot_PSD[0].plot(granulo_data._r_grain, granulo_data._frac_vol_fine_cumul[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[0].set_xscale('log')
|
|
# self.axis_plot_PSD[0].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[0].set_ylabel('Cumulated size volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def empty_field_for_plot_sand_PSD_class(self):
|
|
# self.axis_plot_PSD[1].cla()
|
|
# self.axis_plot_PSD[1].set_xscale('log')
|
|
# self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[1].set_ylabel('Size class volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def update_plot_sand_PSD_class(self, profil_position, color_list):
|
|
# granulo_data = deepcopy(
|
|
# GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
# self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
# self.axis_plot_PSD[1].cla()
|
|
# for profil_position_num, color_plot in zip(profil_position, color_list):
|
|
# self.axis_plot_PSD[1].plot(granulo_data._r_grain, granulo_data._frac_vol_sand[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[1].set_xscale('log')
|
|
# self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[1].set_ylabel('Size class volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def empty_field_for_plot_sand_PSD_cumul(self):
|
|
# self.axis_plot_PSD[1].cla()
|
|
# self.axis_plot_PSD[1].set_xscale('log')
|
|
# self.axis_plot_PSD[1].set_xlabel('Radius ($\mu m$)')
|
|
# self.axis_plot_PSD[1].set_ylabel('Cumulated size volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
# def update_plot_sand_PSD_cumul(self, profil_position, color_list):
|
|
# granulo_data = deepcopy(
|
|
# GranuloLoader(self.lineEdit_fine_sediment.toolTip() + "/" + self.lineEdit_fine_sediment.text(),
|
|
# self.lineEdit_sand.toolTip() + "/" + self.lineEdit_sand.text()))
|
|
# self.axis_plot_PSD[1].cla()
|
|
# for profil_position_num, color_plot in zip(profil_position, color_list):
|
|
# self.axis_plot_PSD[1].plot(granulo_data._r_grain, granulo_data._frac_vol_sand_cumul[profil_position_num, :],
|
|
# color=color_plot)
|
|
# self.axis_plot_PSD[1].set_xscale('log')
|
|
# self.axis_plot_PSD[1].set_xlabel('Radius (m)')
|
|
# self.axis_plot_PSD[1].set_ylabel('Cumulated size volume fraction')
|
|
# self.canvas_plot_PSD.draw()
|
|
|
|
|
|
|