# ============================================================================== # # mainwindow.py - AcouSed # # Copyright (C) 2024 INRAE # # # # This program is free software: you can redistribute it and/or modify # # it under the terms of the GNU General Public License as published by # # the Free Software Foundation, either version 3 of the License, or # # (at your option) any later version. # # # # This program is distributed in the hope that it will be useful, # # but WITHOUT ANY WARRANTY; without even the implied warranty of # # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # # GNU General Public License for more details. # # # # You should have received a copy of the GNU General Public License # # along with this program. If not, see . # # by Brahim MOUDJED # # ============================================================================== # # -*- coding: utf-8 -*- 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 itertools import matplotlib.pyplot as plt from matplotlib.colors import CSS4_COLORS, LogNorm, BASE_COLORS 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 import csv # from View.show_popup_combobox import ComboBoxShowPopUpWindow from Model.granulo_loader import GranuloLoader from View.checkable_combobox import CheckableComboBox import Translation.constant_string as cs import settings as stg _translate = QCoreApplication.translate class SampleDataTab(QWidget): clickedState = pyqtSignal(bool) ShowPopUpWindowSignal = pyqtSignal() def __init__(self, widget_tab): super().__init__() path_icon = "./icons/" icon_folder = QIcon(path_icon + "folder.png") ### --- 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 # Sample position | Table of values fines # Display options | Table of values sand self.verticalLayout_groupboxes_plot_sample_position_display_option = QVBoxLayout() self.horizontalLayoutTop_sampleDataTab.addLayout(self.verticalLayout_groupboxes_plot_sample_position_display_option, 4) self.groupbox_plot_sample_position_on_transect = QGroupBox() self.verticalLayout_groupboxes_plot_sample_position_display_option.addWidget(self.groupbox_plot_sample_position_on_transect, 7) self.groupbox_display_option = QGroupBox() self.verticalLayout_groupboxes_plot_sample_position_display_option.addWidget(self.groupbox_display_option, 3) # self.verticalLayout_groupboxes_fine_sand = QVBoxLayout() # self.horizontalLayoutTop_sampleDataTab.addLayout(self.verticalLayout_groupboxes_fine_sand, 6) self.groupbox_fine = QGroupBox() self.horizontalLayoutTop_sampleDataTab.addWidget(self.groupbox_fine, 4) self.groupbox_sand = QGroupBox() self.horizontalLayoutTop_sampleDataTab.addWidget(self.groupbox_sand, 4) # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # +++ --- GroupBox download and visualize tables of values --- +++ # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # --- Download + Table of values : fine sediments --- self.verticalLayout_groupbox_fine = QVBoxLayout(self.groupbox_fine) self.groupbox_fine.setTitle("Fine sediments") self.horizontalLayout_download_fine_sediment = QHBoxLayout() self.verticalLayout_groupbox_fine.addLayout(self.horizontalLayout_download_fine_sediment) self.pushbutton_fine_sediment = QPushButton() self.pushbutton_fine_sediment.setIcon(icon_folder) self.horizontalLayout_download_fine_sediment.addWidget(self.pushbutton_fine_sediment) self.lineEdit_fine_sediment = QLineEdit() self.horizontalLayout_download_fine_sediment.addWidget(self.lineEdit_fine_sediment) self.horizontalSpacerItem_fine = QSpacerItem(50, 10, QSizePolicy.Expanding, QSizePolicy.Minimum) self.horizontalLayout_download_fine_sediment.addItem(self.horizontalSpacerItem_fine) # self.pushbutton_fine_sediment.clicked.connect(self.open_dialog_box_fine_sediment) self.tableWidget_fine = QTableWidget() self.row_fine = self.tableWidget_fine.setRowCount(10) self.column_fine = self.tableWidget_fine.setColumnCount(10) self.verticalLayout_groupbox_fine.addWidget(self.tableWidget_fine) # --- Download + Table of values : sand sediments --- self.verticalLayout_groupbox_sand = QVBoxLayout(self.groupbox_sand) self.groupbox_sand.setTitle("Sand sediments") self.horizontalLayout_download_sand_sediment = QHBoxLayout() self.verticalLayout_groupbox_sand.addLayout(self.horizontalLayout_download_sand_sediment) self.pushbutton_sand_sediment = QPushButton() self.pushbutton_sand_sediment.setIcon(icon_folder) self.horizontalLayout_download_sand_sediment.addWidget(self.pushbutton_sand_sediment) self.lineEdit_sand_sediment = QLineEdit() self.horizontalLayout_download_sand_sediment.addWidget(self.lineEdit_sand_sediment) self.horizontalSpacerItem_sand = QSpacerItem(50, 10, QSizePolicy.Expanding, QSizePolicy.Minimum) self.horizontalLayout_download_sand_sediment.addItem(self.horizontalSpacerItem_sand) self.tableWidget_sand = QTableWidget() self.row_sand = self.tableWidget_sand.setRowCount(10) self.column_sand = self.tableWidget_sand.setColumnCount(10) self.verticalLayout_groupbox_sand.addWidget(self.tableWidget_sand) # +++++++++++++++++++++++++++++++++++++++++++++ # +++ --- GroupBox plot sample position --- +++ # +++++++++++++++++++++++++++++++++++++++++++++ self.verticalLayout_groupbox_plot_sample_position_on_transect = QVBoxLayout( self.groupbox_plot_sample_position_on_transect) self.groupbox_plot_sample_position_on_transect.setTitle("Plot samples positions") self.horizontalLayout_pushbutton_comboboxes_sample_position_on_transect = QHBoxLayout() self.verticalLayout_groupbox_plot_sample_position_on_transect.addLayout(self.horizontalLayout_pushbutton_comboboxes_sample_position_on_transect) self.pushbutton_plot_transect = QPushButton() self.pushbutton_plot_transect.setText("Plot Acoustic data") self.horizontalLayout_pushbutton_comboboxes_sample_position_on_transect.addWidget(self.pushbutton_plot_transect) self.combobox_acoustic_data = QComboBox() self.horizontalLayout_pushbutton_comboboxes_sample_position_on_transect.addWidget(self.combobox_acoustic_data) self.combobox_frequencies = QComboBox() self.horizontalLayout_pushbutton_comboboxes_sample_position_on_transect.addWidget(self.combobox_frequencies) self.groupbox_plot_transect = QGroupBox() self.verticalLayout_groupbox_plot_transect = QVBoxLayout(self.groupbox_plot_transect) self.verticalLayout_groupbox_plot_sample_position_on_transect.addWidget(self.groupbox_plot_transect) self.canvas_plot_sample_position_on_transect = FigureCanvas() # self.verticalLayout_groupbox_plot_sample_position_on_transect.addWidget(self.canvas_plot_sample_position_on_transect) self.verticalLayout_groupbox_plot_transect.addWidget(self.canvas_plot_sample_position_on_transect) self.verticalLayout_groupbox_display_option = QVBoxLayout(self.groupbox_display_option) self.groupbox_display_option.setTitle("Display options") # +++++++++++++++++++++++++++++++++++++++ # +++ --- GroupBox display option --- +++ # +++++++++++++++++++++++++++++++++++++++ self.horizontalLayout_pushbutton_combobox_transect = QHBoxLayout() self.verticalLayout_groupbox_display_option.addLayout(self.horizontalLayout_pushbutton_combobox_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.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) # --- 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) # -------------------------------------------------------------------------------------------------------------- ### --- Layout of groupbox in the Bottom horizontal layout box # Plot Ctot | Plot PSD fine + sand # --- Groupbox plot total concentration of sediments --- self.groupbox_plot_total_concentration = QGroupBox() self.horizontalLayoutBottom_sampleDataTab.addWidget(self.groupbox_plot_total_concentration, 3) self.verticalLayout_groupbox_plot_total_concentration = QVBoxLayout(self.groupbox_plot_total_concentration) self.groupbox_plot_total_concentration.setTitle("Plot total concentration") self.canvas_plot_total_concentration = FigureCanvas() self.toolbar_plot_total_concentration = NavigationToolBar(self.canvas_plot_total_concentration, self) self.verticalLayout_groupbox_plot_total_concentration.addWidget(self.toolbar_plot_total_concentration) self.verticalLayout_groupbox_plot_total_concentration.addWidget(self.canvas_plot_total_concentration) # --- Groupbox plot Particle Size Distributions --- self.groupbox_plot_PSD = QGroupBox() self.horizontalLayoutBottom_sampleDataTab.addWidget(self.groupbox_plot_PSD, 6) self.verticalLayout_groupbox_plot_PSD = QVBoxLayout(self.groupbox_plot_PSD) self.groupbox_plot_PSD.setTitle("Plot particle size distribution") self.canvas_plot_PSD = FigureCanvas() self.toolbar_plot_PSD = NavigationToolBar(self.canvas_plot_PSD, self) self.verticalLayout_groupbox_plot_PSD.addWidget(self.toolbar_plot_PSD) self.verticalLayout_groupbox_plot_PSD.addWidget(self.canvas_plot_PSD) # -------------------------------------------------------------------------------------------------------------- # --- Connect signal of widget --- self.pushbutton_fine_sediment.clicked.connect(self.open_dialog_box_fine_sediment) self.pushbutton_sand_sediment.clicked.connect(self.open_dialog_box_sand_sediment) self.pushbutton_plot_transect.clicked.connect(self.fill_comboboxes_and_plot_transect) # self.combobox_acoustic_data.ShowPopUpWindowSignal.connect(self.event_combobobx_acoustic_data) # self.combobox_frequencies.currentTextChanged.connect(self.update_plot_sample_position_on_transect) # self.pushbutton_plot_transect.clicked.connect(self.plot_sample_position_on_transect) # self.combobox_x_axis.currentTextChanged.connect(self.plot_total_concentration) # # self.combobox_y_axis.currentTextChanged.connect(self.plot_total_concentration) self.combobox_PSD_plot.currentTextChanged.connect(self.plot_PSD_fine_and_sand_sediments) # ______ _______ # | | | | \ # | | | | \ # | | | | | # | | | | / # |______| |________ |________/ # COMMENT OLD CODE LINE FROM HERE .... # ### --- 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, 6) # # self.groupbox_display_option = QGroupBox() # self.verticalLayout_sampleposition_displayoption.addWidget(self.groupbox_display_option, 4) # # 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(340, 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) # # # --- Table of values of fine sediments --- # self.groupbox_table_fine = QGroupBox() # self.verticalLayout_groupbox_table_fine = QVBoxLayout(self.groupbox_table_fine) # self.groupbox_table_fine.setTitle("Fine sediments") # self.verticalLayout_groupbox_table.addWidget(self.groupbox_table_fine) # # self.tableWidget_fine = QTableWidget() # self.row_fine = self.tableWidget_fine.setRowCount(10) # self.column_fine = self.tableWidget_fine.setColumnCount(10) # self.verticalLayout_groupbox_table_fine.addWidget(self.tableWidget_fine) # # # --- Table of values of sand sediments --- # self.groupbox_table_sand = QGroupBox() # self.verticalLayout_groupbox_table_sand = QVBoxLayout(self.groupbox_table_sand) # self.groupbox_table_sand.setTitle("Sand sediments") # self.verticalLayout_groupbox_table.addWidget(self.groupbox_table_sand) # # self.tableWidget_sand = QTableWidget() # self.row_sand = self.tableWidget_sand.setRowCount(10) # self.column_sand = self.tableWidget_sand.setColumnCount(10) # self.verticalLayout_groupbox_table_sand.addWidget(self.tableWidget_sand) # # # 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_plot_sample_position_on_transect = 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.horizontalLayout_pushbutton_combobox_transect = QHBoxLayout() # self.verticalLayout_groupbox_display_option.addLayout(self.horizontalLayout_pushbutton_combobox_transect) # # self.pushbutton_plot_transect = QPushButton() # self.pushbutton_plot_transect.setText("Plot transect to visualise sample position") # self.horizontalLayout_pushbutton_combobox_transect.addWidget(self.pushbutton_plot_transect) # # self.pushbutton_plot_transect.clicked.connect(self.plot_sample_position_on_transect) # # self.combobox_frequencies = QComboBox() # self.horizontalLayout_pushbutton_combobox_transect.addWidget(self.combobox_frequencies) # # # self.combobox_frequencies.currentTextChanged.connect(self.update_plot_sample_position_on_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): print("Fine sediment file", [stg.path_fine if stg.path_fine else stg.path_sand if stg.path_sand else stg.path_BS_raw_data[-1] if self.combobox_acoustic_data.count() > 0 else ""][0]) filename_fine_sediment = QFileDialog.getOpenFileName( self, "Fine sediment file", [stg.path_fine if stg.path_fine else stg.path_sand if stg.path_sand else stg.path_BS_raw_data[-1] if self.combobox_acoustic_data.count() > 0 else ""][0], "Fine sediment file (*.xlsx, *xls, *.ods)", options=QFileDialog.DontUseNativeDialog) try: stg.path_fine = path.dirname(filename_fine_sediment[0]) stg.filename_fine = path.basename(filename_fine_sediment[0]) print(stg.path_fine, stg.filename_fine) self.load_fine_sediment_data() except IsADirectoryError: msgBox = QMessageBox() msgBox.setWindowTitle("Download Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please select a file") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() else: self.lineEdit_fine_sediment.clear() self.lineEdit_fine_sediment.setText(stg.filename_fine) self.lineEdit_fine_sediment.setToolTip(stg.path_fine) self.fill_table_fine() # --- Function to select directory and file name of sand sediments sample data --- def open_dialog_box_sand_sediment(self): print("Sand sediment file", [stg.path_sand if stg.path_sand else stg.path_fine if stg.path_fine else stg.path_BS_raw_data[-1] if self.combobox_acoustic_data.count() > 0 else ""][0]) filename_sand_sediment = QFileDialog.getOpenFileName( self, "Sand sediment file", [stg.path_sand if stg.path_sand else stg.path_fine if stg.path_fine else stg.path_BS_raw_data[-1] if self.combobox_acoustic_data.count() > 0 else ""][0], "Sand sediment file (*.xlsx, *xls, *.ods)", options=QFileDialog.DontUseNativeDialog) try: stg.path_sand = path.dirname(filename_sand_sediment[0]) stg.filename_sand = path.basename(filename_sand_sediment[0]) self.load_sand_sediment_data() except IsADirectoryError: msgBox = QMessageBox() msgBox.setWindowTitle("Download Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please select a file") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() else: self.lineEdit_sand_sediment.setText(stg.filename_sand) self.lineEdit_sand_sediment.setToolTip(stg.path_sand) self.fill_table_sand() def load_fine_sediment_data(self): fine_granulo_data = GranuloLoader(stg.path_fine + "/" + stg.filename_fine) stg.columns_fine = fine_granulo_data._data.columns stg.time_fine = fine_granulo_data._time stg.distance_from_bank_fine = fine_granulo_data._y stg.depth_fine = fine_granulo_data._z stg.radius_grain_fine = fine_granulo_data._r_grain stg.Ctot_fine = fine_granulo_data._Ctot stg.D50_fine = fine_granulo_data._D50 stg.frac_vol_fine = fine_granulo_data._frac_vol stg.frac_vol_fine_cumul = fine_granulo_data._frac_vol_cumul def load_sand_sediment_data(self): sand_granulo_data = GranuloLoader(stg.path_sand + "/" + stg.filename_sand) stg.columns_sand = sand_granulo_data._data.columns stg.time_sand = sand_granulo_data._time stg.distance_from_bank_sand = sand_granulo_data._y stg.depth_sand = sand_granulo_data._z stg.radius_grain_sand = sand_granulo_data._r_grain stg.Ctot_sand = sand_granulo_data._Ctot stg.D50_sand = sand_granulo_data._D50 stg.frac_vol_sand = sand_granulo_data._frac_vol stg.frac_vol_sand_cumul = sand_granulo_data._frac_vol_cumul def compute_Ctot_per_cent(self): if (self.lineEdit_fine_sediment.text()) and not (self.lineEdit_sand_sediment.text()): stg.Ctot_fine_per_cent = [100 * f / f for f in stg.Ctot_fine] elif not (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand_sediment.text()): stg.Ctot_sand_per_cent = [100 * s / s for s in stg.Ctot_sand] elif (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand_sediment.text()): stg.Ctot_fine_per_cent = [100 * f / (f + s) for f, s in zip(stg.Ctot_fine, stg.Ctot_sand)] stg.Ctot_sand_per_cent = [100 * s / (f + s) for f, s in zip(stg.Ctot_fine, stg.Ctot_sand)] # ------------------------------------------------------------------------------------------------------------------ # --- Function to fill table of values --- def fill_table_fine(self): # if (self.lineEdit_fine_sediment.text()) and not (self.lineEdit_sand.text()): if self.lineEdit_fine_sediment.text(): self.row_fine = self.tableWidget_fine.setRowCount(len(stg.depth_fine)) self.column_fine = self.tableWidget_fine.setColumnCount(6 + stg.radius_grain_fine.shape[0]) # --- Set horizontal header --- # horizontal_header = list(map(str, ["Color", "Sample"] + stg.fine_sediment_columns + # stg.sand_sediment_columns[2:])) print("stg.columns_fine ", stg.columns_fine) horizontal_header = list(itertools.chain(["Color", "Sample"], list(map(str, stg.columns_fine[[0, 2]])), list(map(str, stg.columns_fine[3:])))) for horizontal_header_text in horizontal_header: # print(horizontal_header_text) self.horizontal_header_item_fine = QTableWidgetItem() # print(np.where(horizontal_header == horizontal_header_text)[0][0]) self.tableWidget_fine.setHorizontalHeaderItem(horizontal_header.index(horizontal_header_text), self.horizontal_header_item_fine) self.horizontal_header_item_fine.setText(horizontal_header_text) # --- Set vertical header (color) --- self.tableWidget_fine.verticalHeader().setVisible(False) color_list = BASE_COLORS for i in range(self.tableWidget_fine.rowCount()): exec("self.comboBox_sample_table_fine" + str(i) + "= QComboBox()") exec("self.comboBox_sample_table_fine" + str(i) + ".addItems(color_list)") eval(f"self.tableWidget_fine.setCellWidget(i, 0, self.comboBox_sample_table_fine{i})") # eval(f"self.comboBox_sample_table_fine{i}.currentTextChanged." # f"connect(self.extract_position_list_and_color_list_from_table_checkboxes_fine)") eval(f"self.comboBox_sample_table_fine{i}.currentTextChanged." f"connect(self.plot_total_concentration)") eval(f"self.comboBox_sample_table_fine{i}.currentTextChanged." f"connect(self.plot_PSD_fine_and_sand_sediments)") eval(f"self.comboBox_sample_table_fine{i}.currentTextChanged." f"connect(self.update_plot_sample_position_on_transect)") # --- Fill Sample column with checkbox --- for i in range(self.tableWidget_fine.rowCount()): self.item_checkbox_fine = QTableWidgetItem() self.item_checkbox_fine.setCheckState(Qt.Checked) self.tableWidget_fine.setItem(i, 1, self.item_checkbox_fine) self.item_checkbox_fine.setText("F" + str(i + 1)) stg.sample_fine.append(("F" + str(i + 1), i)) # print(f"S{i+1} ", self.tableWidget_sample.item(i, 1).checkState()) # --- Fill table with data --- for i in range(stg.frac_vol_fine.shape[0]): for j in range(stg.frac_vol_fine.shape[1]): # self.tableWidget_sample.setItem(i, j + 2, QTableWidgetItem(str(granulo_data._data_fine.iloc[i, j]))) self.tableWidget_fine.setItem(i, 2, QTableWidgetItem(str(stg.time_fine[i]))) self.tableWidget_fine.setItem(i, 3, QTableWidgetItem(str(stg.depth_fine[i]))) self.tableWidget_fine.setItem(i, 4, QTableWidgetItem(str(stg.Ctot_fine[i]))) self.tableWidget_fine.setItem(i, 5, QTableWidgetItem(str(stg.D50_fine[i]))) self.tableWidget_fine.setItem(i, j + 6, QTableWidgetItem(str(stg.frac_vol_fine[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_fine.itemChanged.connect( # self.extract_position_list_and_color_list_from_table_checkboxes_fine) self.tableWidget_fine.itemChanged.connect(self.update_plot_sample_position_on_transect) self.tableWidget_fine.itemChanged.connect(self.plot_total_concentration) self.tableWidget_fine.itemChanged.connect(self.plot_PSD_fine_and_sand_sediments) self.combobox_x_axis.currentIndexChanged.connect(self.plot_total_concentration) self.combobox_y_axis.currentIndexChanged.connect(self.plot_total_concentration) self.plot_sample_position_on_transect() self.plot_total_concentration() self.plot_PSD_fine_and_sand_sediments() # elif not (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand.text()): # # self.row = self.tableWidget_sample.setRowCount(stg.sample_depth.shape[0]) # self.col = self.tableWidget_sample.setColumnCount(6 + stg.radius_grain.shape[0]) # # # --- Set horizontal header --- # # horizontal_header = list(map(str, ["Color", "Sample"] + stg.fine_sediment_columns + # # stg.sand_sediment_columns[2:])) # horizontal_header = list(itertools.chain(["Color", "Sample"], # list(map(str, stg.sand_sediment_columns[[0, 2]])), # # list(map(str, stg.sand_sediment_columns[3:])))) # # 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)") # eval(f"self.comboBox_sample_table{i}.currentTextChanged." # f"connect(self.update_plot_sample_position_on_transect)") # # # --- 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)) # stg.samples.append("S" + str(i + 1)) # # print(f"S{i+1} ", self.tableWidget_sample.item(i, 1).checkState()) # # # --- Fill table with data --- # for i in range(stg.frac_vol_sand.shape[0]): # for j in range(stg.frac_vol_sand.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(stg.sample_time[i]))) # self.tableWidget_sample.setItem(i, 3, QTableWidgetItem(str(stg.sample_depth[i]))) # # self.tableWidget_sample.setItem(i, 4, QTableWidgetItem(str(stg.Ctot_sand[i]))) # self.tableWidget_sample.setItem(i, 5, QTableWidgetItem(str(stg.D50_sand[i]))) # self.tableWidget_sample.setItem(i, j + 6, QTableWidgetItem(str(stg.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) # self.tableWidget_sample.itemChanged.connect(self.update_plot_sample_position_on_transect) # # elif (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand.text()): # print(f"stg.sample_depth.shape[0] {stg.sample_depth.shape[0]}") # self.row = self.tableWidget_sample.setRowCount(stg.sample_depth.shape[0]) # self.col = self.tableWidget_sample.setColumnCount(8+2*stg.radius_grain.shape[0]) # # # --- Set horizontal header --- # # horizontal_header = list(map(str, ["Color", "Sample"] + stg.fine_sediment_columns + # # stg.sand_sediment_columns[2:])) # horizontal_header = list(itertools.chain(["Color", "Sample"], # list(map(str, stg.fine_sediment_columns[[0, 2]])), # list(map(str, stg.fine_sediment_columns[3:])), # list(map(str, stg.sand_sediment_columns[3:])))) # # 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)") # eval(f"self.comboBox_sample_table{i}.currentTextChanged." # f"connect(self.update_plot_sample_position_on_transect)") # # # --- 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)) # stg.samples.append("S" + str(i + 1)) # # print(f"S{i+1} ", self.tableWidget_sample.item(i, 1).checkState()) # # # --- Fill table with data --- # for i in range(stg.frac_vol_fine.shape[0]): # for j in range(stg.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(stg.sample_time[i]))) # self.tableWidget_sample.setItem(i, 3, QTableWidgetItem(str(stg.sample_depth[i]))) # # self.tableWidget_sample.setItem(i, 4, QTableWidgetItem(str(stg.Ctot_fine[i]))) # self.tableWidget_sample.setItem(i, 5, QTableWidgetItem(str(stg.D50_fine[i]))) # self.tableWidget_sample.setItem(i, j + 6, QTableWidgetItem(str(stg.frac_vol_fine[i, j]))) # # self.tableWidget_sample.setItem(i, stg.frac_vol_fine.shape[1] + 6, QTableWidgetItem(str(stg.Ctot_sand[i]))) # self.tableWidget_sample.setItem(i, stg.frac_vol_fine.shape[1] + 7, QTableWidgetItem(str(stg.D50_sand[i]))) # self.tableWidget_sample.setItem(i, stg.frac_vol_fine.shape[1] + 8 + j, QTableWidgetItem(str(stg.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) # self.tableWidget_sample.itemChanged.connect(self.update_plot_sample_position_on_transect) 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() def fill_table_sand(self): # if (self.lineEdit_fine_sediment.text()) and not (self.lineEdit_sand.text()): if self.lineEdit_sand_sediment.text(): self.row_sand = self.tableWidget_sand.setRowCount(len(stg.depth_sand)) self.column_sand = self.tableWidget_sand.setColumnCount(6 + stg.radius_grain_sand.shape[0]) # --- Set horizontal header --- # horizontal_header = list(map(str, ["Color", "Sample"] + stg.fine_sediment_columns + # stg.sand_sediment_columns[2:])) horizontal_header = list(itertools.chain(["Color", "Sample"], list(map(str, stg.columns_sand[[0, 2]])), list(map(str, stg.columns_sand[3:])))) for horizontal_header_text in horizontal_header: # print(horizontal_header_text) self.horizontal_header_item_sand = QTableWidgetItem() # print(np.where(horizontal_header == horizontal_header_text)[0][0]) self.tableWidget_sand.setHorizontalHeaderItem(horizontal_header.index(horizontal_header_text), self.horizontal_header_item_sand) self.horizontal_header_item_sand.setText(horizontal_header_text) # --- Set vertical header (color) --- self.tableWidget_sand.verticalHeader().setVisible(False) color_list = BASE_COLORS for i in range(self.tableWidget_sand.rowCount()): exec("self.comboBox_sample_table_sand" + str(i) + "= QComboBox()") exec("self.comboBox_sample_table_sand" + str(i) + ".addItems(color_list)") eval(f"self.tableWidget_sand.setCellWidget(i, 0, self.comboBox_sample_table_sand{i})") # eval(f"self.comboBox_sample_table_sand{i}.currentTextChanged." # f"connect(self.extract_position_list_and_color_list_from_table_checkboxes_sand)") eval(f"self.comboBox_sample_table_sand{i}.currentTextChanged." f"connect(self.plot_total_concentration)") eval(f"self.comboBox_sample_table_sand{i}.currentTextChanged." f"connect(self.plot_PSD_fine_and_sand_sediments)") eval(f"self.comboBox_sample_table_sand{i}.currentTextChanged." f"connect(self.update_plot_sample_position_on_transect)") # --- Fill Sample column with checkbox --- for i in range(self.tableWidget_sand.rowCount()): self.item_checkbox_sand = QTableWidgetItem() self.item_checkbox_sand.setCheckState(Qt.Checked) self.tableWidget_sand.setItem(i, 1, self.item_checkbox_sand) self.item_checkbox_sand.setText("S" + str(i + 1)) stg.sample_sand.append(("S" + str(i + 1), i)) # print(f"S{i+1} ", self.tableWidget_sample.item(i, 1).checkState()) # --- Fill table with data --- for i in range(stg.frac_vol_sand.shape[0]): for j in range(stg.frac_vol_sand.shape[1]): # self.tableWidget_sample.setItem(i, j + 2, QTableWidgetItem(str(granulo_data._data_fine.iloc[i, j]))) self.tableWidget_sand.setItem(i, 2, QTableWidgetItem(str(stg.time_sand[i]))) self.tableWidget_sand.setItem(i, 3, QTableWidgetItem(str(stg.depth_sand[i]))) self.tableWidget_sand.setItem(i, 4, QTableWidgetItem(str(stg.Ctot_sand[i]))) self.tableWidget_sand.setItem(i, 5, QTableWidgetItem(str(stg.D50_sand[i]))) self.tableWidget_sand.setItem(i, j + 6, QTableWidgetItem(str(stg.frac_vol_sand[i, j]))) # --- Connect checkbox items of tableWidget to update plots --- # self.tableWidget_sand.itemChanged.connect( # self.extract_position_list_and_color_list_from_table_checkboxes_sand) self.tableWidget_sand.itemChanged.connect(self.update_plot_sample_position_on_transect) self.tableWidget_sand.itemChanged.connect(self.plot_total_concentration) self.tableWidget_sand.itemChanged.connect(self.plot_PSD_fine_and_sand_sediments) self.combobox_x_axis.currentIndexChanged.connect(self.plot_total_concentration) self.combobox_y_axis.currentIndexChanged.connect(self.plot_total_concentration) self.plot_sample_position_on_transect() self.plot_total_concentration() self.plot_PSD_fine_and_sand_sediments() # --- Function to extract position of sample from table checkboxes to update plots --- def extract_position_list_and_color_list_from_table_checkboxes_fine(self): # if self.tableWidget_fine.columnCount() > 10: position = [] color_list = [] sample_checkbox = np.zeros((1, len(range(self.tableWidget_fine.rowCount())))) for i in range(self.tableWidget_fine.rowCount()): if self.tableWidget_fine.item(i, 1).checkState() == 2: if self.tableWidget_fine.item(i, 1).checkState() == Qt.Checked: position.append(i) eval(f"color_list.append(self.comboBox_sample_table_fine{i}.currentText())") sample_checkbox[0, i] = 2 print("FINE : position ", position, " color_list ", color_list) return position, color_list def read_select_samples_fine(self): # --- Read selected samples (checkboxes) --- position_list_fine, _ = self.extract_position_list_and_color_list_from_table_checkboxes_fine() Ctot_fine_to_plot = [] Ctot_fine_percent_to_plot = [] sample_depth_to_plot_fine = [] indices_bottom_fine = [] depth_bottom_to_plot_fine = [] print("time fine ", stg.time_fine) for k in range(len(position_list_fine)): # print("k = ", k, "type(k) = ", type(k)) Ctot_fine_to_plot.append(stg.Ctot_fine[position_list_fine[k]]) Ctot_fine_percent_to_plot.append(stg.Ctot_fine_per_cent[position_list_fine[k]]) sample_depth_to_plot_fine.append(stg.depth_fine[position_list_fine[k]]) # if stg.depth_bottom[self.combobox_acoustic_data.currentIndex()].shape != (0,): # print("stg.time_fine ", stg.time_fine[position_list_fine[k]]) # if stg.time_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): # # indices_bottom_fine.append(np.where(np.abs([stg.time_cross_section[ # self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - # stg.time_fine[position_list_fine[k]]]) == # np.nanmin(np.abs(stg.time_cross_section[ # self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - # stg.time_fine[position_list_fine[k]])))[0][0]) # # elif stg.time[self.combobox_acoustic_data.currentIndex()].shape != (0,): # # indices_bottom_fine.append(np.where(np.abs([stg.time[ # self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - # stg.time_fine[position_list_fine[k]]]) == # np.nanmin(np.abs(stg.time[ # self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - # stg.time_fine[position_list_fine[k]])))[0][0]) if stg.time_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): indices_bottom_fine.append(np.where( np.abs(stg.time_cross_section[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex()] - stg.time_fine[position_list_fine[k]]) == np.nanmin( np.abs(stg.time_cross_section[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex()] - stg.time_fine[position_list_fine[k]])))[ 0][0]) else: indices_bottom_fine.append(np.where( np.abs(stg.time[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()] - stg.time_fine[position_list_fine[k]]) == np.nanmin( np.abs( stg.time[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()] - stg.time_fine[position_list_fine[k]])))[ 0][0]) # print("indices_bottom_fine ", indices_bottom_fine) if stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): depth_bottom_to_plot_fine.append( stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), -1]) else: depth_bottom_to_plot_fine.append( stg.depth[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), -1]) if stg.depth_bottom[self.combobox_acoustic_data.currentIndex()].shape != (0,): depth_bottom_to_plot_fine.append( stg.depth_bottom[self.combobox_acoustic_data.currentIndex()][indices_bottom_fine[-1]]) # print("depth_bottom_to_plot_fine ", depth_bottom_to_plot_fine) return Ctot_fine_to_plot, Ctot_fine_percent_to_plot, sample_depth_to_plot_fine, indices_bottom_fine, depth_bottom_to_plot_fine def extract_position_list_and_color_list_from_table_checkboxes_sand(self): if self.tableWidget_sand.columnCount() > 10: position = [] color_list = [] sample_checkbox = np.zeros((1, len(range(self.tableWidget_sand.rowCount())))) for i in range(self.tableWidget_sand.rowCount()): if self.tableWidget_sand.item(i, 1).checkState() == 2: if self.tableWidget_sand.item(i, 1).checkState() == Qt.Checked: position.append(i) eval(f"color_list.append(self.comboBox_sample_table_sand{i}.currentText())") sample_checkbox[0, i] = 2 # print("SAND : position ", position, " color_list ", color_list) # self.update_plot_sample_position_on_transect() return position, color_list def read_select_samples_sand(self): # --- Read selected sand samples (checkboxes) --- position_list_sand, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() Ctot_sand_to_plot = [] Ctot_sand_percent_to_plot = [] sample_depth_to_plot_sand = [] indices_bottom_sand = [] depth_bottom_to_plot_sand = [] for k in range(len(position_list_sand)): Ctot_sand_to_plot.append(stg.Ctot_sand[position_list_sand[k]]) Ctot_sand_percent_to_plot.append(stg.Ctot_sand_per_cent[position_list_sand[k]]) sample_depth_to_plot_sand.append(stg.depth_sand[position_list_sand[k]]) # if stg.depth_bottom[self.combobox_acoustic_data.currentIndex()].shape != (0,): # # indices_bottom_sand.append(np.where(np.abs( # stg.time_cross_section[self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - stg.time_sand[ # position_list_sand[k]]) == # np.nanmin(np.abs(stg.time_cross_section[ # self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - # stg.time_sand[k])))[0][0]) # depth_bottom_to_plot_sand.append( # stg.depth_bottom[self.combobox_acoustic_data.currentIndex()][indices_bottom_sand[-1]]) if stg.time_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): # print("The test 0 : ", np.where(np.abs( # stg.time_cross_section[self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - stg.time_sand[ # position_list_sand[k]]) == # np.nanmin(np.abs(stg.time_cross_section[ # self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - # stg.time_sand[k])))) indices_bottom_sand.append(np.where( np.abs(stg.time_cross_section[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex()] - stg.time_sand[position_list_sand[k]]) == np.nanmin( np.abs(stg.time_cross_section[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex()] - stg.time_sand[position_list_sand[k]])))[ 0][0]) depth_bottom_to_plot_sand.append( stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), -1]) else: # print("The test 1 : ", np.where( # np.abs( # stg.time[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()] - # stg.time_sand[position_list_sand[k]]) == # np.nanmin( # np.abs(stg.time[self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex()] - stg.time_sand[position_list_sand[k]])))) indices_bottom_sand.append(np.where( np.abs( stg.time[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()] - stg.time_sand[position_list_sand[k]]) == np.nanmin( np.abs(stg.time[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex()] - stg.time_sand[position_list_sand[k]])))[ 0][0]) # depth_bottom_to_plot_sand.append( # stg.depth[self.combobox_acoustic_data.currentIndex()][ # self.combobox_frequencies.currentIndex(), -1]) if stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): depth_bottom_to_plot_sand.append( stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), -1]) else: depth_bottom_to_plot_sand.append( stg.depth[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), -1]) if stg.depth_bottom[self.combobox_acoustic_data.currentIndex()].shape != (0,): depth_bottom_to_plot_sand.append( stg.depth_bottom[self.combobox_acoustic_data.currentIndex()][indices_bottom_sand[-1]]) return Ctot_sand_to_plot, Ctot_sand_percent_to_plot, sample_depth_to_plot_sand, indices_bottom_sand, depth_bottom_to_plot_sand def check_allChkBox(self, state): for i in range(self.tableWidget_sample.rowCount()): self.tableWidget_sample.item(i, 1).setCheckState(state) # --- Function to export data of table --- def export_table(self): pass # if self.tableWidget_sample.columnCount() > 10: # name = QFileDialog.getSaveFileName(self, 'Save File') # with open(fichiercsv, 'w', newline='') as csvfile: # csvwriter = csv.writer(csvfile, delimiter=';', quoting=csv.QUOTE_MINIMAL) # for row in range(0, self.tableWidget_sample.rowCount()): # ligne = [] # for col in range(0, self.tableWidget_sample.columnCount()): # valeurcase = self.tableWidget_sample.item(row, col).text().strip() # ligne.append(valeurcase) # csvwriter.writerow(ligne) # 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 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 event_combobobx_acoustic_data(self): self.ShowPopUpWindowSignal.emit() print(stg.filename_BS_raw_data) self.combobox_acoustic_data.clear() for i in range(len(stg.filename_BS_raw_data)): self.combobox_acoustic_data.addItem(stg.filename_BS_raw_data[i]) self.combobox_acoustic_data.showPopup() def fill_comboboxes_and_plot_transect(self): self.combobox_acoustic_data.clear() for n, m in enumerate(stg.noise_method): print("n = ", n, "m = ", m) if stg.noise_method[n] == 0: print("stg.filename_BS_raw_data ", stg.filename_BS_raw_data) self.combobox_acoustic_data.addItem(stg.filename_BS_raw_data[n]) elif stg.noise_method[n]!=0: print("stg.data_preprocessed ", stg.data_preprocessed) print("stg.data_preprocessed[n] ", stg.data_preprocessed[n]) self.combobox_acoustic_data.addItem(stg.data_preprocessed[n]) self.plot_sample_position_on_transect() self.combobox_acoustic_data.currentIndexChanged.connect(self.update_plot_sample_position_on_transect) self.combobox_frequencies.currentIndexChanged.connect(self.update_plot_sample_position_on_transect) def plot_sample_position_on_transect(self): self.verticalLayout_groupbox_plot_transect.removeWidget(self.canvas_plot_sample_position_on_transect) self.figure_plot_sample_position_on_transect, self.axis_plot_sample_position_on_transect = \ plt.subplots(nrows=1, ncols=1, layout="constrained") self.canvas_plot_sample_position_on_transect = FigureCanvas(self.figure_plot_sample_position_on_transect) self.verticalLayout_groupbox_plot_transect.addWidget(self.canvas_plot_sample_position_on_transect) if self.combobox_acoustic_data.count() == 0: if self.tableWidget_fine.columnCount() > 10: position_list_fine, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() self.axis_plot_sample_position_on_transect.scatter( stg.time_fine, stg.depth_fine, linestyle='None', marker="x", s=15, c=color_list_fine, label='fine') for i in range(len(stg.time_fine)): self.axis_plot_sample_position_on_transect.text( stg.time_fine[i] - 25, stg.depth_fine[i] - .1, "F" + str(i+1), fontstyle="normal", fontweight="light", fontsize=8) if self.tableWidget_sand.columnCount() > 10: position_list_sand, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() self.axis_plot_sample_position_on_transect.scatter( stg.time_sand, stg.depth_sand, linestyle='None', marker="o", s=60, facecolors='None', edgecolors=color_list_sand, label='sand') for i in range(len(stg.time_sand)): self.axis_plot_sample_position_on_transect.text( stg.time_sand[i] + 10, stg.depth_sand[i] - .1, "S" + str(i+1), fontstyle="normal", fontweight="light", fontsize=8) else: self.combobox_frequencies.clear() self.combobox_frequencies.addItems(stg.freq_text[self.combobox_acoustic_data.currentIndex()]) # self.combobox_frequencies.currentTextChanged.connect(self.update_plot_sample_position_on_transect) if stg.time_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): if stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time_cross_section[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()] elif stg.depth[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time_cross_section[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth[self.combobox_acoustic_data.currentIndex()] else: if stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()] elif stg.depth[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth[self.combobox_acoustic_data.currentIndex()] if stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin(stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) self.axis_plot_sample_position_on_transect.plot( x_time[self.combobox_frequencies.currentIndex(), :], -stg.depth_bottom[self.combobox_acoustic_data.currentIndex()], color='black', linewidth=1, linestyle="solid") elif stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin(stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) self.axis_plot_sample_position_on_transect.plot( x_time[self.combobox_frequencies.currentIndex(), :], -stg.depth_bottom[self.combobox_acoustic_data.currentIndex()], color='black', linewidth=1, linestyle="solid") elif stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin(stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) self.axis_plot_sample_position_on_transect.plot( x_time[self.combobox_frequencies.currentIndex(), :], -stg.depth_bottom[self.combobox_acoustic_data.currentIndex()], color='black', linewidth=1, linestyle="solid") elif stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin(stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin(stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin(stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) if self.tableWidget_fine.columnCount() > 10: position_list_fine, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() self.axis_plot_sample_position_on_transect.scatter( stg.time_fine, stg.depth_fine, linestyle='None', marker="x", s=15, c=color_list_fine, label='fine') for i in range(len(stg.time_fine)): self.axis_plot_sample_position_on_transect.text( stg.time_fine[i] - 25, stg.depth_fine[i] - .1, "F" + str(i+1), fontstyle="normal", fontweight="light", fontsize=8) if self.tableWidget_sand.columnCount() > 10: position_list_sand, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() self.axis_plot_sample_position_on_transect.scatter( stg.time_sand, stg.depth_sand, linestyle='None', marker="o", s=60, facecolors='None', edgecolors=color_list_sand, label='sand') for i in range(len(stg.time_sand)): self.axis_plot_sample_position_on_transect.text( stg.time_sand[i] + 10, stg.depth_sand[i] - .1, "S" + str(i+1), fontstyle="normal", fontweight="light", fontsize=8) self.axis_plot_sample_position_on_transect.text( 1, .85, stg.freq_text[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()], fontsize=14, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5, horizontalalignment='right', verticalalignment='bottom', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.tick_params(axis='y', labelrotation=90) self.axis_plot_sample_position_on_transect.tick_params(axis='both', labelsize=8) self.axis_plot_sample_position_on_transect.text(.98, .03, "Time (sec)", fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='horizontal', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.text(.04, .53, "Depth (m)", fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='vertical', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.legend(loc="lower left") self.figure_plot_sample_position_on_transect.canvas.draw_idle() def update_plot_sample_position_on_transect(self): self.axis_plot_sample_position_on_transect.cla() if self.combobox_acoustic_data.count() == 0: if self.tableWidget_fine.columnCount() > 10: position_list_fine, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() if len(position_list_fine) != 0: time_fine_to_plot = [] depth_fine_to_plot = [] for k in position_list_fine: time_fine_to_plot.append(stg.time_fine[k]) depth_fine_to_plot.append(stg.depth_fine[k]) self.axis_plot_sample_position_on_transect.scatter( time_fine_to_plot, depth_fine_to_plot, linestyle='None', marker="x", s=15, c=color_list_fine, label='fine') for i in range(len(time_fine_to_plot)): self.axis_plot_sample_position_on_transect.text( time_fine_to_plot[i] - 25, depth_fine_to_plot[i] - .1, "F" + str(i+1), fontstyle="normal", fontweight="light", fontsize=8) if self.tableWidget_sand.columnCount() > 10: position_list_sand, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() if len(position_list_sand) != 0: time_sand_to_plot = [] depth_sand_to_plot = [] for k in position_list_sand: time_sand_to_plot.append(stg.time_sand[k]) depth_sand_to_plot.append(stg.depth_sand[k]) self.axis_plot_sample_position_on_transect.scatter( time_sand_to_plot, depth_sand_to_plot, linestyle='None', marker="o", s=60, facecolors='None', edgecolors=color_list_sand, label='sand') for i in range(len(time_sand_to_plot)): self.axis_plot_sample_position_on_transect.text( time_sand_to_plot[i] + 10, depth_sand_to_plot[i] - .1, "S" + str(i+1), fontstyle="normal", fontweight="light", fontsize=8) else: if stg.time_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): if stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time_cross_section[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()] elif stg.depth[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time_cross_section[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth[self.combobox_acoustic_data.currentIndex()] else: if stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth_cross_section[self.combobox_acoustic_data.currentIndex()] elif stg.depth[self.combobox_acoustic_data.currentIndex()].shape != (0,): x_time = stg.time[self.combobox_acoustic_data.currentIndex()] y_depth = stg.depth[self.combobox_acoustic_data.currentIndex()] # --- Create canvas of Matplotlib figure --- if stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) self.axis_plot_sample_position_on_transect.plot( x_time[self.combobox_frequencies.currentIndex(), :], -stg.depth_bottom[self.combobox_acoustic_data.currentIndex()], color='black', linewidth=1, linestyle="solid") elif stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) self.axis_plot_sample_position_on_transect.plot( x_time[self.combobox_frequencies.currentIndex(), :], -stg.depth_bottom[self.combobox_acoustic_data.currentIndex()], color='black', linewidth=1, linestyle="solid") elif stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin(stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) self.axis_plot_sample_position_on_transect.plot( x_time[self.combobox_frequencies.currentIndex(), :], -stg.depth_bottom[self.combobox_acoustic_data.currentIndex()], color='black', linewidth=1, linestyle="solid") elif stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_cross_section[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) elif stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()].shape != (0,): val_min = np.nanmin( stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) val_max = np.nanmax( stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :]) if val_min == 0: val_min = 1e-5 self.axis_plot_sample_position_on_transect.pcolormesh( x_time[self.combobox_frequencies.currentIndex(), :], -y_depth[self.combobox_frequencies.currentIndex(), :], stg.BS_raw_data[self.combobox_acoustic_data.currentIndex()][ self.combobox_frequencies.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) # --- Read selected samples (checkboxes) --- if self.tableWidget_fine.columnCount() > 10: position_list_fine, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() if len(position_list_fine) != 0: time_fine_to_plot = [] depth_fine_to_plot = [] label_fine_to_plot = [] for k in position_list_fine: time_fine_to_plot.append(stg.time_fine[k]) depth_fine_to_plot.append(stg.depth_fine[k]) label_fine_to_plot.append(stg.sample_fine[k][0]) self.axis_plot_sample_position_on_transect.scatter( time_fine_to_plot, depth_fine_to_plot, linestyle='None', marker="x", s=15, c=color_list_fine, label='fine') for i in range(len(time_fine_to_plot)): self.axis_plot_sample_position_on_transect.text( time_fine_to_plot[i] - 25, depth_fine_to_plot[i] - .1, label_fine_to_plot[i], fontstyle="normal", fontweight="light", fontsize=8) if self.tableWidget_sand.columnCount() > 10: position_list_sand, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() if len(position_list_sand) != 0: time_sand_to_plot = [] depth_sand_to_plot = [] label_sand_to_plot = [] for k in position_list_sand: time_sand_to_plot.append(stg.time_sand[k]) depth_sand_to_plot.append(stg.depth_sand[k]) label_sand_to_plot.append(stg.sample_sand[k][0]) self.axis_plot_sample_position_on_transect.scatter( time_sand_to_plot, depth_sand_to_plot, linestyle='None', marker="o", s=60, facecolors='None', edgecolors=color_list_sand, label='sand') for i in range(len(time_sand_to_plot)): self.axis_plot_sample_position_on_transect.text( time_sand_to_plot[i] + 10, depth_sand_to_plot[i] - .1, label_sand_to_plot[i], fontstyle="normal", fontweight="light", fontsize=8) self.axis_plot_sample_position_on_transect.text( 1, .85, stg.freq_text[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()], fontsize=14, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5, horizontalalignment='right', verticalalignment='bottom', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.tick_params(axis='y', labelrotation=90) self.axis_plot_sample_position_on_transect.tick_params(axis='both', labelsize=8) self.axis_plot_sample_position_on_transect.text(.98, .03, "Time (sec)", fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='horizontal', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.text(.04, .53, "Depth (m)", fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='vertical', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.legend(loc="lower right") self.figure_plot_sample_position_on_transect.canvas.draw_idle() # if stg.BS_raw_data.size == 0: # # self.verticalLayout_groupbox_plot_sample_position.removeWidget(self.canvas_plot_sample_position_on_transect) # self.figure_plot_sample_position_on_transect, self.axis_plot_sample_position_on_transect = \ # plt.subplots(nrows=1, ncols=1, layout="constrained") # self.canvas_plot_sample_position_on_transect = FigureCanvas(self.figure_plot_sample_position_on_transect) # self.verticalLayout_groupbox_plot_sample_position.addWidget(self.canvas_plot_sample_position_on_transect) # # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[position_list], # stg.sample_depth[position_list], # linestyle='None', marker="o", s=14, c=color_list) # # self.axis_plot_sample_position_on_transect.set_xticks([]) # self.axis_plot_sample_position_on_transect.set_yticks([]) # self.figure_plot_sample_position_on_transect.canvas.draw_idle() # # elif stg.BS_stream_bed.size == 0: # # val_min = np.nanmin(stg.BS_cross_section[stg.freq_bottom_detection, :, :]) # val_max = np.nanmax(stg.BS_cross_section[stg.freq_bottom_detection, :, :]) # if val_min == 0: # val_min = 1e-5 # # self.axis_plot_sample_position_on_transect.pcolormesh( # stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :], # stg.BS_cross_section[self.combobox_frequencies.currentIndex(), :, :], # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) # # if stg.r_bottom.size != 0: # self.axis_plot_sample_position_on_transect.plot( # stg.t[stg.freq_bottom_detection, :], -stg.r_bottom, # color='black', linewidth=1, linestyle="solid") # # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[position_list], # stg.sample_depth[position_list], # linestyle='None', marker="o", s=14, c=color_list) # # # self.axis_plot_sample_position_on_transect.set_xticks([]) # self.axis_plot_sample_position_on_transect.set_yticks([]) # self.figure_plot_sample_position_on_transect.canvas.draw_idle() # # else: # # val_min = np.nanmin(stg.BS_stream_bed[stg.freq_bottom_detection, :, :]) # val_max = np.nanmax(stg.BS_stream_bed[stg.freq_bottom_detection, :, :]) # if val_min == 0: # val_min = 1e-5 # # self.axis_plot_sample_position_on_transect.pcolormesh( # stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :], # stg.BS_stream_bed[self.combobox_frequencies.currentIndex(), :, :], # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) # # if stg.r_bottom.size != 0: # self.axis_plot_sample_position_on_transect.plot( # stg.t[stg.freq_bottom_detection, :], -stg.r_bottom, color='black', linewidth=1, linestyle="solid") # # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[position_list], # stg.sample_depth[position_list], # linestyle='None', marker="o", s=14, c=color_list) # # self.axis_plot_sample_position_on_transect.set_xticks([]) # self.axis_plot_sample_position_on_transect.set_yticks([]) # self.figure_plot_sample_position_on_transect.canvas.draw_idle() # ------------------------------------------------------------------------------------------------------------------ # --- 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 plot_total_concentration(self): """ Update total concentration plot according to choices of x-axis and y-axis combo-boxes """ if (self.tableWidget_fine.columnCount() == 10) and (self.tableWidget_sand.columnCount() == 10): 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() else: self.verticalLayout_groupbox_plot_total_concentration.removeWidget(self.canvas_plot_total_concentration) self.verticalLayout_groupbox_plot_total_concentration.removeWidget(self.toolbar_plot_total_concentration) self.figure_total_concentration, self.axis_total_concentration \ = plt.subplots(nrows=1, ncols=1, layout="constrained") self.canvas_plot_total_concentration = FigureCanvas(self.figure_total_concentration) self.toolbar_plot_total_concentration = NavigationToolBar(self.canvas_plot_total_concentration, self) self.verticalLayout_groupbox_plot_total_concentration.addWidget(self.toolbar_plot_total_concentration) self.verticalLayout_groupbox_plot_total_concentration.addWidget(self.canvas_plot_total_concentration) print("axis_total_concentration ", self.axis_total_concentration) # =================================================== # --- FINE file uploaded / SAND file NOT uploaded --- if (self.lineEdit_fine_sediment.text()) and not (self.lineEdit_sand_sediment.text()): self.compute_Ctot_per_cent() _, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() (Ctot_fine_to_plot, Ctot_fine_percent_to_plot, sample_depth_to_plot_fine, indices_bottom_fine, depth_bottom_to_plot_fine) = self.read_select_samples_fine() # self.axis_total_concentration.cla() # --- Concentration (g/L) VS z (m) --- if (self.combobox_x_axis.currentIndex() == 0) and (self.combobox_y_axis.currentIndex() == 0): self.axis_total_concentration.cla() self.axis_total_concentration.scatter(Ctot_fine_to_plot, sample_depth_to_plot_fine, s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (%) VS z (m) --- elif (self.combobox_x_axis.currentIndex() == 1) and (self.combobox_y_axis.currentIndex() == 0): self.axis_total_concentration.cla() self.axis_total_concentration.scatter(Ctot_fine_percent_to_plot, sample_depth_to_plot_fine, s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') self.axis_total_concentration.set_xlim(0, 100) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (g/L) VS z / h --- elif (self.combobox_x_axis.currentIndex() == 0) and (self.combobox_y_axis.currentIndex() == 1): self.axis_total_concentration.cla() if stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): self.axis_total_concentration.scatter( Ctot_fine_to_plot, [x / y for x, y in zip(sample_depth_to_plot_fine, depth_bottom_to_plot_fine)], s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') else: msgBox = QMessageBox() msgBox.setWindowTitle("Axis choice Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please detect bottom before plotting axis z/h") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() self.axis_total_concentration.set_ylim(-1, 0) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (%) VS z / h --- elif (self.combobox_x_axis.currentIndex() == 1) and (self.combobox_y_axis.currentIndex() == 1): self.axis_total_concentration.cla() if stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): self.axis_total_concentration.scatter( Ctot_fine_percent_to_plot, [x / y for x, y in zip(sample_depth_to_plot_fine, depth_bottom_to_plot_fine)], s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') else: msgBox = QMessageBox() msgBox.setWindowTitle("Axis choice Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please detect bottom before plotting axis z/h") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() self.axis_total_concentration.set_xlim(0, 100) self.axis_total_concentration.set_ylim(-1, 0) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # self.figure_total_concentration.canvas.draw_idle() # =================================================== # --- FINE file NOT uploaded / SAND file uploaded --- elif not (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand_sediment.text()): self.compute_Ctot_per_cent() print("Ctot sand % ", stg.Ctot_sand_per_cent) _, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() (Ctot_sand_to_plot, Ctot_sand_percent_to_plot, sample_depth_to_plot_sand, indices_bottom_sand, depth_bottom_to_plot_sand) = self.read_select_samples_sand() # self.axis_total_concentration.cla() # --- Concentration (g/L) VS z (m) --- if (self.combobox_x_axis.currentIndex() == 0) and (self.combobox_y_axis.currentIndex() == 0): self.axis_total_concentration.cla() print("Je suis dans 1") self.axis_total_concentration.scatter(Ctot_sand_to_plot, sample_depth_to_plot_sand, s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (%) VS z (m) --- elif (self.combobox_x_axis.currentIndex() == 1) and (self.combobox_y_axis.currentIndex() == 0): self.axis_total_concentration.cla() print("Je suis dans 2") print("Ctot_sand_percent_to_plot ", Ctot_sand_percent_to_plot) self.axis_total_concentration.scatter(Ctot_sand_percent_to_plot, sample_depth_to_plot_sand, s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') self.axis_total_concentration.set_xlim(0, 100) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (g/L) VS z / h --- elif (self.combobox_x_axis.currentIndex() == 0) and (self.combobox_y_axis.currentIndex() == 1): self.axis_total_concentration.cla() print("Je suis dans 3") if stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): self.axis_total_concentration.scatter( Ctot_sand_to_plot, [x / y for x, y in zip(sample_depth_to_plot_sand, depth_bottom_to_plot_sand)], # stg.depth_bottom[self.combobox_acoustic_data.currentIndex()][indices_bottom_sand], s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') else: msgBox = QMessageBox() msgBox.setWindowTitle("Axis choice Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please detect bottom before plotting axis z/h") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() self.axis_total_concentration.set_ylim(-1, 0) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (%) VS z / h --- elif (self.combobox_x_axis.currentIndex() == 1) and (self.combobox_y_axis.currentIndex() == 1): self.axis_total_concentration.cla() print("Je suis dans 4") if stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): self.axis_total_concentration.scatter( Ctot_sand_percent_to_plot, [x / y for x, y in zip(sample_depth_to_plot_sand, depth_bottom_to_plot_sand)], # stg.depth_bottom[self.combobox_acoustic_data.currentIndex()][indices_bottom_sand], s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') else: msgBox = QMessageBox() msgBox.setWindowTitle("Axis choice Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please detect bottom before plotting axis z/h") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() self.axis_total_concentration.set_xlim(0, 100) self.axis_total_concentration.set_ylim(-1, 0) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # self.figure_total_concentration.canvas.draw_idle() # =============================================== # --- FINE file uploaded / SAND file uploaded --- elif (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand_sediment.text()): self.compute_Ctot_per_cent() _, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() (Ctot_fine_to_plot, Ctot_fine_percent_to_plot, sample_depth_to_plot_fine, indices_bottom_fine, depth_bottom_to_plot_fine) = self.read_select_samples_fine() _, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() (Ctot_sand_to_plot, Ctot_sand_percent_to_plot, sample_depth_to_plot_sand, indices_bottom_sand, depth_bottom_to_plot_sand) = self.read_select_samples_sand() # --- Concentration (g/L) VS z (m) --- if (self.combobox_x_axis.currentIndex() == 0) and (self.combobox_y_axis.currentIndex() == 0): self.axis_total_concentration.cla() self.axis_total_concentration.scatter(Ctot_fine_to_plot, sample_depth_to_plot_fine, s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') self.axis_total_concentration.scatter(Ctot_sand_to_plot, sample_depth_to_plot_sand, s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (%) VS z (m) --- elif (self.combobox_x_axis.currentIndex() == 1) and (self.combobox_y_axis.currentIndex() == 0): self.axis_total_concentration.cla() print("Ctot_fine_percent_to_plot", Ctot_fine_percent_to_plot) print("sample_depth_to_plot_fine", sample_depth_to_plot_fine) self.axis_total_concentration.scatter(Ctot_fine_percent_to_plot, sample_depth_to_plot_fine, s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') self.axis_total_concentration.scatter(Ctot_sand_percent_to_plot, sample_depth_to_plot_sand, s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') self.axis_total_concentration.set_xlim(0, 100) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (g/L) VS z / h --- elif (self.combobox_x_axis.currentIndex() == 0) and (self.combobox_y_axis.currentIndex() == 1): self.axis_total_concentration.cla() if stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): print("x/y ", [x / y for x, y in zip(sample_depth_to_plot_fine, depth_bottom_to_plot_fine)]) self.axis_total_concentration.scatter( Ctot_fine_to_plot, [x / y for x, y in zip(sample_depth_to_plot_fine, depth_bottom_to_plot_fine)], s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') self.axis_total_concentration.scatter( Ctot_sand_to_plot, [x / y for x, y in zip(sample_depth_to_plot_sand, depth_bottom_to_plot_sand)], s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') else: msgBox = QMessageBox() msgBox.setWindowTitle("Axis choice Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please detect bottom before plotting axis z/h") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() self.axis_total_concentration.set_ylim(-1, 0) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) # --- Concentration (%) VS z / h --- elif (self.combobox_x_axis.currentIndex() == 1) and (self.combobox_y_axis.currentIndex() == 1): self.axis_total_concentration.cla() if stg.BS_stream_bed[self.combobox_acoustic_data.currentIndex()].shape != (0,): self.axis_total_concentration.scatter( Ctot_fine_percent_to_plot, [x / y for x, y in zip(sample_depth_to_plot_fine, depth_bottom_to_plot_fine)], s=100, facecolor=color_list_fine, edgecolor="None", alpha=0.5, label='fine') self.axis_total_concentration.scatter( Ctot_sand_percent_to_plot, [x / y for x, y in zip(sample_depth_to_plot_sand, depth_bottom_to_plot_sand)], s=300, facecolor="None", edgecolor=color_list_sand, alpha=0.5, label='sand') else: msgBox = QMessageBox() msgBox.setWindowTitle("Axis choice Error") msgBox.setIcon(QMessageBox.Warning) msgBox.setText("Please detect bottom before plotting axis z/h") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec() self.axis_total_concentration.set_xlim(0, 100) self.axis_total_concentration.set_ylim(-1, 0) self.axis_total_concentration.set_xlabel(self.combobox_x_axis.currentText()) self.axis_total_concentration.set_ylabel(self.combobox_y_axis.currentText()) self.axis_total_concentration.legend(loc="upper right") self.figure_total_concentration.canvas.draw_idle() # ------------------------------------------------------------------------------------------------------------------ # 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 plot_PSD_fine_and_sand_sediments(self): """ Update the plot of Particle Size Distribution according to choices of x-axis and y-axis combo-boxes """ if (self.tableWidget_fine.columnCount() == 10) and (self.tableWidget_sand.columnCount() == 10): 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() # if (position_list_fine == []) and (position_list_sand == []): # # 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: self.verticalLayout_groupbox_plot_PSD.removeWidget(self.canvas_plot_PSD) self.verticalLayout_groupbox_plot_PSD.removeWidget(self.toolbar_plot_PSD) 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.toolbar_plot_PSD = NavigationToolBar(self.canvas_plot_PSD, self) self.verticalLayout_groupbox_plot_PSD.addWidget(self.toolbar_plot_PSD) self.verticalLayout_groupbox_plot_PSD.addWidget(self.canvas_plot_PSD) # --- FINE file uploaded / SAND file NOT uploaded --- if (self.lineEdit_fine_sediment.text()) and not (self.lineEdit_sand_sediment.text()): self.axis_plot_PSD[0].cla() self.axis_plot_PSD[1].cla() position_list_fine, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() if self.combobox_PSD_plot.currentIndex() == 0: for profil_position_num, color_plot in zip(position_list_fine, color_list_fine): self.axis_plot_PSD[0].plot(stg.radius_grain_fine, stg.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() 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_fine, color_list_fine): self.axis_plot_PSD[0].plot(stg.radius_grain_fine, stg.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() 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') self.figure_plot_PSD.canvas.draw_idle() # --- FINE file NOT uploaded / SAND file uploaded --- if not (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand_sediment.text()): self.axis_plot_PSD[0].cla() self.axis_plot_PSD[1].cla() position_list_sand, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() if self.combobox_PSD_plot.currentIndex() == 0: for profil_position_num, color_plot in zip(position_list_sand, color_list_sand): self.axis_plot_PSD[0].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(stg.radius_grain_sand, stg.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_sand, color_list_sand): self.axis_plot_PSD[0].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(stg.radius_grain_sand, stg.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.figure_plot_PSD.canvas.draw_idle() # --- FINE file uploaded / SAND file uploaded --- if (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand_sediment.text()): self.axis_plot_PSD[0].cla() self.axis_plot_PSD[1].cla() position_list_fine, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine() position_list_sand, color_list_sand = self.extract_position_list_and_color_list_from_table_checkboxes_sand() if self.combobox_PSD_plot.currentIndex() == 0: for profil_position_num_fine, color_plot_fine in zip(position_list_fine, color_list_fine): self.axis_plot_PSD[0].plot(stg.radius_grain_fine, stg.frac_vol_fine[profil_position_num_fine, :], color=color_plot_fine) 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') for profil_position_num_sand, color_plot_sand in zip(position_list_sand, color_list_sand): self.axis_plot_PSD[1].plot(stg.radius_grain_sand, stg.frac_vol_sand[profil_position_num_sand, :], color=color_plot_sand) 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_fine, color_plot_fine in zip(position_list_fine, color_list_fine): self.axis_plot_PSD[0].plot(stg.radius_grain_fine, stg.frac_vol_fine_cumul[profil_position_num_fine, :], color=color_plot_fine) 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') for profil_position_num_sand, color_plot_sand in zip(position_list_sand, color_list_sand): self.axis_plot_PSD[1].plot(stg.radius_grain_sand, stg.frac_vol_sand_cumul[profil_position_num_sand, :], color=color_plot_sand) 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.figure_plot_PSD.canvas.draw_idle() # # --- 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() # # elif (self.lineEdit_fine_sediment.text()) and not (self.lineEdit_sand.text()): # # 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(stg.radius_grain, # stg.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() # 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(stg.radius_grain, # stg.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() # 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() # # elif not (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand.text()): # # # --- 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() # 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(stg.radius_grain, # stg.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() # 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(stg.radius_grain, # stg.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() # # elif (self.lineEdit_fine_sediment.text()) and (self.lineEdit_sand.text()): # # # --- 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(stg.radius_grain, # stg.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(stg.radius_grain, # stg.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(stg.radius_grain, # stg.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(stg.radius_grain, # stg.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()