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

Implementation of SNR data from UBSediFlow ABS tool

dev-brahim
brahim 2023-10-10 18:51:50 +02:00
parent 92a0b5fa54
commit 426c68c880
3 changed files with 306 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
Model/acoustic_data_loader_UBSediFlow.py
View File

@ -4,7 +4,7 @@ import numpy as np
import pandas as pd import pandas as pd
import datetime import datetime
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm from matplotlib.colors import LogNorm, BoundaryNorm
from Model.udt_extract.raw_extract import raw_extract from Model.udt_extract.raw_extract import raw_extract
# raw_20210519_102332.udt raw_20210520_135452.udt raw_20210525_092759.udt raw_20210525_080454.udt # raw_20210519_102332.udt raw_20210520_135452.udt raw_20210525_092759.udt raw_20210525_080454.udt
@ -43,14 +43,17 @@ class AcousticDataLoaderUBSediFlow():
self._freq = np.array([[]]) self._freq = np.array([[]])
self._r = np.array([[]]) self._r = np.array([[]])
self._time = np.array([[]]) self._time = np.array([[]])
self._time_snr = np.array([[]])
self._BS_raw_data = np.array([[[]]]) self._BS_raw_data = np.array([[[]]])
self._SNR_data = np.array([[[]]])
time_len = [] time_len = []
time_snr_len = []
for config in param_us_dicts.keys(): for config in param_us_dicts.keys():
# print("-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x") # print("-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x")
# print(f"config : {config} \n") # print(f"config : {config} \n")
for channel in param_us_dicts[config].keys(): for channel in param_us_dicts[config].keys():
print("-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x") # print("-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x")
print(f"channel : {channel} \n") # print(f"channel : {channel} \n")
print(data_us_dicts[config][channel].keys()) print(data_us_dicts[config][channel].keys())
# print(data_us_dicts[config][channel]['echo_avg_profile']) # print(data_us_dicts[config][channel]['echo_avg_profile'])
@ -65,7 +68,7 @@ class AcousticDataLoaderUBSediFlow():
else: else:
self._r = np.append(self._r, [depth], axis=0) self._r = np.append(self._r, [depth], axis=0)
# --- Time for each frequencies --- # --- BS Time for each frequencies ---
time = [[(t - data_us_dicts[config][channel]['echo_avg_profile']['time'][0]).total_seconds() time = [[(t - data_us_dicts[config][channel]['echo_avg_profile']['time'][0]).total_seconds()
for t in data_us_dicts[config][channel]['echo_avg_profile']['time']]] for t in data_us_dicts[config][channel]['echo_avg_profile']['time']]]
time_len = np.append(time_len, len(time[0])) time_len = np.append(time_len, len(time[0]))
@ -93,20 +96,62 @@ class AcousticDataLoaderUBSediFlow():
self._time = np.append(self._time, time, axis=0) self._time = np.append(self._time, time, axis=0)
# print(f"self._time.shape {self._time.shape}") # print(f"self._time.shape {self._time.shape}")
# --- US Backscatter raw signal --- # --- SNR Time for each frequencies ---
time_snr = [[(t - data_us_dicts[config][channel]['snr_doppler_avg_profile']['time'][0]).total_seconds()
for t in data_us_dicts[config][channel]['snr_doppler_avg_profile']['time']]]
time_snr_len = np.append(time_snr_len, len(time_snr[0]))
if len(time_snr_len) == 1:
# print(f"1 time length : {len(time[0])}")
self._time_snr = np.array(time_snr)
# print(f"self._time.shape {self._time.shape}")
elif self._time_snr.shape[1] == len(time_snr[0]):
# print(f"2 time length : {len(time[0])}")
self._time_snr = np.append(self._time_snr, time_snr, axis=0)
# print(f"self._time.shape {self._time.shape}")
elif self._time_snr.shape[1] > len(time_snr[0]):
# print(f"3 time length : {len(time[0])}")
# print(f"self._time.shape {self._time.shape}")
# print([int(np.min(time_len)) + int(i) - 1 for i in range(1, int(np.max(time_len))-int(np.min(time_len))+1)])
self._time_snr = np.delete(self._time_snr,
[int(np.min(time_snr_len)) + int(i) - 1 for i in
range(1, int(np.max(time_snr_len)) - int(np.min(time_snr_len)) + 1)],
axis=1)
self._time_snr = np.append(self._time_snr, time_snr, axis=0)
# print(f"self._time.shape {self._time.shape}")
elif self._time_snr.shape[1] < len(time_snr[0]):
# print(f"4 time length : {len(time[0])}")
time_snr = time_snr[:int(np.max(time_snr_len)) - (int(np.max(time_snr_len)) - int(np.min(time_snr_len)))]
self._time_snr = np.append(self._time_snr, time_snr, axis=0)
# print(f"self._time.shape {self._time.shape}")
# --- US Backscatter raw signal + SNR data ---
for f, freq in enumerate(self._freq): for f, freq in enumerate(self._freq):
if f == 0: if f == 0:
# print(data_us_dicts[config][channel]['echo_avg_profile']['data']) # print(data_us_dicts[config][channel]['echo_avg_profile']['data'])
self._BS_raw_data = np.array([np.reshape(data_us_dicts[config][channel]['echo_avg_profile']['data'], self._BS_raw_data = np.array([np.reshape(data_us_dicts[config][channel]['echo_avg_profile']['data'],
(self._time.shape[1], self._r.shape[1])).transpose()]) (self._time.shape[1], self._r.shape[1])).transpose()])
# print(self._BS_raw_data.shape) # print(self._BS_raw_data.shape)
self._SNR_data = np.array(
[np.reshape(np.abs(data_us_dicts[config][channel]['snr_doppler_avg_profile']['data']),
(self._time.shape[1], self._r.shape[1])).transpose()])
else: else:
self._BS_raw_data = np.append(self._BS_raw_data, self._BS_raw_data = np.append(self._BS_raw_data,
np.array([np.reshape(np.array( np.array([np.reshape(np.array(
data_us_dicts[config][channel]['echo_avg_profile']['data']), data_us_dicts[config][channel]['echo_avg_profile']['data']),
(self._time.shape[1], self._r.shape[1])).transpose()]), (self._time.shape[1], self._r.shape[1])).transpose()]),
axis=0) axis=0)
self._SNR_data = np.append(self._SNR_data,
np.array([np.reshape(np.array(
np.abs(data_us_dicts[config][channel]['snr_doppler_avg_profile']['data'])),
(self._time.shape[1], self._r.shape[1])).transpose()]),
axis=0)
# print(self._BS_raw_data.shape) # print(self._BS_raw_data.shape)
# --- US Backscatter raw signal ---
# print(len(self._BS_raw_data)) # print(len(self._BS_raw_data))
# print(self._BS_raw_data) # print(self._BS_raw_data)
@ -121,6 +166,9 @@ class AcousticDataLoaderUBSediFlow():
# self._BS_raw_data = np.array(np.reshape(self._BS_raw_data, (len(self._freq), self._r.shape[1], self._time.shape[1]))) # self._BS_raw_data = np.array(np.reshape(self._BS_raw_data, (len(self._freq), self._r.shape[1], self._time.shape[1])))
print("self._BS_raw_data.shape ", self._BS_raw_data.shape) print("self._BS_raw_data.shape ", self._BS_raw_data.shape)
print("self._SNR_data.shape ", self._SNR_data.shape)
print(self._SNR_data)
# print("device_name ", device_name, "\n") # print("device_name ", device_name, "\n")
# print("time_begin ", time_begin, "\n") # print("time_begin ", time_begin, "\n")
@ -168,17 +216,56 @@ class AcousticDataLoaderUBSediFlow():
# print(self._time[np.where(np.floor(self._time) == 175)]) # print(self._time[np.where(np.floor(self._time) == 175)])
# print(np.where((self._time) == 155)[0][0]) # print(np.where((self._time) == 155)[0][0])
# --- Plot Backscatter US data ---
# fig, ax = plt.subplots(nrows=len(self._freq), ncols=1) # fig, ax = plt.subplots(nrows=len(self._freq), ncols=1)
# for f, freq in enumerate(self._freq): # for f, freq in enumerate(self._freq):
# # print(f"{f} : {freq} \n") # # print(f"{f} : {freq} \n")
# pcm = ax[f].pcolormesh(self._time[f, :], self._r[f, :], (self._BS_raw_data[f, :, :self._time.shape[1]]), # pcm = ax[f].pcolormesh(self._time[f, :], self._r[f, :], (self._BS_raw_data[f, :, :self._time.shape[1]]),
# cmap='viridis', # cmap='viridis',
# norm=LogNorm(vmin=np.min(self._BS_raw_data[f, :, :]), vmax=np.max(self._BS_raw_data[f, :, :])), shading='gouraud') # ) # norm=LogNorm(vmin=np.min(self._BS_raw_data[f, :, :]), vmax=np.max(self._BS_raw_data[f, :, :])), shading='gouraud')
# # ax.pcolormesh(range(self._BS_raw_data.shape[2]), range(self._BS_raw_data.shape[0]), self._BS_raw_data[:, 1, :], cmap='viridis', # # ax.pcolormesh(range(self._BS_raw_data.shape[2]), range(self._BS_raw_data.shape[0]), self._BS_raw_data[:, 1, :], cmap='viridis',
# # norm=LogNorm(vmin=1e-5, vmax=np.max(self._BS_raw_data[:, 0, :]))) # , shading='gouraud') # # norm=LogNorm(vmin=1e-5, vmax=np.max(self._BS_raw_data[:, 0, :]))) # , shading='gouraud')
# fig.colorbar(pcm, ax=ax[:], shrink=1, location='right') # fig.colorbar(pcm, ax=ax[:], shrink=1, location='right')
# plt.show() # plt.show()
# --- Plot SNR data ---
# fig_snr, ax_snr = plt.subplots(nrows=len(self._freq), ncols=1)
#
# x, y = np.meshgrid(self._time[0, :], self._r[0, :])
#
# for f, freq in enumerate(self._freq):
#
# val_min = np.nanmin(abs(self._SNR_data[f, :, :]))
# print(f"val_min = {val_min}")
# val_max = np.nanmax(self._SNR_data[f, :, :])
# print(f"val_max = {val_max}")
# if int(val_min) == 0:
# val_min = 1e-5
# if int(val_max) < 1000:
# levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
# bounds = [00.1, 1, 2, 10, 100, 1000, 1e6, 1e6 * 1.2]
# 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(f"levels = {levels}")
# print(f"norm = {norm.boundaries}")
#
# cf = ax_snr[f].contourf(x, y, self._SNR_data[f, :, :])#, levels, cmap='gist_rainbow', norm=norm)
#
# ax_snr[f].text(1, .70, self._freq_text[f],
# fontsize=14, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5,
# horizontalalignment='right', verticalalignment='bottom',
# transform=ax_snr[f].transAxes)
#
# fig_snr.supxlabel('Time (sec)', fontsize=10)
# fig_snr.supylabel('Depth (m)', fontsize=10)
# cbar = fig_snr.colorbar(cf, ax=ax_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$'])
# plt.show()
# fig, ax = plt.subplots(nrows=1, ncols=1) # fig, ax = plt.subplots(nrows=1, ncols=1)
# ax.plot(list(range(self._time.shape[1])), self._time[0, :]) # ax.plot(list(range(self._time.shape[1])), self._time[0, :])
# # ax.set_ylim(2, 20) # # ax.set_ylim(2, 20)
@ -197,6 +284,13 @@ class AcousticDataLoaderUBSediFlow():
# print(BS_raw_cross_section.shape) # print(BS_raw_cross_section.shape)
return BS_raw_cross_section return BS_raw_cross_section
def reshape_SNR_data(self):
SNR_data = np.reshape(self._SNR_data,
(self._r.shape[1]*self._time.shape[1], len(self._freq)),
order="F")
# print(BS_raw_cross_section.shape)
return SNR_data
def reshape_r(self): def reshape_r(self):
r = np.zeros((self._r.shape[1]*self._time.shape[1], len(self._freq))) r = np.zeros((self._r.shape[1]*self._time.shape[1], len(self._freq)))
for i, _ in enumerate(self._freq): for i, _ in enumerate(self._freq):
@ -215,6 +309,13 @@ class AcousticDataLoaderUBSediFlow():
# print(t.shape) # print(t.shape)
return t return t
def reshape_t_snr(self):
t = np.zeros((self._r.shape[1]*self._time_snr.shape[1], len(self._freq)))
for i, _ in enumerate(self._freq):
t[:, i] = np.repeat(self._time_snr[i, :], self._r.shape[1])
# print(t.shape)
return t
# def concatenate_data(self): # def concatenate_data(self):
# self.reshape_BS_raw_cross_section() # self.reshape_BS_raw_cross_section()

172
View/acoustic_data_tab.py
View File

@ -783,6 +783,8 @@ class AcousticDataTab(QWidget):
stg.BS_raw_data_reshape = acoustic_data.reshape_BS_raw_cross_section() stg.BS_raw_data_reshape = acoustic_data.reshape_BS_raw_cross_section()
stg.r_reshape = acoustic_data.reshape_r() stg.r_reshape = acoustic_data.reshape_r()
stg.time_reshape = acoustic_data.reshape_t() stg.time_reshape = acoustic_data.reshape_t()
stg.snr = acoustic_data._SNR_data
stg.snr_reshape = acoustic_data.reshape_SNR_data()
def load_noise_data_and_compute_SNR(self): def load_noise_data_and_compute_SNR(self):
if self.combobox_ABS_system_choice.currentIndex() == 1: if self.combobox_ABS_system_choice.currentIndex() == 1:
@ -804,13 +806,10 @@ class AcousticDataTab(QWidget):
noise_data = AcousticDataLoaderUBSediFlow(stg.path_BS_noise_data + "/" + stg.filename_BS_noise_data) noise_data = AcousticDataLoaderUBSediFlow(stg.path_BS_noise_data + "/" + stg.filename_BS_noise_data)
stg.date_noise = noise_data._date stg.date_noise = noise_data._date
stg.hour_noise = noise_data._hour stg.hour_noise = noise_data._hour
stg.time_snr = noise_data._time stg.time_snr = noise_data._time_snr
noise = np.zeros(stg.BS_raw_data.shape) stg.time_snr_reshape = noise_data.reshape_t_snr()
for f in range(noise_data._freq.shape[0]): stg.snr = noise_data._SNR_data
noise[:, f, :] = np.mean(noise_data._BS_raw_data[:, f, :], axis=(0, 1)) stg.snr_reshape = noise_data.reshape_SNR_data()
stg.BS_noise_data = noise
stg.snr = np.divide((stg.BS_raw_data - stg.BS_noise_data) ** 2, stg.BS_noise_data ** 2)
stg.snr_reshape = np.reshape(stg.snr, (stg.r.shape[0] * stg.time.shape[0], stg.freq.shape[0]), order="F")
def fill_measurements_information_groupbox(self): def fill_measurements_information_groupbox(self):
if self.combobox_ABS_system_choice.currentIndex() == 1: if self.combobox_ABS_system_choice.currentIndex() == 1:
@ -872,15 +871,17 @@ class AcousticDataTab(QWidget):
elif self.combobox_ABS_system_choice.currentIndex() == 2: elif self.combobox_ABS_system_choice.currentIndex() == 2:
if ((self.lineEdit_acoustic_file.text()) and (self.lineEdit_noise_file.text())): if ((self.lineEdit_acoustic_file.text()) and (self.lineEdit_noise_file.text())):
stg.DataFrame_acoustic = pd.DataFrame( stg.DataFrame_acoustic = pd.DataFrame(
np.concatenate((stg.time_reshape, stg.BS_raw_data_reshape, stg.snr_reshape), axis=1), np.concatenate((stg.time_reshape, stg.BS_raw_data_reshape, stg.time_snr_reshape, stg.snr_reshape), axis=1),
columns=list(map(str, ["Time"] + ["BS - " + f for f in stg.freq_text] + columns=list(map(str, ["Time BS - " + f for f in stg.freq_text] +
["BS - " + f for f in stg.freq_text] +
["Time SNR - " + f for f in stg.freq_text] +
["SNR - " + f for f in stg.freq_text]))) ["SNR - " + f for f in stg.freq_text])))
self.tableModel = TableModel(stg.DataFrame_acoustic) self.tableModel = TableModel(stg.DataFrame_acoustic)
self.tableView.setModel(self.tableModel) self.tableView.setModel(self.tableModel)
elif self.lineEdit_acoustic_file.text(): elif self.lineEdit_acoustic_file.text():
stg.DataFrame_acoustic = pd.DataFrame( stg.DataFrame_acoustic = pd.DataFrame(
np.concatenate((stg.time_reshape, stg.BS_raw_data_reshape), axis=1), np.concatenate((stg.time_reshape, stg.BS_raw_data_reshape), axis=1),
columns=list(map(str, ["Time - " + f for f in stg.freq_text] + ["BS - " + f for f in stg.freq_text]))) columns=list(map(str, ["Time BS - " + f for f in stg.freq_text] + ["BS - " + f for f in stg.freq_text])))
self.tableModel = TableModel(stg.DataFrame_acoustic) self.tableModel = TableModel(stg.DataFrame_acoustic)
self.tableView.setModel(self.tableModel) self.tableView.setModel(self.tableModel)
else: else:
@ -1105,6 +1106,8 @@ class AcousticDataTab(QWidget):
# self.spinbox_tmin.setValue(np.min(noise_data._time_snr)) # self.spinbox_tmin.setValue(np.min(noise_data._time_snr))
# self.spinbox_tmax.setValue(np.round(np.max(noise_data._time_snr), 2)) # self.spinbox_tmax.setValue(np.round(np.max(noise_data._time_snr), 2))
if self.combobox_ABS_system_choice.currentIndex() == 1:
x, y = np.meshgrid( x, y = np.meshgrid(
stg.time[np.where(np.round(stg.time, 2) == self.spinbox_tmin.value())[0][0]: stg.time[np.where(np.round(stg.time, 2) == self.spinbox_tmin.value())[0][0]:
np.where(np.round(stg.time, 2) == self.spinbox_tmax.value())[0][0]], np.where(np.round(stg.time, 2) == self.spinbox_tmax.value())[0][0]],
@ -1142,6 +1145,54 @@ class AcousticDataTab(QWidget):
cbar.set_ticklabels(['0', '1', '2', '10', '100', r'10$^3$', r'10$^6$']) cbar.set_ticklabels(['0', '1', '2', '10', '100', r'10$^3$', r'10$^6$'])
self.fig_SNR.canvas.draw_idle() self.fig_SNR.canvas.draw_idle()
elif self.combobox_ABS_system_choice.currentIndex() == 2:
x = np.array([[[]]])
y = np.array([[[]]])
print(f"x : {x.shape}, y : {y.shape}")
for f, freq in enumerate(stg.freq):
if x.shape[2] == 0:
x, y = np.meshgrid(stg.time_snr[f, :], stg.r[f, :])
x = np.array([x])
y = np.array([y])
print(f"x : {x.shape}, y : {y.shape}")
else:
x0, y0 = np.meshgrid(stg.time_snr[f, :], stg.r[f, :])
x = np.append(x, np.array([x0]), axis=0)
y = np.append(y, np.array([y0]), axis=0)
print(f"x : {x.shape}, y : {y.shape}")
val_min = np.nanmin(abs(stg.snr[f, :, :]))
# print(f"val_min = {val_min}")
val_max = np.nanmax(abs(stg.snr[f, :, :]))
# print(f"val_max = {val_max}")
if int(val_min) == 0:
val_min = 1e-5
if int(val_max) < 1000:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
bounds = [00.1, 1, 2, 10, 100, 1000, 1e6, 1e6 * 1.2]
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(f"levels = {levels}")
# print(f"norm = {norm.boundaries}")
cf = self.axis_SNR[f].contourf(x[f, :, :], y[f, :, :], stg.snr[f, :, :])#, levels, cmap='gist_rainbow', norm=norm)
self.axis_SNR[f].text(1, .70, stg.freq_text[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)
self.fig_SNR.canvas.draw_idle()
def update_xaxis_transect_with_SNR_data(self): def update_xaxis_transect_with_SNR_data(self):
# if self.canvas_SNR == None: # if self.canvas_SNR == None:
@ -1155,25 +1206,76 @@ class AcousticDataTab(QWidget):
if ((self.canvas_BS != None) and (self.canvas_SNR != None)): if ((self.canvas_BS != None) and (self.canvas_SNR != None)):
# --- Backscatter noise signal is recorded for next tab --- # --- Backscatter noise signal is recorded for next tab ---
stg.Noise_data = stg.BS_noise_data[:, :, np.where(np.round(stg.time, 2) == self.spinbox_tmin.value())[0][0]:
np.where(np.round(stg.time, 2) == self.spinbox_tmax.value())[0][0]]
stg.SNR_data = stg.snr[:, :, np.where(np.round(stg.time, 2) == self.spinbox_tmin.value())[0][0]: stg.tmin_snr = np.array([])
np.where(np.round(stg.time, 2) == self.spinbox_tmax.value())[0][0]] stg.tmax_snr = np.array([])
x, y = np.meshgrid( stg.SNR_data = np.array([[[]]])
stg.time[np.where(np.round(stg.time, 2) == self.spinbox_tmin.value())[0][0]: stg.t_snr = np.array([[]])
np.where(np.round(stg.time, 2) == self.spinbox_tmax.value())[0][0]],
stg.r)
x = np.array([[[]]])
y = np.array([[[]]])
print(f"x : {x.shape}, y : {y.shape}")
for f in range(stg.freq.shape[0]): for f in range(stg.freq.shape[0]):
if x.shape[2] == 0:
x, y = np.meshgrid(stg.time_snr[f, :], stg.r[f, :])
x = np.array([x])
y = np.array([y])
print(f"x : {x.shape}, y : {y.shape}")
else:
x0, y0 = np.meshgrid(stg.time_snr[f, :], stg.r[f, :])
x = np.append(x, np.array([x0]), axis=0)
y = np.append(y, np.array([y0]), axis=0)
print(f"x : {x.shape}, y : {y.shape}")
# print(np.abs(np.round(stg.time_snr[f, :], 2) - self.spinbox_tmin.value()))
# print(np.where(np.abs(np.round(stg.time_snr[f, :], 2) - self.spinbox_tmin.value()) ==
# np.nanmin(np.abs(np.round(stg.time_snr[f, :], 2) - self.spinbox_tmin.value())))[0][0])
stg.tmin_snr = (
np.append(stg.tmin_snr,
np.where(np.abs(np.round(stg.time_snr[f, :], 2) - self.spinbox_tmin.value()) ==
np.nanmin(np.abs(np.round(stg.time_snr[f, :], 2) - self.spinbox_tmin.value())))[0][
0])
)
stg.tmax_snr = (
np.append(stg.tmax_snr,
np.where(np.abs(np.round(stg.time_snr[f, :], 2) - self.spinbox_tmax.value()) ==
np.nanmin(np.abs(np.round(stg.time_snr[f, :], 2) - self.spinbox_tmax.value())))[0][
0])
)
print("stg.tmin[f] ", stg.tmin_snr[f])
print("stg.tmax[f] ", stg.tmax_snr[f])
if stg.SNR_data.shape[2] == 0:
stg.SNR_data = np.array([stg.snr[f, :, int(stg.tmin_snr[f]):int(stg.tmax_snr[f])]])
else:
stg.SNR_data = np.append(stg.SNR_data,
np.array([stg.snr[f, :, int(stg.tmin_snr[f]):int(stg.tmax_snr[f])]]),
axis=0)
# stg.BS_data = np.stack(np.array([stg.BS_raw_data[f, :, int(stg.tmin[f]):int(stg.tmax[f])]]), axis=0)
# stg.BS_data = np.append(stg.BS_data, np.array([stg.BS_raw_data[f, :, int(stg.tmin[f]):int(stg.tmax[f])]]), axis=2)
if stg.t_snr.shape[1] == 0:
stg.t_snr = np.array([stg.time_snr[f, int(stg.tmin_snr[f]):int(stg.tmax_snr[f])]])
else:
stg.t_snr = np.append(stg.t_snr, np.array([stg.time_snr[f, int(stg.tmin_snr[f]):int(stg.tmax_snr[f])]]), axis=0)
# stg.t = np.append(stg.t, np.array([stg.time[f, int(stg.tmin[f]):int(stg.tmax[f])]]), axis=0)
print("stg.t shape ", stg.t_snr.shape)
self.axis_SNR[f].cla() self.axis_SNR[f].cla()
val_min = np.min(stg.snr[:, f, :]) if self.combobox_ABS_system_choice.currentIndex() == 1:
val_max = np.max(stg.snr[:, f, :])
val_min = np.nanmin(stg.SNR_data[f, :, :])
val_max = np.nanmax(stg.snr[f, :, :])
if val_min == 0: if val_min == 0:
val_min = 1e-5 val_min = 1e-5
if val_max > 1000: if val_max < 1000:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
else: else:
levels = np.array([00.1, 1, 2, 10, 100, val_max]) levels = np.array([00.1, 1, 2, 10, 100, val_max])
@ -1192,6 +1294,34 @@ class AcousticDataTab(QWidget):
horizontalalignment='right', verticalalignment='bottom', horizontalalignment='right', verticalalignment='bottom',
transform=self.axis_SNR[f].transAxes) transform=self.axis_SNR[f].transAxes)
elif self.combobox_ABS_system_choice.currentIndex() == 2:
val_min = np.nanmin(abs(stg.snr[f, :, :]))
# print(f"val_min = {val_min}")
val_max = np.nanmax(abs(stg.snr[f, :, :]))
# print(f"val_max = {val_max}")
if int(val_min) == 0:
val_min = 1e-5
if int(val_max) < 1000:
levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6])
bounds = [00.1, 1, 2, 10, 100, 1000, 1e6, 1e6 * 1.2]
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(f"levels = {levels}")
# print(f"norm = {norm.boundaries}")
cf = self.axis_SNR[f].contourf(x[f, :, int(stg.tmin_snr[f]):int(stg.tmax_snr[f])],
y[f, :, int(stg.tmin_snr[f]):int(stg.tmax_snr[f])],
stg.snr[f, :, int(stg.tmin_snr[f]):int(stg.tmax_snr[f])]) # , levels, cmap='gist_rainbow', norm=norm)
self.axis_SNR[f].text(1, .70, stg.freq_text[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('Distance from left bank (m)', fontsize=10) self.fig_SNR.supxlabel('Distance from left bank (m)', fontsize=10)
self.fig_SNR.supylabel('Depth (m)', fontsize=10) self.fig_SNR.supylabel('Depth (m)', fontsize=10)
self.fig_SNR.canvas.draw_idle() self.fig_SNR.canvas.draw_idle()

4
settings.py
View File

@ -38,6 +38,7 @@ time_snr = np.array([])
# --- reshape raw data for table of values in Acoustic Data tab --- # --- reshape raw data for table of values in Acoustic Data tab ---
time_reshape = np.array([]) time_reshape = np.array([])
time_snr_reshape = np.array([])
r_reshape = np.array([]) r_reshape = np.array([])
BS_raw_data_reshape = np.array([]) BS_raw_data_reshape = np.array([])
snr_reshape = np.array([]) # snr is reshape to be included in table of values in acoustic data tab snr_reshape = np.array([]) # snr is reshape to be included in table of values in acoustic data tab
@ -45,12 +46,15 @@ DataFrame_acoustic = pd.DataFrame()
# --- Processed data in Acoustic Data Tab and used in Acoustic processing tab --- # --- Processed data in Acoustic Data Tab and used in Acoustic processing tab ---
tmin = np.array([]) # minimum boundary of time (spin box tmin) tmin = np.array([]) # minimum boundary of time (spin box tmin)
tmin_snr = np.array([])
tmax = np.array([]) # maximum boundary of time (spin box tmin) tmax = np.array([]) # maximum boundary of time (spin box tmin)
tmax_snr = np.array([])
BS_data = np.array([]) # BS data limited with tmin and tmax values of spin box BS_data = np.array([]) # BS data limited with tmin and tmax values of spin box
BS_data_section = np.array([]) # BS data in the section. Values NaN outside the bottom of the section are deleted BS_data_section = np.array([]) # BS data in the section. Values NaN outside the bottom of the section are deleted
Noise_data = np.array([]) # Noise_data = BS_noise_data[:, :, tmin:tmax] Noise_data = np.array([]) # Noise_data = BS_noise_data[:, :, tmin:tmax]
SNR_data = np.array([]) # SNR_data = snr[:, :, tmin:tmax] SNR_data = np.array([]) # SNR_data = snr[:, :, tmin:tmax]
t = np.array([]) t = np.array([])
t_snr = np.array([])
r_bottom = np.array([]) r_bottom = np.array([])
val_bottom = np.array([]) val_bottom = np.array([])
ind_bottom = np.array([]) ind_bottom = np.array([])