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

3324 lines
189 KiB
Python
Raw Blame History

import sys
from PyQt5.QtWidgets import (QWidget, QHBoxLayout, QVBoxLayout, QPushButton, QGroupBox, QLabel, QCheckBox,
QSpinBox, QDoubleSpinBox, QComboBox, QLineEdit, QSlider, QGridLayout, QMessageBox,
QScrollArea, QRadioButton, QFileDialog, QSpacerItem, QSizePolicy, QTextEdit, QPlainTextEdit)
from PyQt5.QtGui import QFont, QIcon, QPixmap, QSyntaxHighlighter, QTextCharFormat
from PyQt5.QtCore import Qt, QCoreApplication, QEvent, pyqtSignal
import numpy as np
from copy import deepcopy
from scipy.ndimage import convolve1d
import matplotlib.pyplot as plt
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolBar
from matplotlib.colors import LogNorm, BoundaryNorm
from scipy import stats
from os import path
from View.show_popup_combobox import ComboBoxShowPopUpWindow
import Translation.constant_string as cs
from Model.acoustic_data_loader import AcousticDataLoader
import settings as stg
_translate = QCoreApplication.translate
class SyntaxHighlighter(QSyntaxHighlighter):
def __init__(self, parent):
super(SyntaxHighlighter, self).__init__(parent)
self._highlight_lines = dict()
def highlight_line(self, line, fmt):
if isinstance(line, int) and line >= 0 and isinstance(fmt, QTextCharFormat):
self._highlight_lines[line] = fmt
tb = self.document().findBlockByLineNumber(line)
self.rehighlightBlock(tb)
print("self._highlight_lines ", self._highlight_lines[line])
print("tb", tb)
print("self.rehighlightBlock(tb) ", self.rehighlightBlock(tb))
def clear_highlight(self):
self._highlight_lines = dict()
self.rehighlight()
print("self._highlight_lines ", self._highlight_lines)
def highlightBlock(self, text):
line = self.currentBlock().blockNumber()
fmt = self._highlight_lines.get(line)
if fmt is not None:
self.setFormat(0, len(text), fmt)
class SignalProcessingTab(QWidget):
''' This class generates the Signal Processing Tab '''
FillCombobox = pyqtSignal()
def __init__(self, widget_tab):
super().__init__()
self.path_icon = "./icons/"
self.icon_folder = QIcon(self.path_icon + "folder.png")
self.icon_triangle_left = QIcon(self.path_icon + "triangle_left.png")
self.icon_triangle_right = QIcon(self.path_icon + "triangle_right.png")
self.icon_triangle_left_to_begin = QIcon(self.path_icon + "triangle_left_to_begin.png")
self.icon_triangle_right_to_end = QIcon(self.path_icon + "triangle_right_to_end.png")
self.icon_update = QIcon(self.path_icon + "update.png")
self.icon_clear = QIcon(self.path_icon + "clear.png")
### --- General layout of widgets ---
self.verticalLayoutMain = QVBoxLayout(widget_tab)
self.horizontalLayout_Top = QHBoxLayout()
self.verticalLayoutMain.addLayout(self.horizontalLayout_Top, 5)
self.horizontalLayout_Bottom = QHBoxLayout()
self.verticalLayoutMain.addLayout(self.horizontalLayout_Bottom, 5)
# --------------------------------------------------------------------------------------------------------------
### --- Layout of groupbox in the top layout box
self.groupbox_study_data = QGroupBox()
self.horizontalLayout_Top.addWidget(self.groupbox_study_data, 2)
self.groupbox_plot_SNR = QGroupBox()
self.horizontalLayout_Top.addWidget(self.groupbox_plot_SNR, 4)
self.groupbox_plot_BS_signal_filtered_with_SNR = QGroupBox()
self.horizontalLayout_Top.addWidget(self.groupbox_plot_BS_signal_filtered_with_SNR, 4)
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# +++ --- Download noise file + compute noise data from profile tail + --- +++
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
self.verticalLayout_groupbox_study_data = QVBoxLayout(self.groupbox_study_data)
self.groupbox_data_to_be_processed = QGroupBox()
self.horizontalLayout_groupbox_data_to_be_processed = QHBoxLayout(self.groupbox_data_to_be_processed)
self.groupbox_data_to_be_processed.setTitle("Data to be processed")
# self.textEdit_acoustic_file_to_be_processed = QTextEdit()
# self.verticalLayout_groupbox_data_to_be_processed.addWidget(self.textEdit_acoustic_file_to_be_processed)
self.combobox_fileListWidget = ComboBoxShowPopUpWindow()
self.horizontalLayout_groupbox_data_to_be_processed.addWidget(self.combobox_fileListWidget)
self.pushbutton_update = QPushButton()
self.pushbutton_update.setIcon(self.icon_update)
self.pushbutton_update.setMaximumWidth(40)
self.horizontalLayout_groupbox_data_to_be_processed.addWidget(self.pushbutton_update)
self.verticalLayout_groupbox_study_data.addWidget(self.groupbox_data_to_be_processed)
### --- Radio button : File VS Profile tail VS Value ---
self.gridLayout_radiobutton_noise_data = QGridLayout()
self.verticalLayout_groupbox_study_data.addLayout(self.gridLayout_radiobutton_noise_data)
self.radiobutton_file = QRadioButton("File")
self.radiobutton_file.setChecked(True)
self.gridLayout_radiobutton_noise_data.addWidget(self.radiobutton_file, 0, 0, 1, 1)
self.radiobutton_profile_tail = QRadioButton("Profile tail")
# self.radiobutton_file.setChecked(False)
self.gridLayout_radiobutton_noise_data.addWidget(self.radiobutton_profile_tail, 0, 1, 1, 1)
self.radiobutton_value = QRadioButton("Value")
self.gridLayout_radiobutton_noise_data.addWidget(self.radiobutton_value, 0, 2, 1, 1)
self.pushbutton_clear_noise = QPushButton()
self.pushbutton_clear_noise.setIcon(self.icon_clear)
self.pushbutton_clear_noise.setMaximumWidth(50)
self.gridLayout_radiobutton_noise_data.addWidget(self.pushbutton_clear_noise, 0, 3, 1, 1)
### --- Groupbox download noise file ---
self.groupbox_download_noise_file = QGroupBox()
self.groupbox_download_noise_file.setVisible(True)
self.gridLayout_groupbox_noise_file = QGridLayout(self.groupbox_download_noise_file)
self.pushbutton_noise_file = QPushButton()
self.pushbutton_noise_file.setObjectName("pushbutton_noise_file")
self.pushbutton_noise_file.setIcon(self.icon_folder)
self.gridLayout_groupbox_noise_file.addWidget(self.pushbutton_noise_file, 0, 1, 1, 1)
self.lineEdit_noise_file = QLineEdit()
self.gridLayout_groupbox_noise_file.addWidget(self.lineEdit_noise_file, 0, 2, 1, 1)
# self.label_date_groupbox_noise_file = QLabel()
# self.gridLayout_groupbox_noise_file.addWidget(self.label_date_groupbox_noise_file, 1, 0, 1, 2)
# self.label_hour_groupbox_noise_file = QLabel()
# self.gridLayout_groupbox_noise_file.addWidget(self.label_hour_groupbox_noise_file, 1, 2, 1, 1)
# Download Push Button event : connect button clicked signal to open file slot
self.verticalLayout_groupbox_study_data.addWidget(self.groupbox_download_noise_file)
### --- Groupbox compute noise from profile tail ---
self.groupbox_compute_noise_from_profile_tail = QGroupBox()
self.groupbox_compute_noise_from_profile_tail.setVisible(False)
self.verticalLayout_groupbox_study_data.addWidget(self.groupbox_compute_noise_from_profile_tail)
### --- Groupbox compute noise from value ---
self.groupbox_compute_noise_from_value = QGroupBox()
self.groupbox_compute_noise_from_value.setVisible(False)
self.gridLayout_compute_noise_from_value = QGridLayout(self.groupbox_compute_noise_from_value)
self.label_noise_value = QLabel()
self.label_noise_value.setText("Value : ")
self.gridLayout_compute_noise_from_value.addWidget(self.label_noise_value, 0, 0, 1, 1)
self.spinbox_compute_noise_from_value = QDoubleSpinBox()
self.spinbox_compute_noise_from_value.setDecimals(6)
self.gridLayout_compute_noise_from_value.addWidget(self.spinbox_compute_noise_from_value, 0, 1, 1, 1)
self.label_Volts = QLabel("Volts")
self.gridLayout_compute_noise_from_value.addWidget(self.label_Volts, 0, 2, 1, 1)
self.pushbutton_compute_noise_from_value = QPushButton()
self.pushbutton_compute_noise_from_value.setText("Apply noise")
self.gridLayout_compute_noise_from_value.addWidget(self.pushbutton_compute_noise_from_value, 0, 3, 1, 1)
self.verticalLayout_groupbox_study_data.addWidget(self.groupbox_compute_noise_from_value)
### --- Push button plot noise ---
self.pushbutton_plot_noise = QPushButton()
self.pushbutton_plot_noise.setText("Plot noise")
self.verticalLayout_groupbox_study_data.addWidget(self.pushbutton_plot_noise)
### --- Groupbox SNR criterion ---
self.groupbox_SNR_criterion = QGroupBox()
self.groupbox_SNR_criterion.setTitle("SNR filter")
self.gridLayout_SNR_criterion = QGridLayout(self.groupbox_SNR_criterion)
self.label_SNR_criterion = QLabel("SNR < ")
self.gridLayout_SNR_criterion.addWidget(self.label_SNR_criterion, 0, 0, 1, 1)
self.spinbox_SNR_criterion = QSpinBox()
self.gridLayout_SNR_criterion.addWidget(self.spinbox_SNR_criterion, 0, 1, 1, 1)
self.pushbutton_Apply_SNR_filter = QPushButton()
self.gridLayout_SNR_criterion.addWidget(self.pushbutton_Apply_SNR_filter, 0, 2, 1, 1)
self.verticalLayout_groupbox_study_data.addWidget(self.groupbox_SNR_criterion)
# +++++++++++++++++++++++++++++
# +++ --- Plot SNR data --- +++
# +++++++++++++++++++++++++++++
# self.verticalLayout_groupbox_plot_Noise_SNR = QVBoxLayout(self.groupbox_plot_Noise_SNR)
### --- Groupbox plot noise data ---
# self.groupbox_plot_noise_data = QGroupBox()
# self.horizontalLayout_groupbox_plot_noise_data = QHBoxLayout(self.groupbox_plot_noise_data)
#
# self.combobox_freq_noise = QComboBox()
# self.horizontalLayout_groupbox_plot_noise_data.addWidget(self.combobox_freq_noise)
#
# self.spacerItem_frequency_noise = QSpacerItem(10, 10, QSizePolicy.Expanding, QSizePolicy.Minimum)
# self.horizontalLayout_groupbox_plot_noise_data.addItem(self.spacerItem_frequency_noise)
#
# self.canvas_noise = None
#
# self.verticalLayout_groupbox_plot_Noise_SNR.addWidget(self.groupbox_plot_noise_data, 3)
### --- Groupbox plot SNR ---
# self.groupbox_plot_SNR = QGroupBox()
self.groupbox_plot_SNR.setTitle("Plot SNR")
self.verticalLayout_groupbox_plot_SNR = QVBoxLayout(self.groupbox_plot_SNR)
# self.pushbutton_plot_SNR = QPushButton()
# self.verticalLayout_groupbox_plot_Noise_SNR.addWidget(self.pushbutton_plot_SNR)
# self.pushbutton_plot_SNR.clicked.connect(self.plot_transect_with_SNR_data)
# self.canvas_SNR = None
# self.scroll_SNR = None
self.canvas_SNR = FigureCanvas()
self.navigationToolBar_SNR = NavigationToolBar(self.canvas_SNR, )
self.verticalLayout_groupbox_plot_SNR.addWidget(self.navigationToolBar_SNR)
self.scroll_SNR = QScrollArea()
self.scroll_SNR.setWidget(self.canvas_SNR)
self.scroll_SNR.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scroll_SNR.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scroll_SNR.setAlignment(Qt.AlignCenter)
self.verticalLayout_groupbox_plot_SNR.addWidget(self.scroll_SNR)
# self.verticalLayout_groupbox_plot_SNR.addWidget(self.groupbox_plot_SNR, 7)
# ++++++++++++++++++++++++++++++++++++++++++++++
# +++ --- Plot BS data filtered with SNR --- +++
# ++++++++++++++++++++++++++++++++++++++++++++++
self.groupbox_plot_BS_signal_filtered_with_SNR.setTitle("Plot SNR Filter for recording of acoustic backscatter")
self.verticalLayout_groupbox_plot_BS_field = QVBoxLayout(self.groupbox_plot_BS_signal_filtered_with_SNR)
# self.verticalLayout_groupbox_plot_BS_field.addWidget(self.groupbox_SNR_criterion, 2)
### --- Groupbox plot BS signal filtered with SNR criterion ---
# self.groupbox_BS_SNR_filter = QGroupBox()
# self.verticalLayout_groupbox_BS_SNR_filter = QVBoxLayout(self.groupbox_BS_SNR_filter)
# self.canvas_BS = None
# self.scroll_BS = None
self.canvas_BS = FigureCanvas()
self.scroll_BS = QScrollArea()
self.scroll_BS.setWidget(self.canvas_BS)
self.scroll_BS.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scroll_BS.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scroll_BS.setAlignment(Qt.AlignCenter)
self.verticalLayout_groupbox_plot_BS_field.addWidget(self.scroll_BS)
# self.verticalLayout_groupbox_plot_BS_field.addWidget(self.groupbox_BS_SNR_filter, 8)
# --------------------------------------------------------------------------------------------------------------
### --- Layout of groupbox in the bottom layout box
self.groupbox_pre_processing = QGroupBox()
self.horizontalLayout_Bottom.addWidget(self.groupbox_pre_processing, 4)
self.groupbox_plot_pre_processed_data = QGroupBox()
self.horizontalLayout_Bottom.addWidget(self.groupbox_plot_pre_processed_data, 5)
self.groupbox_list_pre_processed_data = QGroupBox()
self.horizontalLayout_Bottom.addWidget(self.groupbox_list_pre_processed_data, 1)
# +++++++++++++++++++++++++++++++++++++
# +++ --- Pre-processing option --- +++
# +++++++++++++++++++++++++++++++++++++
self.verticalLayout_groupbox_pre_processing = QVBoxLayout(self.groupbox_pre_processing)
# --- Rayleigh criterion groupbox ---
self.groupbox_Rayleigh_criterion = QGroupBox()
self.gridLayout_Rayleigh_criterion = QGridLayout(self.groupbox_Rayleigh_criterion)
self.label_Rayleigh_criterion = QLabel()
self.label_Rayleigh_criterion.setText("<V²>/<V>² <=")
self.gridLayout_Rayleigh_criterion.addWidget(self.label_Rayleigh_criterion, 0, 0, 1, 1)
self.spinbox_Rayleigh_criterion = QSpinBox()
self.spinbox_Rayleigh_criterion.setRange(0, 9999)
self.spinbox_Rayleigh_criterion.setValue(10)
self.gridLayout_Rayleigh_criterion.addWidget(self.spinbox_Rayleigh_criterion, 0, 1, 1, 1)
self.label_4pi = QLabel()
self.label_4pi.setText("% x 4/pi")
self.gridLayout_Rayleigh_criterion.addWidget(self.label_4pi, 0, 2, 1, 1)
self.pushbutton_despiking_signal = QPushButton()
self.pushbutton_despiking_signal.setText("Despiking the signal")
self.gridLayout_Rayleigh_criterion.addWidget(self.pushbutton_despiking_signal, 0, 3, 1, 1)
self.verticalLayout_groupbox_pre_processing.addWidget(self.groupbox_Rayleigh_criterion)
# --- Average signal groupbox ---
self.groupbox_window_size = QGroupBox()
self.gridLayout_groupbox_window_size = QGridLayout(self.groupbox_window_size)
self.label_signal_averaging_horizontal = QLabel()
self.label_signal_averaging_horizontal.setText("Horizontal +/- ")
# self.horizontalLayout_groupbox_window_size.addWidget(self.label_signal_averaging_over)
self.gridLayout_groupbox_window_size.addWidget(self.label_signal_averaging_horizontal, 0, 0, 1, 1)
self.spinbox_average_horizontal = QSpinBox()
self.spinbox_average_horizontal.setRange(0, 9999)
self.spinbox_average_horizontal.setValue(0)
# self.horizontalLayout_groupbox_window_size.addWidget(self.spinbox_average)
self.gridLayout_groupbox_window_size.addWidget(self.spinbox_average_horizontal, 0, 1, 1, 1)
self.label_cells_horizontal = QLabel()
self.label_cells_horizontal.setText("cells = +/- ? sec")
# self.horizontalLayout_groupbox_window_size.addWidget(self.label_cells)
self.gridLayout_groupbox_window_size.addWidget(self.label_cells_horizontal, 0, 2, 1, 1)
self.pushbutton_average = QPushButton()
self.pushbutton_average.setText("Apply averaging")
self.gridLayout_groupbox_window_size.addWidget(self.pushbutton_average, 0, 3, 1, 1)
self.verticalLayout_groupbox_pre_processing.addWidget(self.groupbox_window_size)
# +++++++++++++++++++++++++++++++++++++++
# +++ --- Plot pre-processed data --- +++
# +++++++++++++++++++++++++++++++++++++++
self.verticalLayout_groupbox_plot_pre_processed_data = QVBoxLayout(self.groupbox_plot_pre_processed_data)
self.horizontalLayout_label_profile_number_combobox_frequency_profile = QHBoxLayout()
self.verticalLayout_groupbox_plot_pre_processed_data.addLayout(self.horizontalLayout_label_profile_number_combobox_frequency_profile)
self.label_profile_number = QLabel()
self.label_profile_number.setText("Profile ")
self.horizontalLayout_label_profile_number_combobox_frequency_profile.addWidget(self.label_profile_number)
self.spacerItem_frequency_profile = QSpacerItem(50, 10, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout_label_profile_number_combobox_frequency_profile.addSpacerItem(self.spacerItem_frequency_profile)
self.combobox_frequency_profile = QComboBox()
self.horizontalLayout_label_profile_number_combobox_frequency_profile.addWidget(self.combobox_frequency_profile)
self.canvas_profile = None
# --- Figure to plot profiles and BS signal 2D field below---
# self.verticalLayout_groupbox_plot_pre_processed_data.removeWidget(self.canvas_profile)
# self.figure_profile, self.axis_profile = plt.subplots(nrows=2, ncols=1)#, gridspec_kw={'width_ratios': [2, 1],
# # 'height_ratios': [3, 1]})
# self.canvas_profile = FigureCanvas(self.figure_profile)
self.canvas_profile = FigureCanvas()
self.scroll_profile = QScrollArea()
self.scroll_profile.setWidget(self.canvas_profile)
self.scroll_profile.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scroll_profile.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# self.scroll_BS.setWidgetResizable(True)
self.scroll_profile.setAlignment(Qt.AlignCenter)
self.verticalLayout_groupbox_plot_pre_processed_data.addWidget(self.scroll_profile)
# self.verticalLayout_groupbox_plot_pre_processed_data.addWidget(self.canvas_profile)
# --- Slider for moving the profile ---
self.horizontalLayout_slider = QHBoxLayout()
self.verticalLayout_groupbox_plot_pre_processed_data.addLayout(self.horizontalLayout_slider)
self.pushbutton_slider_left_to_begin = QPushButton()
self.pushbutton_slider_left_to_begin.setIcon(self.icon_triangle_left_to_begin)
self.horizontalLayout_slider.addWidget(self.pushbutton_slider_left_to_begin)
self.pushbutton_slider_left = QPushButton()
self.pushbutton_slider_left.setIcon(self.icon_triangle_left)
self.horizontalLayout_slider.addWidget(self.pushbutton_slider_left)
self.lineEdit_slider = QLineEdit()
self.lineEdit_slider.setText("1")
self.lineEdit_slider.setFixedWidth(50)
self.horizontalLayout_slider.addWidget(self.lineEdit_slider)
self.pushbutton_slider_right = QPushButton()
self.pushbutton_slider_right.setIcon(self.icon_triangle_right)
self.horizontalLayout_slider.addWidget(self.pushbutton_slider_right)
self.pushbutton_slider_right_to_end = QPushButton()
self.pushbutton_slider_right_to_end.setIcon(self.icon_triangle_right_to_end)
self.horizontalLayout_slider.addWidget(self.pushbutton_slider_right_to_end)
self.slider = QSlider()
self.horizontalLayout_slider.addWidget(self.slider, 9)
self.slider.setOrientation(Qt.Horizontal)
self.slider.setCursor(Qt.OpenHandCursor)
self.slider.setMinimum(1)
self.slider.setMaximum(100)
self.slider.setTickInterval(1)
self.slider.setValue(1)
# ++++++++++++++++++++++++++++++++++++++++++
# +++ --- List of pre-processed data --- +++
# ++++++++++++++++++++++++++++++++++++++++++
self.verticalLayout_list_pre_processed_data = QVBoxLayout(self.groupbox_list_pre_processed_data)
self.plaintextedit_list_pre_processed_data = QPlainTextEdit()
self.verticalLayout_list_pre_processed_data.addWidget(self.plaintextedit_list_pre_processed_data)
# self.plaintextedit_list_pre_processed_data.appendPlainText("blablabla \nblobloblo")
# --------------------------------------------------------------------------------------------------------------
# --- Connect signal of widget ---
self.pushbutton_update.clicked.connect(self.update_SignalPreprocessingTab)
# self.combobox_fileListWidget.ShowPopUpWindowSignal.connect(self.event_combobobx_fileListWidget)
self.combobox_fileListWidget.currentIndexChanged.connect(self.combobox_fileListWidget_change_index)
self.radiobutton_file.toggled.connect(self.onClicked_radiobutton_noise_data)
self.radiobutton_profile_tail.toggled.connect(self.onClicked_radiobutton_noise_data)
self.radiobutton_value.toggled.connect(self.onClicked_radiobutton_noise_data)
self.pushbutton_clear_noise.clicked.connect(self.clear_noise_data)
self.pushbutton_noise_file.clicked.connect(self.open_dialog_box)
self.pushbutton_compute_noise_from_value.clicked.connect(self.compute_noise_from_value)
self.pushbutton_Apply_SNR_filter.clicked.connect(self.remove_point_with_snr_filter)
self.pushbutton_average.clicked.connect(self.compute_averaged_BS_data)
self.pushbutton_average.clicked.connect(self.plot_profile_and_position_on_transect_with_slider)
self.pushbutton_slider_left_to_begin.clicked.connect(self.slide_profile_number_to_begin)
self.pushbutton_slider_left.clicked.connect(self.slide_profile_number_to_left)
self.lineEdit_slider.returnPressed.connect(self.profile_number_on_lineEdit)
self.pushbutton_slider_right.clicked.connect(self.slide_profile_number_to_right)
self.pushbutton_slider_right_to_end.clicked.connect(self.slide_profile_number_to_end)
self.slider.valueChanged.connect(self.update_lineEdit_by_moving_slider)
self.slider.valueChanged.connect(self.plot_profile_and_position_on_transect_with_slider)
# ______ _______
# | | | | \
# | | | | \
# | | | | |
# | | | | /
# |______| |________ |________/
# COMMENT OLD CODE LINE FROM HERE ....
# ### --- General layout of widgets ---
#
# # ___________ ____________________________
# # | profile | | Profile |
# # | position | | |
# # | | | |
# # | | | Averaged profile |
# # | post | | |
# # | proc | | |
# # | options | | FCB option |
# # |___________| |____________________________|
#
# self.horizontalLayout_Main = QHBoxLayout(widget_tab)
#
# self.verticalLayout_Left = QVBoxLayout()
# self.horizontalLayout_Main.addLayout(self.verticalLayout_Left, 2)
#
# self.verticalLayout_Right = QVBoxLayout()
# self.horizontalLayout_Main.addLayout(self.verticalLayout_Right, 8)
#
#
# # --------------------------------------------------------------------------------------------------------------
# ### --- Layout of groupbox in the Left vertical layout box
#
# # Push button Load data
# # ---------------------
# # Profile position
# # ---------------------
# # Post processing
# # ---------------------
# # FCB options
#
# self.horizontalLayout_pushbutton_load_data_plot_bottom_line = QHBoxLayout()
# self.verticalLayout_Left.addLayout(self.horizontalLayout_pushbutton_load_data_plot_bottom_line)
#
# self.groupbox_display_profile_position = QGroupBox()
# self.verticalLayout_Left.addWidget(self.groupbox_display_profile_position)
#
# self.groupbox_post_processing = QGroupBox()
# self.verticalLayout_Left.addWidget(self.groupbox_post_processing)
#
# self.groupbox_FCBoption = QGroupBox()
# self.verticalLayout_Left.addWidget(self.groupbox_FCBoption)
#
# # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# # +++ --- Push button Load data + Push button plot bottom --- +++
# # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
# self.pushbutton_load_data = QPushButton()
# self.horizontalLayout_pushbutton_load_data_plot_bottom_line.addWidget(self.pushbutton_load_data)
# self.pushbutton_load_data.clicked.connect(self.compute_BS_data_section)
# # self.pushbutton_load_data.clicked.connect(self.plot_profile_position_on_transect)
# # self.pushbutton_load_data.clicked.connect(self.plot_profile)
#
# self.combobox_frequency = QComboBox()
# self.horizontalLayout_pushbutton_load_data_plot_bottom_line.addWidget(self.combobox_frequency)
# # self.combobox_frequency.currentTextChanged.connect(self.update_plot_profile_position_on_transect)
#
# # +++++++++++++++++++++++++++++++++++++++++++++++++
# # +++ --- GroupBox Display Profile Position --- +++
# # +++++++++++++++++++++++++++++++++++++++++++++++++
#
# self.verticalLayout_groupbox_display_profile_position = QVBoxLayout(self.groupbox_display_profile_position)
#
# self.label_profile_number = QLabel()
# self.label_profile_number.setFont(QFont("Ubuntu", 16, QFont.Bold))
# self.label_profile_number.setAlignment(Qt.AlignCenter)
# # self.label_profile_number.setText("Profile 1 / " + str(stg.nb_profiles))
# self.verticalLayout_groupbox_display_profile_position.addWidget(self.label_profile_number)
#
# self.canvas_plot_profile_position_on_transect = None
#
# # self.figure_plot_profile_position_on_transect, self.axis_plot_profile_position_on_transect = \
# # plt.subplots(nrows=1, ncols=1, layout="constrained")
# # self.canvas_plot_profile_position_on_transect = FigureCanvas(self.figure_plot_profile_position_on_transect)
# # self.plot_transect_bottom_with_profile_position(0)
# #
# # # self.axis_plot_profile_position_on_transect.plot(
# # # 0 * np.ones(self.model.r_bottom_cross_section.shape[0]),
# # # self.model.r_bottom_cross_section, color='red', linestyle="solid", linewidth=2)
# #
# # self.verticalLayout_groupbox_display_profile_position.addWidget(self.canvas_plot_profile_position_on_transect)
# #
# # self.horizontalLayout_slider_plot_profile_position = QHBoxLayout()
# # self.verticalLayout_groupbox_display_profile_position.addLayout(
# # self.horizontalLayout_slider_plot_profile_position)
# #
# # # self.icon_triangle_left = QPixmap(path_icon + "triangle_left.png")
# # # self.pushButton_slider_plot_profile_position_left = QPushButton()
# # # self.pushButton_slider_plot_profile_position_left.setIcon(QIcon(self.icon_triangle_left))
# # # self.icon_triangle_right = QPixmap(path_icon + "triangle_right.png")
# # # self.pushButton_slider_plot_profile_position_right = QPushButton()
# # # self.pushButton_slider_plot_profile_position_right.setIcon(QIcon(self.icon_triangle_right))
# # #
# # # self.horizontalLayout_slider_plot_profile_position.addWidget(self.pushButton_slider_plot_profile_position_left)
# # # self.horizontalLayout_slider_plot_profile_position.addWidget(self.pushButton_slider_plot_profile_position_right)
# # #
# # # self.lineEdit_slider_plot_profile_position = QLineEdit()
# # # self.horizontalLayout_slider_plot_profile_position.addWidget(self.lineEdit_slider_plot_profile_position)
# # #
# # # self.slider_plot_profile_position = QSlider()
# # # self.slider_plot_profile_position.setOrientation(Qt.Horizontal)
# # # self.slider_plot_profile_position.setTickPosition(QSlider.TicksBelow)
# # # self.slider_plot_profile_position.setCursor(Qt.OpenHandCursor)
# # # self.slider_plot_profile_position.setMinimum(0)
# # # self.slider_plot_profile_position.setMaximum(1)
# # # self.slider_plot_profile_position.setTickInterval(1)
# # # self.slider_plot_profile_position.setValue(0)
# # # self.horizontalLayout_slider_plot_profile_position.addWidget(self.slider_plot_profile_position)
# #
# # # self.horizontalLayoutTop_signalProcessing.addWidget(self.groupbox_display_profile_position, 3)
#
# # ++++++++++++++++++++++++++++++++++++++++
# # +++ --- GroupBox Post Processing --- +++
# # ++++++++++++++++++++++++++++++++++++++++
#
# self.verticalLayout_groupbox_post_processing = QVBoxLayout(self.groupbox_post_processing)
#
# self.groupbox_acoustic_profile = QGroupBox()
# self.verticalLayout_groupbox_post_processing.addWidget(self.groupbox_acoustic_profile)
#
# self.groupbox_rayleigh_criterion = QGroupBox()
# self.verticalLayout_groupbox_post_processing.addWidget(self.groupbox_rayleigh_criterion)
#
# self.groupbox_window_size = QGroupBox()
# self.verticalLayout_groupbox_post_processing.addWidget(self.groupbox_window_size)
#
# # --- Groupbox acoustic profile ---
#
# self.gridLayout_groupbox_acoustic_profile = QGridLayout(self.groupbox_acoustic_profile)
#
# # self.checkbox_SNR_criterion = QCheckBox()
# self.label_SNR_criterion = QLabel()
# self.gridLayout_groupbox_acoustic_profile.addWidget(self.label_SNR_criterion, 0, 0, 1, 1)
# self.spinbox_SNR_criterion = QSpinBox()
# self.spinbox_SNR_criterion.setRange(0, 9999)
# self.spinbox_SNR_criterion.setValue(0)
# # self.spinbox_SNR_criterion.setDisabled(True)
# self.gridLayout_groupbox_acoustic_profile.addWidget(self.spinbox_SNR_criterion, 0, 1, 1, 1)
#
# # self.spinbox_SNR_criterion.valueChanged.connect(self.remove_point_with_snr_filter)
#
# self.pushbutton_snr_filter = QPushButton()
# self.pushbutton_snr_filter.setText("Apply SNR")
# self.gridLayout_groupbox_acoustic_profile.addWidget(self.pushbutton_snr_filter, 0, 2, 1, 1)
#
# self.pushbutton_snr_filter.clicked.connect(self.remove_point_with_snr_filter)
# # self.pushbutton_snr_filter.clicked.connect(self.update_plot_profile)
# # self.pushbutton_snr_filter.clicked.connect(self.update_plot_profile_position_on_transect)
#
# # --- Groupbox Rayleigh criterion ---
#
# self.gridLayout_rayleigh_criterion = QGridLayout(self.groupbox_rayleigh_criterion)
#
# self.label_Rayleigh_criterion = QLabel()
# self.label_Rayleigh_criterion.setText("<V²>/<V>² <=")
# self.gridLayout_rayleigh_criterion.addWidget(self.label_Rayleigh_criterion, 0, 0, 1, 1)
#
# self.spinbox_rayleigh_criterion = QSpinBox()
# self.spinbox_rayleigh_criterion.setRange(0, 9999)
# self.spinbox_rayleigh_criterion.setValue(10)
# self.gridLayout_rayleigh_criterion.addWidget(self.spinbox_rayleigh_criterion, 0, 1, 1, 1)
#
# self.label_4pi = QLabel()
# self.label_4pi.setText("% x 4/pi")
# self.gridLayout_rayleigh_criterion.addWidget(self.label_4pi, 0, 2, 1, 1)
#
# self.pushbutton_despiking_signal = QPushButton()
# self.pushbutton_despiking_signal.setText("Despiking the signal")
# self.gridLayout_rayleigh_criterion.addWidget(self.pushbutton_despiking_signal, 0, 3, 1, 1)
#
# # --- Groupbox Window size ---
#
# # self.horizontalLayout_groupbox_window_size = QHBoxLayout(self.groupbox_window_size)
# self.gridLayout_groupbox_window_size = QGridLayout(self.groupbox_window_size)
#
# self.label_signal_averaging_horizontal = QLabel()
# self.label_signal_averaging_horizontal.setText("Horizontal +/- ")
# # self.horizontalLayout_groupbox_window_size.addWidget(self.label_signal_averaging_over)
# self.gridLayout_groupbox_window_size.addWidget(self.label_signal_averaging_horizontal, 0, 0, 1, 1)
# self.spinbox_average_horizontal = QSpinBox()
# self.spinbox_average_horizontal.setRange(0, 9999)
# self.spinbox_average_horizontal.setValue(0)
# # self.horizontalLayout_groupbox_window_size.addWidget(self.spinbox_average)
# self.gridLayout_groupbox_window_size.addWidget(self.spinbox_average_horizontal, 0, 1, 1, 1)
# self.label_cells_horizontal = QLabel()
# self.label_cells_horizontal.setText("cells = +/- ? sec")
# # self.horizontalLayout_groupbox_window_size.addWidget(self.label_cells)
# self.gridLayout_groupbox_window_size.addWidget(self.label_cells_horizontal, 0, 2, 1, 1)
#
# # self.label_signal_averaging_vertical = QLabel()
# # self.label_signal_averaging_vertical.setText("Vertical +/- ")
# # # self.horizontalLayout_groupbox_window_size.addWidget(self.label_signal_averaging_over)
# # self.gridLayout_groupbox_window_size.addWidget(self.label_signal_averaging_vertical, 1, 0, 1, 1)
# # self.spinbox_average_vertical = QSpinBox()
# # self.spinbox_average_vertical.setRange(0, 9999)
# # self.spinbox_average_vertical.setValue(0)
# # # self.horizontalLayout_groupbox_window_size.addWidget(self.spinbox_average)
# # self.gridLayout_groupbox_window_size.addWidget(self.spinbox_average_vertical, 1, 1, 1, 1)
# # self.label_cells_vertical = QLabel()
# # self.label_cells_vertical.setText("cells = +/- ? sec")
# # # self.horizontalLayout_groupbox_window_size.addWidget(self.label_cells)
# # self.gridLayout_groupbox_window_size.addWidget(self.label_cells_vertical, 1, 2, 1, 1)
#
# # self.spinbox_average.valueChanged.connect(self.compute_averaged_profile)
#
# self.pushbutton_average = QPushButton()
# self.pushbutton_average.setText("Apply averaging")
# # self.pushbutton_snr_filter.setDisabled(True)
# # self.horizontalLayout_groupbox_window_size.addWidget(self.pushbutton_average)
# self.gridLayout_groupbox_window_size.addWidget(self.pushbutton_average, 0, 3, 2, 1)
#
# self.pushbutton_average.clicked.connect(self.compute_averaged_profile)
# # self.pushbutton_average.clicked.connect(self.update_plot_profile_position_on_transect)
# # self.pushbutton_average.clicked.connect(self.plot_averaged_profile)
#
# # ++++++++++++++++++++++++++++++++++++
# # +++ --- GroupBox FCB options --- +++
# # ++++++++++++++++++++++++++++++++++++
#
# self.verticalLayout_groupbox_FCBoption = QVBoxLayout(self.groupbox_FCBoption)
#
# self.groupbox_water_attenuation = QGroupBox()
# self.verticalLayout_groupbox_FCBoption.addWidget(self.groupbox_water_attenuation)
#
# self.groupbox_fit_regression_line = QGroupBox()
# self.verticalLayout_groupbox_FCBoption.addWidget(self.groupbox_fit_regression_line)
#
# # --- Groupbox water attenuation ---
#
# self.gridLayout_groupbox_water_attenuation = QGridLayout(self.groupbox_water_attenuation)
#
# self.combobox_water_attenuation_model = QComboBox()
# self.combobox_water_attenuation_model.addItem("François & Garrison 1982")
# self.combobox_water_attenuation_model.addItem("Other model")
# self.gridLayout_groupbox_water_attenuation.addWidget(self.combobox_water_attenuation_model, 0, 0, 1, 1)
#
# self.label_temperature_water_attenation = QLabel()
# self.gridLayout_groupbox_water_attenuation.addWidget(self.label_temperature_water_attenation, 0, 1, 1, 1)
#
# self.spinbox_temperature_water_attenuation = QSpinBox()
# self.gridLayout_groupbox_water_attenuation.addWidget(self.spinbox_temperature_water_attenuation, 0, 2, 1, 1)
#
# self.label_degre_celsius = QLabel()
# self.label_degre_celsius.setText("°C")
# self.gridLayout_groupbox_water_attenuation.addWidget(self.label_degre_celsius, 0, 3, 1, 1)
#
# self.combobox_freq_for_water_attenuation = QComboBox()
# # self.combobox_water_attenuation.currentIndexChanged.connect(self.alpha_value_changed)
# self.gridLayout_groupbox_water_attenuation.addWidget(self.combobox_freq_for_water_attenuation, 1, 0, 1, 1)
#
# self.pushbutton_water_attenuation = QPushButton()
# self.pushbutton_water_attenuation.setText("Compute \u03B1w")
# self.gridLayout_groupbox_water_attenuation.addWidget(self.pushbutton_water_attenuation, 1, 1, 1, 1)
# self.pushbutton_water_attenuation.clicked.connect(self.compute_water_attenuation)
#
# self.label_water_attenuation = QLabel()
# self.label_water_attenuation.setText("\u03B1w = 0.00 dB/m")
# self.label_water_attenuation.setFont(QFont("Ubuntu", 14, QFont.Normal))
# self.gridLayout_groupbox_water_attenuation.addWidget(self.label_water_attenuation, 1, 2, 1, 1)
#
# # --- Groupbox fit regression line ---
#
# self.gridLayout_groupbox_fit_regression = QGridLayout(self.groupbox_fit_regression_line)
#
# self.label_alphaS_expression = QLabel()
# # self.label_alphaS_expression.setText("For homogeneous suspension: dFCB/dr = -2\u03B1<sub>s<\sub>")
# self.gridLayout_groupbox_fit_regression.addWidget(self.label_alphaS_expression, 0, 0, 1, 5)
#
# self.combobox_frequency_compute_alphaS = QComboBox()
# self.gridLayout_groupbox_fit_regression.addWidget(self.combobox_frequency_compute_alphaS, 1, 0, 1, 1)
#
# self.label_alphaS_computation_from = QLabel()
# self.label_alphaS_computation_from.setText("From -")
# self.gridLayout_groupbox_fit_regression.addWidget(self.label_alphaS_computation_from, 1, 1, 1, 1)
#
# self.spinbox_alphaS_computation_from = QDoubleSpinBox()
# self.spinbox_alphaS_computation_from.setRange(0, 9999)
# self.gridLayout_groupbox_fit_regression.addWidget(self.spinbox_alphaS_computation_from, 1, 2, 1, 1)
#
# self.label_alphaS_computation_to = QLabel()
# self.label_alphaS_computation_to.setText("To -")
# self.gridLayout_groupbox_fit_regression.addWidget(self.label_alphaS_computation_to, 1, 3, 1, 1)
#
# self.spinbox_alphaS_computation_to = QDoubleSpinBox()
# self.gridLayout_groupbox_fit_regression.addWidget(self.spinbox_alphaS_computation_to, 1, 4, 1, 1)
#
# self.pushbutton_plot_FCB = QPushButton()
# self.pushbutton_plot_FCB.setText("Plot FCB")
# self.gridLayout_groupbox_fit_regression.addWidget(self.pushbutton_plot_FCB, 2, 0, 1, 1)
#
# self.pushbutton_plot_FCB.clicked.connect(self.compute_FCB)
# # self.pushbutton_plot_FCB.clicked.connect(self.plot_FCB)
#
# self.pushbutton_fit_linear_regression = QPushButton()
# self.pushbutton_fit_linear_regression.setText("Fit && Compute \u03B1s")
# self.gridLayout_groupbox_fit_regression.addWidget(self.pushbutton_fit_linear_regression, 2, 1, 1, 1)
#
# self.pushbutton_fit_linear_regression.clicked.connect(self.fit_FCB_profile_with_linear_regression_and_compute_alphaS)
# self.pushbutton_fit_linear_regression.clicked.connect(self.plot_FCB)
#
# self.label_alphaS = QLabel()
# self.label_alphaS.setText("\u03B1s = " + "0.0" + "dB/m")
# self.label_alphaS.setFont(QFont("Ubuntu", 14, QFont.Normal))
# self.gridLayout_groupbox_fit_regression.addWidget(self.label_alphaS, 2, 3, 1, 1)
#
# # self.verticalLayout_groupbox_fit_regression
#
# # --------------------------------------------------------------------------------------------------------------
# ### --- Layout of groupbox in the Right vertical layout box
#
# # Plot Profiles
# # -------------------------
# # Plot averaged profile
# # -------------------------
# # Plot FCB profiles
#
# self.groupbox_plot_profile = QGroupBox()
# self.verticalLayout_Right.addWidget(self.groupbox_plot_profile)
#
# self.groupbox_plot_averaged_profile = QGroupBox()
# self.verticalLayout_Right.addWidget(self.groupbox_plot_averaged_profile)
#
# self.groupbox_FCB_profile = QGroupBox()
# self.verticalLayout_Right.addWidget(self.groupbox_FCB_profile)
#
# # +++++++++++++++++++++++++++++++++++++
# # +++ --- GroupBox Plot profile --- +++
# # +++++++++++++++++++++++++++++++++++++
#
# self.verticalLayout_groupbox_plot_profile = QVBoxLayout(self.groupbox_plot_profile)
#
# self.canvas_profile = None
# self.scroll_profile = None
#
# # # self.data_test_slider = np.array([[0, 1, 2, 3, 4, 5],
# # # [0, 1, 4, 9, 16, 25],
# # # [0, 1, 8, 27, 64, 125]])
# #
# #
# #
# # self.verticalLayout_plotprofiles = QVBoxLayout(self.groupbox_plot_profile)
# # self.figure_profile, self.axis_profile = plt.subplots(nrows=1, ncols=4, layout='constrained')
# # self.canvas_profile = FigureCanvas(self.figure_profile)
# # # self.toolbar_profile =import NavigationToolBar(self.canvas_profile, self)
# # # self.addToolBar(Qt.RightToolBarArea, self.toolbar_profile)
# # # self.linear(self.figure_profile, self.axis_profile)
# # for i in range(4):
# # self.axis_profile[i].plot(self.model.BS_raw_cross_section.V[:, i, 0], self.model.r, c='k')
# # # self.axis_profile.plot(self.data_test_slider[0, :], self.data_test_slider[0, :])
# #
# # self.toolbar_post_processing_tab = NavigationToolBar(self.canvas_profile, self)
# # # self.addToolBar(Qt.RightToolBarArea, self.toolbar_post_processing_tab)
# #
# # # self.label_icon = QLabel()
# # # self.label_icon.setPixmap(QPixmap("../icons/smiley1.jpg"))
# #
# # # self.verticalLayout_plotprofiles.addWidget(self.toolbar_profile)
# # self.verticalLayout_plotprofiles.addWidget(self.canvas_profile)
# # # self.verticalLayout_plotprofiles.addLayout(self.horizontalLayout_slider_plotprofil)
# #
# # # # self.verticalLayout_plotprofiles.addWidget(self.label_icon)
# # # self.verticalLayout_plotprofiles.addWidget(self.slider_plotprofile)
# #
# # # self.slider_plotprofile.valueChanged.connect(self.changePlot)
# #
# # # self.horizontalLayoutTop_signalProcessing.addLayout(self.verticalLayout_plotprofiles, 7)
# # # self.horizontalLayoutTop_signalProcessing.addWidget(self.groupbox_plot_profile, 7)
# # # self.verticalLayout_right_SignalProcessingTab.addWidget(self.toolbar_profile)
#
# # ++++++++++++++++++++++++++++++++++++++++++++++
# # +++ --- GroupBox Plot averaged profile --- +++
# # ++++++++++++++++++++++++++++++++++++++++++++++
#
# self.verticalLayout_groupbox_plot_averaged_profile = QVBoxLayout(self.groupbox_plot_averaged_profile)
#
# self.canvas_averaged_profile = None
# self.scroll_averaged_profile = None
#
# # self.verticalLayout_averagedprofile = QVBoxLayout(self.groupbox_plot_averaged_profile)
# # self.figure_averagedprofile, self.axis_averagedprofile = plt.subplots(nrows=1, ncols=4, layout='constrained')
# # self.canvas_averagedprofile = FigureCanvas(self.figure_averagedprofile)
# # # self.toolbar_averagedprofile = NavigationToolBar(self.canvas_averagedprofile, self)
# # # self.addToolBar(Qt.RightToolBarArea, self.toolbar_averagedprofile)
# # # self.toolbar_profile = NavigationToolBar(self.canvas_averagedprofile, self)
# # # self.polynome(self.figure_averagedprofile, self.axis_averagedprofile)
# # for i in range(4):
# # self.axis_averagedprofile[i].plot(self.model.BS_averaged_cross_section.V[:, i, 0], self.model.r, c='b')
# #
# # self.toolbar_post_processing_tab = NavigationToolBar(self.canvas_averagedprofile, self)
# #
# # # self.horizontalLayout_slider_averagedprofile = QHBoxLayout()
# # #
# # # self.pushButton_slider_averagedprofile_right = QPushButton()
# # # self.pushButton_slider_averagedprofile_right.setIcon(icon_triangle_right)
# # #
# # # self.pushButton_slider_averagedprofile_left = QPushButton()
# # # self.pushButton_slider_averagedprofile_left.setIcon(icon_triangle_left)
# # #
# # # self.horizontalLayout_slider_averagedprofile.addWidget(self.pushButton_slider_averagedprofile_left)
# # # self.horizontalLayout_slider_averagedprofile.addWidget(self.pushButton_slider_averagedprofile_right)
# # #
# # # self.lineEdit_slider_averaged_profile = QLineEdit()
# # # self.lineEdit_slider_averaged_profile.setFixedWidth(50)
# # # self.lineEdit_slider_averaged_profile.setText("1")
# # # self.horizontalLayout_slider_averagedprofile.addWidget(self.lineEdit_slider_averaged_profile)
# # #
# # # self.slider_averagedprofile = QSlider()
# # # self.slider_averagedprofile.setOrientation(Qt.Horizontal)
# # # self.slider_averagedprofile.setTickPosition(QSlider.TicksBelow)
# # # self.slider_averagedprofile.setCursor(Qt.OpenHandCursor)
# # # self.slider_averagedprofile.setMinimum(0)
# # # self.slider_averagedprofile.setMaximum(1)
# # # self.slider_averagedprofile.setTickInterval(1)
# # # self.slider_averagedprofile.setValue(0)
# # # # self.slider_plotprofile.valueChanged.connect(self.changePlot)
# # #
# # # self.horizontalLayout_slider_averagedprofile.addWidget(self.slider_averagedprofile)
# #
# # # self.verticalLayout_averagedprofile.addWidget(self.toolbar_averagedprofile)
# # self.verticalLayout_averagedprofile.addWidget(self.canvas_averagedprofile)
# # # self.verticalLayout_averagedprofile.addLayout(self.horizontalLayout_slider_averagedprofile)
# #
# # # self.horizontalLayoutMid_signalProcessing.addLayout(self.verticalLayout_averagedprofile, 7)
# # # self.horizontalLayoutMid_signalProcessing.addWidget(self.groupbox_plot_averaged_profile, 7)
#
# # ++++++++++++++++++++++++++++++++++++++++++++++
# # +++ --- GroupBox Plot FCB profile --- +++
# # ++++++++++++++++++++++++++++++++++++++++++++++
#
# self.verticalLayout_groupbox_plot_FCB_profile = QVBoxLayout(self.groupbox_FCB_profile)
#
# self.canvas_FCB_profile = None
# self.scroll_FCB_profile = None
#
# # self.verticalLayout_FCBoptions = QVBoxLayout(self.groupbox_FCB_profile)
# # self.figure_FCBoptions, self.axis_FCBoptions = plt.subplots(nrows=1, ncols=4, layout="constrained")
# # self.canvas_FCBoptions = FigureCanvas(self.figure_FCBoptions)
# # self.toolbar_FCBoptions = NavigationToolBar(self.canvas_FCBoptions, self)
# # # self.addToolBar(Qt.LeftToolBarArea, self.toolbar_FCBoptions)
# # # self.toolbar_profile = NavigationToolBar(self.canvas_FCBoptions, self)
# # # self.cubique(self.figure_FCBoptions, self.axis_FCBoptions)
# # for i in range(4):
# # self.axis_FCBoptions[i].plot(self.model.FCB[:, i, 0], self.model.r, c='r')
# #
# # self.toolbar_post_processing_tab = NavigationToolBar(self.canvas_FCBoptions, self)
# #
# # # self.horizontalLayout_slider_FCBoptions = QHBoxLayout()
# # #
# # # self.pushButton_slider_FCBoptions_right = QPushButton()
# # # self.pushButton_slider_FCBoptions_right.setIcon(icon_triangle_right)
# # #
# # # self.pushButton_slider_FCBoptions_left = QPushButton()
# # # self.pushButton_slider_FCBoptions_left.setIcon(icon_triangle_left)
# # #
# # # self.horizontalLayout_slider_FCBoptions.addWidget(self.pushButton_slider_FCBoptions_left)
# # # self.horizontalLayout_slider_FCBoptions.addWidget(self.pushButton_slider_FCBoptions_right)
# # #
# # # self.lineEdit_slider_FCBplot = QLineEdit()
# # # self.lineEdit_slider_FCBplot.setFixedWidth(50)
# # # self.lineEdit_slider_FCBplot.setText("1")
# # # self.horizontalLayout_slider_FCBoptions.addWidget(self.lineEdit_slider_FCBplot)
# # #
# # # self.slider_FCBoptions = QSlider()
# # # self.slider_FCBoptions.setOrientation(Qt.Horizontal)
# # # self.slider_FCBoptions.setTickPosition(QSlider.TicksBelow)
# # # self.slider_FCBoptions.setCursor(Qt.OpenHandCursor)
# # # self.slider_FCBoptions.setMinimum(0)
# # # self.slider_FCBoptions.setMaximum(1)
# # # self.slider_FCBoptions.setTickInterval(1)
# # # self.slider_FCBoptions.setValue(0)
# # # # self.slider_plotprofile.valueChanged.connect(self.changePlot)
# # #
# # # self.horizontalLayout_slider_FCBoptions.addWidget(self.slider_FCBoptions)
# #
# # # self.verticalLayout_FCBoptions.addWidget(self.toolbar_FCBoptions)
# # self.verticalLayout_FCBoptions.addWidget(self.canvas_FCBoptions)
# # # self.verticalLayout_FCBoptions.addLayout(self.horizontalLayout_slider_FCBoptions)
# #
# # # self.horizontalLayoutBottom_signalProcessing.addLayout(self.verticalLayout_FCBoptions, 7)
# # # self.horizontalLayoutBottom_signalProcessing.addWidget(self.groupbox_FCB_profile, 7)
# #
#
#
# # --- Slider ----
#
# self.horizontalLayout_slider = QHBoxLayout()
# self.verticalLayout_Right.addLayout(self.horizontalLayout_slider)
#
# self.pushbutton_slider_left = QPushButton()
# self.pushbutton_slider_left.setIcon(icon_triangle_left)
# self.horizontalLayout_slider.addWidget(self.pushbutton_slider_left)
#
# self.pushbutton_slider_right = QPushButton()
# self.pushbutton_slider_right.setIcon(icon_triangle_right)
# self.horizontalLayout_slider.addWidget(self.pushbutton_slider_right)
#
# self.pushbutton_slider_right.clicked.connect(self.slide_profile_number_to_right)
#
# self.pushbutton_slider_left.clicked.connect(self.slide_profile_number_to_left)
#
# # self.horizontalLayout_slider_plotprofil.addWidget(self.pushButton_slider_plotprofile_left)
# # self.horizontalLayout_slider_plotprofil.addWidget(self.pushButton_slider_plotprofile_right)
# #
# self.lineEdit_slider = QLineEdit()
# self.lineEdit_slider.setText("1")
# # # self.lineEdit_slider_acoustic_profile.setFixedWidth(self.pushButton_slider_plotprofile_left.size().width())
# self.lineEdit_slider.setFixedWidth(50)
# self.horizontalLayout_slider.addWidget(self.lineEdit_slider)
#
# self.lineEdit_slider.returnPressed.connect(self.profile_number_on_lineEdit)
#
# self.slider = QSlider()
# self.horizontalLayout_slider.addWidget(self.slider, 9)
#
# self.slider.setOrientation(Qt.Horizontal)
# # # self.slider_plotprofile.setTickPosition(QSlider.TicksBelow)
# self.slider.setCursor(Qt.OpenHandCursor)
# self.slider.setMinimum(1)
# # self.slider.setMaximum(stg.nb_profiles)#self.model.BS_averaged_cross_section_corr.V.shape[2])
# self.slider.setTickInterval(1)
# self.slider.setValue(1)
#
# self.slider.valueChanged.connect(self.update_lineEdit_by_moving_slider)
# self.slider.valueChanged.connect(self.update_plot_profile_position_on_transect)
# self.slider.valueChanged.connect(self.update_plot_profile)
# # self.slider.valueChanged.connect(self.update_plot_averaged_profile)
# self.slider.valueChanged.connect(self.update_plot_FCB)
# .... UP TO HERE. END OF COMMENT OF OLD LINE CODE
self.retranslate_signal_processing_tab()
# # -------------------- Functions for Signal processing Tab --------------------
# def retranslate_signal_processing_tab(self):
# self.pushbutton_load_data.setText(_translate("CONSTANT_STRING", cs.LOAD_DATA_FROM_ACOUSTIC_DATA_TAB))
#
# self.groupbox_display_profile_position.setTitle(_translate("CONSTANT_STRING", cs.DISPLAY_PROFILE_POSITION))
# # self.label_profile_number.setText(_translate("CONSTANT_STRING", cs.PROFILE_NUMBER) + " " +
# # str(self.string_profile_number) + " / " + str(self.string_profile_number_max))
#
# self.groupbox_post_processing.setTitle(_translate("CONSTANT_STRING", cs.POST_PROCESSING))
#
# self.groupbox_acoustic_profile.setTitle(_translate("CONSTANT_STRING", cs.ACOUSTIC_PROFILE))
# # self.checkbox_substract_noise.setText(_translate("CONSTANT_STRING", cs.SUBTRACT_THE_NOISE))
# self.label_SNR_criterion.setText(_translate("CONSTANT_STRING", cs.SNR_CRITERION))
#
# self.groupbox_window_size.setTitle(_translate("CONSTANT_STRING", cs.WINDOW_SIZE))
# # self.label_averageH.setText(_translate("CONSTANT_STRING", cs.HORIZONTAL) + ": +/-")
# # self.label_cells.setText(_translate("CONSTANT_STRING", cs.CELLS) + " = +/- ? sec")
#
# self.groupbox_rayleigh_criterion.setTitle(_translate("CONSTANT_STRING", cs.RAYLEIGH_CRITERION))
# # self.checkbox_despiked_acoustic_signal.setText(_translate("CONSTANT_STRING", cs.DESPIKING))
#
# self.groupbox_FCBoption.setTitle(_translate("CONSTANT_STRING", cs.FCB_OPTIONS))
#
# self.groupbox_water_attenuation.setTitle(_translate("CONSTANT_STRING", cs.COMPUTING_WATER_ATTENUATION))
# self.label_temperature_water_attenation.setText(_translate("CONSTANT_STRING", cs.TEMPERATURE) + ":")
#
# self.groupbox_fit_regression_line.setTitle(_translate("CONSTANT_STRING", cs.FIT_REGRESSION_LINE))
# self.label_alphaS_expression.setText(
# _translate("CONSTANT_STRING", cs.FOR_HOMOGENEOUS_SUSPENSION) + ": dFCB/dr = -2\u03B1<sub>s<\sub>")
# # self.label_alphaS_computation_from.setText(_translate("CONSTANT_STRING", cs.FROM))
# # self.label_alphaS_computation_to.setText(_translate("CONSTANT_STRING", cs.TO))
#
# self.groupbox_plot_profile.setTitle(_translate("CONSTANT_STRING", cs.PROFILE))
# self.groupbox_plot_averaged_profile.setTitle(_translate("CONSTANT_STRING", cs.AVERAGED_PROFILE))
# self.groupbox_FCB_profile.setTitle(_translate("CONSTANT_STRING", cs.FCB_PROFILE))
def retranslate_signal_processing_tab(self):
self.groupbox_study_data.setTitle("Study data")
self.groupbox_download_noise_file.setTitle("Download noise file")
self.groupbox_compute_noise_from_profile_tail.setTitle("Compute Noise from profile tail")
self.groupbox_compute_noise_from_value.setTitle("Compute Noise from value")
# self.groupbox_plot_noise_data.setTitle("Plot noise data")
# self.label_date_groupbox_noise_file.setText(_translate("CONSTANT_STRING", cs.DATE) + ": ")
# self.label_hour_groupbox_noise_file.setText(_translate("CONSTANT_STRING", cs.HOUR) + ": ")
# self.groupbox_plot_Noise_SNR.setTitle("Plot Noise and SNR 2D fields")
# self.pushbutton_plot_SNR.setText("Plot SNR")
self.pushbutton_Apply_SNR_filter.setText("Apply SNR")
self.groupbox_plot_BS_signal_filtered_with_SNR.setTitle("Plot BS signal filtered with SNR")
self.groupbox_pre_processing.setTitle("Pre-processing")
self.groupbox_Rayleigh_criterion.setTitle("Rayleigh criterion")
self.groupbox_window_size.setTitle("Window size")
self.groupbox_plot_pre_processed_data.setTitle("Plot pre-processed data")
self.groupbox_list_pre_processed_data.setTitle("List pre-processed data")
def event_combobobx_fileListWidget(self):
print("self.combobox_fileListWidget.maxCount()", self.combobox_fileListWidget.maxCount())
print("self.combobox_fileListWidget.count()", self.combobox_fileListWidget.count())
print("len(stg.filename_BS_noise_data ", len(stg.filename_BS_noise_data))
self.combobox_fileListWidget.clear()
# self.combobox_fileListWidget.addItem("")
for i in range(len(stg.filename_BS_raw_data)):
self.combobox_fileListWidget.addItem(stg.filename_BS_raw_data[i])
# print("len stg.BS_noise_raw_data : ", len(stg.BS_noise_raw_data))
# if len(stg.BS_noise_raw_data) == 0:
# stg.BS_noise_raw_data = [np.array([]) for _ in range(self.combobox_fileListWidget.count() - 1)]
# print("stg.BS_noise_raw_data : ", stg.BS_noise_raw_data)
# print("len stg.BS_noise_raw_data : ", len(stg.BS_noise_raw_data))
# stg.BS_noise_averaged_data = [np.array([]) for _ in range(self.combobox_fileListWidget.count() - 1)]
# stg.SNR_raw_data = [np.array([]) for _ in range(self.combobox_fileListWidget.count() - 1)]
# stg.SNR_cross_section = [np.array([]) for _ in range(self.combobox_fileListWidget.count() - 1)]
# stg.SNR_stream_bed = [np.array([]) for _ in range(self.combobox_fileListWidget.count() - 1)]
# stg.time_noise = [np.array([]) for _ in range(self.combobox_fileListWidget.count() - 1)]
# stg.noise_method = [0]*(self.combobox_fileListWidget.count() - 1)
# elif len(stg.BS_noise_raw_data) < (self.combobox_fileListWidget.count() - 1):
# stg.BS_noise_raw_data.append(np.array([]))
# stg.BS_noise_averaged_data.append(np.array([]))
# stg.SNR_raw_data.append(np.array([]))
# stg.SNR_cross_section.append(np.array([]))
# stg.SNR_stream_bed.append(np.array([]))
# stg.time_noise.append(np.array([]))
# stg.noise_method.append(0)
# if (stg.noise_method == 1) or (stg.noise_method == 0):
# self.radiobutton_file.setChecked(True)
# if stg.filename_BS_noise_data[self.combobox_fileListWidget.currentIndex()] != "":
# self.lineEdit_noise_file.setText(stg.filename_BS_noise_data[self.combobox_fileListWidget.currentIndex()])
# self.radiobutton_profile_tail.setChecked(False)
# self.radiobutton_value.setChecked(False)
# elif stg.noise_method == 2:
# self.radiobutton_file.setChecked(False)
# self.radiobutton_profile_tail.setChecked(True)
# self.radiobutton_value.setChecked(False)
# elif stg.noise_method == 3:
# self.radiobutton_file.setChecked(False)
# self.radiobutton_profile_tail.setChecked(False)
# self.radiobutton_value.setChecked(True)
# self.spinbox_compute_noise_from_value.setValue(stg.noise_value[self.combobox_fileListWidget.currentIndex()])
# self.combobox_fileListWidget.currentIndexChanged.connect(self.combobox_fileListWidget_change_index)
# def fill_combobox_fileListWidget(self):
# self.combobox_fileListWidget.addItems([stg.filename_BS_raw_data])
def update_SignalPreprocessingTab(self):
""" The tab is updated in two cases :
- the user remove a file (in the list widget) in the first tab (Acoustic data), so that the combobox
of data to be processed is updated,
- the user change the limits of one or all the records in the first tab (Acoustic data) """
print("filename BS_raw_data before clear ", stg.filename_BS_raw_data)
self.combobox_fileListWidget.clear()
print("filename BS_raw_data after clear ", stg.filename_BS_raw_data)
self.combobox_fileListWidget.addItems(stg.filename_BS_raw_data)
# self.combobox_fileListWidget.setCurrentIndex(0)
# self.combobox_fileListWidget.currentIndexChanged.connect(self.combobox_fileListWidget_change_index)
self.plaintextedit_list_pre_processed_data.clear()
for t in range(self.combobox_fileListWidget.count()):
self.plaintextedit_list_pre_processed_data.appendPlainText(stg.filename_BS_raw_data[t] + "\n")
self.plaintextedit_list_pre_processed_data.textChanged.connect(self.rename_data_preprocessed)
# if self.combobox_fileListWidget.count() > 0:
# for c in range(self.combobox_frequency_profile.count()):
#
# if (stg.SNR_stream_bed[c].shape != (0,)) and (stg.SNR_stream_bed[c] != stg.BS_stream_bed[c]):
#
# # --- Case where the user change limits of BS_stream_bed or BS_cross_section in Acoustic data tab ---
# stg.SNR_stream_bed[c] = (
# stg.SNR_stream_bed[c][:, :stg.BS_stream_bed[c].shape[1], :stg.BS_stream_bed[c].shape[2]])
#
# # --- Case where user change limits of BS_raw_data so that BS_cross_section is computed ---
# # else:
# #
# # if stg.noise_method[c] == 1:
# # self.load_noise_data_and_compute_SNR()
# # elif stg.noise_method[c] == 2:
# # pass
# # elif stg.noise_method[c] == 3:
# # self.compute_noise_from_value()
#
# # continuer ici en calculant SNR_stream_bed si on a travailler avec raw data et qu'on revient sur le 1er onglet
# # pour couper ou rajouter la detection du fond. Du coup, il faudra recalculer le SNR stream bed ou cross section
#
# stg.BS_stream_bed_pre_process_SNR[c] = (
# stg.SNR_stream_bed[c][:, :stg.BS_stream_bed[c].shape[1], :stg.BS_stream_bed[c].shape[2]])
#
# if stg.BS_stream_bed_pre_process_SNR_average[c].shape != (0,):
# stg.BS_stream_bed_pre_process_SNR_average[c] = (
# stg.BS_stream_bed_pre_process_SNR_average[c][:, :stg.BS_stream_bed[c].shape[1], :stg.BS_stream_bed[c].shape[2]])
#
# elif stg.BS_stream_bed_pre_process_average[c].shape != (0,):
# stg.BS_stream_bed_pre_process_average[c] = (
# stg.BS_stream_bed_pre_process_average[c][:, :stg.BS_stream_bed[c].shape[1], :stg.BS_stream_bed[c].shape[2]])
#
# elif (stg.BS_cross_section[c].shape != (0,)) and (stg.SNR_cross_section[c] != stg.BS_cross_section[c]):
#
# # if stg.SNR_cross_section[c] != stg.BS_cross_section[c]:
#
# stg.SNR_cross_section[c] = (
# stg.SNR_cross_section[c][:, stg.BS_cross_section[c].shape[1], stg.BS_cross_section[c].shape[2]])
#
# stg.BS_cross_section_pre_process_SNR[c] = (
# stg.SNR_cross_section[c][:, stg.BS_cross_section[c].shape[1], stg.BS_cross_section[c].shape[2]])
#
# if stg.BS_cross_section_pre_process_SNR_average[c].shape != (0,):
# stg.BS_cross_section_pre_process_SNR_average[c] = (
# stg.BS_cross_section_pre_process_SNR_average[c][:, stg.BS_cross_section[c].shape[1],stg.BS_cross_section[c].shape[2]])
#
# elif stg.BS_cross_section_pre_process_average[c].shape != (0,):
# stg.BS_cross_section_pre_process_average[c] = (
# stg.BS_cross_section_pre_process_average[c][:, stg.BS_cross_section[c].shape[1],stg.BS_cross_section[c].shape[2]])
#
# self.plot_transect_with_SNR_data()
# else:
#
# if stg.SNR_cross_section[c] != stg.BS_cross_section[c]:
#
# stg.SNR_cross_section[c] = (
# stg.SNR_cross_section[c][:, stg.BS_cross_section[c].shape[1], stg.BS_cross_section[c].shape[2]])
#
# stg.BS_cross_section_pre_process_SNR[c] = (
# stg.SNR_cross_section[c][:, stg.BS_cross_section[c].shape[1], stg.BS_cross_section[c].shape[2]])
#
# if stg.BS_cross_section_pre_process_SNR_average[c].shape != (0,):
# stg.BS_cross_section_pre_process_SNR_average[c] = (
# stg.BS_cross_section_pre_process_SNR_average[c][:, stg.BS_cross_section[c].shape[1],stg.BS_cross_section[c].shape[2]])
#
# elif stg.BS_cross_section_pre_process_average[c].shape != (0,):
# stg.BS_cross_section_pre_process_average[c] = (
# stg.BS_cross_section_pre_process_average[c][:, stg.BS_cross_section[c].shape[1],stg.BS_cross_section[c].shape[2]])
def rename_data_preprocessed(self):
print("stg.data_preprocessed ", stg.data_preprocessed)
print("QPlainTextEdit.textCursor().blockNumber() ", QPlainTextEdit.textCursor(self.plaintextedit_list_pre_processed_data).blockNumber())
line_number = int(QPlainTextEdit.textCursor(self.plaintextedit_list_pre_processed_data).blockNumber()/2)
stg.data_preprocessed[line_number] = (
QPlainTextEdit.textCursor(self.plaintextedit_list_pre_processed_data).blockNumber()/2)
print("stg.data_preprocessed ", stg.data_preprocessed)
line = QPlainTextEdit.textCursor(self.plaintextedit_list_pre_processed_data).blockNumber()
print(self.plaintextedit_list_pre_processed_data.setTextCursor(QPlainTextEdit.textCursor(self.plaintextedit_list_pre_processed_data)))
# textCursor().currentList().itemText(line)
def combobox_fileListWidget_change_index(self):
if (stg.noise_method[self.combobox_fileListWidget.currentIndex()] == 1)\
or (stg.noise_method[self.combobox_fileListWidget.currentIndex()] == 0):
self.radiobutton_file.setChecked(True)
self.lineEdit_noise_file.setText(stg.filename_BS_noise_data[self.combobox_fileListWidget.currentIndex()])
self.radiobutton_profile_tail.setChecked(False)
self.radiobutton_value.setChecked(False)
elif stg.noise_method[self.combobox_fileListWidget.currentIndex()] == 2:
self.radiobutton_file.setChecked(False)
self.radiobutton_profile_tail.setChecked(True)
self.radiobutton_value.setChecked(False)
elif stg.noise_method[self.combobox_fileListWidget.currentIndex()] == 3:
self.radiobutton_file.setChecked(False)
self.radiobutton_profile_tail.setChecked(False)
self.radiobutton_value.setChecked(True)
self.spinbox_compute_noise_from_value.setValue(stg.noise_value[self.combobox_fileListWidget.currentIndex()])
self.spinbox_SNR_criterion.setValue(stg.SNR_filter_value[self.combobox_fileListWidget.currentIndex()])
self.plot_transect_with_SNR_data()
self.plot_BS_signal_filtered_with_SNR()
self.spinbox_average_horizontal.setValue(stg.Nb_cells_to_average_BS_signal[self.combobox_fileListWidget.currentIndex()])
self.plot_profile_and_position_on_transect_with_slider()
def onClicked_radiobutton_noise_data(self):
# radiobutton = self.sender()
# if radiobutton.isChecked():
if self.radiobutton_file.isChecked():
self.groupbox_download_noise_file.setVisible(True)
self.groupbox_compute_noise_from_profile_tail.setVisible(False)
self.groupbox_compute_noise_from_value.setVisible(False)
elif self.radiobutton_profile_tail.isChecked():
self.groupbox_download_noise_file.setVisible(False)
self.groupbox_compute_noise_from_profile_tail.setVisible(True)
self.groupbox_compute_noise_from_value.setVisible(False)
elif self.radiobutton_value.isChecked():
self.groupbox_download_noise_file.setVisible(False)
self.groupbox_compute_noise_from_profile_tail.setVisible(False)
self.groupbox_compute_noise_from_value.setVisible(True)
def clear_noise_data(self):
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.time_noise[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.noise_method[self.combobox_fileListWidget.currentIndex()] = 0
stg.SNR_filter_value[self.combobox_fileListWidget.currentIndex()] = 0
stg.BS_raw_data_pre_process_SNR[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_raw_data_pre_process_average[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_raw_data_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_cross_section_pre_process_average[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_cross_section_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_stream_bed_pre_process_average[self.combobox_fileListWidget.currentIndex()] = np.array([])
stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()] = np.array([])
print("All is clear")
if self.radiobutton_file.isChecked():
self.lineEdit_noise_file.clear()
elif self.radiobutton_profile_tail.isChecked():
pass
elif self.radiobutton_value.isChecked():
self.spinbox_compute_noise_from_value.setValue(0)
self.spinbox_SNR_criterion.setValue(0)
self.spinbox_average_horizontal.setValue(0)
self.label_profile_number.clear()
self.label_profile_number.setText("Profile ")
self.canvas_SNR.figure.clear()
self.fig_SNR.clf()
self.axis_SNR.tolist().clear()
self.canvas_SNR = FigureCanvas()
self.scroll_SNR.setWidget(self.canvas_SNR)
print("SNR plot is clear")
self.canvas_BS.figure.clear()
self.fig_BS.clf()
self.axis_BS.tolist().clear()
self.canvas_BS = FigureCanvas()
self.scroll_BS.setWidget(self.canvas_BS)
print("BS plot is clear")
self.combobox_frequency_profile.clear()
self.canvas_profile.figure.clear()
self.figure_profile.clf()
self.axis_profile.tolist().clear()
self.canvas_profile = FigureCanvas()
self.scroll_profile.setWidget(self.canvas_profile)
print("Profile plot is clear")
self.slider.setValue(0)
self.slider.setMaximum(10)
def open_dialog_box(self):
if self.sender().objectName() == "pushbutton_noise_file":
filename = QFileDialog.getOpenFileName(self, "Open file",
"/home/bmoudjed/Documents/3 SSC acoustic meas project/Graphical interface project/Data",
"Aquascat file (*.aqa)")
dir_name = path.dirname(filename[0])
name = path.basename(filename[0])
try:
stg.path_BS_noise_data[self.combobox_fileListWidget.currentIndex()] = dir_name
stg.filename_BS_noise_data[self.combobox_fileListWidget.currentIndex()] = name
print("stg.path_BS_noise_data : ", stg.path_BS_noise_data)
print("stg.filename_BS_noise_data : ", stg.filename_BS_noise_data)
self.load_noise_data_and_compute_SNR()
except ValueError as e:
print("error = ", e)
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_noise_file.setText(stg.filename_BS_noise_data[self.combobox_fileListWidget.currentIndex()])
self.lineEdit_noise_file.setToolTip(stg.path_BS_noise_data[self.combobox_fileListWidget.currentIndex()])
# self.plot_noise()
self.plot_transect_with_SNR_data()
# self.combobox_freq_noise.addItems([f for f in stg.freq_text])
# self.combobox_freq_noise.currentIndexChanged.connect(self.plot_noise)
# self.spinbox_SNR_criterion.setValue(2)
self.remove_point_with_snr_filter()
self.combobox_frequency_profile.addItems([f for f in stg.freq_text[self.combobox_fileListWidget.currentIndex()]])
self.combobox_frequency_profile.currentIndexChanged.connect(self.plot_profile_and_position_on_transect_with_slider)
if stg.time_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
self.slider.setMaximum(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()].shape[1])
else:
self.slider.setMaximum(stg.time[self.combobox_fileListWidget.currentIndex()].shape[1])
# if len(stg.BS_stream_bed) and stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape:
#
# self.slider.setMaximum(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()].shape[1])
#
# elif (stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape[2]
# < stg.BS_raw_data[self.combobox_fileListWidget.currentIndex()].shape[2]):
#
# self.slider.setMaximum(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()].shape[1])
#
# else:
#
# self.slider.setMaximum(stg.time[self.combobox_fileListWidget.currentIndex()].shape[1])
self.compute_averaged_BS_data()
self.plot_profile_and_position_on_transect_with_slider()
stg.noise_method[self.combobox_fileListWidget.currentIndex()] = 1
def load_noise_data_and_compute_SNR(self):
stg.noise_method[self.combobox_fileListWidget.currentIndex()] = 1
noise_data = AcousticDataLoader(stg.path_BS_noise_data[self.combobox_fileListWidget.currentIndex()] +
"/" +
stg.filename_BS_noise_data[self.combobox_fileListWidget.currentIndex()])
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()] = noise_data._BS_raw_data
# stg.date_noise = noise_data._date
# stg.hour_noise = noise_data._hour
stg.time_noise[self.combobox_fileListWidget.currentIndex()] = noise_data._time
# stg.time_snr_reshape = stg.time_reshape
# print("len(stg.BS_cross_section) : ", len(stg.BS_cross_section))
# print("stg.BS_cross_section[0] : ", stg.BS_cross_section[0].shape)
# print("len(stg.BS_stream_bed) : ", len(stg.BS_stream_bed))
if stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape != (0,):
print("Je suis dans stream bed")
noise = np.zeros(stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape)
for f, _ in enumerate(noise_data._freq):
noise[f, :, :] = np.mean(
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()][f, :, :], axis=(0, 1))
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] = noise
stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()] = (
np.divide((stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()] -
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()]) ** 2,
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] ** 2))
elif stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
print("Je suis dans cross section")
noise = np.zeros(stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape)
for f, _ in enumerate(noise_data._freq):
noise[f, :, :] = np.mean(
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()][f, :, :], axis=(0, 1))
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] = noise
stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()] = (
np.divide((stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()] -
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()]) ** 2,
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] ** 2))
# stg.SNR_reshape = np.reshape(stg.SNR_cross_section, (stg.r.shape[1] * stg.t.shape[1], stg.freq.shape[0]), order="F")
else:
print("Je suis dans raw")
noise = np.zeros(stg.BS_raw_data[self.combobox_fileListWidget.currentIndex()].shape)
for f, _ in enumerate(noise_data._freq):
noise[f, :, :] = np.mean(
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()][f, :, :], axis=(0, 1))
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] = noise
stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()] = (
np.divide((stg.BS_raw_data[self.combobox_fileListWidget.currentIndex()] -
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()]) ** 2,
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] ** 2))
# print("stg.SNR_raw_data[0].shape ", stg.SNR_raw_data)
print("C'est fait")
# def compute_noise_from_value(self):
#
# # --- Compute noise from value and compute SNR ---
#
# if stg.BS_stream_bed.size == 0:
#
# stg.time_snr = stg.t
#
# if self.spinbox_compute_noise_from_value.value() == 0:
#
# stg.BS_noise_raw_data = np.full(stg.BS_cross_section.shape,
# self.spinbox_compute_noise_from_value.value())
# print(f"stg.BS_noise_raw_data.shape : {stg.BS_noise_raw_data.shape}")
# stg.SNR_cross_section = np.full(stg.BS_cross_section.shape, 1e3)
#
# else:
#
# stg.BS_noise_raw_data = np.full(stg.BS_cross_section.shape, self.spinbox_compute_noise_from_value.value())
# stg.SNR_cross_section = np.divide((stg.BS_cross_section - stg.BS_noise_raw_data) ** 2,
# stg.BS_noise_raw_data ** 2)
#
# else:
#
# stg.time_snr = stg.t
#
# if self.spinbox_compute_noise_from_value.value() == 0:
#
# stg.BS_noise_raw_data = np.full(stg.BS_stream_bed.shape,
# self.spinbox_compute_noise_from_value.value())
# stg.SNR_stream_bed = np.full(stg.BS_stream_bed.shape, 1e3)
#
# else:
#
# stg.BS_noise_raw_data = np.full(stg.BS_stream_bed.shape,
# self.spinbox_compute_noise_from_value.value())
# stg.SNR_stream_bed = np.divide((stg.BS_stream_bed - stg.BS_noise_raw_data) ** 2,
# stg.BS_noise_raw_data ** 2)
#
#
#
# # --- Trigger graphic widgets ---
#
# self.combobox_freq_noise.addItems([f for f in stg.freq_text])
# self.plot_noise()
# self.plot_transect_with_SNR_data()
# self.combobox_freq_noise.currentIndexChanged.connect(self.plot_noise)
# self.spinbox_SNR_criterion.setValue(0)
# self.remove_point_with_snr_filter()
#
# self.combobox_frequency_profile.addItems([f for f in stg.freq_text])
# self.combobox_frequency_profile.currentIndexChanged.connect(self.plot_profile_and_position_on_transect_with_slider)
# self.slider.setMaximum(stg.t.shape[1])
# self.compute_averaged_BS_data()
# self.plot_profile_and_position_on_transect_with_slider()
def compute_noise_from_value(self):
stg.noise_method[self.combobox_fileListWidget.currentIndex()] = 3
stg.noise_value[self.combobox_fileListWidget.currentIndex()] = self.spinbox_compute_noise_from_value.value()
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()] = (
np.full(stg.BS_raw_data[self.combobox_fileListWidget.currentIndex()].shape,
self.spinbox_compute_noise_from_value.value()))
# --- Compute noise from value and compute SNR ---
if stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape != (0,):
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] = (
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()][:, :,
:stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape[2]])
stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()] = (
np.divide((stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()]
- stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()]) ** 2,
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()] ** 2))
stg.time_noise[self.combobox_fileListWidget.currentIndex()] = (
stg.time_cross_section[self.combobox_fileListWidget.currentIndex()])
elif stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] = (
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()][:, :,
:stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape[2]])
stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()] = (
np.divide((stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()]
- stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()]) ** 2,
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()] ** 2))
stg.time_noise[self.combobox_fileListWidget.currentIndex()] = (
stg.time_cross_section[self.combobox_fileListWidget.currentIndex()])
else:
stg.BS_noise_averaged_data[self.combobox_fileListWidget.currentIndex()] = (
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()])
stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()] = (
np.divide((stg.BS_raw_data[self.combobox_fileListWidget.currentIndex()]
- stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()]) ** 2,
stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()] ** 2))
stg.time_noise[self.combobox_fileListWidget.currentIndex()] = (
stg.time[self.combobox_fileListWidget.currentIndex()])
# if len(stg.BS_stream_bed) == 0:
#
# if self.spinbox_compute_noise_from_value.value() == 0:
#
# stg.BS_noise_raw_data = np.full(stg.BS_cross_section[0].shape,
# self.spinbox_compute_noise_from_value.value())
# print(f"stg.BS_noise_raw_data.shape : {stg.BS_noise_raw_data.shape}")
# stg.SNR_cross_section = np.full(stg.BS_cross_section[0].shape, 1e3)
#
# else:
#
# stg.BS_noise_raw_data = np.full(stg.BS_cross_section[0].shape,
# self.spinbox_compute_noise_from_value.value())
# stg.SNR_cross_section = np.divide((stg.BS_cross_section[0] - stg.BS_noise_raw_data) ** 2,
# stg.BS_noise_raw_data ** 2)
#
# else:
#
# if self.spinbox_compute_noise_from_value.value() == 0:
#
# stg.BS_noise_raw_data = np.full(stg.BS_stream_bed.shape,
# self.spinbox_compute_noise_from_value.value())
# stg.SNR_stream_bed = np.full(stg.BS_stream_bed.shape, 1e3)
#
# else:
#
# stg.BS_noise_raw_data = np.full(stg.BS_stream_bed.shape,
# self.spinbox_compute_noise_from_value.value())
# stg.SNR_stream_bed = np.divide((stg.BS_stream_bed - stg.BS_noise_raw_data) ** 2,
# stg.BS_noise_raw_data ** 2)
# --- Trigger graphic widgets ---
if stg.SNR_filter_value[self.combobox_fileListWidget.currentIndex()] == 0:
self.spinbox_SNR_criterion.setValue(0)
else:
self.spinbox_SNR_criterion.setValue(stg.SNR_filter_value[self.combobox_fileListWidget.currentIndex()])
self.plot_transect_with_SNR_data()
self.remove_point_with_snr_filter()
self.combobox_frequency_profile.addItems(
[f for f in stg.freq_text[self.combobox_fileListWidget.currentIndex()]])
self.combobox_frequency_profile.currentIndexChanged.connect(
self.plot_profile_and_position_on_transect_with_slider)
if stg.time_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
self.slider.setMaximum(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()].shape[1])
else:
self.slider.setMaximum(stg.time[self.combobox_fileListWidget.currentIndex()].shape[1])
self.compute_averaged_BS_data()
self.plot_profile_and_position_on_transect_with_slider()
def plot_noise(self):
self.horizontalLayout_groupbox_plot_noise_data.removeWidget(self.canvas_noise)
self.fig_noise, self.axis_noise = plt.subplots(nrows=1, ncols=1, layout="constrained")
self.canvas_noise = FigureCanvas(self.fig_noise)
self.horizontalLayout_groupbox_plot_noise_data.addWidget(self.canvas_noise)
val_min = np.nanmin(stg.BS_noise_raw_data[self.combobox_freq_noise.currentIndex(), :, :])
val_max = np.nanmax(stg.BS_noise_raw_data[self.combobox_freq_noise.currentIndex(), :, :])
print(f"0/ val_min for plot noise = {val_min}")
print(f"0/ val_max for plot noise = {val_max}")
if val_min == val_max:
pcm = self.axis_noise.pcolormesh(stg.time_snr[0, :],
-stg.depth[self.combobox_freq_noise.currentIndex(), :],
stg.BS_noise_raw_data[self.combobox_freq_noise.currentIndex(), :, :],
cmap='viridis')
else:
if val_min == 0:
val_min = 1e-5
pcm = self.axis_noise.pcolormesh(stg.time_snr[0, :],
-stg.r[self.combobox_freq_noise.currentIndex(), :],
stg.BS_noise_raw_data[self.combobox_freq_noise.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
self.axis_noise.tick_params(axis='both', which='minor', labelsize=10)
# cbar = self.fig_noise.colorbar(pcm, ax=self.axis_noise, shrink=1, location='top')
# cbar.set_label(label='Noise signal (V)', rotation=0, labelpad=8)
# self.axis_noise.text(1, .70, stg.freq_text[self.combobox_freq_noise.currentIndex()],
# fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_noise.transAxes)
def plot_transect_with_SNR_data(self):
# --- Condition if table is not filled ---
# if not self.lineEdit_noise_file.text():
if len(stg.BS_noise_raw_data) == 0:
msgBox = QMessageBox()
msgBox.setWindowTitle("Plot transect Error")
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText("Load data before plot transect 2D field")
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.exec()
# elif self.canvas_SNR == None:
else:
if ((self.combobox_fileListWidget.currentIndex() != -1)
and (stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()].shape != (0,))):
self.fig_SNR, self.axis_SNR = plt.subplots(nrows=stg.freq[self.combobox_fileListWidget.currentIndex()].shape[0], ncols=1, sharex=True, sharey=False, layout='constrained')
self.canvas_SNR = FigureCanvas(self.fig_SNR)
# self.verticalLayout_groupbox_plot_Noise_SNR.addWidget(self.canvas_SNR)
# self.verticalLayout_groupbox_plot_SNR
# self.verticalLayout_groupbox_plot_Noise_SNR.removeWidget(self.scroll_SNR)
# self.scroll_SNR = QScrollArea()
self.scroll_SNR.setWidget(self.canvas_SNR)
self.navigationToolBar_SNR = NavigationToolBar(self.canvas_SNR, self.groupbox_plot_SNR)
# self.scroll_SNR.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# self.scroll_SNR.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# self.scroll_SNR.setAlignment(Qt.AlignCenter)
# self.verticalLayout_groupbox_plot_SNR.addWidget(self.scroll_SNR)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
if stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()].shape != (0,):
x, y = np.meshgrid(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][0, :],
stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][0, :])
print("0 plot SNR with SNR_stream_bed")
val_min = np.nanmin(stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()][f, :, :])
val_max = np.nanmax(stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()][f, :, :])
if val_min == val_max:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
else:
if val_min == 0:
val_min = 1e-5
if val_max > 1000:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
else:
levels = np.array([00.1, 1, 2, 10, 100, val_max])
bounds = [00.1, 1, 2, 10, 100, 1000, val_max, val_max * 1.2]
norm = BoundaryNorm(boundaries=bounds, ncolors=300)
cf = (self.axis_SNR[f].contourf(x, -y,
stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()][f, :, :],
levels, cmap='gist_rainbow',
norm=norm))
elif stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
x, y = np.meshgrid(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][0, :],
stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][0, :])
print("1 plot SNR with SNR_cross_section")
val_min = np.nanmin(stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()][f, :, :])
val_max = np.nanmax(stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()][f, :, :])
if val_min == val_max:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
else:
if val_min == 0:
val_min = 1e-5
if val_max > 1000:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
else:
levels = np.array([00.1, 1, 2, 10, 100, val_max])
bounds = [00.1, 1, 2, 10, 100, 1000, val_max, val_max * 1.2]
norm = BoundaryNorm(boundaries=bounds, ncolors=300)
cf = (self.axis_SNR[f].contourf(x, -y,
stg.SNR_cross_section[
self.combobox_fileListWidget.currentIndex()][f, :, :],
levels, cmap='gist_rainbow', norm=norm))
else:
x, y = np.meshgrid(stg.time[self.combobox_fileListWidget.currentIndex()][0, :],
stg.depth[self.combobox_fileListWidget.currentIndex()][0, :])
print("0 plot SNR with SNR_raw_data")
val_min = np.nanmin(stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()][f, :, :])
val_max = np.nanmax(stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()][f, :, :])
if val_min == val_max:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
else:
if val_min == 0:
val_min = 1e-5
if val_max > 1000:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
else:
levels = np.array([00.1, 1, 2, 10, 100, val_max])
bounds = [00.1, 1, 2, 10, 100, 1000, val_max, val_max * 1.2]
norm = BoundaryNorm(boundaries=bounds, ncolors=300)
print("self.combobox_fileListWidget.currentIndex() ", self.combobox_fileListWidget.currentIndex())
print("x ", x.shape)
print("y ", y.shape)
print("stg.SNR_raw_data", stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()].shape)
cf = (self.axis_SNR[f].contourf(x, -y,
stg.SNR_raw_data[
self.combobox_fileListWidget.currentIndex()][f, :, :],
levels, cmap='gist_rainbow', norm=norm))
self.axis_SNR[f].text(1, .70, stg.freq_text[self.combobox_fileListWidget.currentIndex()][f],
fontsize=14, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_SNR[f].transAxes)
self.fig_SNR.supxlabel('Time (sec)', fontsize=10)
self.fig_SNR.supylabel('Depth (m)', fontsize=10)
cbar = self.fig_SNR.colorbar(cf, ax=self.axis_SNR[:], shrink=1, location='right')
cbar.set_label(label='Signal to Noise Ratio', rotation=270, labelpad=10)
cbar.set_ticklabels(['0', '1', '2', '10', '100', r'10$^3$', r'10$^6$'])
self.fig_SNR.canvas.draw_idle()
# # --- Plot red solid line on transect to visualize position of plotted profile ---
# self.axis_BS[self.combobox_frequency_profile.currentIndex()].plot(
# stg.time[self.combobox_frequency_profile.currentIndex(), 0] * np.ones(
# stg.r.shape[1]),
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# color='red', linestyle="solid", linewidth=2)
else:
# self.canvas_SNR.figure.clear()
# self.fig_SNR.clf()
# self.axis_SNR.tolist().clear()
self.canvas_SNR = FigureCanvas()
self.scroll_SNR.setWidget(self.canvas_SNR)
def remove_point_with_snr_filter(self):
if len(stg.BS_noise_raw_data) == 0:
msgBox = QMessageBox()
msgBox.setWindowTitle("SNR filter Error")
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText("Load Noise data from acoustic data tab before using SNR filter")
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.exec()
else:
stg.SNR_filter_value[self.combobox_fileListWidget.currentIndex()] = self.spinbox_SNR_criterion.value()
if stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape != (0,):
stg.BS_stream_bed_pre_process_SNR = deepcopy(stg.BS_stream_bed)
# stg.Noise_data = deepcopy(stg.BS_noise_averaged_data[:, :, :stg.t.shape[1]])
# stg.SNR_data_average = np.divide(
# (stg.BS_stream_bed_pre_process_SNR - stg.Noise_data) ** 2, stg.Noise_data ** 2)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][
f,
np.where(stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()][f, :, :] < self.spinbox_SNR_criterion.value())[0],
np.where(stg.SNR_stream_bed[self.combobox_fileListWidget.currentIndex()][f, :, :] < self.spinbox_SNR_criterion.value())[1]] \
= np.nan
elif stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
stg.BS_cross_section_pre_process_SNR = deepcopy(stg.BS_cross_section)
# stg.Noise_data = deepcopy(stg.BS_noise_averaged_data[:, :, :stg.t.shape[1]])
# stg.SNR_data_average = np.divide(
# (stg.BS_stream_bed_pre_process_SNR - stg.Noise_data) ** 2, stg.Noise_data ** 2)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][
f,
np.where(stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()][f, :,
:] < self.spinbox_SNR_criterion.value())[0],
np.where(stg.SNR_cross_section[self.combobox_fileListWidget.currentIndex()][f, :,
:] < self.spinbox_SNR_criterion.value())[1]] \
= np.nan
else:
stg.BS_raw_data_pre_process_SNR = deepcopy(stg.BS_raw_data)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
stg.BS_raw_data_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][
f,
np.where(stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()][f, :,
:] < self.spinbox_SNR_criterion.value())[0],
np.where(stg.SNR_raw_data[self.combobox_fileListWidget.currentIndex()][f, :,
:] < self.spinbox_SNR_criterion.value())[1]] \
= np.nan
# elif stg.BS_stream_bed_pre_process_average.size != 0:
# stg.BS_stream_bed_pre_process_SNR = deepcopy(stg.BS_stream_bed_pre_process_average)
# BS_noise_cross_section = deepcopy(stg.BS_noise_averaged_data[:, :, :stg.t.shape[1]])
# print("BS_noise_cross_section.shape ", BS_noise_cross_section.shape)
# stg.SNR_data_average = np.divide(
# (stg.BS_stream_bed_pre_process_SNR - BS_noise_cross_section) ** 2, BS_noise_cross_section ** 2)
#
# print(stg.SNR_data_average[0, :, :])
# fig, ax = plt.subplots(nrows=1, ncols=1)
# x, y = np.meshgrid(list(range(stg.SNR_data_average.shape[2])),
# list(range(stg.SNR_data_average.shape[1])))
# levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
# bounds = [00.1, 1, 2, 10, 100, 1000, 1e6, 1e6 * 1.2]
# norm = BoundaryNorm(boundaries=bounds, ncolors=300)
# cf = ax.contourf(x, -y, stg.SNR_data_average[0, :, :], cmap='gist_rainbow') # , levels, norm=norm)
# cbar = fig.colorbar(cf, ax=ax, shrink=1, location='right')
# plt.show()
#
# for f, _ in enumerate(stg.freq):
# print("----------------------------------------------")
# print(np.where(stg.SNR_data_average[f, :, :] < self.spinbox_SNR_criterion.value())[0])
# print(np.where(stg.SNR_data_average[f, :, :] < self.spinbox_SNR_criterion.value())[1])
# stg.BS_stream_bed_pre_process_SNR[
# f,
# np.where(stg.SNR_data_average[f, :, :] < self.spinbox_SNR_criterion.value())[0],
# np.where(stg.SNR_data_average[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \
# = np.nan
self.plot_BS_signal_filtered_with_SNR()
# self.update_plot_profile_position_on_transect()
# self.update_plot_averaged_profile()
self.compute_averaged_BS_data()
self.plot_profile_and_position_on_transect_with_slider()
def plot_BS_signal_filtered_with_SNR(self):
# self.verticalLayout_groupbox_BS_SNR_filter.removeWidget(self.scroll_BS)
if ((self.combobox_fileListWidget.currentIndex() != -1)
and (stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()].shape != (0,))):
self.fig_BS, self.axis_BS = plt.subplots(nrows=stg.freq[self.combobox_fileListWidget.currentIndex()].shape[0], ncols=1, sharex=True, sharey=False, layout="constrained")
self.canvas_BS = FigureCanvas(self.fig_BS)
# self.verticalLayout_groupbox_plot_SNR.addWidget(self.canvas_SNR)
# self.verticalLayout_groupbox_plot_SNR.removeWidget(self.scroll_SNR)
# self.scroll_BS = QScrollArea()
self.scroll_BS.setWidget(self.canvas_BS)
# self.scroll_BS.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# self.scroll_BS.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# self.scroll_BS.setAlignment(Qt.AlignCenter)
# self.verticalLayout_groupbox_BS_SNR_filter.addWidget(self.scroll_BS)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
if stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape != (0,):
val_min = np.nanmin(stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :])
val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :])
if val_min == 0:
val_min = 1e-5
pcm = self.axis_BS[f].pcolormesh(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][f, :],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][f, :],
stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
self.axis_BS[f].plot(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][f, :],
-stg.depth_bottom[self.combobox_fileListWidget.currentIndex()],
color='black', linewidth=1, linestyle="solid")
elif stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape != (0,):
val_min = np.nanmin(
stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :])
val_max = np.nanmax(
stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :])
if val_min == 0:
val_min = 1e-5
pcm = self.axis_BS[f].pcolormesh(
stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][f, :],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][f, :],
stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
else:
val_min = np.nanmin(
stg.BS_raw_data_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :])
val_max = np.nanmax(
stg.BS_raw_data_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, :, :])
if val_min == 0:
val_min = 1e-5
pcm = self.axis_BS[f].pcolormesh(stg.time[self.combobox_fileListWidget.currentIndex()][f, :],
-stg.depth[self.combobox_fileListWidget.currentIndex()][f, :],
stg.BS_raw_data_pre_process_SNR[
self.combobox_fileListWidget.currentIndex()][f, :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
self.axis_BS[f].text(1, .70, stg.freq_text[self.combobox_fileListWidget.currentIndex()][f],
fontsize=14, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_BS[f].transAxes)
self.fig_BS.supxlabel('Time (sec)', fontsize=10)
self.fig_BS.supylabel('Depth (m)', fontsize=10)
cbar = self.fig_BS.colorbar(pcm, ax=self.axis_BS[:], shrink=1, location='right')
cbar.set_label(label='Acoustic backscatter signal (V)', rotation=270, labelpad=10)
self.fig_BS.canvas.draw_idle()
else:
# self.canvas_BS.figure.clear()
# self.fig_BS.clf()
# self.axis_BS.tolist().clear()
self.canvas_BS = FigureCanvas()
self.scroll_BS.setWidget(self.canvas_BS)
def compute_averaged_BS_data(self):
if len(stg.BS_noise_raw_data) == 0:
msgBox = QMessageBox()
msgBox.setWindowTitle("Average Backscatter signal Error")
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText("Load data from acoustic data tab before averaging backscatter signal")
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.exec()
else:
kernel = np.ones(2*self.spinbox_average_horizontal.value()+1)
print(kernel)
if stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Données pré-traitées avec SNR : BS stream bed pre process SNR -> BS stream bed pre process SNR average ---
if stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# ((stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()].shape) or
# (stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape))):
stg.BS_stream_bed_pre_process_SNR_average = deepcopy(stg.BS_stream_bed_pre_process_SNR)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
for i in range(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]):
stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()][f, i,:] \
= convolve1d(stg.BS_stream_bed_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, i, :], weights=kernel) / len(kernel)
print("1 - Je suis dans stg.BS_stream_bed_pre_process_SNR_average")
# --- Données BS stream bed : BS stream bed -> BS stream bed pre process average ---
else:
# elif ((stg.BS_stream_bed_pre_process_average[self.combobox_fileListWidget.currentIndex()].shape) or
# (stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()].shape)):
stg.BS_stream_bed_pre_process_average = deepcopy(stg.BS_stream_bed)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
for i in range(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]):
stg.BS_stream_bed_pre_process_average[self.combobox_fileListWidget.currentIndex()][f, i, :] \
= convolve1d(stg.BS_stream_bed[self.combobox_fileListWidget.currentIndex()][f, i, :], weights=kernel) / len(kernel)
print("2 - Je suis dans stg.BS_stream_bed_pre_process_average")
elif stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Données pré-traitées avec SNR : BS cross section pre process SNR -> BS cross section pre process SNR average ---
if stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# if ((stg.BS_cross_section_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()].shape) or
# (stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape)):
stg.BS_cross_section_pre_process_SNR_average = deepcopy(stg.BS_cross_section_pre_process_SNR)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
for i in range(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]):
stg.BS_cross_section_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()][f, i, :] \
= convolve1d(stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, i, :], weights=kernel) / len(kernel)
print("3 - Je suis dans stg.BS_cross_section_pre_process_SNR_average")
# --- Données BS section : BS cross section -> BS cross section pre process average ---
else:
# elif ((stg.BS_cross_section_pre_process_average[self.combobox_fileListWidget.currentIndex()].shape) or
# (stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape)):
stg.BS_cross_section_pre_process_average = deepcopy(stg.BS_cross_section)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
for i in range(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]):
stg.BS_cross_section_pre_process_average[self.combobox_fileListWidget.currentIndex()][f, i, :] \
= convolve1d(stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()][f, i, :], weights=kernel) / len(kernel)
print("4 - Je suis dans stg.BS_cross_section_pre_process_average")
else:
# --- Données pré-traitées avec SNR : BS raw data pre process SNR -> BS raw data pre process SNR average ---
if stg.BS_cross_section_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# if ((stg.BS_raw_data_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()].shape) or
# (stg.BS_raw_data_pre_process_SNR[self.combobox_fileListWidget.currentIndex()].shape)):
stg.BS_raw_data_pre_process_SNR_average = deepcopy(stg.BS_raw_data_pre_process_SNR)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
for i in range(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]):
stg.BS_raw_data_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()][f, i, :] \
= convolve1d(stg.BS_raw_data_pre_process_SNR[self.combobox_fileListWidget.currentIndex()][f, i, :], weights=kernel) / len(kernel)
print("5 - Je suis dans stg.BS_raw_data_pre_process_SNR_average")
# --- Données BS brutes : BS raw data -> BS raw data pre process average ---
else:
stg.BS_raw_data_pre_process_average = deepcopy(stg.BS_raw_data)
for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
for i in range(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]):
stg.BS_raw_data_pre_process_average[self.combobox_fileListWidget.currentIndex()][f, i,:] \
= convolve1d(stg.BS_raw_data[self.combobox_fileListWidget.currentIndex()][f, i, :], weights=kernel) / len(kernel)
print("6 - Je suis dans stg.BS_raw_data_pre_process_average")
# if (stg.BS_cross_section[self.combobox_fileListWidget.currentIndex()].shape ==
# stg.BS_raw_data[self.combobox_fileListWidget.currentIndex()].shape):
#
# stg.BS_raw_data_pre_process_average = deepcopy(stg.BS_raw_data)
#
# for f, _ in enumerate(stg.freq[self.combobox_fileListWidget.currentIndex()]):
# for i in range(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]):
# stg.BS_raw_data_pre_process_average[self.combobox_fileListWidget.currentIndex()][f, i, :] \
# = convolve1d(stg.BS_stream_bed_pre_process_SNR[f, i, :], weights=kernel) / len(kernel)
#
# stg.BS_stream_bed_pre_process_SNR_average = deepcopy(stg.BS_stream_bed_pre_process_SNR)
# # print(f"1/ stg.BS_stream_bed_pre_process_average : {stg.BS_stream_bed_pre_process_SNR_average}")
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_stream_bed_pre_process_SNR_average[f, i, :] \
# = convolve1d(stg.BS_stream_bed_pre_process_SNR[f, i, :], weights=kernel) / len(kernel)
# # stg.BS_stream_bed_pre_process_average[i, f, :] \
# # = convolve1d(stg.BS_cross_section[i, f, :], weights=filter_convolve) / filter_convolve.shape[0]
#
# return stg.BS_stream_bed_pre_process_SNR_average
#
# elif stg.BS_cross_section_pre_process_SNR.size != 0:
#
# stg.BS_cross_section_pre_process_SNR_average = deepcopy(stg.BS_cross_section_pre_process_SNR)
# print(f"2/ stg.BS_cross_section_averaged : {stg.BS_cross_section_pre_process_SNR_average}")
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_cross_section_pre_process_SNR_average[f, i, :] \
# = convolve1d(stg.BS_cross_section_pre_process_SNR[f, i, :],
# weights=kernel) / len(kernel)
#
# return stg.BS_cross_section_pre_process_SNR_average
#
# elif stg.BS_stream_bed.size != 0:
#
# stg.BS_stream_bed_pre_process_average = deepcopy(stg.BS_stream_bed)
# # print(f"3/ stg.BS_stream_bed_pre_process_average : {stg.BS_stream_bed_pre_process_average.shape}")
# print(stg.BS_stream_bed_pre_process_average[0, 10, :50])
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_stream_bed_pre_process_average[f, i, :] \
# = convolve1d(stg.BS_stream_bed[f, i, :],
# weights=kernel) / len(kernel)
# print(stg.BS_stream_bed_pre_process_average[0, 10, :50])
#
# return stg.BS_stream_bed_pre_process_average
#
# elif stg.BS_cross_section.size != 0:
#
# stg.BS_cross_section_averaged = deepcopy(stg.BS_cross_section)
# # print(f"4/ stg.BS_cross_section_averaged : {stg.BS_cross_section_averaged.shape}")
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_cross_section_averaged[f, i, :] \
# = convolve1d(stg.BS_cross_section[f, i, :],
# weights=kernel) / len(kernel)
#
# return stg.BS_cross_section_averaged
#
# if stg.ABS_name == "Aquascat 1000R":
# self.label_cells_horizontal.clear()
# self.label_cells_horizontal.setText(
# "cells = +/- " + str((self.spinbox_average_horizontal.value() // 2)*(1/stg.nb_profiles_per_sec)) + " sec")
self.plot_profile_and_position_on_transect_with_slider()
def plot_profile_and_position_on_transect_with_slider(self):
# --- Update label "Profile N / max(N)" ---
self.label_profile_number.clear()
self.label_profile_number.setText("Profile " + str(self.slider.value()) + " / " + str(self.slider.maximum()))
if ((self.combobox_fileListWidget.currentIndex() != -1) and
(stg.BS_noise_raw_data[self.combobox_fileListWidget.currentIndex()].shape != (0,))):
self.figure_profile, self.axis_profile = plt.subplots(nrows=2, ncols=1, layout="constrained")
self.canvas_profile = FigureCanvas(self.figure_profile)
self.scroll_profile.setWidget(self.canvas_profile)
self.axis_profile[0].cla()
self.axis_profile[1].cla()
if stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Plot profile ---
self.axis_profile[0].plot(
stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_fileListWidget.currentIndex()][self.combobox_frequency_profile.currentIndex()],
fontsize=10, fontweight='bold', fontname="Ubuntu",
fontstyle="normal", c="black", alpha=0.2,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_profile[0].transAxes)
# --- Plot transect with profile position ---
self.axis_profile[1].cla()
val_min = np.nanmin(
stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
val_max = np.nanmax(
stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
if val_min == 0:
val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][self.combobox_frequency_profile.currentIndex(), :],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][self.combobox_frequency_profile.currentIndex(), :],
stg.BS_stream_bed_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.BS_stream_bed_pre_process_average[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Plot profile ---
self.axis_profile[0].plot(
stg.BS_stream_bed_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex()],
fontsize=10, fontweight='bold', fontname="Ubuntu",
fontstyle="normal", c="black", alpha=0.2,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_profile[0].transAxes)
# --- Plot transect with profile position ---
self.axis_profile[1].cla()
val_min = np.nanmin(
stg.BS_stream_bed_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
val_max = np.nanmax(
stg.BS_stream_bed_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
if val_min == 0:
val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
stg.BS_stream_bed_pre_process_average[
self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.BS_cross_section_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Plot profile ---
self.axis_profile[0].plot(
stg.BS_cross_section_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex()],
fontsize=10, fontweight='bold', fontname="Ubuntu",
fontstyle="normal", c="black", alpha=0.2,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_profile[0].transAxes)
# --- Plot transect with profile position ---
self.axis_profile[1].cla()
val_min = np.nanmin(
stg.BS_cross_section_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
val_max = np.nanmax(
stg.BS_cross_section_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
if val_min == 0:
val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
stg.BS_cross_section_pre_process_SNR_average[
self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.BS_cross_section_pre_process_average[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Plot profile ---
self.axis_profile[0].plot(
stg.BS_cross_section_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex()],
fontsize=10, fontweight='bold', fontname="Ubuntu",
fontstyle="normal", c="black", alpha=0.2,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_profile[0].transAxes)
# --- Plot transect with profile position ---
self.axis_profile[1].cla()
val_min = np.nanmin(
stg.BS_cross_section_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
val_max = np.nanmax(
stg.BS_cross_section_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
if val_min == 0:
val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
stg.BS_cross_section_pre_process_average[
self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.BS_raw_data_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Plot profile ---
self.axis_profile[0].plot(
stg.BS_raw_data_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex()],
fontsize=10, fontweight='bold', fontname="Ubuntu",
fontstyle="normal", c="black", alpha=0.2,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_profile[0].transAxes)
# --- Plot transect with profile position ---
self.axis_profile[1].cla()
val_min = np.nanmin(
stg.BS_raw_data_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
val_max = np.nanmax(
stg.BS_raw_data_pre_process_SNR_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
if val_min == 0:
val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
-stg.depth_cross_section[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
stg.BS_raw_data_pre_process_SNR_average[
self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.BS_raw_data_pre_process_average[self.combobox_fileListWidget.currentIndex()].shape != (0,):
# --- Plot profile ---
self.axis_profile[0].plot(
stg.BS_raw_data_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
-stg.depth[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex()],
fontsize=10, fontweight='bold', fontname="Ubuntu",
fontstyle="normal", c="black", alpha=0.2,
horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_profile[0].transAxes)
# --- Plot transect with profile position ---
self.axis_profile[1].cla()
val_min = np.nanmin(
stg.BS_raw_data_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
val_max = np.nanmax(
stg.BS_raw_data_pre_process_average[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :])
if val_min == 0:
val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.time[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
-stg.depth[self.combobox_fileListWidget.currentIndex()][
self.combobox_frequency_profile.currentIndex(), :],
stg.BS_raw_data_pre_process_average[
self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
self.axis_profile[1].plot(
stg.time[self.combobox_fileListWidget.currentIndex()]
[self.combobox_frequency_profile.currentIndex(), self.slider.value() - 1] *
np.ones(stg.depth[self.combobox_fileListWidget.currentIndex()].shape[1]),
-stg.depth[self.combobox_fileListWidget.currentIndex()][self.combobox_frequency_profile.currentIndex(), :],
color='red', linestyle="solid", linewidth=2)
self.axis_profile[0].set_xlabel("Acoustic Backscatter Signal (V)")
self.axis_profile[0].set_ylabel("Depth (m)")
if len(stg.depth_bottom[self.combobox_fileListWidget.currentIndex()]) != 0:
if stg.time_cross_section[self.combobox_fileListWidget.currentIndex()].shape != (0,):
self.axis_profile[1].plot(stg.time_cross_section[self.combobox_fileListWidget.currentIndex()][self.combobox_frequency_profile.currentIndex(), :],
-stg.depth_bottom[self.combobox_fileListWidget.currentIndex()],
color='black', linewidth=1, linestyle="solid")
else:
self.axis_profile[1].plot(stg.time[self.combobox_fileListWidget - 1][
self.combobox_frequency_profile.currentIndex(), :],
-stg.depth_bottom[self.combobox_fileListWidget.currentIndex()],
color='black', linewidth=1, linestyle="solid")
self.axis_profile[1].set_xticks([])
self.axis_profile[1].set_yticks([])
self.figure_profile.canvas.draw_idle()
else:
# self.canvas_profile.figure.clear()
# self.figure_profile.clf()
# self.axis_profile.tolist().clear()
self.canvas_profile = FigureCanvas()
self.scroll_profile.setWidget(self.canvas_profile)
# if stg.BS_stream_bed_pre_process_SNR_average.size != 0:
#
# # --- Plot profile ---
# self.axis_profile[0].plot(
# stg.BS_stream_bed_pre_process_SNR_average[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_frequency_profile.currentIndex()],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[0].transAxes)
#
# # --- Plot transect with profile position ---
# self.axis_profile[1].cla()
# val_min = np.nanmin(stg.BS_stream_bed_pre_process_SNR_average[self.combobox_frequency_profile.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR_average[self.combobox_frequency_profile.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
# self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# stg.BS_stream_bed_pre_process_SNR_average[self.combobox_frequency_profile.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
#
# elif stg.BS_cross_section_pre_process_SNR_average.size != 0:
# # --- Plot profile ---
# self.axis_profile[0].plot(
# stg.BS_cross_section_pre_process_SNR_average[self.combobox_frequency_profile.currentIndex(), :,
# self.slider.value() - 1],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_frequency_profile.currentIndex()],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[0].transAxes)
#
# # --- Plot transect with profile position ---
# self.axis_profile[1].cla()
# val_min = np.nanmin(stg.BS_cross_section_pre_process_SNR_average[self.combobox_frequency_profile.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_cross_section_pre_process_SNR_average[self.combobox_frequency_profile.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
# self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# stg.BS_cross_section_pre_process_SNR_average[
# self.combobox_frequency_profile.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
#
# elif stg.BS_stream_bed_pre_process_SNR.size != 0:
#
# # --- Plot profile ---
# self.axis_profile[0].plot(
# stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_frequency_profile.currentIndex()],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[0].transAxes)
#
# # --- Plot transect with profile position ---
# self.axis_profile[1].cla()
# val_min = np.nanmin(stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency_profile.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency_profile.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
# self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency_profile.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
#
# elif stg.BS_cross_section_pre_process_SNR.size != 0:
# # --- Plot profile ---
# self.axis_profile[0].plot(
# stg.BS_cross_section_pre_process_SNR[self.combobox_frequency_profile.currentIndex(), :,
# self.slider.value() - 1],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_frequency_profile.currentIndex()],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[0].transAxes)
#
# # --- Plot transect with profile position ---
# self.axis_profile[1].cla()
# val_min = np.nanmin(stg.BS_cross_section_pre_process_SNR[self.combobox_frequency_profile.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_cross_section_pre_process_SNR[self.combobox_frequency_profile.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
# self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
# -stg.r[self.combobox_frequency_profile.currentIndex(), :],
# stg.BS_cross_section_pre_process_SNR[
# self.combobox_frequency_profile.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# ------------------------------------- Connect Push Button Load Data + Slider -------------------------------------
def slide_profile_number_to_begin(self):
self.slider.setValue(int(self.slider.minimum()))
self.lineEdit_slider.setText(str(self.slider.value()))
def slide_profile_number_to_right(self):
self.slider.setValue(int(self.slider.value()) + 1)
self.lineEdit_slider.setText(str(self.slider.value()))
def profile_number_on_lineEdit(self):
self.slider.setValue(int(self.lineEdit_slider.text()))
def slide_profile_number_to_left(self):
self.slider.setValue(int(self.slider.value()) - 1)
self.lineEdit_slider.setText(str(self.slider.value()))
def slide_profile_number_to_end(self):
self.slider.setValue(int(self.slider.maximum()))
self.lineEdit_slider.setText(str(self.slider.value()))
def update_lineEdit_by_moving_slider(self):
self.lineEdit_slider.setText(str(self.slider.value()))
# ______ _______
# | | | | \
# | | | | \
# | | | | |
# | | | | /
# |______| |________ |________/
# COMMENT OLD CODE LINE FROM HERE ....
# def compute_BS_data_section(self):
# if stg.BS_cross_section.size == 0:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Load data Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Please check acoustic data Tab")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
# else:
# # if stg.r_bottom.size == 0:
# # stg.BS_stream_bed = deepcopy(stg.BS_cross_section)
# if stg.r_bottom.size != 0:
# stg.BS_stream_bed = deepcopy(stg.BS_cross_section)
# for f, _ in enumerate(stg.freq):
# for k, _ in enumerate(stg.r_bottom):
# # print(k, np.where(stg.r >= stg.r_bottom[k])[0])
# stg.BS_stream_bed[f, np.where(stg.r[self.combobox_frequency.currentIndex(), :] >= stg.r_bottom[k])[0], k] = np.nan
#
# # --- Choose frequency (Combo box) to plot transect with profile position ---
# self.combobox_frequency.addItems(stg.freq_text)
# self.combobox_frequency.currentTextChanged.connect(self.update_plot_profile_position_on_transect)
#
# # --- Choose frequency (Combo box) to compute water attenuation ---
# self.combobox_freq_for_water_attenuation.addItems(stg.freq_text)
#
# # --- Choose frequency (Combo box) to compute sediment attenuation ---
# self.combobox_frequency_compute_alphaS.addItems(stg.freq_text)
#
# # --- Fix maximum value of slider + Edit Label Profile number ---
# self.slider.setMaximum(stg.t.shape[1])
# self.label_profile_number.clear()
# self.label_profile_number.setText("Vertical " + str(self.slider.value()) + " / " + str(self.slider.maximum()))
#
# self.plot_profile_position_on_transect()
# self.plot_profile()
#
# # ---------------------------------------- Connect Groupbox filter with SNR ----------------------------------------
#
#
#
# # ----------------------------------------- Connect Groupbox average data -----------------------------------------
#
# def compute_averaged_profile(self):
#
# if stg.BS_cross_section.size == 0:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Average Backscatter signal Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Load data from acoustic data tab before averaging backscatter signal")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
# else:
# if self.spinbox_average_horizontal.value() % 2 == 0:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Average Backscatter signal Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Please enter an odd number")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
# else:
#
# filter_convolve = np.ones(self.spinbox_average_horizontal.value())
# print(filter_convolve)
#
# if stg.BS_stream_bed_pre_process_SNR.size != 0:
#
# # stg.BS_stream_bed_pre_process_average = np.zeros((stg.r.shape[0], stg.freq.shape[0], stg.t.shape[0]))
# # stg.BS_stream_bed_pre_process_average = np.zeros((stg.freq.shape[0], stg.r.shape[1], stg.t.shape[1]))
# stg.BS_stream_bed_pre_process_average = deepcopy(stg.BS_stream_bed_pre_process_SNR)
# print(f"1/ stg.BS_stream_bed_pre_process_average : {stg.BS_stream_bed_pre_process_average}")
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_stream_bed_pre_process_average[f, i, :] \
# = convolve1d(stg.BS_stream_bed_pre_process_SNR[f, i, :], weights=filter_convolve) / len(filter_convolve)
# # stg.BS_stream_bed_pre_process_average[i, f, :] \
# # = convolve1d(stg.BS_cross_section[i, f, :], weights=filter_convolve) / filter_convolve.shape[0]
#
# elif stg.BS_cross_section_pre_process_SNR.size != 0:
#
# stg.BS_cross_section_averaged = deepcopy(stg.BS_cross_section_pre_process_SNR)
# print(f"2/ stg.BS_cross_section_averaged : {stg.BS_cross_section_averaged}")
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_stream_bed_pre_process_average[f, i, :] \
# = convolve1d(stg.BS_cross_section_pre_process_SNR[f, i, :],
# weights=filter_convolve) / len(filter_convolve)
#
# elif stg.BS_stream_bed.size != 0:
#
# stg.BS_stream_bed_pre_process_average = deepcopy(stg.BS_stream_bed)
# print(f"3/ stg.BS_stream_bed_pre_process_average : {stg.BS_stream_bed_pre_process_average.shape}")
# print(stg.BS_stream_bed_pre_process_average[0, 10, :50])
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_stream_bed_pre_process_average[f, i, :] \
# = convolve1d(stg.BS_stream_bed[f, i, :],
# weights=filter_convolve) / len(filter_convolve)
# print(stg.BS_stream_bed_pre_process_average[0, 10, :50])
#
# elif stg.BS_cross_section.size != 0:
#
# stg.BS_cross_section_averaged = deepcopy(stg.BS_cross_section)
# print(f"4/ stg.BS_cross_section_averaged : {stg.BS_cross_section_averaged.shape}")
# for f, _ in enumerate(stg.freq):
# for i in range(stg.r.shape[1]):
# stg.BS_cross_section_averaged[f, i, :] \
# = convolve1d(stg.BS_cross_section[f, i, :],
# weights=filter_convolve) / len(filter_convolve)
#
# if stg.ABS_name == "Aquascat 1000R":
# self.label_cells_horizontal.clear()
# self.label_cells_horizontal.setText(
# "cells = +/- " + str((self.spinbox_average_horizontal.value() // 2)*(1/stg.nb_profiles_per_sec)) + " sec")
#
# # self.label_cells_vertical.clear()
# # self.label_cells_vertical.setText(
# # "cells = +/- " + str((self.spinbox_average_vertical.value() // 2) * (1 / stg.nb_profiles_per_sec)) + " sec")
#
# self.plot_averaged_profile()
# self.update_plot_profile_position_on_transect()
#
# self.slider.valueChanged.connect(self.update_plot_averaged_profile)
#
# # fig, ax = plt.subplots(nrows=1, ncols=1)
# # val_min = np.nanmin(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :])
# # val_max = np.nanmax(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :])
# # if val_min == 0:
# # val_min = 1e-5
# #
# # ax.pcolormesh(stg.t[self.combobox_frequency.currentIndex(), :],
# # -stg.r[self.combobox_frequency.currentIndex(), :],
# # stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :],
# # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# #
# # plt.show()
#
# def compute_water_attenuation(self):
# if (stg.freq.size == 0) or (self.spinbox_temperature_water_attenuation.value() == 0):
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Water attenuation Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Load Backscatter data from acoustic data tab and enter a value of temperature")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
#
# else:
#
# if self.combobox_water_attenuation_model.currentIndex() == 0:
# self.Francois_and_Garrison_1982()
#
# else:
# pass
#
# print(f"{stg.water_attenuation:.2f}")
# self.label_water_attenuation.clear()
# self.label_water_attenuation.setText("\u03B1w = " + f"{stg.water_attenuation:.4f}" + " dB/m")
#
# def Francois_and_Garrison_1982(self):
# if self.spinbox_temperature_water_attenuation.value() > 20:
# stg.water_attenuation = ((3.964 * 1e-4 - 1.146 * 1e-5 * self.spinbox_temperature_water_attenuation.value() +
# 1.45 * 1e-7 * self.spinbox_temperature_water_attenuation.value() ** 2 -
# 6.5 * 1e-10 * self.spinbox_temperature_water_attenuation.value() ** 3) * 1e-3 *
# (np.log(10) / 20) *
# (stg.freq[self.combobox_freq_for_water_attenuation.currentIndex()] * 1e-3) ** 2)
# else:
# stg.water_attenuation = ((4.937 * 1e-4 - 2.59 * 1e-5 * self.spinbox_temperature_water_attenuation.value() +
# 9.11 * 1e-7 * self.spinbox_temperature_water_attenuation.value() ** 2 -
# 1.5 * 1e-8 * self.spinbox_temperature_water_attenuation.value() ** 3) * 1e-3 *
# (np.log(10) / 20) *
# (stg.freq[self.combobox_freq_for_water_attenuation.currentIndex()] * 1e-3) ** 2)
#
# # ------------ Computing real cell size ------------ #
# def range_cells_function(self):
# """ Computing the real cell size, that depends on the temperature """
# # defaut Aquascat cell size
# aquascat_cell_size = stg.r[0, 1] - stg.r[0, 0]
# # Pulse duration
# tau = aquascat_cell_size * 2 / 1500 # figure 2.9 1500 vitesse du son entrée pour le paramètrage des mesures aquascat
# # Sound speed
# cel = self.inv_hc.water_velocity(self.spinbox_temperature_water_attenuation.value())
# # Real cell size
# real_cell_size = cel * tau / 2 # voir fig 2.9
#
# # Converting to real cell profile
# real_r = stg.r / aquascat_cell_size * real_cell_size # (/ aquascat_cell_size) pour ramener BS.r entre 0 et 1
# # (* real_cell_size) pour remettre les échelles spatiales sur la taille réelle des cellules
#
# # R with right shape (numpy array)
# R_real = real_r # np.repeat(real_r, len(stg.freq), axis=1)
#
# return R_real
#
# def compute_FCB(self):
# if stg.BS_stream_bed.size == 0:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("FCB Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Load Backscatter data from acoustic data tab and compute water attenuation")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
# else:
# print(f"self.range_cells_function() : {self.range_cells_function()}")
# print(f"self.range_cells_function() shape : {self.range_cells_function().shape}")
# R_real = np.repeat(self.range_cells_function()[:, :, np.newaxis], stg.t.shape[1], axis=2)
# print(f"R_real shape : {R_real.shape}")
# if (stg.BS_stream_bed_pre_process_average.size == 0) and (stg.BS_stream_bed_pre_process_SNR.size == 0):
# stg.FCB = (np.log(stg.BS_stream_bed) + np.log(R_real) +
# 2 * stg.water_attenuation * R_real)
# elif stg.BS_stream_bed_pre_process_SNR.size == 0:
# stg.FCB = (np.log(stg.BS_stream_bed_pre_process_average) + np.log(R_real) +
# 2 * stg.water_attenuation * R_real)
# else:
# stg.FCB = (np.log(stg.BS_stream_bed_pre_process_SNR) + np.log(R_real) +
# 2 * stg.water_attenuation * R_real)
# self.plot_FCB()
#
# def fit_FCB_profile_with_linear_regression_and_compute_alphaS(self):
#
# if stg.FCB.size == 0:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Linear regression error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Please compute FCB before")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
# else:
# try:
# y0 = stg.FCB[self.combobox_frequency_compute_alphaS.currentIndex(), :, self.slider.value()]
# y = y0[np.where(np.isnan(y0) == False)]
#
# x0 = stg.r[0, :].reshape(-1)
# x = x0[np.where(np.isnan(y0) == False)]
#
# value1 = np.where(np.round(np.abs(x - self.spinbox_alphaS_computation_from.value()), 2)
# == np.min(np.round(np.abs(x - self.spinbox_alphaS_computation_from.value()), 2)))
# value2 = np.where(np.round(np.abs(x - self.spinbox_alphaS_computation_to.value()), 2)
# == np.min(np.round(np.abs(x - self.spinbox_alphaS_computation_to.value()), 2)))
#
# # print(np.round(np.abs(x - self.spinbox_alphaS_computation_from.value()), 2))
# # # print("value1 ", value1[0][0])
# # print(np.round(np.abs(x - self.spinbox_alphaS_computation_to.value()), 2))
# # print("value2 ", value2[0][0])
#
# # print("y limited ", y[value1[0][0]:value2[0][0]])
#
# lin_reg_compute = stats.linregress(x[value1[0][0]:value2[0][0]], y[value1[0][0]:value2[0][0]])
# except ValueError:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Linear regression error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Please check boundaries to fit a linear line")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
# else:
# stg.lin_reg = (lin_reg_compute.slope, lin_reg_compute.intercept)
# # print(f"y = {stg.lin_reg[0]}x + {stg.lin_reg[1]}")
#
# self.label_alphaS.clear()
# self.label_alphaS.setText(f"\u03B1s = {-0.5*stg.lin_reg[0]:.4f} dB/m")
#
# # for i, value_freq in enumerate(stg.freq):
# # for k, value_t in enumerate(stg.t):
# # # print(f"indice i: {i}, indice k: {k}")
# # # print(f"values of FCB: {stg.FCB[:, i, k]}")
# # y = stg.FCB[:, i, k]
# # # print("y : ", y)
# # # print(f"values of FCB where FCB is not Nan {y[np.where(np.isnan(y) == False)]}")
# # # print(f"values of r where FCB is not Nan {x[np.where(np.isnan(y) == False)]}")
# # lin_reg_compute = stats.linregress(x[np.where(np.isnan(y) == False)], y[np.where(np.isnan(y) == False)])
# # lin_reg_tuple = (lin_reg_compute.slope, lin_reg_compute.intercept)
# # stg.lin_reg.append(lin_reg_tuple)
#
# # print(f"y = {lin_reg.slope}x + {lin_reg.intercept}")
#
# # plt.figure()
# # plt.plot(stg.r, stg.FCB[:, 0, 825], 'k-', stg.r, lin_reg.slope*stg.r + lin_reg.intercept, "b--")
# # plt.show()
#
# # print("lin_reg length ", len(stg.lin_reg))
# # print("lin_reg ", stg.lin_reg)
#
# # ---------------------------------------- PLOT PROFILE POSITION ON TRANSECT ---------------------------------------
#
# def plot_profile_position_on_transect(self):
#
# # --- Create Matplotlib canvas (with figure and axis) to plot transect ---
# self.canvas_plot_profile_position_on_transect = FigureCanvas()
# self.figure_plot_profile_position_on_transect, self.axis_plot_profile_position_on_transect = \
# plt.subplots(nrows=1, ncols=1, layout="constrained")
# self.canvas_plot_profile_position_on_transect = FigureCanvas(self.figure_plot_profile_position_on_transect)
# self.verticalLayout_groupbox_display_profile_position.addWidget(self.canvas_plot_profile_position_on_transect)
#
# # --- Plot transect with profile position ---
#
# if stg.ABS_name == "Aquascat 1000R":
# if stg.BS_stream_bed.size != 0:
#
# 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_profile_position_on_transect.pcolormesh(
# stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :],
# stg.BS_stream_bed[stg.freq_bottom_detection, :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# else:
#
# 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_profile_position_on_transect.pcolormesh(
# stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :],
# stg.BS_cross_section[stg.freq_bottom_detection, :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
#
# elif stg.ABS_name == "UB-SediFlow":
#
# if stg.BS_stream_bed.size != 0:
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :],
# np.log(stg.BS_stream_bed[stg.freq_bottom_detection, :, :]),
# cmap='Blues')
# else:
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :],
# np.log(stg.BS_cross_section[stg.freq_bottom_detection, :, :]),
# cmap='Blues')
#
# if stg.r_bottom.size != 0:
# self.axis_plot_profile_position_on_transect.plot(
# stg.t[stg.freq_bottom_detection, :], -stg.r_bottom, color='black', linewidth=1, linestyle="solid")
#
# self.axis_plot_profile_position_on_transect.plot(
# stg.t[stg.freq_bottom_detection, self.slider.value() - 1] * np.ones(stg.r.shape[1]), -stg.r[stg.freq_bottom_detection, :],
# color='red', linestyle="solid", linewidth=2)
#
# self.axis_plot_profile_position_on_transect.set_xticks([])
# self.axis_plot_profile_position_on_transect.set_yticks([])
#
# self.figure_plot_profile_position_on_transect.canvas.draw_idle()
#
# def update_plot_profile_position_on_transect(self):
#
# # --- Update label "Profile N / max(N)" ---
# self.label_profile_number.clear()
# self.label_profile_number.setText("Vertical " + str(self.slider.value()) + " / " + str(self.slider.maximum()))
#
# # --- Update transect plot ---
#
# if self.canvas_plot_profile_position_on_transect is None:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Plot Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Load and post-process data before plotting transect with profile position")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
#
# else:
#
# if stg.BS_stream_bed.size != 0:
#
# if (stg.BS_stream_bed_pre_process_average.size == 0) and (stg.BS_stream_bed_pre_process_SNR.size == 0):
#
# self.axis_plot_profile_position_on_transect.cla()
#
# val_min = np.nanmin(stg.BS_stream_bed[self.combobox_frequency.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_stream_bed[self.combobox_frequency.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
#
# if stg.ABS_name == "Aquascat 1000R":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# stg.BS_stream_bed[self.combobox_frequency.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# elif stg.ABS_name == "UB-SediFlow":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# np.log(stg.BS_stream_bed[self.combobox_frequency.currentIndex(), :, :]),
# cmap='Blues')
#
# elif (stg.BS_stream_bed_pre_process_average.size != 0) and (stg.BS_stream_bed_pre_process_SNR.size == 0):
#
# self.axis_plot_profile_position_on_transect.cla()
#
# val_min = np.nanmin(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
#
# if stg.ABS_name == "Aquascat 1000R":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# elif stg.ABS_name == "UB-SediFlow":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# np.log(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :]),
# cmap='Blues')
#
# elif stg.BS_stream_bed_pre_process_SNR.size != 0:
#
# self.axis_plot_profile_position_on_transect.cla()
#
# val_min = np.nanmin(stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
#
# if stg.ABS_name == "Aquascat 1000R":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# elif stg.ABS_name == "UB-SediFlow":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# np.log(stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :]),
# cmap='Blues')
#
# else:
#
# if (stg.BS_cross_section_averaged.size == 0) and (stg.BS_cross_section_pre_process_SNR.size == 0):
#
# self.axis_plot_profile_position_on_transect.cla()
#
# val_min = np.nanmin(stg.BS_cross_section[self.combobox_frequency.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_cross_section[self.combobox_frequency.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
#
# if stg.ABS_name == "Aquascat 1000R":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# stg.BS_cross_section[self.combobox_frequency.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# elif stg.ABS_name == "UB-SediFlow":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# np.log(stg.BS_cross_section[self.combobox_frequency.currentIndex(), :, :]),
# cmap='Blues')
#
# elif (stg.BS_cross_section_averaged.size != 0) and (stg.BS_cross_section_pre_process_SNR.size == 0):
#
# self.axis_plot_profile_position_on_transect.cla()
#
# val_min = np.nanmin(stg.BS_cross_section_averaged[self.combobox_frequency.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_cross_section_averaged[self.combobox_frequency.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
#
# if stg.ABS_name == "Aquascat 1000R":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# stg.BS_cross_section_averaged[self.combobox_frequency.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# elif stg.ABS_name == "UB-SediFlow":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# np.log(stg.BS_cross_section_averaged[self.combobox_frequency.currentIndex(), :, :]),
# cmap='Blues')
#
# elif stg.BS_cross_section_pre_process_SNR.size != 0:
#
# self.axis_plot_profile_position_on_transect.cla()
#
# val_min = np.nanmin(stg.BS_cross_section_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :])
# val_max = np.nanmax(stg.BS_cross_section_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :])
# if val_min == 0:
# val_min = 1e-5
#
# if stg.ABS_name == "Aquascat 1000R":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# stg.BS_cross_section_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :],
# cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# elif stg.ABS_name == "UB-SediFlow":
# self.axis_plot_profile_position_on_transect.pcolormesh(
# stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[self.combobox_frequency.currentIndex(), :],
# np.log(stg.BS_cross_section_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :]),
# cmap='Blues')
#
# if stg.r_bottom.size != 0:
# self.axis_plot_profile_position_on_transect.plot(stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r_bottom,
# color='black', linewidth=1, linestyle="solid")
#
# self.axis_plot_profile_position_on_transect.plot(
# stg.t[self.combobox_frequency.currentIndex(), self.slider.value() - 1] * np.ones(stg.r.shape[1]),
# -stg.r[self.combobox_frequency.currentIndex(), :],
# color='red', linestyle="solid", linewidth=2)
#
# self.axis_plot_profile_position_on_transect.set_xticks([])
# self.axis_plot_profile_position_on_transect.set_yticks([])
#
# self.figure_plot_profile_position_on_transect.canvas.draw_idle()
#
# # -------------------------------------------------- PLOT PROFILE -------------------------------------------------
#
# def plot_profile(self):
#
# # --- Raw profile ---
#
# self.figure_profile, self.axis_profile \
# = plt.subplots(nrows=1, ncols=stg.freq.shape[0], sharex=True, sharey=True, layout='constrained')
# self.canvas_profile = FigureCanvas(self.figure_profile)
# self.verticalLayout_groupbox_plot_profile.addWidget(self.canvas_profile)
# # self.scroll_profile = QScrollArea()
# # self.scroll_profile.setWidget(self.canvas_profile)
# # self.scroll_profile.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# # self.scroll_profile.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# # self.scroll_profile.setAlignment(Qt.AlignCenter)
# # self.verticalLayout_groupbox_plot_profile.addWidget(self.scroll_profile)
#
# if stg.BS_stream_bed.size == 0:
#
# for f, _ in enumerate(stg.freq):
# self.axis_profile[f].cla()
# self.axis_profile[f].plot(stg.BS_cross_section[f, :, self.slider.value() - 1], -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[f].transAxes)
#
# else:
#
# for f, _ in enumerate(stg.freq):
# self.axis_profile[f].cla()
# self.axis_profile[f].plot(stg.BS_stream_bed[f, :, self.slider.value() - 1], -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[f].transAxes)
#
# self.figure_profile.supxlabel("Acoustic Backscatter Signal (V)")
# self.figure_profile.supylabel("Depth (m)")
#
# # --- Raw averaged profile ---
#
# self.figure_averaged_profile, self.axis_averaged_profile \
# = plt.subplots(nrows=1, ncols=stg.freq.shape[0], sharex=True, sharey=True, layout='constrained')
# self.canvas_averaged_profile = FigureCanvas(self.figure_averaged_profile)
# self.verticalLayout_groupbox_plot_averaged_profile.addWidget(self.canvas_averaged_profile)
# # self.scroll_averaged_profile = QScrollArea()
# # self.scroll_averaged_profile.setWidget(self.canvas_averaged_profile)
# # self.scroll_averaged_profile.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# # self.scroll_averaged_profile.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# # self.scroll_averaged_profile.setAlignment(Qt.AlignCenter)
# # self.verticalLayout_groupbox_plot_averaged_profile.addWidget(self.scroll_averaged_profile)
#
# # self.axis_averaged_profile[f].text(.95, .05, stg.freq_text[f],
# # fontsize=10, fontweight='bold', fontname="Ubuntu",
# # fontstyle="normal", c="black", alpha=0.2,
# # horizontalalignment='right', verticalalignment='bottom',
# # transform=self.axis_averaged_profile[f].transAxes)
#
# # --- Raw FCB profile ---
#
# self.figure_FCB_profile, self.axis_FCB_profile \
# = plt.subplots(nrows=1, ncols=stg.freq.shape[0], sharex=True, sharey=True, layout='constrained')
# self.canvas_FCB_profile = FigureCanvas(self.figure_FCB_profile)
# self.verticalLayout_groupbox_plot_FCB_profile.addWidget(self.canvas_FCB_profile)
# # self.scroll_FCB_profile = QScrollArea()
# # self.scroll_FCB_profile.setWidget(self.canvas_FCB_profile)
# # self.scroll_FCB_profile.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# # self.scroll_FCB_profile.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# # self.scroll_FCB_profile.setAlignment(Qt.AlignCenter)
# # self.verticalLayout_groupbox_plot_FCB_profile.addWidget(self.scroll_FCB_profile)
#
# # self.axis_FCB_profile[f].text(.95, .05, stg.freq_text[f],
# # fontsize=10, fontweight='bold', fontname="Ubuntu",
# # fontstyle="normal", c="black", alpha=0.2,
# # horizontalalignment='right', verticalalignment='bottom',
# # transform=self.axis_FCB_profile[f].transAxes)
#
# def update_plot_profile(self):
# if self.canvas_profile is None:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Plot Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Load and post-process data before plotting profiles")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
#
# else:
#
# if stg.BS_stream_bed.size == 0:
#
# for f, _ in enumerate(stg.freq):
# self.axis_profile[f].cla()
# self.axis_profile[f].plot(stg.BS_cross_section[f, :, self.slider.value() - 1], -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[f].transAxes)
#
# else:
#
# for f, _ in enumerate(stg.freq):
# self.axis_profile[f].cla()
# self.axis_profile[f].plot(stg.BS_stream_bed[f, :, self.slider.value() - 1], -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# self.axis_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_profile[f].transAxes)
#
# self.figure_profile.supxlabel("Acoustic Backscatter Signal (V)")
# self.figure_profile.supylabel("Depth (m)")
# self.figure_profile.canvas.draw_idle()
#
# # --------------------------------- PLOT AVERAGED PROFILE FILTERED OR NOT WITH SNR ---------------------------------
#
# def plot_averaged_profile(self):
#
# if stg.BS_stream_bed_pre_process_average.size == 0:
#
# for f, _ in enumerate(stg.freq):
# self.axis_averaged_profile[f].cla()
# self.axis_averaged_profile[f].plot(stg.BS_cross_section_averaged[f, :, self.slider.value()-1], -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# # self.axis_averaged_profile[f].set_ylim(-np.max(stg.r[f, :]), np.min(stg.r[f, :]))
# self.axis_averaged_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_averaged_profile[f].transAxes)
#
# else:
#
# for f, _ in enumerate(stg.freq):
# self.axis_averaged_profile[f].cla()
# self.axis_averaged_profile[f].plot(stg.BS_stream_bed_pre_process_average[f, :, self.slider.value()-1], -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# # self.axis_averaged_profile[f].set_ylim(-np.max(stg.r[f, :]), np.min(stg.r[f, :]))
# self.axis_averaged_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_averaged_profile[f].transAxes)
#
# self.figure_averaged_profile.supxlabel("Acoustic Backscatter Signal (V)")
# self.figure_averaged_profile.supylabel("Depth (m)")
# self.figure_averaged_profile.canvas.draw_idle()
#
# def update_plot_averaged_profile(self):
# if self.canvas_averaged_profile is None:
# msgBox = QMessageBox()
# msgBox.setWindowTitle("Plot Error")
# msgBox.setIcon(QMessageBox.Warning)
# msgBox.setText("Load and post-process data before plotting averaged profiles")
# msgBox.setStandardButtons(QMessageBox.Ok)
# msgBox.exec()
#
# else:
#
# if stg.BS_stream_bed_pre_process_average.size == 0:
#
# for f, _ in enumerate(stg.freq):
# self.axis_averaged_profile[f].cla()
# self.axis_averaged_profile[f].plot(stg.BS_cross_section_averaged[f, :, self.slider.value() - 1],
# -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# # self.axis_averaged_profile[f].set_ylim(-np.max(stg.r[f, :]), np.min(stg.r[f, :]))
# self.axis_averaged_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_averaged_profile[f].transAxes)
#
# else:
#
# for f, _ in enumerate(stg.freq):
# self.axis_averaged_profile[f].cla()
# self.axis_averaged_profile[f].plot(stg.BS_stream_bed_pre_process_average[f, :, self.slider.value() - 1],
# -stg.r[f, :],
# linestyle='solid', color='k', linewidth=1)
# # self.axis_averaged_profile[f].set_ylim(-np.max(stg.r[f, :]), np.min(stg.r[f, :]))
# self.axis_averaged_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_averaged_profile[f].transAxes)
#
# self.figure_averaged_profile.supxlabel("Acoustic Backscatter Signal (V)")
# self.figure_averaged_profile.supylabel("Depth (m)")
# self.figure_averaged_profile.canvas.draw_idle()
#
# # ---------------------------------------------------- PLOT FCB ----------------------------------------------------
#
# def plot_FCB(self):
#
# for f in range(stg.freq.shape[0]):
#
# self.axis_FCB_profile[f].cla()
#
# self.axis_FCB_profile[f].plot(stg.r[f, :], stg.FCB[f, :, self.slider.value()], linestyle="solid", linewidth=1, color="k")
#
# # self.axis_FCB_profile[f].set_ylim(np.max(stg.r), np.min(stg.r))
# self.axis_FCB_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_FCB_profile[f].transAxes)
#
# if len(stg.lin_reg) != 0:
# self.axis_FCB_profile[self.combobox_frequency_compute_alphaS.currentIndex()]. \
# plot(stg.r[f, :], stg.lin_reg[0]*stg.r[f, :] + stg.lin_reg[1], linestyle="dashed", linewidth=1, color="b")
#
# self.figure_FCB_profile.supylabel("FCB")
# self.figure_FCB_profile.supxlabel("Depth (m)")
# self.figure_FCB_profile.canvas.draw_idle()
#
# def update_plot_FCB(self):
#
# if stg.FCB.size != 0:
#
# for f in range(stg.freq.shape[0]):
#
# self.axis_FCB_profile[f].cla()
#
# self.axis_FCB_profile[f].plot(stg.r[f, :], stg.FCB[f, :, self.slider.value()], linestyle="solid", linewidth=1, color="k")
#
# # self.axis_FCB_profile[f].set_ylim(-np.max(stg.r), np.min(stg.r))
#
# self.axis_FCB_profile[f].text(.95, .05, stg.freq_text[f],
# fontsize=10, fontweight='bold', fontname="Ubuntu",
# fontstyle="normal", c="black", alpha=0.2,
# horizontalalignment='right', verticalalignment='bottom',
# transform=self.axis_FCB_profile[f].transAxes)
#
# self.figure_FCB_profile.supylabel("FCB")
# self.figure_FCB_profile.supxlabel("Depth (m)")
# self.figure_FCB_profile.canvas.draw_idle()
#
Reference in New Issue View Git Blame Copy Permalink