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("/² <=") 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("/² <=") # 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\u03B1s<\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\u03B1s<\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() #