444 lines
23 KiB
Python
444 lines
23 KiB
Python
# ============================================================================== #
|
|
# read_table_for_open.py - AcouSed #
|
|
# Copyright (C) 2024 INRAE #
|
|
# #
|
|
# This program is free software: you can redistribute it and/or modify #
|
|
# it under the terms of the GNU General Public License as published by #
|
|
# the Free Software Foundation, either version 3 of the License, or #
|
|
# (at your option) any later version. #
|
|
# #
|
|
# This program is distributed in the hope that it will be useful, #
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
|
|
# GNU General Public License for more details. #
|
|
# #
|
|
# You should have received a copy of the GNU General Public License #
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>. #
|
|
|
|
# by Brahim MOUDJED #
|
|
# ============================================================================== #
|
|
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import os
|
|
import sys
|
|
import sqlite3
|
|
import logging
|
|
import numpy as np
|
|
|
|
from PyQt5.QtWidgets import QFileDialog, QApplication, QWidget, QTabWidget
|
|
|
|
import settings as stg
|
|
from settings import BS_raw_data, acoustic_data
|
|
|
|
from View.acoustic_data_tab import AcousticDataTab
|
|
|
|
|
|
logger = logging.getLogger("acoused")
|
|
|
|
class ReadTableForOpen:
|
|
|
|
def __init__(self):
|
|
self.opened = False
|
|
|
|
self.open_file_dialog()
|
|
|
|
def open_file_dialog(self):
|
|
name, _ = QFileDialog.getOpenFileName(
|
|
caption="Open Acoused file",
|
|
directory="",
|
|
filter="Acoused file (*.acd)",
|
|
options=QFileDialog.DontUseNativeDialog
|
|
)
|
|
|
|
if name != "":
|
|
stg.dirname_open = os.path.dirname(name)
|
|
stg.filename_open = os.path.basename(name)
|
|
|
|
try:
|
|
os.chdir(stg.dirname_open)
|
|
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):
|
|
|
|
stg.read_table_trigger = 1
|
|
|
|
# connexion to File db
|
|
cnx = sqlite3.connect(stg.filename_open)
|
|
|
|
# Create database cursor to execute SQL statements and fetch results from SQL queries.
|
|
cur = cnx.cursor()
|
|
|
|
# --------------------------------------------------------------------------------------------------------------
|
|
# +++++++++++++++++++++++++++
|
|
# --- Table Acoustic File ---
|
|
# +++++++++++++++++++++++++++
|
|
|
|
query0 = f'''SELECT acoustic_data FROM AcousticFile'''
|
|
data0 = cur.execute(query0).fetchall()
|
|
print("data0 ", data0)
|
|
|
|
stg.acoustic_data = [x[0] for x in data0]
|
|
print("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()
|
|
print("data acoustic file", data)
|
|
|
|
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])
|
|
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])
|
|
|
|
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 ---
|
|
# +++++++++++++++++++++
|
|
|
|
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)
|
|
|
|
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.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])
|
|
stg.nb_profiles_per_sec.append([x[8] for x in data1])
|
|
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.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)
|
|
|
|
print(stg.date)
|
|
print(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})'''
|
|
|
|
data2 = cur.execute(query2).fetchall()
|
|
print("len data2 ", len(data2))
|
|
|
|
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 == [])
|
|
|
|
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([]))
|
|
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])))
|
|
|
|
if len(np.frombuffer(data2[0][10], dtype=np.float64)) == 0:
|
|
stg.BS_stream_bed.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])))
|
|
|
|
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)
|
|
|
|
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])))
|
|
|
|
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 ---
|
|
# +++++++++++++++++++++++
|
|
|
|
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})'''
|
|
|
|
data3 = cur.execute(query3).fetchall()
|
|
|
|
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])
|
|
|
|
# --------------------------------------------------------------------------------------------------------------
|
|
# +++++++++++++++++++++++++++
|
|
# --- Table Sediment File ---
|
|
# +++++++++++++++++++++++++++
|
|
|
|
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()
|
|
|
|
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)
|
|
|
|
# --------------------------------------------------------------------------------------------------------------
|
|
# +++++++++++++++++++++++++++
|
|
# --- Table Sediment Data ---
|
|
# +++++++++++++++++++++++++++
|
|
|
|
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()
|
|
|
|
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))
|
|
|
|
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)
|
|
|
|
|
|
# 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")
|
|
|
|
# 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])))
|