From 680f18b7417529c79b2fc0f85635239f3ecc0891 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Thu, 20 Mar 2025 17:43:14 +0100 Subject: [PATCH 01/16] Model: Start simple refactoring read table. --- Model/read_table_for_open.py | 550 +++++++++++++++++++++++------------ 1 file changed, 360 insertions(+), 190 deletions(-) diff --git a/Model/read_table_for_open.py b/Model/read_table_for_open.py index a6ca72d..7eff069 100644 --- a/Model/read_table_for_open.py +++ b/Model/read_table_for_open.py @@ -60,41 +60,59 @@ class ReadTableForOpen: except OSError as e: logger.warning(f"chdir: {str(e)}") - self.sql_file_to_open = open(stg.filename_open) self.read_table() self.opened = True - def read_table(self): + def execute(self, query): + return self._cur.execute(query).fetchall() + def read_table(self): stg.read_table_trigger = 1 - # connexion to File db + logger.debug(f"Open '{stg.filename_open}'") + cnx = sqlite3.connect(stg.filename_open) + self._cur = cnx.cursor() - # Create database cursor to execute SQL statements and fetch results from SQL queries. - cur = cnx.cursor() + self.read_table_acoustic_file() + self.read_table_measure() + self.read_table_BS_raw_data() + self.read_table_settings() + self.read_table_sediment_file() + self.read_table_table_sediment_data() - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++++++ - # --- Table Acoustic File --- - # +++++++++++++++++++++++++++ + logger.debug(f"Reading '{stg.filename_open}' done") + self._cur.close() + cnx.close() + + logger.debug(f"'{stg.filename_open}' closed") + + def read_table_acoustic_file(self): query0 = f'''SELECT acoustic_data FROM AcousticFile''' - data0 = cur.execute(query0).fetchall() - print("data0 ", data0) + data0 = self.execute(query0) + + logger.debug(f"data0: {data0}") stg.acoustic_data = [x[0] for x in data0] - print("stg.acoustic_data ", stg.acoustic_data) + logger.debug(f"stg.acoustic_data: {stg.acoustic_data}") for k in range(len(stg.acoustic_data)): - print("hello") - query = f'''SELECT acoustic_data, acoustic_file, ABS_name, path_BS_noise_data, filename_BS_noise_data, - noise_method, noise_value, data_preprocessed FROM AcousticFile WHERE (acoustic_data = {k})''' - data = cur.execute(query).fetchall() + query = f''' + SELECT + acoustic_data, acoustic_file, ABS_name, path_BS_noise_data, + filename_BS_noise_data, + noise_method, noise_value, data_preprocessed + FROM AcousticFile + WHERE (acoustic_data = {k}) + ''' + data = self.execute(query) print("data acoustic file", data) - stg.filename_BS_raw_data.append([str(y[1]) + '.aqa' for y in data][0]) + stg.filename_BS_raw_data.append( + [str(y[1]) + '.aqa' for y in data][0] + ) stg.ABS_name.append([z[2] for z in data][0]) stg.path_BS_noise_data.append([z[3] for z in data][0]) stg.filename_BS_noise_data.append([z[4] for z in data][0]) @@ -102,31 +120,45 @@ class ReadTableForOpen: stg.noise_value.append([z[6] for z in data][0]) stg.data_preprocessed.append([z[7] for z in data][0]) - print("data acoustic file ", stg.filename_BS_raw_data, stg.ABS_name, stg.path_BS_noise_data, stg.filename_BS_noise_data, - stg.noise_method, stg.noise_value, stg.data_preprocessed) - - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++ - # --- Table Measure --- - # +++++++++++++++++++++ + logger.debug("data acoustic file:") + logger.debug(f"- {stg.filename_BS_raw_data}") + logger.debug(f"- {stg.ABS_name}") + logger.debug(f"- {stg.path_BS_noise_data}") + logger.debug(f"- {stg.filename_BS_noise_data}") + logger.debug(f"- {stg.noise_method}") + logger.debug(f"- {stg.noise_value}") + logger.debug(f"- {stg.data_preprocessed}") + def read_table_measure(self): stg.date = [0]*len(stg.acoustic_data) stg.hour = [0]*len(stg.acoustic_data) - for i in range(len(stg.acoustic_data)): - print("i = ", i) - query1 = f'''SELECT acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected, NbProfiles, - NbProfilesPerSeconds, NbCells, CellSize, PulseLength, NbPingsPerSeconds, NbPingsAveragedPerProfile, - GainRx, GainTx FROM Measure WHERE (acoustic_data = {i})''' - data1 = cur.execute(query1).fetchall() - print("--------------------------------------") - print("data1 ", data1) + for i in range(len(stg.acoustic_data)): + query1 = f''' + SELECT + acoustic_data, Date, Hour, frequency, + sound_attenuation, kt_read, kt_corrected, NbProfiles, + NbProfilesPerSeconds, NbCells, CellSize, PulseLength, + NbPingsPerSeconds, NbPingsAveragedPerProfile, + GainRx, GainTx + FROM Measure + WHERE (acoustic_data = {i}) + ''' + data1 = self.execute(query1) + + logger.debug(f"data1 for {i}: {data1}") stg.date[i] = data1[0][1] stg.hour[i] = data1[0][2] - stg.freq.append(np.array([x[3] for x in data1])) - stg.freq_text.append([str(x[3]*1e-6) + 'MHz' for x in data1]) - stg.water_attenuation.append([x[4] for x in data1]) + stg.freq.append( + np.array([x[3] for x in data1]) + ) + stg.freq_text.append( + [str(x[3]*1e-6) + 'MHz' for x in data1] + ) + stg.water_attenuation.append( + [x[4] for x in data1] + ) stg.kt_read.append([x[5] for x in data1]) stg.kt_corrected = [x[6] for x in data1] stg.nb_profiles.append([x[7] for x in data1]) @@ -134,154 +166,309 @@ class ReadTableForOpen: stg.nb_cells.append([x[9] for x in data1]) stg.cell_size.append([x[10] for x in data1]) stg.pulse_length.append([x[11] for x in data1]) - stg.nb_pings_per_sec.append([x[12] for x in data1]) - stg.nb_pings_averaged_per_profile.append([x[13] for x in data1]) + stg.nb_pings_per_sec.append( + [x[12] for x in data1] + ) + stg.nb_pings_averaged_per_profile.append( + [x[13] for x in data1] + ) stg.gain_rx.append([x[14] for x in data1]) stg.gain_tx.append([x[15] for x in data1]) - print(stg.acoustic_data, stg.freq, stg.water_attenuation, stg.kt_read, stg.kt_corrected, stg.nb_profiles, stg.nb_profiles_per_sec, - stg.nb_cells, stg.cell_size, stg.pulse_length, stg.nb_pings_per_sec, stg.nb_pings_averaged_per_profile, - stg.gain_rx, stg.gain_tx) + logger.debug("measure:") + logger.debug(f"- {stg.acoustic_data}") + logger.debug(f"- {stg.freq}") + logger.debug(f"- {stg.water_attenuation}") + logger.debug(f"- {stg.kt_read}") + logger.debug(f"- {stg.kt_corrected}") + logger.debug(f"- {stg.nb_profiles}") + logger.debug(f"- {stg.nb_profiles_per_sec}") + logger.debug(f"- {stg.nb_cells}") + logger.debug(f"- {stg.cell_size}") + logger.debug(f"- {stg.pulse_length}") + logger.debug(f"- {stg.nb_pings_per_sec}") + logger.debug(f"- {stg.nb_pings_averaged_per_profile}") + logger.debug(f"- {stg.gain_rx}") + logger.debug(f"- {stg.gain_tx}") - print(stg.date) - print(stg.hour) + logger.debug(f"- {stg.date}") + logger.debug(f"- {stg.hour}") - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++ - # --- Table BSRawData --- - # ++++++++++++++++++++++ - print("len stg.acoustic_data ", len(stg.acoustic_data)) - for j in range(len(stg.acoustic_data)): - print(f"j = {j}") - query2 = f'''SELECT acoustic_data, time, depth, BS_raw_data, - time_reshape, depth_reshape, BS_raw_data_reshape, - time_cross_section, depth_cross_section, - BS_cross_section, BS_stream_bed, - depth_bottom, val_bottom, ind_bottom, - time_noise, depth_noise, BS_noise_raw_data, - SNR_raw_data, SNR_cross_section, SNR_stream_bed, - BS_raw_data_pre_process_SNR, BS_raw_data_pre_process_average, - BS_cross_section_pre_process_SNR, BS_cross_section_pre_process_average, - BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average, BS_mean - FROM BSRawData WHERE (acoustic_data = {j})''' + def read_table_BS_raw_data(self): + logger.debug(f"len stg.acoustic_data: {len(stg.acoustic_data)}") - data2 = cur.execute(query2).fetchall() - print("len data2 ", len(data2)) + for i in range(len(stg.acoustic_data)): + query = lambda values: f''' + SELECT + {", ".join(values)} + FROM BSRawData + WHERE (acoustic_data = {i}) + ''' - stg.time.append(np.frombuffer(data2[0][1], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("stg.time[0].shape ", stg.time[j].shape, np.frombuffer(data2[0][1], dtype=np.float64).shape) - print(stg.time) - stg.depth.append(np.frombuffer(data2[0][2], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("stg.depth[0].shape ", stg.depth[j].shape) - print(stg.depth) - stg.BS_raw_data.append(np.frombuffer(data2[0][3], dtype=np.float64).reshape((stg.freq[j].shape[0], stg.depth[j].shape[1], stg.time[j].shape[1]))) - print("BS_raw_data ", stg.BS_raw_data[j].shape) - stg.time_reshape.append(np.frombuffer(data2[0][4], dtype=np.float64).reshape((-1, stg.freq[j].shape[0]))) - print("stg.time_reshape[0].shape ", stg.time_reshape[j].shape) - stg.depth_reshape.append(np.frombuffer(data2[0][5], dtype=np.float64).reshape((-1, stg.freq[j].shape[0]))) - stg.BS_raw_data_reshape.append(np.frombuffer(data2[0][6], dtype=np.float64).reshape((-1, stg.freq[j].shape[0]))) - print("time cross section ", stg.time_cross_section, stg.time_cross_section == []) + self.read_table_BS_raw_data_raw(query, i) + self.read_table_BS_raw_data_cross_section(query, i) + self.read_table_BS_raw_data_bed(query, i) + self.read_table_BS_raw_data_noise(query, i) + self.read_table_BS_raw_data_SNR(query, i) + self.read_table_BS_raw_data_rest(query, i) + self.read_table_BS_raw_data_mean(query, i) - print("np.frombuffer(data2[0][9], dtype=np.float64) ", np.frombuffer(data2[0][9], dtype=np.float64)) - if len(np.frombuffer(data2[0][9], dtype=np.float64)) == 0: - print("Je suis là") - stg.time_cross_section.append(np.array([])) - stg.depth_cross_section.append(np.array([])) - stg.BS_cross_section.append(np.array([])) + def read_table_BS_raw_data_raw(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "time", "depth", + "BS_raw_data", + "time_reshape", "depth_reshape", + "BS_raw_data_reshape", + ] + ) + )[0] + + it = iter(data) + + time = next(it) + depth = next(it) + BS_raw_data = next(it) + time_reshape = next(it) + depth_reshape = next(it) + BS_raw_data_reshape = next(it) + + stg.time.append( + np_f64_parse(time).reshape((stg.freq[i].shape[0], -1)) + ) + stg.depth.append(np_f64_parse(depth).reshape( + (stg.freq[i].shape[0], -1) + )) + stg.BS_raw_data.append( + np_f64_parse(BS_raw_data).reshape( + ( + stg.freq[i].shape[0], + stg.depth[i].shape[1], + stg.time[i].shape[1] + ) + ) + ) + stg.time_reshape.append( + np_f64_parse(time_reshape).reshape( + (-1, stg.freq[i].shape[0]) + ) + ) + stg.depth_reshape.append( + np_f64_parse(depth_reshape).reshape( + (-1, stg.freq[i].shape[0]) + ) + ) + stg.BS_raw_data_reshape.append( + np_f64_parse(BS_raw_data_reshape).reshape( + (-1, stg.freq[i].shape[0]) + ) + ) + + def read_table_BS_raw_data_cross_section(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "time_cross_section", + "depth_cross_section", + "BS_cross_section", + ] + ) + )[0] + + it = iter(data) + + time = next(it) + depth = next(it) + BS = np_f64_parse(next(it)) + + if len(BS) == 0: + stg.time_cross_section.append(np.array([])) + stg.depth_cross_section.append(np.array([])) + stg.BS_cross_section.append(np.array([])) + else: + stg.time_cross_section.append( + np_f64_parse(time).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + stg.depth_cross_section.append( + np_f64_parse(depth).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + + stg.BS_cross_section.append( + BS.reshape( + ( + stg.freq[i].shape[0], + stg.depth_cross_section[i].shape[1], + stg.time_cross_section[i].shape[1] + ) + ) + ) + + def read_table_BS_raw_data_bed(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "BS_stream_bed", + "depth_bottom", "val_bottom", "ind_bottom", + ] + ) + )[0] + + it = iter(data) + + BS = np_f64_parse(next(it)) + depth = np_f64_parse(next(it)) + val = np_f64_parse(next(it)) + ind = np_f64_parse(next(it)) + + if len(BS) == 0: + stg.BS_stream_bed.append(np.array([])) + else: + stg.BS_stream_bed.append( + BS.reshape( + ( + stg.freq[i].shape[0], + stg.depth_cross_section[i].shape[1], + stg.time_cross_section[i].shape[1] + ) + ) + ) + + if len(depth) == 0: + stg.depth_bottom.append(np.array([])) + stg.val_bottom.append([]) + stg.ind_bottom.append([]) + else: + stg.depth_bottom.append(depth) + stg.val_bottom.append(val.tolist()) + stg.ind_bottom.append(ind.tolist()) + + def read_table_BS_raw_data_noise(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "time_noise", "depth_noise", "BS_noise_raw_data", + ] + ) + )[0] + + it = iter(data) + + time = next(it) + depth = next(it) + BS = np_f64_parse(next(it)) + + if len(BS) == 0: + stg.time_noise.append(np.array([])) + stg.depth_noise.append(np.array([])) + stg.BS_noise_raw_data.append(np.array([])) + else: + stg.time_noise.append( + np_f64_parse(time).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + stg.depth_noise.append( + np_f64_parse(depth).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + stg.BS_noise_raw_data.append( + BS.reshape( + ( + stg.freq[i].shape[0], + stg.depth_noise[i].shape[1], + stg.time_noise[i].shape[1] + ) + ) + ) + + def read_table_BS_raw_data_SNR(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "SNR_raw_data", "SNR_cross_section", "SNR_stream_bed", + ] + ) + )[0] + + it = iter(data) + + SNR_vars = [ + (stg.SNR_raw_data, stg.BS_raw_data), + (stg.SNR_cross_section, stg.BS_cross_section), + (stg.SNR_cross_section, stg.BS_stream_bed), + ] + + for dest, resh in SNR_vars: + SNR = np_f64_parse(next(it)) + + if len(SNR) == 0: + dest.append(np.array([])) else: - print("Je suis ici") - print(stg.freq[j].shape) - print(np.frombuffer(data2[0][7], dtype=np.float64).shape) - stg.time_cross_section.append(np.frombuffer(data2[0][7], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("time cross section ", stg.time_cross_section, stg.time_cross_section[j].shape) - stg.depth_cross_section.append(np.frombuffer(data2[0][8], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("depth cross section ", stg.depth_cross_section, stg.depth_cross_section[j].shape) - stg.BS_cross_section.append(np.frombuffer(data2[0][9], dtype=np.float64).reshape( - (stg.freq[j].shape[0], stg.depth_cross_section[j].shape[1], stg.time_cross_section[j].shape[1]))) + dest.append(SNR.reshape(resh[i].shape)) - if len(np.frombuffer(data2[0][10], dtype=np.float64)) == 0: - stg.BS_stream_bed.append(np.array([])) + + def read_table_BS_raw_data_rest(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "BS_raw_data_pre_process_SNR", + "BS_raw_data_pre_process_average", + "BS_cross_section_pre_process_SNR", + "BS_cross_section_pre_process_average", + "BS_stream_bed_pre_process_SNR", + "BS_stream_bed_pre_process_average", + ] + ) + )[0] + + BS_vars = [ + (stg.BS_raw_data_pre_process_SNR, stg.BS_raw_data), + (stg.BS_raw_data_pre_process_average, stg.BS_raw_data), + (stg.BS_cross_section_pre_process_SNR, stg.BS_cross_section), + (stg.BS_cross_section_pre_process_average, stg.BS_cross_section), + (stg.BS_stream_bed_pre_process_SNR, stg.BS_stream_bed), + (stg.BS_stream_bed_pre_process_average, stg.BS_stream_bed), + ] + + it = iter(data) + for dest, resh in BS_vars: + BS = np_f64_parse(next(it)) + + if len(BS) == 0: + dest.append(np.array([])) else: - stg.BS_stream_bed.append(np.frombuffer(data2[0][10], dtype=np.float64).reshape( - (stg.freq[j].shape[0], stg.depth_cross_section[j].shape[1], stg.time_cross_section[j].shape[1]))) + dest.append(BS.reshape(resh[i].shape)) - if len(np.frombuffer(data2[0][11], dtype=np.float64)) == 0: - stg.depth_bottom.append(np.array([])) - stg.val_bottom.append([]) - stg.ind_bottom.append([]) - else: - stg.depth_bottom.append(np.frombuffer(data2[0][11], dtype=np.float64)) - stg.val_bottom.append(np.frombuffer(data2[0][12], dtype=np.float64).tolist()) - stg.ind_bottom.append(np.frombuffer(data2[0][13], dtype=np.float64).tolist()) - print("stg.depth_bottom ", stg.depth_bottom) - print("stg.val_bottom ", stg.val_bottom) - print("stg.ind_bottom ", stg.ind_bottom) + def read_table_BS_raw_data_mean(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query(["BS_mean"]) + )[0] - if len(np.frombuffer(data2[0][14], dtype=np.float64)) == 0: - stg.time_noise.append(np.array([])) - stg.depth_noise.append(np.array([])) - stg.BS_noise_raw_data.append(np.array([])) - else: - stg.time_noise.append(np.frombuffer(data2[0][14], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - stg.depth_noise.append(np.frombuffer(data2[0][15], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - stg.BS_noise_raw_data.append(np.frombuffer(data2[0][16], dtype=np.float64).reshape( - (stg.freq[j].shape[0], stg.depth_noise[j].shape[1], stg.time_noise[j].shape[1]))) + BS = np_f64_parse(data[0]) - if len(np.frombuffer(data2[0][17], dtype=np.float64)) == 0: - stg.SNR_raw_data.append(np.array([])) - else: - stg.SNR_raw_data.append(np.frombuffer(data2[0][17], dtype=np.float64).reshape(stg.BS_raw_data[j].shape)) - - if len(np.frombuffer(data2[0][18], dtype=np.float64)) == 0: - stg.SNR_cross_section.append(np.array([])) - else: - stg.SNR_cross_section.append(np.frombuffer(data2[0][18], dtype=np.float64).reshape(stg.BS_cross_section[j].shape)) - - if len(np.frombuffer(data2[0][19], dtype=np.float64)) == 0: - stg.SNR_stream_bed.append(np.array([])) - else: - stg.SNR_stream_bed.append(np.frombuffer(data2[0][19], dtype=np.float64).reshape(stg.BS_stream_bed[j].shape)) - - if len(np.frombuffer(data2[0][20], dtype=np.float64)) == 0: - stg.BS_raw_data_pre_process_SNR.append(np.array([])) - else: - stg.BS_raw_data_pre_process_SNR.append(np.frombuffer(data2[0][20], dtype=np.float64).reshape(stg.BS_raw_data[j].shape)) - - if len(np.frombuffer(data2[0][21], dtype=np.float64)) == 0: - stg.BS_raw_data_pre_process_average.append(np.array([])) - else: - stg.BS_raw_data_pre_process_average.append(np.frombuffer(data2[0][21], dtype=np.float64).reshape(stg.BS_raw_data[j].shape)) - - if len(np.frombuffer(data2[0][22], dtype=np.float64)) == 0: - stg.BS_cross_section_pre_process_SNR.append(np.array([])) - else: - stg.BS_cross_section_pre_process_SNR.append(np.frombuffer(data2[0][22], dtype=np.float64).reshape(stg.BS_cross_section[j].shape)) - - if len(np.frombuffer(data2[0][23], dtype=np.float64)) == 0: - stg.BS_cross_section_pre_process_average.append(np.array([])) - else: - stg.BS_cross_section_pre_process_average.append(np.frombuffer(data2[0][23], dtype=np.float64).reshape(stg.BS_cross_section[j].shape)) - - if len(np.frombuffer(data2[0][24], dtype=np.float64)) == 0: - stg.BS_stream_bed_pre_process_SNR.append(np.array([])) - else: - stg.BS_stream_bed_pre_process_SNR.append(np.frombuffer(data2[0][24], dtype=np.float64).reshape(stg.BS_stream_bed[j].shape)) - - if len(np.frombuffer(data2[0][25], dtype=np.float64)) == 0: - stg.BS_stream_bed_pre_process_average.append(np.array([])) - else: - stg.BS_stream_bed_pre_process_average.append(np.frombuffer(data2[0][25], dtype=np.float64).reshape(stg.BS_stream_bed[j].shape)) - - if len(np.frombuffer(data2[0][26], dtype=np.float64)) == 0: - stg.BS_mean.append(np.array([])) - else: - stg.BS_mean.append(np.frombuffer(data2[0][26], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print(stg.BS_mean[j].shape) - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++ - # --- Table Settings --- - # +++++++++++++++++++++++ + if len(BS) == 0: + stg.BS_mean.append(np.array([])) + else: + stg.BS_mean.append( + BS.reshape( + (stg.freq[i].shape[0], -1) + ) + ) + def read_table_settings(self): for s in range(len(stg.acoustic_data)): query3 = f'''SELECT acoustic_data, temperature, tmin_index, tmin_value, tmax_index, tmax_value, @@ -290,7 +477,7 @@ class ReadTableForOpen: SNR_filter_value, Nb_cells_to_average_BS_signal FROM Settings WHERE (acoustic_data = {s})''' - data3 = cur.execute(query3).fetchall() + data3 = self.execute(query3) stg.temperature = [x[1] for x in data3][0] stg.tmin.append([(x[2], x[3]) for x in data3]) @@ -301,18 +488,14 @@ class ReadTableForOpen: stg.SNR_filter_value.append([x[12] for x in data3]) stg.Nb_cells_to_average_BS_signal.append([x[13] for x in data3]) - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++++++ - # --- Table Sediment File --- - # +++++++++++++++++++++++++++ - + def read_table_sediment_file(self): query4 = f'''SELECT path_fine, filename_fine, radius_grain_fine, path_sand, filename_sand, radius_grain_sand, time_column_label, distance_from_bank_column_label, depth_column_label, Ctot_fine_column_label, D50_fine_column_label, Ctot_sand_column_label, D50_sand_column_label from SedimentsFile''' - data4 = cur.execute(query4).fetchall() + data4 = self.execute(query4) print("data4 ", data4) @@ -329,18 +512,14 @@ class ReadTableForOpen: print(stg.radius_grain_fine, stg.radius_grain_sand) print('stg.columns_fine ', stg.columns_fine) - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++++++ - # --- Table Sediment Data --- - # +++++++++++++++++++++++++++ - + def read_table_table_sediment_data(self): query5 = f'''SELECT sample_fine_name, sample_fine_index, distance_from_bank_fine, depth_fine, time_fine, Ctot_fine, Ctot_fine_per_cent, D50_fine, frac_vol_fine, frac_vol_fine_cumul, sample_sand_name, sample_sand_index, distance_from_bank_sand, depth_sand, time_sand, Ctot_sand, Ctot_sand_per_cent, D50_sand, frac_vol_sand, frac_vol_sand_cumul from SedimentsData''' - data5 = cur.execute(query5).fetchall() + data5 = self.execute(query5) stg.frac_vol_fine = [] stg.frac_vol_fine_cumul = [] @@ -378,15 +557,6 @@ class ReadTableForOpen: print(stg.Ctot_fine, stg.sample_sand) print(type(stg.frac_vol_fine_cumul), stg.frac_vol_fine_cumul) - - # Close database cursor - cur.close() - - # Close database connection - cnx.close() - - print("read table finished") - def fill_acoustic_data_tab(self): print("start fill acoustic data tab") From bdfcff88a52e0d6d221a9a022d40cee278a7c0d2 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Thu, 20 Mar 2025 18:20:26 +0100 Subject: [PATCH 02/16] Model: Continue refactoring. --- Model/read_table_for_open.py | 65 +++++++++++++++++++++--------------- 1 file changed, 39 insertions(+), 26 deletions(-) diff --git a/Model/read_table_for_open.py b/Model/read_table_for_open.py index 7eff069..097551e 100644 --- a/Model/read_table_for_open.py +++ b/Model/read_table_for_open.py @@ -470,12 +470,16 @@ class ReadTableForOpen: def read_table_settings(self): for s in range(len(stg.acoustic_data)): - query3 = f'''SELECT acoustic_data, temperature, - tmin_index, tmin_value, tmax_index, tmax_value, - rmin_index, rmin_value, rmax_index, rmax_value, - freq_bottom_detection_index, freq_bottom_detection_value, - SNR_filter_value, Nb_cells_to_average_BS_signal - FROM Settings WHERE (acoustic_data = {s})''' + query3 = f''' + SELECT + acoustic_data, temperature, + tmin_index, tmin_value, tmax_index, tmax_value, + rmin_index, rmin_value, rmax_index, rmax_value, + freq_bottom_detection_index, freq_bottom_detection_value, + SNR_filter_value, Nb_cells_to_average_BS_signal + FROM Settings + WHERE (acoustic_data = {s}) + ''' data3 = self.execute(query3) @@ -489,28 +493,37 @@ class ReadTableForOpen: stg.Nb_cells_to_average_BS_signal.append([x[13] for x in data3]) def read_table_sediment_file(self): - query4 = f'''SELECT path_fine, filename_fine, radius_grain_fine, path_sand, filename_sand, radius_grain_sand, - time_column_label, distance_from_bank_column_label, depth_column_label, - Ctot_fine_column_label, D50_fine_column_label, - Ctot_sand_column_label, D50_sand_column_label - from SedimentsFile''' + query = f''' + SELECT + path_fine, filename_fine, radius_grain_fine, + path_sand, filename_sand, radius_grain_sand, + time_column_label, distance_from_bank_column_label, + depth_column_label, + Ctot_fine_column_label, D50_fine_column_label, + Ctot_sand_column_label, D50_sand_column_label + FROM SedimentsFile + ''' - data4 = self.execute(query4) + data = self.execute(query)[0] - print("data4 ", data4) - - stg.path_fine = data4[0][0] - stg.filename_fine = data4[0][1] - stg.radius_grain_fine = np.array(np.frombuffer(data4[0][2], dtype=np.float64)) - stg.path_sand = data4[0][3] - stg.filename_sand = data4[0][4] - stg.radius_grain_sand = np.array(np.frombuffer(data4[0][5], dtype=np.float64)) - stg.columns_fine = [data4[0][6], data4[0][7], data4[0][8], data4[0][9], data4[0][10]] + list(stg.radius_grain_fine) - stg.columns_sand = [data4[0][6], data4[0][7], data4[0][8], data4[0][11], data4[0][12]] + list(stg.radius_grain_sand) - - print("sediment file : ", stg.path_fine, stg.filename_fine, stg.path_sand, stg.filename_sand) - print(stg.radius_grain_fine, stg.radius_grain_sand) - print('stg.columns_fine ', stg.columns_fine) + stg.path_fine = data[0] + stg.filename_fine = data[1] + stg.radius_grain_fine = np.array( + np.frombuffer(data[2], dtype=np.float64) + ) + stg.path_sand = data[3] + stg.filename_sand = data[4] + stg.radius_grain_sand = np.array( + np.frombuffer(data[5], dtype=np.float64) + ) + stg.columns_fine = ( + [data[6], data[7], data[8], data[9], data[10]] + + list(stg.radius_grain_fine) + ) + stg.columns_sand = ( + [data[6], data[7], data[8], data[11], data[12]] + + list(stg.radius_grain_sand) + ) def read_table_table_sediment_data(self): query5 = f'''SELECT sample_fine_name, sample_fine_index, distance_from_bank_fine, depth_fine, time_fine, From 2e20b2f46433a078d954d694e47d67461f2d8355 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 13:01:21 +0100 Subject: [PATCH 03/16] Model: Finish refactoring read table for open. --- Model/read_table_for_open.py | 127 ++++++++++++----------------------- 1 file changed, 42 insertions(+), 85 deletions(-) diff --git a/Model/read_table_for_open.py b/Model/read_table_for_open.py index 097551e..60cf2d5 100644 --- a/Model/read_table_for_open.py +++ b/Model/read_table_for_open.py @@ -526,101 +526,58 @@ class ReadTableForOpen: ) def read_table_table_sediment_data(self): - query5 = f'''SELECT sample_fine_name, sample_fine_index, distance_from_bank_fine, depth_fine, time_fine, - Ctot_fine, Ctot_fine_per_cent, D50_fine, frac_vol_fine, frac_vol_fine_cumul, - sample_sand_name, sample_sand_index, distance_from_bank_sand, depth_sand, time_sand, - Ctot_sand, Ctot_sand_per_cent, D50_sand, frac_vol_sand, frac_vol_sand_cumul - from SedimentsData''' + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) - data5 = self.execute(query5) + query = f''' + SELECT + sample_fine_name, sample_fine_index, distance_from_bank_fine, + depth_fine, time_fine, Ctot_fine, Ctot_fine_per_cent, D50_fine, + frac_vol_fine, frac_vol_fine_cumul, + + sample_sand_name, sample_sand_index, distance_from_bank_sand, + depth_sand, time_sand, Ctot_sand, Ctot_sand_per_cent, D50_sand, + frac_vol_sand, frac_vol_sand_cumul + FROM SedimentsData + ''' + + data = self.execute(query) stg.frac_vol_fine = [] stg.frac_vol_fine_cumul = [] stg.frac_vol_sand = [] stg.frac_vol_sand_cumul = [] - for f in range(len(data5)): - stg.sample_fine.append((data5[f][0], data5[f][1])) - stg.distance_from_bank_fine.append(data5[f][2]) - stg.depth_fine.append(data5[f][3]) - stg.time_fine.append(data5[f][4]) - stg.Ctot_fine.append(data5[f][5]) - stg.Ctot_fine_per_cent.append(data5[f][6]) - stg.D50_fine.append(data5[f][7]) - print("np.frombuffer(data4[f][8], dtype=np.float64) ", np.frombuffer(data5[f][8], dtype=np.float64)) - stg.frac_vol_fine.append(np.frombuffer(data5[f][8], dtype=np.float64)) - stg.frac_vol_fine_cumul.append(np.frombuffer(data5[f][9], dtype=np.float64)) - stg.sample_sand.append((data5[f][10], data5[f][11])) - stg.distance_from_bank_sand.append(data5[f][12]) - stg.depth_sand.append(data5[f][13]) - stg.time_sand.append(data5[f][14]) - stg.Ctot_sand.append(data5[f][15]) - stg.Ctot_sand_per_cent.append(data5[f][16]) - stg.D50_sand.append(data5[f][17]) - stg.frac_vol_sand.append(np.frombuffer(data5[f][18], dtype=np.float64)) - stg.frac_vol_sand_cumul.append(np.frombuffer(data5[f][19], dtype=np.float64)) + for f in range(len(data)): + stg.sample_fine.append((data[f][0], data[f][1])) + stg.distance_from_bank_fine.append(data[f][2]) + stg.depth_fine.append(data[f][3]) + stg.time_fine.append(data[f][4]) + stg.Ctot_fine.append(data[f][5]) + stg.Ctot_fine_per_cent.append(data[f][6]) + stg.D50_fine.append(data[f][7]) + stg.frac_vol_fine.append( + np_f64_parse(data[f][8]) + ) + stg.frac_vol_fine_cumul.append( + np_f64_parse(data[f][9]) + ) + stg.sample_sand.append((data[f][10], data[f][11])) + stg.distance_from_bank_sand.append(data[f][12]) + stg.depth_sand.append(data[f][13]) + stg.time_sand.append(data[f][14]) + stg.Ctot_sand.append(data[f][15]) + stg.Ctot_sand_per_cent.append(data[f][16]) + stg.D50_sand.append(data[f][17]) + stg.frac_vol_sand.append( + np_f64_parse(data[f][18]) + ) + stg.frac_vol_sand_cumul.append( + np_f64_parse(data[f][19]) + ) stg.frac_vol_fine = np.array(stg.frac_vol_fine) stg.frac_vol_fine_cumul = np.array(stg.frac_vol_fine_cumul) stg.frac_vol_sand = np.array(stg.frac_vol_sand) stg.frac_vol_sand_cumul = np.array(stg.frac_vol_sand_cumul) - # print("data 4 : ", len(data4), data4) - print('data 5 :') - print(stg.Ctot_fine, stg.sample_sand) - print(type(stg.frac_vol_fine_cumul), stg.frac_vol_fine_cumul) - - def fill_acoustic_data_tab(self): - print("start fill acoustic data tab") - - # tab_adt = AcousticDataTab(self.master_widget) - print("1 AcousticDataTab ", id(AcousticDataTab)) - print("tab_adt.combobox_ABS_system_choice ", self.tab.combobox_ABS_system_choice) - self.tab.combobox_ABS_system_choice.editTextChanged.connect(self.tab.ABS_system_choice) - if stg.ABS_name[0] == "AQUAscat": - self.tab.combobox_ABS_system_choice.setCurrentText(stg.ABS_name[0]) - print("combobox_ABS_system_choice.setCurrentIndex(1)", self.tab.combobox_ABS_system_choice.itemText(1), - self.tab.combobox_ABS_system_choice.itemText(2)) - else: - self.tab.combobox_ABS_system_choice.setCurrentText(stg.ABS_name[0]) - - self.tab.plot_backscattered_acoustic_signal_recording() - # app = QApplication(sys.argv) - - # sys.exit(app.exec_()) - - def reshape_variables(self): - - for i in stg.acoustic_data: - for f, _ in enumerate(stg.freq[i]): - - if f == 0: - - depth_temp = np.array([ - stg.depth_reshape[i][np.where(stg.depth_reshape[i][:, f] == stg.depth_reshape[i][0, f])[0][0]: - np.where(stg.depth_reshape[i][:, f] == stg.depth_reshape[i][0, f])[0][1], f] - ]) - - time_temp = np.array([ - stg.time_reshape[i][ - np.where(stg.depth_reshape[i][:, f] == stg.depth_reshape[i][0, f])[0], f] - ]) - - else: - # print(np.where(stg.depth_reshape[i][:, f] == stg.depth_reshape[i][0, f])) - depth_temp = np.insert(depth_temp, - depth_temp.shape[0], - stg.depth_reshape[i][np.where(stg.depth_reshape[i][:, f] == stg.depth_reshape[i][0, f])[0][0]: - np.where(stg.depth_reshape[i][:, f] == stg.depth_reshape[i][0, f])[0][1], f], - axis=0) - time_temp = np.insert(time_temp, - time_temp.shape[0], - stg.time_reshape[i][ - np.where(stg.depth_reshape[i][:, f] == stg.depth_reshape[i][0, f])[0], f], - axis=0) - - stg.depth.append(depth_temp) - stg.time.append(time_temp) - - stg.BS_raw_data.append(np.reshape(stg.BS_raw_data_reshape[i], - (len(stg.freq[i]), stg.depth[i].shape[1], stg.time[i].shape[1]))) + logger.debug(f"fine: {stg.Ctot_fine}, sand: {stg.sample_sand}") From 413e8fb18ed965126d6a82883ce87df07f2bcc9c Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 13:02:10 +0100 Subject: [PATCH 04/16] Acoustic data: Fix open study. --- View/acoustic_data_tab.py | 21 +++++++++++++++++++++ View/acoustic_inversion_tab.py | 10 ++++++++++ View/note_tab.py | 12 ++++++++++++ View/sample_data_tab.py | 11 +++++++++++ View/sediment_calibration_tab.py | 8 ++++++++ View/signal_processing_tab.py | 13 +++++++++++++ View/user_manual_tab.py | 5 +++++ main.py | 24 ++++++++++++++++++------ 8 files changed, 98 insertions(+), 6 deletions(-) diff --git a/View/acoustic_data_tab.py b/View/acoustic_data_tab.py index e54046f..0100bee 100644 --- a/View/acoustic_data_tab.py +++ b/View/acoustic_data_tab.py @@ -733,6 +733,27 @@ class AcousticDataTab(QWidget): # -------------------- Functions for Acoustic dataTab -------------------- + def full_update(self): + logger.debug(f"{__name__}: Update") + self.blockSignals(True) + self.fileListWidget.blockSignals(True) + + self.combobox_ABS_system_choice.setCurrentText(stg.ABS_name[0]) + self.fileListWidget.addFilenames(stg.filename_BS_raw_data) + + self.fill_measurements_information_groupbox() + self.fill_table() + self.plot_backscattered_acoustic_signal_recording() + self.plot_profile() + self.update_frequency_combobox() + self.water_attenuation() + self.compute_tmin_tmax() + self.compute_rmin_rmax() + self.set_range_for_spinboxes_bathymetry() + + self.fileListWidget.blockSignals(False) + self.blockSignals(False) + def retranslate_acoustic_data_tab(self): self.groupbox_info.setTitle(_translate("CONSTANT_STRING", cs.MEASUREMENTS_INFORMATION)) diff --git a/View/acoustic_inversion_tab.py b/View/acoustic_inversion_tab.py index ec13ce3..b898c21 100644 --- a/View/acoustic_inversion_tab.py +++ b/View/acoustic_inversion_tab.py @@ -21,6 +21,7 @@ # -*- coding: utf-8 -*- import os +import logging import numpy as np import pandas as pd from math import isinf @@ -50,6 +51,7 @@ from Model.acoustic_inversion_method_high_concentration import AcousticInversion _translate = QCoreApplication.translate +logger = logging.getLogger("acoused") class AcousticInversionTab(QWidget): @@ -369,6 +371,14 @@ class AcousticInversionTab(QWidget): # ------------------------------------ Functions for Acoustic Inversion Tab ---------------------------------------- # ================================================================================================================== + def full_update(self): + logger.debug(f"{__name__}: Update") + self.blockSignals(True) + + # TODO: Update all widgets + + self.blockSignals(False) + def update_acoustic_data_choice(self): self.combobox_acoustic_data_choice.clear() diff --git a/View/note_tab.py b/View/note_tab.py index 62b2251..019d835 100644 --- a/View/note_tab.py +++ b/View/note_tab.py @@ -1,3 +1,5 @@ +import logging + from PyQt5.QtWidgets import ( QApplication, QWidget, QVBoxLayout, QHBoxLayout, QTextEdit, QPushButton, QSpacerItem, QSpinBox, @@ -8,6 +10,8 @@ from PyQt5.QtCore import Qt import settings as stg +logger = logging.getLogger("acoused") + class NoteTab(QWidget): ''' This class generates a enhanced notepad in Note Tab ''' @@ -130,6 +134,14 @@ class NoteTab(QWidget): ## ------------------------------- + def full_update(self): + logger.debug(f"{__name__}: Update") + self.blockSignals(True) + + # TODO: Update all widgets + + self.blockSignals(False) + # def new_text(self): # window = self.ui_mainwindow.tab5 # window.show() diff --git a/View/sample_data_tab.py b/View/sample_data_tab.py index 85cb76f..d8400b8 100644 --- a/View/sample_data_tab.py +++ b/View/sample_data_tab.py @@ -272,6 +272,17 @@ class SampleDataTab(QWidget): self.groupbox_plot_PSD.setTitle(_translate("CONSTANT_STRING", cs.DISTRIBUTION_PLOT)) + def full_update(self): + logger.debug(f"{__name__}: Update") + self.blockSignals(True) + + self.fill_comboboxes_and_plot_transect() + self.lineEdit_fine_sediment.setText(stg.filename_fine) + self.lineEdit_fine_sediment.setToolTip(stg.path_fine) + self.fill_table_fine() + + self.blockSignals(False) + def last_opened_file_path(self, priority="sand"): lst = [] diff --git a/View/sediment_calibration_tab.py b/View/sediment_calibration_tab.py index 19bf440..7f8b07e 100644 --- a/View/sediment_calibration_tab.py +++ b/View/sediment_calibration_tab.py @@ -857,6 +857,14 @@ class SedimentCalibrationTab(QWidget): # ----------------------------------- Functions for Signal processing Tab -------------------------------------- # ============================================================================================================== + def full_update(self): + logger.debug(f"{__name__}: Update") + self.blockSignals(True) + + # TODO: Update all widgets + + self.blockSignals(False) + def function_pushbutton_update_acoustic_file(self): if len(stg.data_preprocessed) == 0: return diff --git a/View/signal_processing_tab.py b/View/signal_processing_tab.py index f845f0b..5182c46 100644 --- a/View/signal_processing_tab.py +++ b/View/signal_processing_tab.py @@ -516,6 +516,19 @@ class SignalProcessingTab(QWidget): # -------------------------------------------------------------------------------------------------------------- # -------------------------------------------------------------------------------------------------------------- + def full_update(self): + logger.debug(f"{__name__}: Update") + self.blockSignals(True) + self.combobox_acoustic_data_choice.blockSignals(True) + + self.combobox_acoustic_data_choice.addItems(stg.filename_BS_raw_data) + + # self.recompute() + # self.replot() + + self.combobox_acoustic_data_choice.blockSignals(False) + self.blockSignals(False) + def update_SignalPreprocessingTab(self): """ The tab is updated in two cases : diff --git a/View/user_manual_tab.py b/View/user_manual_tab.py index 48e909b..0775f12 100644 --- a/View/user_manual_tab.py +++ b/View/user_manual_tab.py @@ -27,5 +27,10 @@ class UserManualTab(QWidget): # self.label_picture_theory.resize(np.int(pic.width()/100), np.int(pic.height()/100)) # self.verticalLayout_main.addWidget(self.label_picture_theory) + def full_update(self): + logger.debug(f"{__name__}: Update") + self.blockSignals(True) + # TODO: Update all widgets + self.blockSignals(False) diff --git a/main.py b/main.py index 8e83357..93ff65f 100644 --- a/main.py +++ b/main.py @@ -95,6 +95,15 @@ class MainApplication(QMainWindow): # self.user_manual_tab = UserManualTab(self.ui_mainwindow.tab7) + self.tabs = [ + self.acoustic_data_tab, + # self.signal_processing_tab, + # self.sample_data_tab, + # self.sediment_calibration_tab, + # self.acoustic_inversion_tab, + # self.note_tab + ] + # ************************************************** # ---------------- Text File Error ----------------- @@ -108,14 +117,17 @@ class MainApplication(QMainWindow): # traceback.TracebackException.from_exception(e).print(file=sortie) def open_study_update_tabs(self): - self.acoustic_data_tab.combobox_ABS_system_choice.setCurrentText(stg.ABS_name[0]) - self.acoustic_data_tab.fileListWidget.addFilenames(stg.filename_BS_raw_data) + for tab in self.tabs: + tab.full_update() - self.signal_processing_tab.combobox_acoustic_data_choice.addItems(stg.filename_BS_raw_data) + # self.acoustic_data_tab.combobox_ABS_system_choice.setCurrentText(stg.ABS_name[0]) + # self.acoustic_data_tab.fileListWidget.addFilenames(stg.filename_BS_raw_data) - self.sample_data_tab.fill_comboboxes_and_plot_transect() - self.sample_data_tab.lineEdit_fine_sediment.setText(stg.filename_fine) - self.sample_data_tab.lineEdit_fine_sediment.setToolTip(stg.path_fine) + # self.signal_processing_tab.combobox_acoustic_data_choice.addItems(stg.filename_BS_raw_data) + + # self.sample_data_tab.fill_comboboxes_and_plot_transect() + # self.sample_data_tab.lineEdit_fine_sediment.setText(stg.filename_fine) + # self.sample_data_tab.lineEdit_fine_sediment.setToolTip(stg.path_fine) # self.sample_data_tab.fill_table_fine() if __name__ == '__main__': From 0cd9964594041797410e86e0839c8c796fb8d1c8 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 13:50:13 +0100 Subject: [PATCH 05/16] Signal processing: Fix open study file crash. --- Model/read_table_for_open.py | 46 ++++++++++++++++++++--------------- View/acoustic_data_tab.py | 4 +-- View/signal_processing_tab.py | 23 ++++++++++++------ main.py | 2 +- 4 files changed, 45 insertions(+), 30 deletions(-) diff --git a/Model/read_table_for_open.py b/Model/read_table_for_open.py index 60cf2d5..2729db0 100644 --- a/Model/read_table_for_open.py +++ b/Model/read_table_for_open.py @@ -107,18 +107,18 @@ class ReadTableForOpen: FROM AcousticFile WHERE (acoustic_data = {k}) ''' - data = self.execute(query) + data = self.execute(query)[0] print("data acoustic file", data) stg.filename_BS_raw_data.append( - [str(y[1]) + '.aqa' for y in data][0] + str(data[1]) + '.aqa' ) - stg.ABS_name.append([z[2] for z in data][0]) - stg.path_BS_noise_data.append([z[3] for z in data][0]) - stg.filename_BS_noise_data.append([z[4] for z in data][0]) - stg.noise_method.append([z[5] for z in data][0]) - stg.noise_value.append([z[6] for z in data][0]) - stg.data_preprocessed.append([z[7] for z in data][0]) + stg.ABS_name.append(data[2]) + stg.path_BS_noise_data.append(data[3]) + stg.filename_BS_noise_data.append(data[4]) + stg.noise_method.append(data[5]) + stg.noise_value.append(data[6]) + stg.data_preprocessed.append(data[7]) logger.debug("data acoustic file:") logger.debug(f"- {stg.filename_BS_raw_data}") @@ -370,6 +370,7 @@ class ReadTableForOpen: stg.time_noise.append(np.array([])) stg.depth_noise.append(np.array([])) stg.BS_noise_raw_data.append(np.array([])) + stg.BS_noise_averaged_data.append(np.array([])) else: stg.time_noise.append( np_f64_parse(time).reshape( @@ -390,6 +391,7 @@ class ReadTableForOpen: ) ) ) + stg.BS_noise_averaged_data.append(np.array([])) def read_table_BS_raw_data_SNR(self, query, i): np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) @@ -406,9 +408,11 @@ class ReadTableForOpen: SNR_vars = [ (stg.SNR_raw_data, stg.BS_raw_data), (stg.SNR_cross_section, stg.BS_cross_section), - (stg.SNR_cross_section, stg.BS_stream_bed), + (stg.SNR_stream_bed, stg.BS_stream_bed), ] + stg.SNR_stream_bed.append(np.array([])) + for dest, resh in SNR_vars: SNR = np_f64_parse(next(it)) @@ -417,7 +421,6 @@ class ReadTableForOpen: else: dest.append(SNR.reshape(resh[i].shape)) - def read_table_BS_raw_data_rest(self, query, i): np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) data = self.execute( @@ -481,16 +484,21 @@ class ReadTableForOpen: WHERE (acoustic_data = {s}) ''' - data3 = self.execute(query3) + data = self.execute(query3) + x = data[0] - stg.temperature = [x[1] for x in data3][0] - stg.tmin.append([(x[2], x[3]) for x in data3]) - stg.tmax.append([(x[4], x[5]) for x in data3]) - stg.rmin.append([(x[6], x[7]) for x in data3]) - stg.rmax.append([(x[8], x[9]) for x in data3]) - stg.freq_bottom_detection.append([(x[10], x[11]) for x in data3]) - stg.SNR_filter_value.append([x[12] for x in data3]) - stg.Nb_cells_to_average_BS_signal.append([x[13] for x in data3]) + stg.temperature = [x[1]][0] + stg.tmin.append((x[2], x[3])) + stg.tmax.append((x[4], x[5])) + stg.rmin.append((x[6], x[7])) + stg.rmax.append((x[8], x[9])) + stg.freq_bottom_detection.append((x[10], x[11])) + stg.SNR_filter_value.append(x[12]) + stg.Nb_cells_to_average_BS_signal.append(x[13]) + + logger.debug(f"stg.tmin: {stg.tmin}") + logger.debug(f"stg.tmin: {stg.tmax}") + logger.debug(f"stg.SNR_filter_value: {stg.SNR_filter_value}") def read_table_sediment_file(self): query = f''' diff --git a/View/acoustic_data_tab.py b/View/acoustic_data_tab.py index 0100bee..9794129 100644 --- a/View/acoustic_data_tab.py +++ b/View/acoustic_data_tab.py @@ -1653,9 +1653,9 @@ class AcousticDataTab(QWidget): stg.gain_tx.append(acoustic_data._gain_tx) stg.water_attenuation.append([]) - # --- The other acoustic variables lists are filled with empty object. --- - # --- They will be used for pre- and post-processing --- + self.initiate_setting_parameters_new_others() + def initiate_setting_parameters_new_others(self): stg.BS_cross_section.append(np.array([])) stg.depth_cross_section.append(np.array([])) stg.time_cross_section.append(np.array([])) diff --git a/View/signal_processing_tab.py b/View/signal_processing_tab.py index 5182c46..753ef46 100644 --- a/View/signal_processing_tab.py +++ b/View/signal_processing_tab.py @@ -521,15 +521,12 @@ class SignalProcessingTab(QWidget): self.blockSignals(True) self.combobox_acoustic_data_choice.blockSignals(True) - self.combobox_acoustic_data_choice.addItems(stg.filename_BS_raw_data) - - # self.recompute() - # self.replot() + self.update_SignalPreprocessingTab(recompute=True) self.combobox_acoustic_data_choice.blockSignals(False) self.blockSignals(False) - def update_SignalPreprocessingTab(self): + def update_SignalPreprocessingTab(self, recompute=True): """ 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 @@ -567,7 +564,9 @@ class SignalProcessingTab(QWidget): stg.freq_text[data_id] ) - self.recompute() + if recompute: + self.recompute() + self.replot() logger.debug("Update the Signal preprocessing tab... Done") @@ -795,9 +794,17 @@ class SignalProcessingTab(QWidget): self.compute_average_profile_tail() - self.lineEdit_SNR_criterion.setText(str(stg.SNR_filter_value[self.combobox_acoustic_data_choice.currentIndex()])) + self.lineEdit_SNR_criterion.setText( + str(stg.SNR_filter_value[ + self.combobox_acoustic_data_choice.currentIndex() + ]) + ) - self.lineEdit_horizontal_average.setText(str(stg.Nb_cells_to_average_BS_signal[self.combobox_acoustic_data_choice.currentIndex()])) + self.lineEdit_horizontal_average.setText( + str(stg.Nb_cells_to_average_BS_signal[ + self.combobox_acoustic_data_choice.currentIndex() + ]) + ) self.combobox_frequency_profile.clear() self.combobox_frequency_profile.addItems( diff --git a/main.py b/main.py index 93ff65f..74587f7 100644 --- a/main.py +++ b/main.py @@ -97,7 +97,7 @@ class MainApplication(QMainWindow): self.tabs = [ self.acoustic_data_tab, - # self.signal_processing_tab, + self.signal_processing_tab, # self.sample_data_tab, # self.sediment_calibration_tab, # self.acoustic_inversion_tab, From 41132afa90f19b219ac03ab018e4c6c2053fe6d4 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 14:48:38 +0100 Subject: [PATCH 06/16] Sample Data: Fix open study. --- View/sample_data_tab.py | 21 ++++++++++++--------- main.py | 2 +- 2 files changed, 13 insertions(+), 10 deletions(-) diff --git a/View/sample_data_tab.py b/View/sample_data_tab.py index d8400b8..cf9128f 100644 --- a/View/sample_data_tab.py +++ b/View/sample_data_tab.py @@ -271,7 +271,6 @@ class SampleDataTab(QWidget): self.groupbox_plot_PSD.setTitle(_translate("CONSTANT_STRING", cs.DISTRIBUTION_PLOT)) - def full_update(self): logger.debug(f"{__name__}: Update") self.blockSignals(True) @@ -281,6 +280,10 @@ class SampleDataTab(QWidget): self.lineEdit_fine_sediment.setToolTip(stg.path_fine) self.fill_table_fine() + self.lineEdit_sand_sediment.setText(stg.filename_sand) + self.lineEdit_sand_sediment.setToolTip(stg.path_sand) + self.fill_table_sand() + self.blockSignals(False) def last_opened_file_path(self, priority="sand"): @@ -407,7 +410,7 @@ class SampleDataTab(QWidget): horizontal_header = list( itertools.chain( ["Color", "Sample"], - list(map(str, stg.columns_fine[[0, 2]])), + [str(stg.columns_fine[0]), str(stg.columns_fine[2])], list(map(str, stg.columns_fine[3:])) ) ) @@ -506,7 +509,7 @@ class SampleDataTab(QWidget): horizontal_header = list( itertools.chain( ["Color", "Sample"], - list(map(str, stg.columns_sand[[0, 2]])), + [str(stg.columns_fine[0]), str(stg.columns_fine[2])], list(map(str, stg.columns_sand[3:])) ) ) @@ -1009,7 +1012,7 @@ class SampleDataTab(QWidget): self.axis_plot_sample_position_on_transect.text( 1, .85, stg.freq_text[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()], - fontsize=14, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5, + fontsize=14, fontweight='bold', fontname="DejaVu Sans", c="black", alpha=0.5, horizontalalignment='right', verticalalignment='bottom', transform=self.axis_plot_sample_position_on_transect.transAxes) @@ -1017,11 +1020,11 @@ class SampleDataTab(QWidget): self.axis_plot_sample_position_on_transect.tick_params(axis='both', labelsize=8) self.axis_plot_sample_position_on_transect.text(.98, .03, "Time (sec)", - fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9, + fontsize=10, fontweight='bold', fontname="DejaVu Sans", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='horizontal', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.text(.04, .53, "Depth (m)", - fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9, + fontsize=10, fontweight='bold', fontname="DejaVu Sans", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='vertical', transform=self.axis_plot_sample_position_on_transect.transAxes) @@ -1335,7 +1338,7 @@ class SampleDataTab(QWidget): self.axis_plot_sample_position_on_transect.text( 1, .85, stg.freq_text[self.combobox_acoustic_data.currentIndex()][self.combobox_frequencies.currentIndex()], - fontsize=14, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5, + fontsize=14, fontweight='bold', fontname="DejaVu Sans", c="black", alpha=0.5, horizontalalignment='right', verticalalignment='bottom', transform=self.axis_plot_sample_position_on_transect.transAxes) @@ -1343,13 +1346,13 @@ class SampleDataTab(QWidget): self.axis_plot_sample_position_on_transect.tick_params(axis='both', labelsize=8) self.axis_plot_sample_position_on_transect.text(.98, .03, "Time (sec)", - fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", + fontsize=10, fontweight='bold', fontname="DejaVu Sans", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='horizontal', transform=self.axis_plot_sample_position_on_transect.transAxes) self.axis_plot_sample_position_on_transect.text(.04, .53, "Depth (m)", - fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", + fontsize=10, fontweight='bold', fontname="DejaVu Sans", c="black", alpha=0.9, horizontalalignment='right', verticalalignment='bottom', rotation='vertical', diff --git a/main.py b/main.py index 74587f7..df670a7 100644 --- a/main.py +++ b/main.py @@ -98,7 +98,7 @@ class MainApplication(QMainWindow): self.tabs = [ self.acoustic_data_tab, self.signal_processing_tab, - # self.sample_data_tab, + self.sample_data_tab, # self.sediment_calibration_tab, # self.acoustic_inversion_tab, # self.note_tab From 19c2ae9b7f6c622782e44dfe9b128264a76e495c Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 15:40:30 +0100 Subject: [PATCH 07/16] Sediment calibration: Fix crash at open study file. --- Model/read_table_for_open.py | 32 +++++++++++++++++--------------- View/sediment_calibration_tab.py | 4 ---- main.py | 2 +- 3 files changed, 18 insertions(+), 20 deletions(-) diff --git a/Model/read_table_for_open.py b/Model/read_table_for_open.py index 2729db0..1cef2f8 100644 --- a/Model/read_table_for_open.py +++ b/Model/read_table_for_open.py @@ -159,8 +159,10 @@ class ReadTableForOpen: stg.water_attenuation.append( [x[4] for x in data1] ) - stg.kt_read.append([x[5] for x in data1]) + + stg.kt_read = [x[5] for x in data1] stg.kt_corrected = [x[6] for x in data1] + stg.nb_profiles.append([x[7] for x in data1]) stg.nb_profiles_per_sec.append([x[8] for x in data1]) stg.nb_cells.append([x[9] for x in data1]) @@ -176,20 +178,20 @@ class ReadTableForOpen: stg.gain_tx.append([x[15] for x in data1]) logger.debug("measure:") - logger.debug(f"- {stg.acoustic_data}") - logger.debug(f"- {stg.freq}") - logger.debug(f"- {stg.water_attenuation}") - logger.debug(f"- {stg.kt_read}") - logger.debug(f"- {stg.kt_corrected}") - logger.debug(f"- {stg.nb_profiles}") - logger.debug(f"- {stg.nb_profiles_per_sec}") - logger.debug(f"- {stg.nb_cells}") - logger.debug(f"- {stg.cell_size}") - logger.debug(f"- {stg.pulse_length}") - logger.debug(f"- {stg.nb_pings_per_sec}") - logger.debug(f"- {stg.nb_pings_averaged_per_profile}") - logger.debug(f"- {stg.gain_rx}") - logger.debug(f"- {stg.gain_tx}") + logger.debug(f"- stg.acoustic_data: {stg.acoustic_data}") + logger.debug(f"- stg.freq {stg.freq}") + logger.debug(f"- stg.water_attenuation {stg.water_attenuation}") + logger.debug(f"- stg.kt_read {stg.kt_read}") + logger.debug(f"- stg.kt_corrected {stg.kt_corrected}") + logger.debug(f"- stg.nb_profiles {stg.nb_profiles}") + logger.debug(f"- stg.nb_profiles_per_sec {stg.nb_profiles_per_sec}") + logger.debug(f"- stg.nb_cells {stg.nb_cells}") + logger.debug(f"- stg.cell_size {stg.cell_size}") + logger.debug(f"- stg.pulse_length {stg.pulse_length}") + logger.debug(f"- stg.nb_pings_per_sec {stg.nb_pings_per_sec}") + logger.debug(f"- stg.nb_pings_averaged_per_profile {stg.nb_pings_averaged_per_profile}") + logger.debug(f"- stg.gain_rx {stg.gain_rx}") + logger.debug(f"- stg.gain_tx {stg.gain_tx}") logger.debug(f"- {stg.date}") logger.debug(f"- {stg.hour}") diff --git a/View/sediment_calibration_tab.py b/View/sediment_calibration_tab.py index 7f8b07e..6fab038 100644 --- a/View/sediment_calibration_tab.py +++ b/View/sediment_calibration_tab.py @@ -1784,10 +1784,6 @@ class SedimentCalibrationTab(QWidget): ) def update_label_kt_value_for_calibration(self): - print("self.combobox_freq1.currentIndex() ", - self.combobox_freq1.currentIndex(), - self.combobox_freq1.currentText()) - freq_1 = self.combobox_freq1.currentIndex() freq_2 = self.combobox_freq2.currentIndex() diff --git a/main.py b/main.py index df670a7..9d756ff 100644 --- a/main.py +++ b/main.py @@ -99,7 +99,7 @@ class MainApplication(QMainWindow): self.acoustic_data_tab, self.signal_processing_tab, self.sample_data_tab, - # self.sediment_calibration_tab, + self.sediment_calibration_tab, # self.acoustic_inversion_tab, # self.note_tab ] From 81221525de268840386d7eb4fdaa75eb3fc33baf Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 16:10:33 +0100 Subject: [PATCH 08/16] Acoustic inversion: Fix crash at open study. --- View/sediment_calibration_tab.py | 2 +- main.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/View/sediment_calibration_tab.py b/View/sediment_calibration_tab.py index 6fab038..7d4c8ea 100644 --- a/View/sediment_calibration_tab.py +++ b/View/sediment_calibration_tab.py @@ -861,7 +861,7 @@ class SedimentCalibrationTab(QWidget): logger.debug(f"{__name__}: Update") self.blockSignals(True) - # TODO: Update all widgets + self.function_pushbutton_update_acoustic_file() self.blockSignals(False) diff --git a/main.py b/main.py index 9d756ff..51fa980 100644 --- a/main.py +++ b/main.py @@ -100,8 +100,8 @@ class MainApplication(QMainWindow): self.signal_processing_tab, self.sample_data_tab, self.sediment_calibration_tab, - # self.acoustic_inversion_tab, - # self.note_tab + self.acoustic_inversion_tab, + self.note_tab ] # ************************************************** From 943f768720f45f16b19150bca0f437f7cb1741f4 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 17:16:04 +0100 Subject: [PATCH 09/16] Model: Create table: Fix table definition. --- Model/create_table_for_save_as.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Model/create_table_for_save_as.py b/Model/create_table_for_save_as.py index 55866a9..5ec91a0 100644 --- a/Model/create_table_for_save_as.py +++ b/Model/create_table_for_save_as.py @@ -80,8 +80,8 @@ class CreateTableForSaveAs: time BLOB, depth BLOB, BS_raw_data BLOB, time_reshape BLOB, depth_reshape BLOB, BS_raw_data_reshape BLOB, time_cross_section BLOB, depth_cross_section BLOB, - BS_cross_section BLOB, BS_stream_bed BLO B, - depth_bottom, val_bottom, ind_bottom, + BS_cross_section BLOB, BS_stream_bed BLOB, + depth_bottom BLOB, val_bottom BLOB, ind_bottom BLOB, time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB, SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB, BS_raw_data_pre_process_SNR BLOB, From 74137405fc3a5299cc4923b7963b58b8b630812e Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Mon, 24 Mar 2025 17:37:54 +0100 Subject: [PATCH 10/16] Signal processing: Complete missing data at open study. --- View/signal_processing_tab.py | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/View/signal_processing_tab.py b/View/signal_processing_tab.py index 753ef46..07f7aad 100644 --- a/View/signal_processing_tab.py +++ b/View/signal_processing_tab.py @@ -509,23 +509,32 @@ class SignalProcessingTab(QWidget): self.icon_clear = QIcon(path_icon("clear.png")) self.icon_apply = QIcon(path_icon("circle_green_arrow_right.png")) - - # -------------------------------------------------------------------------------------------------------------- - # -------------------------------------------------------------------------------------------------------------- - # +++++++++ FUNCTION +++++++++ - # -------------------------------------------------------------------------------------------------------------- - # -------------------------------------------------------------------------------------------------------------- - def full_update(self): logger.debug(f"{__name__}: Update") self.blockSignals(True) self.combobox_acoustic_data_choice.blockSignals(True) + self.full_update_fill_text() self.update_SignalPreprocessingTab(recompute=True) self.combobox_acoustic_data_choice.blockSignals(False) self.blockSignals(False) + def full_update_fill_text(self): + data_id = self.combobox_acoustic_data_choice.currentIndex() + + self.lineEdit_profile_tail_value.setText( + str(stg.noise_value[data_id]) + ) + + self.lineEdit_SNR_criterion.setText( + str(stg.SNR_filter_value[data_id]) + ) + + self.lineEdit_horizontal_average.setText( + str(stg.Nb_cells_to_average_BS_signal[data_id]) + ) + def update_SignalPreprocessingTab(self, recompute=True): """ The tab is updated in two cases : From 5f7c81f8664fc5257c0901cc39b404525dee46fd Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Tue, 25 Mar 2025 10:03:41 +0100 Subject: [PATCH 11/16] Signal processing: Fix #42. --- View/signal_processing_tab.py | 474 +++++++++++++++------------------- 1 file changed, 205 insertions(+), 269 deletions(-) diff --git a/View/signal_processing_tab.py b/View/signal_processing_tab.py index 07f7aad..df211c3 100644 --- a/View/signal_processing_tab.py +++ b/View/signal_processing_tab.py @@ -515,7 +515,7 @@ class SignalProcessingTab(QWidget): self.combobox_acoustic_data_choice.blockSignals(True) self.full_update_fill_text() - self.update_SignalPreprocessingTab(recompute=True) + self.update_SignalPreprocessingTab() self.combobox_acoustic_data_choice.blockSignals(False) self.blockSignals(False) @@ -535,7 +535,7 @@ class SignalProcessingTab(QWidget): str(stg.Nb_cells_to_average_BS_signal[data_id]) ) - def update_SignalPreprocessingTab(self, recompute=True): + 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 @@ -573,9 +573,7 @@ class SignalProcessingTab(QWidget): stg.freq_text[data_id] ) - if recompute: - self.recompute() - + self.recompute() self.replot() logger.debug("Update the Signal preprocessing tab... Done") @@ -583,6 +581,33 @@ class SignalProcessingTab(QWidget): self.combobox_freq_noise_from_profile_tail.blockSignals(False) self.combobox_acoustic_data_choice.blockSignals(False) + def _is_correct_shape(self, data): + data_id = self.combobox_acoustic_data_choice.currentIndex() + + if stg.time_cross_section[data_id].shape != (0,): + x_time = stg.time_cross_section[data_id] + else: + x_time = stg.time[data_id] + + if stg.depth_cross_section[data_id].shape != (0,): + y_depth = stg.depth_cross_section[data_id] + else: + y_depth = stg.depth[data_id] + + time_shape, = x_time[data_id].shape + depth_shape, = y_depth[data_id].shape + + logger.debug(f"_is_correct_shape: time shape: {time_shape}") + logger.debug(f"_is_correct_shape: depth shape: {depth_shape}") + logger.debug(f"_is_correct_shape: data shape: {data[data_id].shape}") + + if data[data_id].shape == (0,): + return False + + _, y, z = data[data_id].shape + + return (y == depth_shape and z == time_shape) + def recompute(self): data_id = self.combobox_acoustic_data_choice.currentIndex() @@ -835,28 +860,29 @@ class SignalProcessingTab(QWidget): if len(stg.filename_BS_raw_data) == 0: pass else: + data_id = self.combobox_acoustic_data_choice.currentIndex() - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.SNR_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.time_noise[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.SNR_filter_value[self.combobox_acoustic_data_choice.currentIndex()] = 0 + stg.BS_noise_raw_data[data_id] = np.array([]) + stg.BS_noise_averaged_data[data_id] = np.array([]) + stg.SNR_raw_data[data_id] = np.array([]) + stg.SNR_cross_section[data_id] = np.array([]) + stg.SNR_stream_bed[data_id] = np.array([]) + stg.time_noise[data_id] = np.array([]) + stg.SNR_filter_value[data_id] = 0 - stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) + stg.BS_raw_data_pre_process_SNR[data_id] = np.array([]) + stg.BS_raw_data_pre_process_average[data_id] = np.array([]) - stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) + stg.BS_cross_section_pre_process_SNR[data_id] = np.array([]) + stg.BS_cross_section_pre_process_average[data_id] = np.array([]) - stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - print("stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()]", stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()]) - if stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 0: + stg.BS_stream_bed_pre_process_SNR[data_id] = np.array([]) + stg.BS_stream_bed_pre_process_average[data_id] = np.array([]) + print("stg.noise_method[data_id]", stg.noise_method[data_id]) + if stg.noise_method[data_id] == 0: self.lineEdit_noise_file.clear() - elif stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 1: + elif stg.noise_method[data_id] == 1: self.lineEdit_val1.clear() self.lineEdit_val1.setText("0.00") @@ -973,136 +999,140 @@ class SignalProcessingTab(QWidget): def load_noise_data_and_compute_SNR(self): + data_id = self.combobox_acoustic_data_choice.currentIndex() - stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] = 0 + stg.noise_method[data_id] = 0 - noise_data = AcousticDataLoader(stg.path_BS_noise_data[self.combobox_acoustic_data_choice.currentIndex()] + + noise_data = AcousticDataLoader(stg.path_BS_noise_data[data_id] + "/" + - stg.filename_BS_noise_data[self.combobox_acoustic_data_choice.currentIndex()]) - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = noise_data._BS_raw_data + stg.filename_BS_noise_data[data_id]) + stg.BS_noise_raw_data[data_id] = noise_data._BS_raw_data - stg.time_noise[self.combobox_acoustic_data_choice.currentIndex()] = noise_data._time - stg.depth_noise[self.combobox_acoustic_data_choice.currentIndex()] = noise_data._r + stg.time_noise[data_id] = noise_data._time + stg.depth_noise[data_id] = noise_data._r - if stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): + if stg.BS_stream_bed[data_id].shape != (0,): - noise = np.zeros(stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape) + noise = np.zeros(stg.BS_stream_bed[data_id].shape) for f, _ in enumerate(noise_data._freq): noise[f, :, :] = np.mean( - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()][f, :, :], axis=(0, 1)) - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = noise - stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.divide((stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()] - - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()]) ** 2, - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] ** 2)) + stg.BS_noise_raw_data[data_id][f, :, :], axis=(0, 1)) + stg.BS_noise_averaged_data[data_id] = noise + stg.SNR_stream_bed[data_id] = ( + np.divide((stg.BS_stream_bed[data_id] - + stg.BS_noise_averaged_data[data_id]) ** 2, + stg.BS_noise_averaged_data[data_id] ** 2)) - elif stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): + elif stg.BS_cross_section[data_id].shape != (0,): - noise = np.zeros(stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape) + noise = np.zeros(stg.BS_cross_section[data_id].shape) for f, _ in enumerate(noise_data._freq): noise[f, :, :] = np.mean( - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()][f, :, :], axis=(0, 1)) - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = noise - stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.divide((stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()] - - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()]) ** 2, - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] ** 2)) + stg.BS_noise_raw_data[data_id][f, :, :], axis=(0, 1)) + stg.BS_noise_averaged_data[data_id] = noise + stg.SNR_cross_section[data_id] = ( + np.divide((stg.BS_cross_section[data_id] - + stg.BS_noise_averaged_data[data_id]) ** 2, + stg.BS_noise_averaged_data[data_id] ** 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: - noise = np.zeros(stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()].shape) + noise = np.zeros(stg.BS_raw_data[data_id].shape) for f, _ in enumerate(noise_data._freq): noise[f, :, :] = np.mean( - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()][f, :, :], axis=(0, 1)) - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = noise - stg.SNR_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.divide((stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()] - - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()]) ** 2, - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] ** 2)) + stg.BS_noise_raw_data[data_id][f, :, :], axis=(0, 1)) + stg.BS_noise_averaged_data[data_id] = noise + stg.SNR_raw_data[data_id] = ( + np.divide((stg.BS_raw_data[data_id] - + stg.BS_noise_averaged_data[data_id]) ** 2, + stg.BS_noise_averaged_data[data_id] ** 2)) def open_plot_noise_window(self): pnw = PlotNoiseWindow() pnw.exec() def compute_noise_from_profile_tail_value(self): + data_id = self.combobox_acoustic_data_choice.currentIndex() - stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] = 1 + stg.noise_method[data_id] = 1 + stg.noise_value[data_id] = ( + float(self.lineEdit_profile_tail_value.text().replace(",", ".")) + ) - stg.noise_value[self.combobox_acoustic_data_choice.currentIndex()] = ( - float(self.lineEdit_profile_tail_value.text().replace(",", "."))) - - if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - stg.time_noise[self.combobox_acoustic_data_choice.currentIndex()] = ( - stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()]) + if stg.time_cross_section[data_id].shape != (0,): + stg.time_noise[data_id] = ( + stg.time_cross_section[data_id] + ) else: - stg.time_noise[self.combobox_acoustic_data_choice.currentIndex()] = ( - stg.time[self.combobox_acoustic_data_choice.currentIndex()]) - if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - stg.depth_noise[self.combobox_acoustic_data_choice.currentIndex()] = ( - stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()]) + stg.time_noise[data_id] = ( + stg.time[data_id] + ) + if stg.depth_cross_section[data_id].shape != (0,): + stg.depth_noise[data_id] = ( + stg.depth_cross_section[data_id] + ) else: - stg.depth_noise[self.combobox_acoustic_data_choice.currentIndex()] = ( - stg.depth[self.combobox_acoustic_data_choice.currentIndex()]) + stg.depth_noise[data_id] = ( + stg.depth[data_id] + ) # --- Compute noise from value and compute SNR --- - - if stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.full(stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape, + if self._is_correct_shape(stg.BS_stream_bed): + stg.BS_noise_raw_data[data_id] = np.array([]) + stg.BS_noise_raw_data[data_id] = ( + np.full(stg.BS_stream_bed[data_id].shape, float(self.lineEdit_profile_tail_value.text().replace(",", ".")))) - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()][:, :, - :stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape[2]]) - stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.divide((stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()] - - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()]) ** 2, - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] ** 2)) + stg.BS_noise_averaged_data[data_id] = ( + stg.BS_noise_raw_data[data_id][:, :, + :stg.BS_stream_bed[data_id].shape[2]]) + stg.SNR_stream_bed[data_id] = ( + np.divide((stg.BS_stream_bed[data_id] + - stg.BS_noise_raw_data[data_id]) ** 2, + stg.BS_noise_raw_data[data_id] ** 2)) - elif stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.full(stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape, + elif self._is_correct_shape(stg.BS_cross_section): + stg.BS_noise_raw_data[data_id] = ( + np.full(stg.BS_cross_section[data_id].shape, float(self.lineEdit_profile_tail_value.text().replace(",", ".")))) - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()][:, :, - :stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape[2]]) - stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.divide((stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()] - - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()]) ** 2, - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] ** 2)) # + stg.BS_noise_averaged_data[data_id] = ( + stg.BS_noise_raw_data[data_id][:, :, + :stg.BS_cross_section[data_id].shape[2]]) + stg.SNR_cross_section[data_id] = ( + np.divide((stg.BS_cross_section[data_id] + - stg.BS_noise_raw_data[data_id]) ** 2, + stg.BS_noise_raw_data[data_id] ** 2)) # else: - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.full(stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()].shape, + stg.BS_noise_raw_data[data_id] = ( + np.full(stg.BS_raw_data[data_id].shape, float(self.lineEdit_profile_tail_value.text().replace(",", ".")))) - stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()]) - stg.SNR_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = ( - np.divide((stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()] - - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()]) ** 2, - stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] ** 2)) + stg.BS_noise_averaged_data[data_id] = ( + stg.BS_noise_raw_data[data_id]) + stg.SNR_raw_data[data_id] = ( + np.divide((stg.BS_raw_data[data_id] + - stg.BS_noise_raw_data[data_id]) ** 2, + stg.BS_noise_raw_data[data_id] ** 2)) self.combobox_frequency_profile.clear() self.combobox_frequency_profile.addItems( - [f for f in stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()]]) + [f for f in stg.freq_text[data_id]]) # --- Trigger graphic widgets --- - if stg.SNR_filter_value[self.combobox_acoustic_data_choice.currentIndex()] == 0: + if stg.SNR_filter_value[data_id] == 0: self.lineEdit_SNR_criterion.setText("0.00") else: - self.lineEdit_SNR_criterion.setText(str(stg.SNR_filter_value[self.combobox_acoustic_data_choice.currentIndex()])) + self.lineEdit_SNR_criterion.setText(str(stg.SNR_filter_value[data_id])) - if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - self.slider.setMaximum(stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape[1]) + if stg.time_cross_section[data_id].shape != (0,): + self.slider.setMaximum(stg.time_cross_section[data_id].shape[1]) else: - self.slider.setMaximum(stg.time[self.combobox_acoustic_data_choice.currentIndex()].shape[1]) + self.slider.setMaximum(stg.time[data_id].shape[1]) # self.activate_list_of_pre_processed_data() @@ -1150,14 +1180,17 @@ class SignalProcessingTab(QWidget): # elif self.canvas_SNR == None: else: + data_id = self.combobox_acoustic_data_choice.currentIndex() - if ((self.combobox_acoustic_data_choice.currentIndex() != -1) - and (stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): - + if ((data_id != -1) + and (stg.BS_noise_raw_data[data_id].shape != (0,))): self.verticalLayout_groupbox_plot_SNR.removeWidget(self.toolbar_SNR) self.verticalLayout_groupbox_plot_SNR.removeWidget(self.scroll_SNR) - self.fig_SNR, self.axis_SNR = plt.subplots(nrows=stg.freq[self.combobox_acoustic_data_choice.currentIndex()].shape[0], ncols=1, sharex=True, sharey=False, layout='constrained') + self.fig_SNR, self.axis_SNR = plt.subplots( + nrows=stg.freq[data_id].shape[0], ncols=1, + sharex=True, sharey=False, layout='constrained' + ) self.canvas_SNR = FigureCanvas(self.fig_SNR) self.toolbar_SNR = NavigationToolBar(self.canvas_SNR, self) @@ -1166,158 +1199,82 @@ class SignalProcessingTab(QWidget): self.verticalLayout_groupbox_plot_SNR.addWidget(self.toolbar_SNR) self.verticalLayout_groupbox_plot_SNR.addWidget(self.scroll_SNR) - for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]): - - if stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - else: - - if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - val_min = np.nanmin(stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()][f, :, :]) - val_max = np.nanmax(stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()][f, :, :]) - if val_min == val_max: - levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1.2] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) - else: - if val_min == 0: - val_min = 1e-5 - if val_max > 1000: - levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1.2] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) - else: - levels = np.array([00.1, 1, 2, 10, 100, 1000, val_max * 1000 + 1]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1000 + 1] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) - - cf = (self.axis_SNR[f].contourf(x, -y, - stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()][f, :, :], - levels, cmap='gist_rainbow', - norm=norm)) - - elif stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - else: - - if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - x, y = np.meshgrid( - stg.time[self.combobox_acoustic_data_choice.currentIndex()][f, :], - stg.depth[self.combobox_acoustic_data_choice.currentIndex()][f, :]) - - val_min = np.nanmin(stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :, :]) - val_max = np.nanmax(stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, :, :]) - if val_min == val_max: - levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1.2] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) - else: - if val_min == 0: - val_min = 1e-5 - if val_max > 1000: - levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1.2] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) - - else: - levels = np.array([00.1, 1, 2, 10, 100, 1000, val_max * 1000 + 1]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1000 + 1] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) - - cf = (self.axis_SNR[f].contourf(x, -y, - stg.SNR_cross_section[ - self.combobox_acoustic_data_choice.currentIndex()][f, :, :], - levels, cmap='gist_rainbow', norm=norm)) + for f, _ in enumerate(stg.freq[data_id]): + if stg.SNR_stream_bed[data_id].shape != (0,): + SNR_data = stg.SNR_stream_bed + elif stg.SNR_cross_section[data_id].shape != (0,): + SNR_data = stg.SNR_cross_section + if stg.time_cross_section[data_id].shape != (0,): + time_data = stg.time_cross_section else: + time_data = stg.time - x, y = np.meshgrid(stg.time[self.combobox_acoustic_data_choice.currentIndex()][0, :], - stg.depth[self.combobox_acoustic_data_choice.currentIndex()][0, :]) + if stg.depth_cross_section[data_id].shape != (0,): + depth_data = stg.depth_cross_section + elif stg.depth[data_id].shape != (0,): + depth_data = stg.depth - val_min = np.nanmin(stg.SNR_raw_data[self.combobox_acoustic_data_choice.currentIndex()][f, :, :]) - val_max = np.nanmax(stg.SNR_raw_data[self.combobox_acoustic_data_choice.currentIndex()][f, :, :]) - if val_min == val_max: - levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1.2] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) + x, y = np.meshgrid( + time_data[data_id][f, :], + depth_data[data_id][f, :] + ) + + val_min = np.nanmin(SNR_data[data_id][f, :, :]) + val_max = np.nanmax(SNR_data[data_id][f, :, :]) + + levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) + bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1.2] + + if val_min != val_max: + if val_min == 0: + val_min = 1e-5 else: - if val_min == 0: - val_min = 1e-5 - if val_max > 1000: - levels = np.array([00.1, 1, 2, 10, 100, 1000, 1e6]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1.2] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) - else: - levels = np.array([00.1, 1, 2, 10, 100, 1000, val_max*1000 + 1]) - bounds = [00.1, 1, 2, 10, 100, 1000, val_max * 1000 + 1] - norm = BoundaryNorm(boundaries=bounds, ncolors=300) + levels = np.array( + [00.1, 1, 2, 10, 100, 1000, val_max * 1000 + 1] + ) + bounds = [ + 00.1, 1, 2, 10, 100, 1000, + val_max * 1000 + 1 + ] - cf = (self.axis_SNR[f].contourf(x, -y, - stg.SNR_raw_data[ - self.combobox_acoustic_data_choice.currentIndex()][f, :, :], - levels, cmap='gist_rainbow', norm=norm)) + norm = BoundaryNorm(boundaries=bounds, ncolors=300) + cf = self.axis_SNR[f].contourf( + x, -y, + SNR_data[data_id][f, :, :], + levels, cmap='gist_rainbow', + norm=norm + ) - self.axis_SNR[f].text(1, .70, stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()][f], - fontsize=14, fontweight='bold', fontname="DejaVu Sans", c="black", alpha=0.5, - horizontalalignment='right', verticalalignment='bottom', - transform=self.axis_SNR[f].transAxes) + self.axis_SNR[f].text( + 1, .70, stg.freq_text[data_id][f], + fontsize=14, fontweight='bold', fontname="DejaVu Sans", + 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$']) + 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() else: - self.verticalLayout_groupbox_plot_SNR.removeWidget(self.toolbar_SNR) self.verticalLayout_groupbox_plot_SNR.removeWidget(self.scroll_SNR) @@ -1439,9 +1396,6 @@ class SignalProcessingTab(QWidget): x_time = stg.time[data_id] y_depth = stg.depth[data_id] - logger.debug(f"x_time: {x_time[data_id].shape}") - logger.debug(f"y_depth: {y_depth[data_id].shape}") - for f, _ in enumerate(stg.freq[data_id]): if stg.BS_stream_bed_pre_process_average[data_id].shape != (0,): BS_data = stg.BS_stream_bed_pre_process_average @@ -1462,8 +1416,6 @@ class SignalProcessingTab(QWidget): elif stg.BS_raw_data[data_id].shape != (0,): BS_data = stg.BS_raw_data - logger.debug(f"BS_data: {BS_data[data_id].shape}") - val_min = np.nanmin( BS_data[data_id][f, :, :] ) @@ -1574,20 +1526,10 @@ class SignalProcessingTab(QWidget): ) ) - if stg.time_cross_section[data_id].shape != (0,): - if stg.depth_cross_section[data_id].shape != (0,): - x_time = stg.time_cross_section[data_id] - y_depth = stg.depth_cross_section[data_id] - elif stg.depth[data_id].shape != (0,): - x_time = stg.time_cross_section[data_id] - y_depth = stg.depth[data_id] - else: - if stg.depth_cross_section[data_id].shape != (0,): - x_time = stg.time[data_id] - y_depth = stg.depth_cross_section[data_id] - elif stg.depth[data_id].shape != (0,): - x_time = stg.time[data_id] - y_depth = stg.depth[data_id] + if stg.depth_cross_section[data_id].shape != (0,): + y_depth = stg.depth_cross_section[data_id] + elif stg.depth[data_id].shape != (0,): + y_depth = stg.depth[data_id] BS = [ stg.BS_stream_bed_pre_process_SNR, @@ -1607,11 +1549,6 @@ class SignalProcessingTab(QWidget): stg.BS_raw_data_pre_process_average, ] - time_shape, = x_time[data_id].shape - depth_shape, = y_depth[data_id].shape - logger.debug(f"time_shape: {time_shape}") - logger.debug(f"depth_shape: {depth_shape}") - BS_data = stg.BS_raw_data BS_data_ppa = stg.BS_raw_data_pre_process_average for i in range(len(BS)): @@ -1620,8 +1557,7 @@ class SignalProcessingTab(QWidget): if bs[data_id].shape == (0,): continue - x, y, z = bs[data_id].shape - if y == depth_shape and z == time_shape: + if self._is_correct_shape(bs): BS_data = bs BS_data_ppa = BS_ppa[i] break From 1351d7e5fca4e7bf55ee6054935581540923641b Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Tue, 25 Mar 2025 13:22:06 +0100 Subject: [PATCH 12/16] Sample data: Fix plot drawing at study open. --- View/sample_data_tab.py | 36 +++++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/View/sample_data_tab.py b/View/sample_data_tab.py index cf9128f..8697557 100644 --- a/View/sample_data_tab.py +++ b/View/sample_data_tab.py @@ -284,6 +284,10 @@ class SampleDataTab(QWidget): self.lineEdit_sand_sediment.setToolTip(stg.path_sand) self.fill_table_sand() + #self.plot_sample_position_on_transect() + self.plot_total_concentration() + self.plot_PSD_fine_and_sand_sediments() + self.blockSignals(False) def last_opened_file_path(self, priority="sand"): @@ -331,6 +335,10 @@ class SampleDataTab(QWidget): self.lineEdit_fine_sediment.setToolTip(stg.path_fine) self.fill_table_fine() + self.plot_sample_position_on_transect() + self.plot_total_concentration() + self.plot_PSD_fine_and_sand_sediments() + def open_dialog_box_sand_sediment(self): filename_sand_sediment = QFileDialog.getOpenFileName( self, "Sand sediment file", @@ -356,6 +364,10 @@ class SampleDataTab(QWidget): self.lineEdit_sand_sediment.setToolTip(stg.path_sand) self.fill_table_sand() + self.plot_sample_position_on_transect() + self.plot_total_concentration() + self.plot_PSD_fine_and_sand_sediments() + def load_fine_sediment_data(self): fine_granulo_data = GranuloLoader( os.path.join(stg.path_fine, stg.filename_fine) @@ -486,10 +498,6 @@ class SampleDataTab(QWidget): self.combobox_x_axis.currentIndexChanged.connect(self.plot_total_concentration) self.combobox_y_axis.currentIndexChanged.connect(self.plot_total_concentration) - self.plot_sample_position_on_transect() - self.plot_total_concentration() - self.plot_PSD_fine_and_sand_sediments() - self.tableWidget_fine.blockSignals(False) else: msgBox = QMessageBox() @@ -588,10 +596,6 @@ class SampleDataTab(QWidget): self.combobox_y_axis.currentIndexChanged\ .connect(self.plot_total_concentration) - self.plot_sample_position_on_transect() - self.plot_total_concentration() - self.plot_PSD_fine_and_sand_sediments() - self.tableWidget_sand.blockSignals(False) # --- Function to extract position of sample from table checkboxes to update plots --- @@ -752,13 +756,19 @@ class SampleDataTab(QWidget): self.combobox_acoustic_data.clear() for n, m in enumerate(stg.noise_method): if stg.noise_method[n] == 0: - self.combobox_acoustic_data.addItem(stg.filename_BS_raw_data[n]) - elif stg.noise_method[n]!=0: - self.combobox_acoustic_data.addItem(stg.data_preprocessed[n]) + self.combobox_acoustic_data\ + .addItem(stg.filename_BS_raw_data[n]) + elif stg.noise_method[n] != 0: + self.combobox_acoustic_data\ + .addItem(stg.data_preprocessed[n]) self.plot_sample_position_on_transect() - self.combobox_acoustic_data.currentIndexChanged.connect(self.update_plot_sample_position_on_transect) - self.combobox_frequencies.currentIndexChanged.connect(self.update_plot_sample_position_on_transect) + self.combobox_acoustic_data\ + .currentIndexChanged\ + .connect(self.update_plot_sample_position_on_transect) + self.combobox_frequencies\ + .currentIndexChanged\ + .connect(self.update_plot_sample_position_on_transect) def plot_sample_position_on_transect(self): self.verticalLayout_groupbox_plot_transect\ From 466cda0a3521cd4809d3bad12e8966a349e3961d Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Tue, 25 Mar 2025 13:46:28 +0100 Subject: [PATCH 13/16] Note: Disable note tab. --- View/note_tab.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/View/note_tab.py b/View/note_tab.py index 019d835..a5bf496 100644 --- a/View/note_tab.py +++ b/View/note_tab.py @@ -21,6 +21,9 @@ class NoteTab(QWidget): path_icon = "./icons/" + # FIXME: The note are disabled because there are never saved + widget_tab.setEnabled(False) + self.verticalLayout_main_note_tab = QVBoxLayout(widget_tab) self.horizontalLayout_toolbar = QHBoxLayout() From 5631a25b510a6611cf0ca0e6519919b85a5a74aa Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Tue, 25 Mar 2025 15:35:03 +0100 Subject: [PATCH 14/16] MainWindow: Minor change. --- View/mainwindow.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/View/mainwindow.py b/View/mainwindow.py index b1a87a2..d1fd9dc 100644 --- a/View/mainwindow.py +++ b/View/mainwindow.py @@ -21,6 +21,13 @@ # -*- coding: utf-8 -*- import os +import time +import pickle +import logging + +import numpy as np +import pandas as pd +from subprocess import Popen # Form implementation generated from reading ui file 'mainwindow.ui' # @@ -38,12 +45,7 @@ from Model.calibration_constant_kt import CalibrationConstantKt from View.about_window import AboutWindow import settings as stg -import numpy as np -import pandas as pd -from subprocess import Popen - -import time - +logger = logging.getLogger("acoused") class Ui_MainWindow(object): def setupUi(self, MainWindow): From 6dbd1e3e5cc00398b557f68234a59df2a7a92558 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Tue, 25 Mar 2025 16:07:25 +0100 Subject: [PATCH 15/16] Acoustic data: Fix temperature value at study open. --- Model/read_table_for_open.py | 1 + View/acoustic_data_tab.py | 50 +++++++++++++++++++++++------------- 2 files changed, 33 insertions(+), 18 deletions(-) diff --git a/Model/read_table_for_open.py b/Model/read_table_for_open.py index 1cef2f8..3516131 100644 --- a/Model/read_table_for_open.py +++ b/Model/read_table_for_open.py @@ -498,6 +498,7 @@ class ReadTableForOpen: stg.SNR_filter_value.append(x[12]) stg.Nb_cells_to_average_BS_signal.append(x[13]) + logger.debug(f"stg.temperature: {stg.temperature}") logger.debug(f"stg.tmin: {stg.tmin}") logger.debug(f"stg.tmin: {stg.tmax}") logger.debug(f"stg.SNR_filter_value: {stg.SNR_filter_value}") diff --git a/View/acoustic_data_tab.py b/View/acoustic_data_tab.py index 9794129..2b92f81 100644 --- a/View/acoustic_data_tab.py +++ b/View/acoustic_data_tab.py @@ -737,8 +737,11 @@ class AcousticDataTab(QWidget): logger.debug(f"{__name__}: Update") self.blockSignals(True) self.fileListWidget.blockSignals(True) + self.combobox_ABS_system_choice.blockSignals(True) self.combobox_ABS_system_choice.setCurrentText(stg.ABS_name[0]) + self.ABS_system_choice() + self.fileListWidget.addFilenames(stg.filename_BS_raw_data) self.fill_measurements_information_groupbox() @@ -751,6 +754,7 @@ class AcousticDataTab(QWidget): self.compute_rmin_rmax() self.set_range_for_spinboxes_bathymetry() + self.combobox_ABS_system_choice.blockSignals(False) self.fileListWidget.blockSignals(False) self.blockSignals(False) @@ -974,7 +978,7 @@ class AcousticDataTab(QWidget): self.gridLayout_groupbox_info.addWidget(self.lineEdit_temperature, 3, 1, 1, 1, Qt.AlignLeft) self.label_temperature_unit.show() self.gridLayout_groupbox_info.addWidget(self.label_temperature_unit, 3, 2, 1, 1, Qt.AlignLeft) - self.temperature_value() + self.setup_temperature_value() self.label_speed_of_sound.show() self.gridLayout_groupbox_info.addWidget(self.label_speed_of_sound, 4, 0, 1, 1, Qt.AlignLeft) @@ -1227,25 +1231,31 @@ class AcousticDataTab(QWidget): self.update_plot_backscattered_acoustic_signal_recording() self.update_plot_profile() - def temperature_value(self): + def setup_temperature_value(self): + self.water_velocity() + self.water_attenuation() + def temperature_value(self): if findall(r",", self.lineEdit_temperature.text()): stg.temperature = float(self.lineEdit_temperature.text().replace(',', '.')) self.lineEdit_temperature.setText(self.lineEdit_temperature.text().replace(',', '.')) else: stg.temperature = float(self.lineEdit_temperature.text()) self.lineEdit_temperature.setText(self.lineEdit_temperature.text()) + self.water_velocity() self.water_attenuation() def water_velocity(self): """Computing sond speed from Bilaniuk and Wong 1993""" + temp = float(self.lineEdit_temperature.text()) + C = (1.40238744 * 1e3 + - 5.03836171 * float(self.lineEdit_temperature.text()) - - 5.81172916 * 1e-2 * float(self.lineEdit_temperature.text()) ** 2 + - 3.34638117 * 1e-4 * float(self.lineEdit_temperature.text()) ** 3 - - 1.48259672 * 1e-6 * float(self.lineEdit_temperature.text()) ** 4 + - 3.16585020 * 1e-9 * float(self.lineEdit_temperature.text()) ** 5) + 5.03836171 * temp - + 5.81172916 * 1e-2 * temp ** 2 + + 3.34638117 * 1e-4 * temp ** 3 - + 1.48259672 * 1e-6 * temp ** 4 + + 3.16585020 * 1e-9 * temp ** 5) stg.water_velocity = C self.lineEdit_speed_of_sound.setText(str(round(stg.water_velocity, 2))) @@ -1297,26 +1307,29 @@ class AcousticDataTab(QWidget): # -------- Computing water attenuation coefficient ----------- # def water_attenuation(self): """Computing attenuation from François and Garrison 1982""" + temp = float(self.lineEdit_temperature.text()) + file_id = self.fileListWidget.currentRow() + if self.fileListWidget.count() > 0: - stg.water_attenuation[self.fileListWidget.currentRow()].clear() - for f in stg.freq[self.fileListWidget.currentRow()]: - if float(self.lineEdit_temperature.text()) > 20: + stg.water_attenuation[file_id].clear() + for f in stg.freq[file_id]: + if temp > 20: alpha = ((3.964 * 1e-4 - - 1.146 * 1e-5 * float(self.lineEdit_temperature.text()) + - 1.45 * 1e-7 * float(self.lineEdit_temperature.text()) ** 2 - - 6.5 * 1e-10 * float(self.lineEdit_temperature.text()) ** 3) * + 1.146 * 1e-5 * temp + + 1.45 * 1e-7 * temp ** 2 - + 6.5 * 1e-10 * temp ** 3) * 1e-3 * (np.log(10) / 20) * (f * 1e-3) ** 2) else: alpha = ((4.937 * 1e-4 - - 2.59 * 1e-5 * float(self.lineEdit_temperature.text()) + - 9.11 * 1e-7 * float(self.lineEdit_temperature.text()) ** 2 - - 1.5 * 1e-8 * float(self.lineEdit_temperature.text()) ** 3) * + 2.59 * 1e-5 * temp + + 9.11 * 1e-7 * temp ** 2 - + 1.5 * 1e-8 * temp ** 3) * 1e-3 * (np.log(10) / 20) * (f * 1e-3) ** 2) - stg.water_attenuation[self.fileListWidget.currentRow()].append(alpha) + stg.water_attenuation[file_id].append(alpha) self.lineEdit_sound_attenuation.setText( - str("%.6f" % stg.water_attenuation[self.fileListWidget.currentRow()][ + str("%.6f" % stg.water_attenuation[file_id][ self.combobox_frequency_information.currentIndex()])) def open_dialog_box(self): @@ -1752,6 +1765,7 @@ class AcousticDataTab(QWidget): .currentIndexChanged\ .connect(self.combobox_frequency_information_update) + logger.debug(f"Set temperature = {stg.temperature}") self.lineEdit_temperature.setText(str(stg.temperature)) self.label_profiles_value.setText( From 07353ccc3c5d8ece9f566ad2497164d685783deb Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Rouby Date: Tue, 25 Mar 2025 16:41:25 +0100 Subject: [PATCH 16/16] Acoustic data: Minor change. --- View/acoustic_data_tab.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/View/acoustic_data_tab.py b/View/acoustic_data_tab.py index 2b92f81..1217a8d 100644 --- a/View/acoustic_data_tab.py +++ b/View/acoustic_data_tab.py @@ -759,7 +759,6 @@ class AcousticDataTab(QWidget): self.blockSignals(False) def retranslate_acoustic_data_tab(self): - self.groupbox_info.setTitle(_translate("CONSTANT_STRING", cs.MEASUREMENTS_INFORMATION)) self.label_date_acoustic_file.setText(_translate("CONSTANT_STRING", cs.DATE) + ":") @@ -1728,6 +1727,9 @@ class AcousticDataTab(QWidget): self.fill_measurements_information_groupbox_cells() self.fill_measurements_information_groupbox_kt() + self.water_velocity() + self.water_attenuation() + def fill_measurements_information_groupbox_datetime(self): file_id = self.fileListWidget.currentRow() print("file_id ", file_id)