parouby
/
acoused
mirror of https://forgemia.inra.fr/theophile.terraz/acoused
1
0
Fork 0
Code Issues Packages Projects Releases Activity
acoused/View/sample_data_tab.py

2885 lines
164 KiB
Python
Raw Blame History

# ============================================================================== #
# 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 <https://www.gnu.org/licenses/>. #
# 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()
Reference in New Issue View Git Blame Copy Permalink