diff --git a/View/signal_processing_tab.py b/View/signal_processing_tab.py index 069d78d..eb87d34 100644 --- a/View/signal_processing_tab.py +++ b/View/signal_processing_tab.py @@ -1157,13 +1157,13 @@ class SignalProcessingTab(QWidget): if stg.BS_stream_bed.size == 0: - stg.BS_cross_section_SNR_filter = deepcopy(stg.BS_cross_section) + 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_SNR_filter - stg.Noise_data) ** 2, stg.Noise_data ** 2) + # (stg.BS_stream_bed_pre_process_SNR - stg.Noise_data) ** 2, stg.Noise_data ** 2) for f, _ in enumerate(stg.freq): - stg.BS_cross_section_SNR_filter[ + stg.BS_cross_section_pre_process_SNR[ f, np.where(stg.SNR_cross_section[f, :, :] < self.spinbox_SNR_criterion.value())[0], np.where(stg.SNR_cross_section[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \ @@ -1171,25 +1171,25 @@ class SignalProcessingTab(QWidget): else: - stg.BS_stream_bed_SNR_filter = deepcopy(stg.BS_stream_bed) + 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_SNR_filter - stg.Noise_data) ** 2, stg.Noise_data ** 2) + # (stg.BS_stream_bed_pre_process_SNR - stg.Noise_data) ** 2, stg.Noise_data ** 2) for f, _ in enumerate(stg.freq): - stg.BS_stream_bed_SNR_filter[ + stg.BS_stream_bed_pre_process_SNR[ f, np.where(stg.SNR_stream_bed[f, :, :] < self.spinbox_SNR_criterion.value())[0], np.where(stg.SNR_stream_bed[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \ = np.nan - # elif stg.BS_stream_bed_averaged.size != 0: - # stg.BS_stream_bed_SNR_filter = deepcopy(stg.BS_stream_bed_averaged) + # 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_SNR_filter - BS_noise_cross_section) ** 2, BS_noise_cross_section ** 2) + # (stg.BS_stream_bed_pre_process_SNR - BS_noise_cross_section) ** 2, BS_noise_cross_section ** 2) # # print(stg.SNR_data_average[0, :, :]) @@ -1207,7 +1207,7 @@ class SignalProcessingTab(QWidget): # 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_SNR_filter[ + # 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]] \ @@ -1241,24 +1241,24 @@ class SignalProcessingTab(QWidget): if stg.BS_stream_bed.size == 0: - val_min = np.nanmin(stg.BS_cross_section_SNR_filter[f, :, :]) - val_max = np.nanmax(stg.BS_cross_section_SNR_filter[f, :, :]) + val_min = np.nanmin(stg.BS_cross_section_pre_process_SNR[f, :, :]) + val_max = np.nanmax(stg.BS_cross_section_pre_process_SNR[f, :, :]) if val_min == 0: val_min = 1e-5 - pcm = self.axis_BS[f].pcolormesh(stg.t[f, :], -stg.r[f, :], stg.BS_cross_section_SNR_filter[f, :, :], + pcm = self.axis_BS[f].pcolormesh(stg.t[f, :], -stg.r[f, :], stg.BS_cross_section_pre_process_SNR[f, :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) else: - val_min = np.nanmin(stg.BS_stream_bed_SNR_filter[f, :, :]) - val_max = np.nanmax(stg.BS_stream_bed_SNR_filter[f, :, :]) + val_min = np.nanmin(stg.BS_stream_bed_pre_process_SNR[f, :, :]) + val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR[f, :, :]) if val_min == 0: val_min = 1e-5 - pcm = self.axis_BS[f].pcolormesh(stg.t[f, :], -stg.r[f, :], stg.BS_stream_bed_SNR_filter[f, :, :], + pcm = self.axis_BS[f].pcolormesh(stg.t[f, :], -stg.r[f, :], stg.BS_stream_bed_pre_process_SNR[f, :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) self.axis_BS[f].plot(stg.t[f, :], -stg.r_bottom, @@ -1289,44 +1289,44 @@ class SignalProcessingTab(QWidget): filter_convolve = np.ones(2*self.spinbox_average_horizontal.value()+1) print(filter_convolve) - if stg.BS_stream_bed_SNR_filter.size != 0: + if stg.BS_stream_bed_pre_process_SNR.size != 0: - stg.BS_stream_bed_averaged_SNR = deepcopy(stg.BS_stream_bed_SNR_filter) - # print(f"1/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged_SNR}") + 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_averaged_SNR[f, i, :] \ - = convolve1d(stg.BS_stream_bed_SNR_filter[f, i, :], weights=filter_convolve) / len(filter_convolve) - # stg.BS_stream_bed_averaged[i, f, :] \ + stg.BS_stream_bed_pre_process_SNR_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] - return stg.BS_stream_bed_averaged_SNR + return stg.BS_stream_bed_pre_process_SNR_average - elif stg.BS_cross_section_SNR_filter.size != 0: + elif stg.BS_cross_section_pre_process_SNR.size != 0: - stg.BS_cross_section_averaged_SNR = deepcopy(stg.BS_cross_section_SNR_filter) - print(f"2/ stg.BS_cross_section_averaged : {stg.BS_cross_section_averaged_SNR}") + 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_averaged_SNR[f, i, :] \ - = convolve1d(stg.BS_cross_section_SNR_filter[f, i, :], + stg.BS_cross_section_pre_process_SNR_average[f, i, :] \ + = convolve1d(stg.BS_cross_section_pre_process_SNR[f, i, :], weights=filter_convolve) / len(filter_convolve) - return stg.BS_cross_section_averaged_SNR + return stg.BS_cross_section_pre_process_SNR_average elif stg.BS_stream_bed.size != 0: - stg.BS_stream_bed_averaged = deepcopy(stg.BS_stream_bed) - # print(f"3/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged.shape}") - print(stg.BS_stream_bed_averaged[0, 10, :50]) + 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_averaged[f, i, :] \ + 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_averaged[0, 10, :50]) + print(stg.BS_stream_bed_pre_process_average[0, 10, :50]) - return stg.BS_stream_bed_averaged + return stg.BS_stream_bed_pre_process_average elif stg.BS_cross_section.size != 0: @@ -1356,11 +1356,11 @@ class SignalProcessingTab(QWidget): self.axis_profile[0].cla() self.axis_profile[1].cla() - if stg.BS_stream_bed_averaged_SNR.size != 0: + if stg.BS_stream_bed_pre_process_SNR_average.size != 0: # --- Plot profile --- self.axis_profile[0].plot( - stg.BS_stream_bed_averaged_SNR[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1], + 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()], @@ -1371,19 +1371,19 @@ class SignalProcessingTab(QWidget): # --- Plot transect with profile position --- self.axis_profile[1].cla() - val_min = np.nanmin(stg.BS_stream_bed_averaged_SNR[self.combobox_frequency_profile.currentIndex(), :, :]) - val_max = np.nanmax(stg.BS_stream_bed_averaged_SNR[self.combobox_frequency_profile.currentIndex(), :, :]) + 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_averaged_SNR[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_averaged_SNR.size != 0: + elif stg.BS_cross_section_pre_process_SNR_average.size != 0: # --- Plot profile --- self.axis_profile[0].plot( - stg.BS_cross_section_averaged_SNR[self.combobox_frequency_profile.currentIndex(), :, + 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) @@ -1395,21 +1395,21 @@ class SignalProcessingTab(QWidget): # --- Plot transect with profile position --- self.axis_profile[1].cla() - val_min = np.nanmin(stg.BS_cross_section_averaged_SNR[self.combobox_frequency_profile.currentIndex(), :, :]) - val_max = np.nanmax(stg.BS_cross_section_averaged_SNR[self.combobox_frequency_profile.currentIndex(), :, :]) + 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_averaged_SNR[ + 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_SNR_filter.size != 0: + elif stg.BS_stream_bed_pre_process_SNR.size != 0: # --- Plot profile --- self.axis_profile[0].plot( - stg.BS_stream_bed_SNR_filter[self.combobox_frequency_profile.currentIndex(), :, self.slider.value() - 1], + 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()], @@ -1420,19 +1420,19 @@ class SignalProcessingTab(QWidget): # --- Plot transect with profile position --- self.axis_profile[1].cla() - val_min = np.nanmin(stg.BS_stream_bed_SNR_filter[self.combobox_frequency_profile.currentIndex(), :, :]) - val_max = np.nanmax(stg.BS_stream_bed_SNR_filter[self.combobox_frequency_profile.currentIndex(), :, :]) + 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_SNR_filter[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_SNR_filter.size != 0: + elif stg.BS_cross_section_pre_process_SNR.size != 0: # --- Plot profile --- self.axis_profile[0].plot( - stg.BS_cross_section_SNR_filter[self.combobox_frequency_profile.currentIndex(), :, + 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) @@ -1444,13 +1444,13 @@ class SignalProcessingTab(QWidget): # --- Plot transect with profile position --- self.axis_profile[1].cla() - val_min = np.nanmin(stg.BS_cross_section_SNR_filter[self.combobox_frequency_profile.currentIndex(), :, :]) - val_max = np.nanmax(stg.BS_cross_section_SNR_filter[self.combobox_frequency_profile.currentIndex(), :, :]) + 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_SNR_filter[ + stg.BS_cross_section_pre_process_SNR[ self.combobox_frequency_profile.currentIndex(), :, :], cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) @@ -1567,40 +1567,40 @@ class SignalProcessingTab(QWidget): filter_convolve = np.ones(self.spinbox_average_horizontal.value()) print(filter_convolve) - if stg.BS_stream_bed_SNR_filter.size != 0: + if stg.BS_stream_bed_pre_process_SNR.size != 0: - # stg.BS_stream_bed_averaged = np.zeros((stg.r.shape[0], stg.freq.shape[0], stg.t.shape[0])) - # stg.BS_stream_bed_averaged = np.zeros((stg.freq.shape[0], stg.r.shape[1], stg.t.shape[1])) - stg.BS_stream_bed_averaged = deepcopy(stg.BS_stream_bed_SNR_filter) - print(f"1/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged}") + # 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_averaged[f, i, :] \ - = convolve1d(stg.BS_stream_bed_SNR_filter[f, i, :], weights=filter_convolve) / len(filter_convolve) - # stg.BS_stream_bed_averaged[i, f, :] \ + 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_SNR_filter.size != 0: + elif stg.BS_cross_section_pre_process_SNR.size != 0: - stg.BS_cross_section_averaged = deepcopy(stg.BS_cross_section_SNR_filter) + 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_averaged[f, i, :] \ - = convolve1d(stg.BS_cross_section_SNR_filter[f, i, :], + 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_averaged = deepcopy(stg.BS_stream_bed) - print(f"3/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged.shape}") - print(stg.BS_stream_bed_averaged[0, 10, :50]) + 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_averaged[f, i, :] \ + 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_averaged[0, 10, :50]) + print(stg.BS_stream_bed_pre_process_average[0, 10, :50]) elif stg.BS_cross_section.size != 0: @@ -1627,14 +1627,14 @@ class SignalProcessingTab(QWidget): 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_averaged[self.combobox_frequency.currentIndex(), :, :]) - # val_max = np.nanmax(stg.BS_stream_bed_averaged[self.combobox_frequency.currentIndex(), :, :]) + # 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_averaged[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() @@ -1708,14 +1708,14 @@ class SignalProcessingTab(QWidget): 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_averaged.size == 0) and (stg.BS_stream_bed_SNR_filter.size == 0): + 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_SNR_filter.size == 0: - stg.FCB = (np.log(stg.BS_stream_bed_averaged) + np.log(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_SNR_filter) + np.log(R_real) + + stg.FCB = (np.log(stg.BS_stream_bed_pre_process_SNR) + np.log(R_real) + 2 * stg.water_attenuation * R_real) self.plot_FCB() @@ -1867,7 +1867,7 @@ class SignalProcessingTab(QWidget): if stg.BS_stream_bed.size != 0: - if (stg.BS_stream_bed_averaged.size == 0) and (stg.BS_stream_bed_SNR_filter.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() @@ -1889,12 +1889,12 @@ class SignalProcessingTab(QWidget): np.log(stg.BS_stream_bed[self.combobox_frequency.currentIndex(), :, :]), cmap='Blues') - elif (stg.BS_stream_bed_averaged.size != 0) and (stg.BS_stream_bed_SNR_filter.size == 0): + 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_averaged[self.combobox_frequency.currentIndex(), :, :]) - val_max = np.nanmax(stg.BS_stream_bed_averaged[self.combobox_frequency.currentIndex(), :, :]) + 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 @@ -1902,21 +1902,21 @@ class SignalProcessingTab(QWidget): self.axis_plot_profile_position_on_transect.pcolormesh( stg.t[self.combobox_frequency.currentIndex(), :], -stg.r[self.combobox_frequency.currentIndex(), :], - stg.BS_stream_bed_averaged[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_averaged[self.combobox_frequency.currentIndex(), :, :]), + np.log(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :]), cmap='Blues') - elif stg.BS_stream_bed_SNR_filter.size != 0: + 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_SNR_filter[self.combobox_frequency.currentIndex(), :, :]) - val_max = np.nanmax(stg.BS_stream_bed_SNR_filter[self.combobox_frequency.currentIndex(), :, :]) + 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 @@ -1924,18 +1924,18 @@ class SignalProcessingTab(QWidget): self.axis_plot_profile_position_on_transect.pcolormesh( stg.t[self.combobox_frequency.currentIndex(), :], -stg.r[self.combobox_frequency.currentIndex(), :], - stg.BS_stream_bed_SNR_filter[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_SNR_filter[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_SNR_filter.size == 0): + 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() @@ -1957,7 +1957,7 @@ class SignalProcessingTab(QWidget): 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_SNR_filter.size == 0): + 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() @@ -1979,12 +1979,12 @@ class SignalProcessingTab(QWidget): np.log(stg.BS_cross_section_averaged[self.combobox_frequency.currentIndex(), :, :]), cmap='Blues') - elif stg.BS_cross_section_SNR_filter.size != 0: + 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_SNR_filter[self.combobox_frequency.currentIndex(), :, :]) - val_max = np.nanmax(stg.BS_cross_section_SNR_filter[self.combobox_frequency.currentIndex(), :, :]) + 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 @@ -1992,13 +1992,13 @@ class SignalProcessingTab(QWidget): self.axis_plot_profile_position_on_transect.pcolormesh( stg.t[self.combobox_frequency.currentIndex(), :], -stg.r[self.combobox_frequency.currentIndex(), :], - stg.BS_cross_section_SNR_filter[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_SNR_filter[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: @@ -2141,7 +2141,7 @@ class SignalProcessingTab(QWidget): def plot_averaged_profile(self): - if stg.BS_stream_bed_averaged.size == 0: + if stg.BS_stream_bed_pre_process_average.size == 0: for f, _ in enumerate(stg.freq): self.axis_averaged_profile[f].cla() @@ -2158,7 +2158,7 @@ class SignalProcessingTab(QWidget): for f, _ in enumerate(stg.freq): self.axis_averaged_profile[f].cla() - self.axis_averaged_profile[f].plot(stg.BS_stream_bed_averaged[f, :, self.slider.value()-1], -stg.r[f, :], + 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], @@ -2182,7 +2182,7 @@ class SignalProcessingTab(QWidget): else: - if stg.BS_stream_bed_averaged.size == 0: + if stg.BS_stream_bed_pre_process_average.size == 0: for f, _ in enumerate(stg.freq): self.axis_averaged_profile[f].cla() @@ -2200,7 +2200,7 @@ class SignalProcessingTab(QWidget): for f, _ in enumerate(stg.freq): self.axis_averaged_profile[f].cla() - self.axis_averaged_profile[f].plot(stg.BS_stream_bed_averaged[f, :, self.slider.value() - 1], + 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, :])) diff --git a/settings.py b/settings.py index b38d7da..c7dafd4 100644 --- a/settings.py +++ b/settings.py @@ -67,12 +67,21 @@ ind_bottom = np.array([]) freq_bottom_detection = 0 # --- Processed data in Signal Processing Tab --- -BS_cross_section_SNR_filter = np.array([[[]]]) # BS data filtered with SNR values (remove point if SNR < value) - bottom is not detected -BS_stream_bed_SNR_filter = np.array([]) # BS data filtered with SNR values (remove point if SNR < value) - bottom is detected -BS_cross_section_averaged = np.array([[[]]]) # BS data averaged - bottom is not detected -BS_stream_bed_averaged = np.array([]) # BS data averaged - bottom is detected -BS_cross_section_averaged_SNR = np.array([[[]]]) # BS data averaged and filtered with SNR - bottom is not detected -BS_stream_bed_averaged_SNR = np.array([]) # BS data averaged and filtered with SNR - bottom is detected +# BS_cross_section_SNR_filter = np.array([[[]]]) # BS data filtered with SNR values (remove point if SNR < value) - bottom is not detected +# BS_stream_bed_SNR_filter = np.array([]) # BS data filtered with SNR values (remove point if SNR < value) - bottom is detected +# BS_cross_section_averaged = np.array([[[]]]) # BS data averaged - bottom is not detected +# BS_stream_bed_averaged = np.array([]) # BS data averaged - bottom is detected +# BS_cross_section_averaged_SNR = np.array([[[]]]) # BS data averaged and filtered with SNR - bottom is not detected +# BS_stream_bed_averaged_SNR = np.array([]) # BS data averaged and filtered with SNR - bottom is detected + +BS_cross_section_pre_process_SNR = np.array([[[]]]) # BS data filtered with SNR values (remove point if SNR < value) - bottom is not detected +BS_cross_section_pre_process_average = np.array([[[]]]) # BS data averaged - bottom is not detected +BS_cross_section_pre_process_SNR_average = np.array([[[]]]) # BS data averaged and filtered with SNR - bottom is not detected + +BS_stream_bed_pre_process_SNR = np.array([]) # BS data filtered with SNR values (remove point if SNR < value) - bottom is detected +BS_stream_bed_pre_process_average = np.array([]) # BS data averaged - bottom is detected +BS_stream_bed_pre_process_SNR_averaged = np.array([]) # BS data averaged and filtered with SNR - bottom is detected + time_average = np.array([]) SNR_data_average = np.array([]) # SNR data computed with BS signal averaged (not with BS raw signal)