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

BS_cross_section_SNR_filter is renamed BS_cross_section_pre_process_SNR. BS_cross_section_averaged is renamed BS_cross_section_pre_process_average. BS_cross_section_averaged_SNR is renamed BS_cross_section_pre_process_SNR_average. BS_stream_bed_SNR_filter is renamed BS_stream_bed_pre_process_SNR. BS_stream_bed_averaged is renamed BS_stream_bed_pre_process_average. BS_stream_bed_averaged_SNR is renamed BS_stream_bed_pre_process_SNR_average.

dev-brahim
brahim 2024-02-13 16:55:40 +01:00
parent 85a816d922
commit 335cef9d76
2 changed files with 116 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
View/signal_processing_tab.py
View File

@ -1157,13 +1157,13 @@ class SignalProcessingTab(QWidget):
if stg.BS_stream_bed.size == 0: 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.Noise_data = deepcopy(stg.BS_noise_averaged_data[:, :, :stg.t.shape[1]])
# stg.SNR_data_average = np.divide( # 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): for f, _ in enumerate(stg.freq):
stg.BS_cross_section_SNR_filter[ stg.BS_cross_section_pre_process_SNR[
f, 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())[0],
np.where(stg.SNR_cross_section[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \ np.where(stg.SNR_cross_section[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \
@ -1171,25 +1171,25 @@ class SignalProcessingTab(QWidget):
else: 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.Noise_data = deepcopy(stg.BS_noise_averaged_data[:, :, :stg.t.shape[1]])
# stg.SNR_data_average = np.divide( # 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): for f, _ in enumerate(stg.freq):
stg.BS_stream_bed_SNR_filter[ stg.BS_stream_bed_pre_process_SNR[
f, 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())[0],
np.where(stg.SNR_stream_bed[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \ np.where(stg.SNR_stream_bed[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \
= np.nan = np.nan
# elif stg.BS_stream_bed_averaged.size != 0: # elif stg.BS_stream_bed_pre_process_average.size != 0:
# stg.BS_stream_bed_SNR_filter = deepcopy(stg.BS_stream_bed_averaged) # 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]]) # 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) # print("BS_noise_cross_section.shape ", BS_noise_cross_section.shape)
# stg.SNR_data_average = np.divide( # 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, :, :]) # print(stg.SNR_data_average[0, :, :])
@ -1207,7 +1207,7 @@ class SignalProcessingTab(QWidget):
# print("----------------------------------------------") # 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())[0])
# print(np.where(stg.SNR_data_average[f, :, :] < self.spinbox_SNR_criterion.value())[1]) # 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, # 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())[0],
# np.where(stg.SNR_data_average[f, :, :] < self.spinbox_SNR_criterion.value())[1]] \ # 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: if stg.BS_stream_bed.size == 0:
val_min = np.nanmin(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_SNR_filter[f, :, :]) val_max = np.nanmax(stg.BS_cross_section_pre_process_SNR[f, :, :])
if val_min == 0: if val_min == 0:
val_min = 1e-5 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)) cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
else: else:
val_min = np.nanmin(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_SNR_filter[f, :, :]) val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR[f, :, :])
if val_min == 0: if val_min == 0:
val_min = 1e-5 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)) cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
self.axis_BS[f].plot(stg.t[f, :], -stg.r_bottom, 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) filter_convolve = np.ones(2*self.spinbox_average_horizontal.value()+1)
print(filter_convolve) 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) stg.BS_stream_bed_pre_process_SNR_average = deepcopy(stg.BS_stream_bed_pre_process_SNR)
# print(f"1/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged_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 f, _ in enumerate(stg.freq):
for i in range(stg.r.shape[1]): for i in range(stg.r.shape[1]):
stg.BS_stream_bed_averaged_SNR[f, i, :] \ stg.BS_stream_bed_pre_process_SNR_average[f, i, :] \
= convolve1d(stg.BS_stream_bed_SNR_filter[f, i, :], weights=filter_convolve) / len(filter_convolve) = convolve1d(stg.BS_stream_bed_pre_process_SNR[f, i, :], weights=filter_convolve) / len(filter_convolve)
# stg.BS_stream_bed_averaged[i, f, :] \ # stg.BS_stream_bed_pre_process_average[i, f, :] \
# = convolve1d(stg.BS_cross_section[i, f, :], weights=filter_convolve) / filter_convolve.shape[0] # = 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) 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_averaged_SNR}") print(f"2/ stg.BS_cross_section_averaged : {stg.BS_cross_section_pre_process_SNR_average}")
for f, _ in enumerate(stg.freq): for f, _ in enumerate(stg.freq):
for i in range(stg.r.shape[1]): for i in range(stg.r.shape[1]):
stg.BS_cross_section_averaged_SNR[f, i, :] \ stg.BS_cross_section_pre_process_SNR_average[f, i, :] \
= convolve1d(stg.BS_cross_section_SNR_filter[f, i, :], = convolve1d(stg.BS_cross_section_pre_process_SNR[f, i, :],
weights=filter_convolve) / len(filter_convolve) 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: elif stg.BS_stream_bed.size != 0:
stg.BS_stream_bed_averaged = deepcopy(stg.BS_stream_bed) stg.BS_stream_bed_pre_process_average = deepcopy(stg.BS_stream_bed)
# print(f"3/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged.shape}") # print(f"3/ stg.BS_stream_bed_pre_process_average : {stg.BS_stream_bed_pre_process_average.shape}")
print(stg.BS_stream_bed_averaged[0, 10, :50]) print(stg.BS_stream_bed_pre_process_average[0, 10, :50])
for f, _ in enumerate(stg.freq): for f, _ in enumerate(stg.freq):
for i in range(stg.r.shape[1]): 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, :], = convolve1d(stg.BS_stream_bed[f, i, :],
weights=filter_convolve) / len(filter_convolve) 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: elif stg.BS_cross_section.size != 0:
@ -1356,11 +1356,11 @@ class SignalProcessingTab(QWidget):
self.axis_profile[0].cla() self.axis_profile[0].cla()
self.axis_profile[1].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 --- # --- Plot profile ---
self.axis_profile[0].plot( 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(), :], -stg.r[self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1) linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_frequency_profile.currentIndex()], 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 --- # --- Plot transect with profile position ---
self.axis_profile[1].cla() self.axis_profile[1].cla()
val_min = np.nanmin(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_averaged_SNR[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: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :], self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
-stg.r[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)) 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 --- # --- Plot profile ---
self.axis_profile[0].plot( 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], self.slider.value() - 1],
-stg.r[self.combobox_frequency_profile.currentIndex(), :], -stg.r[self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1) linestyle='solid', color='k', linewidth=1)
@ -1395,21 +1395,21 @@ class SignalProcessingTab(QWidget):
# --- Plot transect with profile position --- # --- Plot transect with profile position ---
self.axis_profile[1].cla() self.axis_profile[1].cla()
val_min = np.nanmin(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_averaged_SNR[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: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :], self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
-stg.r[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(), :, :], self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) 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 --- # --- Plot profile ---
self.axis_profile[0].plot( 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(), :], -stg.r[self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1) linestyle='solid', color='k', linewidth=1)
self.axis_profile[0].text(.95, .05, stg.freq_text[self.combobox_frequency_profile.currentIndex()], 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 --- # --- Plot transect with profile position ---
self.axis_profile[1].cla() self.axis_profile[1].cla()
val_min = np.nanmin(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_SNR_filter[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: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :], self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
-stg.r[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)) 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 --- # --- Plot profile ---
self.axis_profile[0].plot( 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], self.slider.value() - 1],
-stg.r[self.combobox_frequency_profile.currentIndex(), :], -stg.r[self.combobox_frequency_profile.currentIndex(), :],
linestyle='solid', color='k', linewidth=1) linestyle='solid', color='k', linewidth=1)
@ -1444,13 +1444,13 @@ class SignalProcessingTab(QWidget):
# --- Plot transect with profile position --- # --- Plot transect with profile position ---
self.axis_profile[1].cla() self.axis_profile[1].cla()
val_min = np.nanmin(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_SNR_filter[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: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :], self.axis_profile[1].pcolormesh(stg.t[self.combobox_frequency_profile.currentIndex(), :],
-stg.r[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(), :, :], self.combobox_frequency_profile.currentIndex(), :, :],
cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) 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()) filter_convolve = np.ones(self.spinbox_average_horizontal.value())
print(filter_convolve) 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_pre_process_average = 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_pre_process_average = 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) stg.BS_stream_bed_pre_process_average = deepcopy(stg.BS_stream_bed_pre_process_SNR)
print(f"1/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged}") print(f"1/ stg.BS_stream_bed_pre_process_average : {stg.BS_stream_bed_pre_process_average}")
for f, _ in enumerate(stg.freq): for f, _ in enumerate(stg.freq):
for i in range(stg.r.shape[1]): 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_SNR_filter[f, i, :], weights=filter_convolve) / len(filter_convolve) = convolve1d(stg.BS_stream_bed_pre_process_SNR[f, i, :], weights=filter_convolve) / len(filter_convolve)
# stg.BS_stream_bed_averaged[i, f, :] \ # stg.BS_stream_bed_pre_process_average[i, f, :] \
# = convolve1d(stg.BS_cross_section[i, f, :], weights=filter_convolve) / filter_convolve.shape[0] # = 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}") print(f"2/ stg.BS_cross_section_averaged : {stg.BS_cross_section_averaged}")
for f, _ in enumerate(stg.freq): for f, _ in enumerate(stg.freq):
for i in range(stg.r.shape[1]): 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_cross_section_SNR_filter[f, i, :], = convolve1d(stg.BS_cross_section_pre_process_SNR[f, i, :],
weights=filter_convolve) / len(filter_convolve) weights=filter_convolve) / len(filter_convolve)
elif stg.BS_stream_bed.size != 0: elif stg.BS_stream_bed.size != 0:
stg.BS_stream_bed_averaged = deepcopy(stg.BS_stream_bed) stg.BS_stream_bed_pre_process_average = deepcopy(stg.BS_stream_bed)
print(f"3/ stg.BS_stream_bed_averaged : {stg.BS_stream_bed_averaged.shape}") print(f"3/ stg.BS_stream_bed_pre_process_average : {stg.BS_stream_bed_pre_process_average.shape}")
print(stg.BS_stream_bed_averaged[0, 10, :50]) print(stg.BS_stream_bed_pre_process_average[0, 10, :50])
for f, _ in enumerate(stg.freq): for f, _ in enumerate(stg.freq):
for i in range(stg.r.shape[1]): 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, :], = convolve1d(stg.BS_stream_bed[f, i, :],
weights=filter_convolve) / len(filter_convolve) 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: elif stg.BS_cross_section.size != 0:
@ -1627,14 +1627,14 @@ class SignalProcessingTab(QWidget):
self.slider.valueChanged.connect(self.update_plot_averaged_profile) self.slider.valueChanged.connect(self.update_plot_averaged_profile)
# fig, ax = plt.subplots(nrows=1, ncols=1) # fig, ax = plt.subplots(nrows=1, ncols=1)
# val_min = np.nanmin(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_averaged[self.combobox_frequency.currentIndex(), :, :]) # val_max = np.nanmax(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :])
# if val_min == 0: # if val_min == 0:
# val_min = 1e-5 # val_min = 1e-5
# #
# ax.pcolormesh(stg.t[self.combobox_frequency.currentIndex(), :], # ax.pcolormesh(stg.t[self.combobox_frequency.currentIndex(), :],
# -stg.r[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)) # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
# #
# plt.show() # plt.show()
@ -1708,14 +1708,14 @@ class SignalProcessingTab(QWidget):
print(f"self.range_cells_function() shape : {self.range_cells_function().shape}") 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) R_real = np.repeat(self.range_cells_function()[:, :, np.newaxis], stg.t.shape[1], axis=2)
print(f"R_real shape : {R_real.shape}") 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) + stg.FCB = (np.log(stg.BS_stream_bed) + np.log(R_real) +
2 * stg.water_attenuation * R_real) 2 * stg.water_attenuation * R_real)
elif stg.BS_stream_bed_SNR_filter.size == 0: elif stg.BS_stream_bed_pre_process_SNR.size == 0:
stg.FCB = (np.log(stg.BS_stream_bed_averaged) + np.log(R_real) + stg.FCB = (np.log(stg.BS_stream_bed_pre_process_average) + np.log(R_real) +
2 * stg.water_attenuation * R_real) 2 * stg.water_attenuation * R_real)
else: 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) 2 * stg.water_attenuation * R_real)
self.plot_FCB() self.plot_FCB()
@ -1867,7 +1867,7 @@ class SignalProcessingTab(QWidget):
if stg.BS_stream_bed.size != 0: 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() 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(), :, :]), np.log(stg.BS_stream_bed[self.combobox_frequency.currentIndex(), :, :]),
cmap='Blues') 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() self.axis_plot_profile_position_on_transect.cla()
val_min = np.nanmin(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_averaged[self.combobox_frequency.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_stream_bed_pre_process_average[self.combobox_frequency.currentIndex(), :, :])
if val_min == 0: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
@ -1902,21 +1902,21 @@ class SignalProcessingTab(QWidget):
self.axis_plot_profile_position_on_transect.pcolormesh( self.axis_plot_profile_position_on_transect.pcolormesh(
stg.t[self.combobox_frequency.currentIndex(), :], stg.t[self.combobox_frequency.currentIndex(), :],
-stg.r[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)) cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.ABS_name == "UB-SediFlow": elif stg.ABS_name == "UB-SediFlow":
self.axis_plot_profile_position_on_transect.pcolormesh( self.axis_plot_profile_position_on_transect.pcolormesh(
stg.t[self.combobox_frequency.currentIndex(), :], stg.t[self.combobox_frequency.currentIndex(), :],
-stg.r[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') 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() self.axis_plot_profile_position_on_transect.cla()
val_min = np.nanmin(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_SNR_filter[self.combobox_frequency.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_stream_bed_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :])
if val_min == 0: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
@ -1924,18 +1924,18 @@ class SignalProcessingTab(QWidget):
self.axis_plot_profile_position_on_transect.pcolormesh( self.axis_plot_profile_position_on_transect.pcolormesh(
stg.t[self.combobox_frequency.currentIndex(), :], stg.t[self.combobox_frequency.currentIndex(), :],
-stg.r[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)) cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.ABS_name == "UB-SediFlow": elif stg.ABS_name == "UB-SediFlow":
self.axis_plot_profile_position_on_transect.pcolormesh( self.axis_plot_profile_position_on_transect.pcolormesh(
stg.t[self.combobox_frequency.currentIndex(), :], stg.t[self.combobox_frequency.currentIndex(), :],
-stg.r[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') cmap='Blues')
else: 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() 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(), :, :]), np.log(stg.BS_cross_section[self.combobox_frequency.currentIndex(), :, :]),
cmap='Blues') 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() 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(), :, :]), np.log(stg.BS_cross_section_averaged[self.combobox_frequency.currentIndex(), :, :]),
cmap='Blues') 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() self.axis_plot_profile_position_on_transect.cla()
val_min = np.nanmin(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_SNR_filter[self.combobox_frequency.currentIndex(), :, :]) val_max = np.nanmax(stg.BS_cross_section_pre_process_SNR[self.combobox_frequency.currentIndex(), :, :])
if val_min == 0: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
@ -1992,13 +1992,13 @@ class SignalProcessingTab(QWidget):
self.axis_plot_profile_position_on_transect.pcolormesh( self.axis_plot_profile_position_on_transect.pcolormesh(
stg.t[self.combobox_frequency.currentIndex(), :], stg.t[self.combobox_frequency.currentIndex(), :],
-stg.r[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)) cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max))
elif stg.ABS_name == "UB-SediFlow": elif stg.ABS_name == "UB-SediFlow":
self.axis_plot_profile_position_on_transect.pcolormesh( self.axis_plot_profile_position_on_transect.pcolormesh(
stg.t[self.combobox_frequency.currentIndex(), :], stg.t[self.combobox_frequency.currentIndex(), :],
-stg.r[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') cmap='Blues')
if stg.r_bottom.size != 0: if stg.r_bottom.size != 0:
@ -2141,7 +2141,7 @@ class SignalProcessingTab(QWidget):
def plot_averaged_profile(self): 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): for f, _ in enumerate(stg.freq):
self.axis_averaged_profile[f].cla() self.axis_averaged_profile[f].cla()
@ -2158,7 +2158,7 @@ class SignalProcessingTab(QWidget):
for f, _ in enumerate(stg.freq): for f, _ in enumerate(stg.freq):
self.axis_averaged_profile[f].cla() 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) 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].set_ylim(-np.max(stg.r[f, :]), np.min(stg.r[f, :]))
self.axis_averaged_profile[f].text(.95, .05, stg.freq_text[f], self.axis_averaged_profile[f].text(.95, .05, stg.freq_text[f],
@ -2182,7 +2182,7 @@ class SignalProcessingTab(QWidget):
else: 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): for f, _ in enumerate(stg.freq):
self.axis_averaged_profile[f].cla() self.axis_averaged_profile[f].cla()
@ -2200,7 +2200,7 @@ class SignalProcessingTab(QWidget):
for f, _ in enumerate(stg.freq): for f, _ in enumerate(stg.freq):
self.axis_averaged_profile[f].cla() 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, :], -stg.r[f, :],
linestyle='solid', color='k', linewidth=1) 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].set_ylim(-np.max(stg.r[f, :]), np.min(stg.r[f, :]))

21
settings.py
View File

@ -67,12 +67,21 @@ ind_bottom = np.array([])
freq_bottom_detection = 0 freq_bottom_detection = 0
# --- Processed data in Signal Processing Tab --- # --- 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_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_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_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_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_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_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([]) time_average = np.array([])
SNR_data_average = np.array([]) # SNR data computed with BS signal averaged (not with BS raw signal) SNR_data_average = np.array([]) # SNR data computed with BS signal averaged (not with BS raw signal)