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

Compare commits

base: parouby:b80e0f3c8ea0ae69d65a9fe2f5c9ec37c81afb41
Branches Tags
parouby:dev-bjvincent-fix-UBSediFlow
parouby:dev-bjvincent
parouby:dev
parouby:fix-save-load
parouby:main
parouby:dev-parouby
parouby:dev-brahim
parouby:v2.2
parouby:v2.1
..
compare: parouby:17619f15acbd0f0ea08267adc6863a47dd8df572
Branches Tags
parouby:dev-bjvincent-fix-UBSediFlow
parouby:dev-bjvincent
parouby:dev
parouby:fix-save-load
parouby:main
parouby:dev-parouby
parouby:dev-brahim
parouby:v2.2
parouby:v2.1

5 Commits
b80e0f3c8e ... 17619f15ac

Author SHA1 Message Date
Pierre-Antoine 17619f15ac Fix save method on existing file #16. 2025-03-06 14:33:30 +01:00
Pierre-Antoine b26d8a2906 Fix note tab click on 'edit settings' button #10. 2025-03-06 14:13:35 +01:00
Pierre-Antoine 52b612ba3e Fix acoustic data loading without selection #3. 2025-03-06 10:47:54 +01:00
Pierre-Antoine 5ebd842346 Fix open and save as method (#2 and #18). 2025-03-06 10:13:00 +01:00
Pierre-Antoine 4af3c4c9ea Fix #7 with exception handler. 2025-03-06 09:18:04 +01:00
7 changed files with 410 additions and 340 deletions
Show Stats Expand all files Collapse all files

236
Model/create_table_for_save_as.py
View File

@ -20,50 +20,54 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import os
import time
import sqlite3
import logging
import numpy as np import numpy as np
from PyQt5.QtWidgets import QFileDialog, QApplication, QMessageBox
import sqlite3
import settings as stg
from os import chdir
import time
from PyQt5.QtWidgets import QFileDialog, QApplication, QMessageBox
import settings as stg
from settings import ABS_name from settings import ABS_name
logger = logging.getLogger()
class CreateTableForSaveAs: class CreateTableForSaveAs:
def __init__(self): def __init__(self):
self.create_AcousticFile = """CREATE TABLE AcousticFile( self.create_AcousticFile = """CREATE TABLE AcousticFile(
ID INTEGER PRIMARY KEY AUTOINCREMENT, ID INTEGER PRIMARY KEY AUTOINCREMENT,
acoustic_data INTEGER, acoustic_data INTEGER,
acoustic_file STRING, acoustic_file STRING,
ABS_name STRING, ABS_name STRING,
path_BS_noise_data STRING, path_BS_noise_data STRING,
filename_BS_noise_data STRING, filename_BS_noise_data STRING,
noise_method FLOAT, noise_method FLOAT,
noise_value FLOAT, noise_value FLOAT,
data_preprocessed STRING data_preprocessed STRING
) )
""" """
self.create_Measure = """ CREATE TABLE Measure( self.create_Measure = """ CREATE TABLE Measure(
ID INTEGER PRIMARY KEY AUTOINCREMENT, ID INTEGER PRIMARY KEY AUTOINCREMENT,
acoustic_data INTEGER, acoustic_data INTEGER,
Date DATE, Date DATE,
Hour TIME, Hour TIME,
frequency FLOAT, frequency FLOAT,
sound_attenuation FLOAT, sound_attenuation FLOAT,
kt_read FLOAT, kt_read FLOAT,
kt_corrected FLOAT, kt_corrected FLOAT,
NbProfiles FLOAT, NbProfiles FLOAT,
NbProfilesPerSeconds FLOAT, NbProfilesPerSeconds FLOAT,
NbCells FLOAT, NbCells FLOAT,
CellSize FLOAT, CellSize FLOAT,
PulseLength FLOAT, PulseLength FLOAT,
NbPingsPerSeconds FLOAT, NbPingsPerSeconds FLOAT,
NbPingsAveragedPerProfile FLOAT, NbPingsAveragedPerProfile FLOAT,
GainRx FLOAT, GainRx FLOAT,
GainTx FLOAT GainTx FLOAT
) )
""" """
@ -71,15 +75,15 @@ class CreateTableForSaveAs:
self.create_BSRawData = '''CREATE TABLE BSRawData( self.create_BSRawData = '''CREATE TABLE BSRawData(
ID INTEGER PRIMARY KEY AUTOINCREMENT, ID INTEGER PRIMARY KEY AUTOINCREMENT,
acoustic_data INTEGER, acoustic_data INTEGER,
time BLOB, depth BLOB, BS_raw_data BLOB, time BLOB, depth BLOB, BS_raw_data BLOB,
time_reshape BLOB, depth_reshape BLOB, BS_raw_data_reshape 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 BLOB, time_cross_section BLOB, depth_cross_section BLOB, BS_cross_section BLOB, BS_stream_bed BLOB,
depth_bottom, val_bottom, ind_bottom, depth_bottom, val_bottom, ind_bottom,
time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB, time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB,
SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB, SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB,
BS_raw_data_pre_process_SNR BLOB, BS_raw_data_pre_process_average BLOB, BS_raw_data_pre_process_SNR BLOB, BS_raw_data_pre_process_average BLOB,
BS_cross_section_pre_process_SNR BLOB, BS_cross_section_pre_process_average BLOB, BS_cross_section_pre_process_SNR BLOB, BS_cross_section_pre_process_average BLOB,
BS_stream_bed_pre_process_SNR BLOB, BS_stream_bed_pre_process_average BLOB, BS_stream_bed_pre_process_SNR BLOB, BS_stream_bed_pre_process_average BLOB,
BS_mean BLOB BS_mean BLOB
)''' )'''
@ -88,76 +92,76 @@ class CreateTableForSaveAs:
acoustic_data INTEGER, acoustic_data INTEGER,
temperature FLOAT, temperature FLOAT,
tmin_index FLOAT, tmin_value FLOAT, tmax_index FLOAT, tmax_value FLOAT, tmin_index FLOAT, tmin_value FLOAT, tmax_index FLOAT, tmax_value FLOAT,
rmin_index FLOAT, rmin_value FLOAT, rmax_index FLOAT, rmax_value FLOAT, rmin_index FLOAT, rmin_value FLOAT, rmax_index FLOAT, rmax_value FLOAT,
freq_bottom_detection_index FLOAT, freq_bottom_detection_value STRING, freq_bottom_detection_index FLOAT, freq_bottom_detection_value STRING,
SNR_filter_value FLOAT, Nb_cells_to_average_BS_signal FLOAT SNR_filter_value FLOAT, Nb_cells_to_average_BS_signal FLOAT
)''' )'''
self.create_SedimentsFile = """CREATE TABLE SedimentsFile( self.create_SedimentsFile = """CREATE TABLE SedimentsFile(
ID INTEGER PRIMARY KEY AUTOINCREMENT, ID INTEGER PRIMARY KEY AUTOINCREMENT,
path_fine STRING, path_fine STRING,
filename_fine STRING, filename_fine STRING,
radius_grain_fine BLOB, radius_grain_fine BLOB,
path_sand STRING, path_sand STRING,
filename_sand STRING, filename_sand STRING,
radius_grain_sand BLOB, radius_grain_sand BLOB,
time_column_label STRING, time_column_label STRING,
distance_from_bank_column_label STRING, distance_from_bank_column_label STRING,
depth_column_label STRING, depth_column_label STRING,
Ctot_fine_column_label STRING, Ctot_fine_column_label STRING,
D50_fine_column_label STRING, D50_fine_column_label STRING,
Ctot_sand_column_label STRING, Ctot_sand_column_label STRING,
D50_sand_column_label STRING D50_sand_column_label STRING
) )
""" """
self.create_SedimentsData = """CREATE TABLE SedimentsData( self.create_SedimentsData = """CREATE TABLE SedimentsData(
ID INTEGER PRIMARY KEY AUTOINCREMENT, ID INTEGER PRIMARY KEY AUTOINCREMENT,
sample_fine_name STRING, sample_fine_name STRING,
sample_fine_index INTEGER, sample_fine_index INTEGER,
distance_from_bank_fine FLOAT, distance_from_bank_fine FLOAT,
depth_fine FLOAT, depth_fine FLOAT,
time_fine FLOAT, time_fine FLOAT,
Ctot_fine FLOAT, Ctot_fine FLOAT,
Ctot_fine_per_cent FLOAT, Ctot_fine_per_cent FLOAT,
D50_fine FLOAT, D50_fine FLOAT,
frac_vol_fine BLOB, frac_vol_fine BLOB,
frac_vol_fine_cumul BLOB, frac_vol_fine_cumul BLOB,
sample_sand_name STRING, sample_sand_name STRING,
sample_sand_index INTEGER, sample_sand_index INTEGER,
distance_from_bank_sand FLOAT, distance_from_bank_sand FLOAT,
depth_sand FLOAT, depth_sand FLOAT,
time_sand FLOAT, time_sand FLOAT,
Ctot_sand FLOAT, Ctot_sand FLOAT,
Ctot_sand_per_cent FLOAT, Ctot_sand_per_cent FLOAT,
D50_sand FLOAT, D50_sand FLOAT,
frac_vol_sand BLOB, frac_vol_sand BLOB,
frac_vol_sand_cumul BLOB frac_vol_sand_cumul BLOB
) )
""" """
self.create_Calibration = """CREATE TABLE Calibration( self.create_Calibration = """CREATE TABLE Calibration(
ID INTEGER PRIMARY KEY AUTOINCREMENT, ID INTEGER PRIMARY KEY AUTOINCREMENT,
path_calibration_file STRING, path_calibration_file STRING,
filename_calibration_file STRING, filename_calibration_file STRING,
range_lin_interp BLOB, range_lin_interp BLOB,
M_profile_fine BLOB, M_profile_fine BLOB,
ks BLOB, ks BLOB,
sv BLOB, sv BLOB,
X_exponent BLOB, X_exponent BLOB,
alpha_s BLOB, alpha_s BLOB,
zeta BLOB, zeta BLOB,
FCB BLOB, FCB BLOB,
depth_real BLOB, depth_real BLOB,
lin_reg BLOB lin_reg BLOB
)""" )"""
self.create_Inversion = """CREATE TABLE Inversion( self.create_Inversion = """CREATE TABLE Inversion(
ID INTEGER PRIMARY KEY AUTOINCREMENT, ID INTEGER PRIMARY KEY AUTOINCREMENT,
J_cross_section_freq1 BLOB, J_cross_section_freq1 BLOB,
J_cross_section_freq2 BLOB, J_cross_section_freq2 BLOB,
VBI_cross_section BLOB, VBI_cross_section BLOB,
SSC_fine BLOB, SSC_fine BLOB,
SSC_sand BLOB SSC_sand BLOB
)""" )"""
@ -165,23 +169,32 @@ class CreateTableForSaveAs:
def open_file_dialog(self): def open_file_dialog(self):
options = QFileDialog.Options() name, _ = QFileDialog.getSaveFileName(
name = QFileDialog.getSaveFileName( caption="Save As",
caption="Save As", directory="", filter="AcouSed Files (*.acd)", options=QFileDialog.DontUseNativeDialog) directory="",
filter="AcouSed Files (*.acd)",
options=QFileDialog.DontUseNativeDialog
)
if name[0]: if name != "":
filename = os.path.basename(name)
if os.path.splitext(filename)[1] != ".acd":
filename += ".acd"
stg.dirname_save_as = "/".join(name[0].split("/")[:-1]) + "/" logger.debug(f"selected save file: '{filename}'")
stg.filename_save_as = name[0].split("/")[-1]
chdir(stg.dirname_save_as) stg.dirname_save_as = os.path.dirname(name)
stg.filename_save_as = filename
try:
os.chdir(stg.dirname_save_as)
except OSError as e:
logger.warning(f"chdir: {str(e)}")
start = time.time() start = time.time()
self.create_table() self.create_table()
print(f"end : {time.time() - start} sec") print(f"end : {time.time() - start} sec")
else: else:
msgBox = QMessageBox() msgBox = QMessageBox()
msgBox.setWindowTitle("Save Error") msgBox.setWindowTitle("Save Error")
msgBox.setIcon(QMessageBox.Warning) msgBox.setIcon(QMessageBox.Warning)
@ -190,9 +203,9 @@ class CreateTableForSaveAs:
msgBox.exec() msgBox.exec()
def create_table(self): def create_table(self):
# Create a new database and open a database connection to allow sqlite3 to work with it. # Create a new database and open a database connection to allow sqlite3 to work with it.
cnx = sqlite3.connect(stg.filename_save_as + '.acd') cnx = sqlite3.connect(stg.filename_save_as)
# Create database cursor to execute SQL statements and fetch results from SQL queries. # Create database cursor to execute SQL statements and fetch results from SQL queries.
cur = cnx.cursor() cur = cnx.cursor()
@ -214,8 +227,8 @@ class CreateTableForSaveAs:
print('stg.ABS_name', stg.ABS_name) print('stg.ABS_name', stg.ABS_name)
print("stg.path_BS_raw_data ", stg.path_BS_raw_data[i]) print("stg.path_BS_raw_data ", stg.path_BS_raw_data[i])
cur.execute(''' INSERT into AcousticFile(acoustic_data, acoustic_file, ABS_name, path_BS_noise_data, cur.execute(''' INSERT into AcousticFile(acoustic_data, acoustic_file, ABS_name, path_BS_noise_data,
filename_BS_noise_data, noise_method, noise_value, data_preprocessed) filename_BS_noise_data, noise_method, noise_value, data_preprocessed)
VALUES(?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.acoustic_data[i], stg.filename_BS_raw_data[i].split('.')[0], stg.ABS_name[i], (stg.acoustic_data[i], stg.filename_BS_raw_data[i].split('.')[0], stg.ABS_name[i],
stg.path_BS_noise_data[i], stg.filename_BS_noise_data[i], stg.noise_method[i], stg.path_BS_noise_data[i], stg.filename_BS_noise_data[i], stg.noise_method[i],
@ -244,9 +257,9 @@ class CreateTableForSaveAs:
for j in range(stg.freq[i].shape[0]): for j in range(stg.freq[i].shape[0]):
cur.execute(''' INSERT into Measure(acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected, cur.execute(''' INSERT into Measure(acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected,
NbProfiles, NbProfilesPerSeconds, NbCells, CellSize, PulseLength, NbProfiles, NbProfilesPerSeconds, NbCells, CellSize, PulseLength,
NbPingsPerSeconds, NbPingsAveragedPerProfile, GainRx, GainTx NbPingsPerSeconds, NbPingsAveragedPerProfile, GainRx, GainTx
) )
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.acoustic_data[i], #stg.date[i], stg.hour[i], (stg.acoustic_data[i], #stg.date[i], stg.hour[i],
@ -276,16 +289,16 @@ class CreateTableForSaveAs:
for i in stg.acoustic_data: for i in stg.acoustic_data:
cur.execute(''' INSERT into BSRawData(acoustic_data, time, depth, BS_raw_data, cur.execute(''' INSERT into BSRawData(acoustic_data, time, depth, BS_raw_data,
time_reshape, depth_reshape, BS_raw_data_reshape, time_reshape, depth_reshape, BS_raw_data_reshape,
time_cross_section, depth_cross_section, time_cross_section, depth_cross_section,
BS_cross_section, BS_stream_bed, BS_cross_section, BS_stream_bed,
depth_bottom, val_bottom, ind_bottom, depth_bottom, val_bottom, ind_bottom,
time_noise, depth_noise, BS_noise_raw_data, time_noise, depth_noise, BS_noise_raw_data,
SNR_raw_data, SNR_cross_section, SNR_stream_bed, SNR_raw_data, SNR_cross_section, SNR_stream_bed,
BS_raw_data_pre_process_SNR, BS_raw_data_pre_process_average, 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_cross_section_pre_process_SNR, BS_cross_section_pre_process_average,
BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average, BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average,
BS_mean) BS_mean)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.acoustic_data[i], stg.time[i].tobytes(), (stg.acoustic_data[i], stg.time[i].tobytes(),
@ -327,9 +340,9 @@ class CreateTableForSaveAs:
cur.execute('''INSERT into Settings(acoustic_data, temperature, cur.execute('''INSERT into Settings(acoustic_data, temperature,
tmin_index, tmin_value, tmax_index, tmax_value, tmin_index, tmin_value, tmax_index, tmax_value,
rmin_index, rmin_value, rmax_index, rmax_value, rmin_index, rmin_value, rmax_index, rmax_value,
freq_bottom_detection_index, freq_bottom_detection_value, freq_bottom_detection_index, freq_bottom_detection_value,
SNR_filter_value, Nb_cells_to_average_BS_signal SNR_filter_value, Nb_cells_to_average_BS_signal
) )
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.acoustic_data[i], stg.temperature, (stg.acoustic_data[i], stg.temperature,
stg.tmin[i][0], stg.tmin[i][1], stg.tmax[i][0], stg.tmax[i][1], stg.tmin[i][0], stg.tmin[i][1], stg.tmax[i][0], stg.tmax[i][1],
@ -355,8 +368,8 @@ class CreateTableForSaveAs:
cur.execute(self.create_SedimentsFile) cur.execute(self.create_SedimentsFile)
cur.execute('''INSERT into SedimentsFile(path_fine, filename_fine, radius_grain_fine, cur.execute('''INSERT into SedimentsFile(path_fine, filename_fine, radius_grain_fine,
path_sand, filename_sand, radius_grain_sand, path_sand, filename_sand, radius_grain_sand,
time_column_label, distance_from_bank_column_label, time_column_label, distance_from_bank_column_label,
depth_column_label, Ctot_fine_column_label, D50_fine_column_label, depth_column_label, Ctot_fine_column_label, D50_fine_column_label,
Ctot_sand_column_label, D50_sand_column_label) Ctot_sand_column_label, D50_sand_column_label)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
@ -382,11 +395,11 @@ class CreateTableForSaveAs:
for f in range(len(stg.sample_fine)): for f in range(len(stg.sample_fine)):
cur.execute('''INSERT into SedimentsData(sample_fine_name, sample_fine_index, distance_from_bank_fine, cur.execute('''INSERT into SedimentsData(sample_fine_name, sample_fine_index, distance_from_bank_fine,
depth_fine, time_fine, Ctot_fine, Ctot_fine_per_cent, D50_fine, depth_fine, time_fine, Ctot_fine, Ctot_fine_per_cent, D50_fine,
frac_vol_fine, frac_vol_fine_cumul, frac_vol_fine, frac_vol_fine_cumul,
sample_sand_name, sample_sand_index, distance_from_bank_sand, sample_sand_name, sample_sand_index, distance_from_bank_sand,
depth_sand, time_sand, Ctot_sand, Ctot_sand_per_cent, D50_sand, depth_sand, time_sand, Ctot_sand, Ctot_sand_per_cent, D50_sand,
frac_vol_sand, frac_vol_sand_cumul frac_vol_sand, frac_vol_sand_cumul
) )
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.sample_fine[f][0] , stg.sample_fine[f][1], (stg.sample_fine[f][0] , stg.sample_fine[f][1],
@ -413,10 +426,10 @@ class CreateTableForSaveAs:
cur.execute(self.create_Calibration) cur.execute(self.create_Calibration)
cur.execute('''INSERT into Calibration(path_calibration_file, filename_calibration_file, cur.execute('''INSERT into Calibration(path_calibration_file, filename_calibration_file,
range_lin_interp, M_profile_fine, range_lin_interp, M_profile_fine,
ks, sv, X_exponent, alpha_s, zeta, ks, sv, X_exponent, alpha_s, zeta,
FCB, depth_real, lin_reg) FCB, depth_real, lin_reg)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.path_calibration_file, stg.filename_calibration_file, (stg.path_calibration_file, stg.filename_calibration_file,
stg.range_lin_interp.tobytes(), stg.M_profile_fine.tobytes(), stg.range_lin_interp.tobytes(), stg.M_profile_fine.tobytes(),
@ -441,8 +454,8 @@ class CreateTableForSaveAs:
cur.execute(self.create_Inversion) cur.execute(self.create_Inversion)
for i in range(len(stg.SSC_fine)): for i in range(len(stg.SSC_fine)):
cur.execute('''INSERT into Inversion(J_cross_section_freq1, J_cross_section_freq2, cur.execute('''INSERT into Inversion(J_cross_section_freq1, J_cross_section_freq2,
VBI_cross_section, SSC_fine, SSC_sand) VBI_cross_section, SSC_fine, SSC_sand)
VALUES(?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?)''',
(stg.J_cross_section[i][0].tobytes(), stg.J_cross_section[i][1].tobytes(), (stg.J_cross_section[i][0].tobytes(), stg.J_cross_section[i][1].tobytes(),
stg.VBI_cross_section[i].tobytes(), stg.SSC_fine[i].tobytes(), stg.SSC_sand[i].tobytes()) stg.VBI_cross_section[i].tobytes(), stg.SSC_fine[i].tobytes(), stg.SSC_sand[i].tobytes())
@ -459,6 +472,3 @@ class CreateTableForSaveAs:
# Close database connection # Close database connection
cnx.close() cnx.close()

78
Model/read_table_for_open.py
View File

@ -20,37 +20,50 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import os
import sys import sys
import numpy as np
from PyQt5.QtWidgets import QFileDialog, QApplication, QWidget, QTabWidget
import sqlite3 import sqlite3
from os import path, chdir import logging
import numpy as np
from PyQt5.QtWidgets import QFileDialog, QApplication, QWidget, QTabWidget
import settings as stg import settings as stg
from settings import BS_raw_data, acoustic_data from settings import BS_raw_data, acoustic_data
from View.acoustic_data_tab import AcousticDataTab from View.acoustic_data_tab import AcousticDataTab
logger = logging.getLogger()
class ReadTableForOpen: class ReadTableForOpen:
def __init__(self): def __init__(self):
self.opened = False
pass self.open_file_dialog()
def open_file_dialog(self): def open_file_dialog(self):
name, _ = QFileDialog.getOpenFileName(
caption="Open Acoused file",
directory="",
filter="Acoused file (*.acd)",
options=QFileDialog.DontUseNativeDialog
)
name = QFileDialog.getOpenFileName(caption="Open Acoused file", directory="", filter="Acoused file (*.acd)", if name != "":
options=QFileDialog.DontUseNativeDialog) stg.dirname_open = os.path.dirname(name)
stg.filename_open = os.path.basename(name)
if name: try:
os.chdir(stg.dirname_open)
except OSError as e:
logger.warning(f"chdir: {str(e)}")
stg.dirname_open = path.dirname(name[0])
stg.filename_open = path.basename(name[0])
chdir(stg.dirname_open)
self.sql_file_to_open = open(stg.filename_open) self.sql_file_to_open = open(stg.filename_open)
self.read_table() self.read_table()
self.opened = True
def read_table(self): def read_table(self):
@ -76,7 +89,7 @@ class ReadTableForOpen:
for k in range(len(stg.acoustic_data)): for k in range(len(stg.acoustic_data)):
print("hello") print("hello")
query = f'''SELECT acoustic_data, acoustic_file, ABS_name, path_BS_noise_data, filename_BS_noise_data, 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})''' noise_method, noise_value, data_preprocessed FROM AcousticFile WHERE (acoustic_data = {k})'''
data = cur.execute(query).fetchall() data = cur.execute(query).fetchall()
print("data acoustic file", data) print("data acoustic file", data)
@ -101,8 +114,8 @@ class ReadTableForOpen:
stg.hour = [0]*len(stg.acoustic_data) stg.hour = [0]*len(stg.acoustic_data)
for i in range(len(stg.acoustic_data)): for i in range(len(stg.acoustic_data)):
print("i = ", i) print("i = ", i)
query1 = f'''SELECT acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected, NbProfiles, query1 = f'''SELECT acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected, NbProfiles,
NbProfilesPerSeconds, NbCells, CellSize, PulseLength, NbPingsPerSeconds, NbPingsAveragedPerProfile, NbProfilesPerSeconds, NbCells, CellSize, PulseLength, NbPingsPerSeconds, NbPingsAveragedPerProfile,
GainRx, GainTx FROM Measure WHERE (acoustic_data = {i})''' GainRx, GainTx FROM Measure WHERE (acoustic_data = {i})'''
data1 = cur.execute(query1).fetchall() data1 = cur.execute(query1).fetchall()
@ -140,16 +153,16 @@ class ReadTableForOpen:
print("len stg.acoustic_data ", len(stg.acoustic_data)) print("len stg.acoustic_data ", len(stg.acoustic_data))
for j in range(len(stg.acoustic_data)): for j in range(len(stg.acoustic_data)):
print(f"j = {j}") print(f"j = {j}")
query2 = f'''SELECT acoustic_data, time, depth, BS_raw_data, query2 = f'''SELECT acoustic_data, time, depth, BS_raw_data,
time_reshape, depth_reshape, BS_raw_data_reshape, time_reshape, depth_reshape, BS_raw_data_reshape,
time_cross_section, depth_cross_section, time_cross_section, depth_cross_section,
BS_cross_section, BS_stream_bed, BS_cross_section, BS_stream_bed,
depth_bottom, val_bottom, ind_bottom, depth_bottom, val_bottom, ind_bottom,
time_noise, depth_noise, BS_noise_raw_data, time_noise, depth_noise, BS_noise_raw_data,
SNR_raw_data, SNR_cross_section, SNR_stream_bed, SNR_raw_data, SNR_cross_section, SNR_stream_bed,
BS_raw_data_pre_process_SNR, BS_raw_data_pre_process_average, 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_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 BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average, BS_mean
FROM BSRawData WHERE (acoustic_data = {j})''' FROM BSRawData WHERE (acoustic_data = {j})'''
data2 = cur.execute(query2).fetchall() data2 = cur.execute(query2).fetchall()
@ -270,10 +283,10 @@ class ReadTableForOpen:
# +++++++++++++++++++++++ # +++++++++++++++++++++++
for s in range(len(stg.acoustic_data)): for s in range(len(stg.acoustic_data)):
query3 = f'''SELECT acoustic_data, temperature, query3 = f'''SELECT acoustic_data, temperature,
tmin_index, tmin_value, tmax_index, tmax_value, tmin_index, tmin_value, tmax_index, tmax_value,
rmin_index, rmin_value, rmax_index, rmax_value, rmin_index, rmin_value, rmax_index, rmax_value,
freq_bottom_detection_index, freq_bottom_detection_value, freq_bottom_detection_index, freq_bottom_detection_value,
SNR_filter_value, Nb_cells_to_average_BS_signal SNR_filter_value, Nb_cells_to_average_BS_signal
FROM Settings WHERE (acoustic_data = {s})''' FROM Settings WHERE (acoustic_data = {s})'''
@ -293,10 +306,10 @@ class ReadTableForOpen:
# --- Table Sediment File --- # --- Table Sediment File ---
# +++++++++++++++++++++++++++ # +++++++++++++++++++++++++++
query4 = f'''SELECT path_fine, filename_fine, radius_grain_fine, path_sand, filename_sand, radius_grain_sand, 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, time_column_label, distance_from_bank_column_label, depth_column_label,
Ctot_fine_column_label, D50_fine_column_label, Ctot_fine_column_label, D50_fine_column_label,
Ctot_sand_column_label, D50_sand_column_label Ctot_sand_column_label, D50_sand_column_label
from SedimentsFile''' from SedimentsFile'''
data4 = cur.execute(query4).fetchall() data4 = cur.execute(query4).fetchall()
@ -321,10 +334,10 @@ class ReadTableForOpen:
# --- Table Sediment Data --- # --- Table Sediment Data ---
# +++++++++++++++++++++++++++ # +++++++++++++++++++++++++++
query5 = f'''SELECT sample_fine_name, sample_fine_index, distance_from_bank_fine, depth_fine, time_fine, 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, 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, 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 Ctot_sand, Ctot_sand_per_cent, D50_sand, frac_vol_sand, frac_vol_sand_cumul
from SedimentsData''' from SedimentsData'''
data5 = cur.execute(query5).fetchall() data5 = cur.execute(query5).fetchall()
@ -428,4 +441,3 @@ class ReadTableForOpen:
stg.BS_raw_data.append(np.reshape(stg.BS_raw_data_reshape[i], 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]))) (len(stg.freq[i]), stg.depth[i].shape[1], stg.time[i].shape[1])))

249
Model/update_table_for_save.py
View File

@ -51,7 +51,7 @@ class UpdateTableForSave:
def update_table(self): def update_table(self):
# Create a new database and open a database connection to allow sqlite3 to work with it. # Create a new database and open a database connection to allow sqlite3 to work with it.
cnx = sqlite3.connect(stg.filename_save_as + '.acd') cnx = sqlite3.connect(stg.filename_save_as)
# Create database cursor to execute SQL statements and fetch results from SQL queries. # Create database cursor to execute SQL statements and fetch results from SQL queries.
cur = cnx.cursor() cur = cnx.cursor()
@ -67,12 +67,12 @@ class UpdateTableForSave:
cur.execute("""CREATE TABLE AcousticFile(ID INTEGER PRIMARY KEY AUTOINCREMENT, cur.execute("""CREATE TABLE AcousticFile(ID INTEGER PRIMARY KEY AUTOINCREMENT,
acoustic_data INTEGER, acoustic_data INTEGER,
acoustic_file STRING, acoustic_file STRING,
ABS_name STRING, ABS_name STRING,
path_BS_noise_data STRING, path_BS_noise_data STRING,
filename_BS_noise_data STRING, filename_BS_noise_data STRING,
noise_method FLOAT, noise_method FLOAT,
noise_value FLOAT, noise_value FLOAT,
data_preprocessed STRING data_preprocessed STRING
)""" )"""
) )
@ -83,8 +83,8 @@ class UpdateTableForSave:
print('stg.ABS_name', stg.ABS_name) print('stg.ABS_name', stg.ABS_name)
print("stg.path_BS_raw_data ", stg.path_BS_raw_data[i]) print("stg.path_BS_raw_data ", stg.path_BS_raw_data[i])
cur.execute(''' INSERT into AcousticFile(acoustic_data, acoustic_file, ABS_name, path_BS_noise_data, cur.execute(''' INSERT into AcousticFile(acoustic_data, acoustic_file, ABS_name, path_BS_noise_data,
filename_BS_noise_data, noise_method, noise_value, data_preprocessed) filename_BS_noise_data, noise_method, noise_value, data_preprocessed)
VALUES(?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.acoustic_data[i], stg.filename_BS_raw_data[i].split('.')[0], stg.ABS_name[i], (stg.acoustic_data[i], stg.filename_BS_raw_data[i].split('.')[0], stg.ABS_name[i],
stg.path_BS_noise_data[i], stg.filename_BS_noise_data[i], stg.noise_method[i], stg.path_BS_noise_data[i], stg.filename_BS_noise_data[i], stg.noise_method[i],
@ -104,42 +104,72 @@ class UpdateTableForSave:
# Drop Table if exists # Drop Table if exists
cur.execute("DROP TABLE if exists Measure") cur.execute("DROP TABLE if exists Measure")
cur.execute("""CREATE TABLE Measure(ID INTEGER PRIMARY KEY AUTOINCREMENT, cur.execute(
acoustic_data INTEGER, """
Date STRING, CREATE TABLE Measure(
Hour STRING, ID INTEGER PRIMARY KEY AUTOINCREMENT,
frequency FLOAT, acoustic_data INTEGER,
sound_attenuation FLOAT, Date STRING,
kt_read FLOAT, Hour STRING,
kt_corrected FLOAT, frequency FLOAT,
NbProfiles FLOAT, sound_attenuation FLOAT,
NbProfilesPerSeconds FLOAT, kt_read FLOAT,
NbCells FLOAT, kt_corrected FLOAT,
CellSize FLOAT, NbProfiles FLOAT,
PulseLength FLOAT, NbProfilesPerSeconds FLOAT,
NbPingsPerSeconds FLOAT, NbCells FLOAT,
NbPingsAveragedPerProfile FLOAT, CellSize FLOAT,
GainRx FLOAT, PulseLength FLOAT,
GainTx FLOAT NbPingsPerSeconds FLOAT,
) NbPingsAveragedPerProfile FLOAT,
""") GainRx FLOAT,
GainTx FLOAT
)"""
)
# Fill the table Measure # Fill the table Measure
for i in stg.acoustic_data: for i in stg.acoustic_data:
for j in range(stg.freq[i].shape[0]): for j in range(stg.freq[i].shape[0]):
cur.execute(''' INSERT into Measure(acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected, NbProfiles, cur.execute(
NbProfilesPerSeconds, NbCells, CellSize, PulseLength, '''
NbPingsPerSeconds, NbPingsAveragedPerProfile, GainRx, GainTx, INSERT into Measure(
) acoustic_data,
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', Date, Hour,
(stg.acoustic_data[i], stg.freq[i][j], stg.water_attenuation[i][j], stg.kt_read[j], stg.kt_corrected[j], frequency,
stg.nb_profiles[i][j], stg.nb_profiles_per_sec[i][j], stg.nb_cells[i][j], sound_attenuation,
stg.cell_size[i][j], stg.pulse_length[i][j], stg.nb_pings_per_sec[i][j], kt_read, kt_corrected,
stg.nb_pings_averaged_per_profile[i][j], stg.gain_rx[i][j], stg.gain_tx[i][j], NbProfiles, NbProfilesPerSeconds,
str(stg.date[i].year) + str('-') + str(stg.date[i].month) + str('-') + str(stg.date[i].day), NbCells, CellSize,
str(stg.hour[i].hour) + str(':') + str(stg.hour[i].minute) PulseLength,
)) NbPingsPerSeconds,
NbPingsAveragedPerProfile,
GainRx, GainTx
) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(
stg.acoustic_data[i],
(
str(stg.date[i].year) + str('-') +
str(stg.date[i].month) + str('-') +
str(stg.date[i].day)
),
(
str(stg.hour[i].hour) + str(':') +
str(stg.hour[i].minute)
),
stg.freq[i][j],
stg.water_attenuation[i][j],
stg.kt_read[j],
stg.kt_corrected[j],
stg.nb_profiles[i][j],
stg.nb_profiles_per_sec[i][j],
stg.nb_cells[i][j],
stg.cell_size[i][j],
stg.pulse_length[i][j],
stg.nb_pings_per_sec[i][j],
stg.nb_pings_averaged_per_profile[i][j],
stg.gain_rx[i][j], stg.gain_tx[i][j]
)
)
# Commit the transaction after executing INSERT. # Commit the transaction after executing INSERT.
cnx.commit() cnx.commit()
@ -150,7 +180,7 @@ class UpdateTableForSave:
# +++++++++++++++++++++++++++ # +++++++++++++++++++++++++++
# --- Table Acoustic Data --- # --- Table Acoustic Data ---
# +++++++++++++++++++++++++++ # +++++++++++++++++++++++++++
start_table_BSRawData = time.time() start_table_BSRawData = time.time()
cur.execute(''' DROP TABLE BSRawData ''') cur.execute(''' DROP TABLE BSRawData ''')
@ -158,29 +188,29 @@ class UpdateTableForSave:
cur.execute('''CREATE TABLE BSRawData(ID INTEGER PRIMARY KEY AUTOINCREMENT, cur.execute('''CREATE TABLE BSRawData(ID INTEGER PRIMARY KEY AUTOINCREMENT,
acoustic_data INTEGER, acoustic_data INTEGER,
time BLOB, depth BLOB, BS_raw_data BLOB, time BLOB, depth BLOB, BS_raw_data BLOB,
time_reshape BLOB, depth_reshape BLOB, BS_raw_data_reshape 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 BLOB, time_cross_section BLOB, depth_cross_section BLOB, BS_cross_section BLOB, BS_stream_bed BLOB,
depth_bottom, val_bottom, ind_bottom, depth_bottom, val_bottom, ind_bottom,
time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB, time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB,
SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB, SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB,
BS_raw_data_pre_process_SNR BLOB, BS_raw_data_pre_process_average BLOB, BS_raw_data_pre_process_SNR BLOB, BS_raw_data_pre_process_average BLOB,
BS_cross_section_pre_process_SNR BLOB, BS_cross_section_pre_process_average BLOB, BS_cross_section_pre_process_SNR BLOB, BS_cross_section_pre_process_average BLOB,
BS_stream_bed_pre_process_SNR BLOB, BS_stream_bed_pre_process_average BLOB, BS_stream_bed_pre_process_SNR BLOB, BS_stream_bed_pre_process_average BLOB,
BS_mean BLOB BS_mean BLOB
)''') )''')
for i in stg.acoustic_data: for i in stg.acoustic_data:
cur.execute(''' INSERT into BSRawData(acoustic_data, time, depth, BS_raw_data, cur.execute(''' INSERT into BSRawData(acoustic_data, time, depth, BS_raw_data,
time_reshape, depth_reshape, BS_raw_data_reshape, time_reshape, depth_reshape, BS_raw_data_reshape,
time_cross_section, depth_cross_section, time_cross_section, depth_cross_section,
BS_cross_section, BS_stream_bed, BS_cross_section, BS_stream_bed,
depth_bottom, val_bottom, ind_bottom, depth_bottom, val_bottom, ind_bottom,
time_noise, depth_noise, BS_noise_raw_data, time_noise, depth_noise, BS_noise_raw_data,
SNR_raw_data, SNR_cross_section, SNR_stream_bed, SNR_raw_data, SNR_cross_section, SNR_stream_bed,
BS_raw_data_pre_process_SNR, BS_raw_data_pre_process_average, 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_cross_section_pre_process_SNR, BS_cross_section_pre_process_average,
BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average, BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average,
BS_mean) BS_mean)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.acoustic_data[i], stg.time[i].tobytes(), stg.depth[i].tobytes(), stg.BS_raw_data[i].tobytes(), (stg.acoustic_data[i], stg.time[i].tobytes(), stg.depth[i].tobytes(), stg.BS_raw_data[i].tobytes(),
@ -219,8 +249,8 @@ class UpdateTableForSave:
acoustic_data INTEGER, acoustic_data INTEGER,
temperature FLOAT, temperature FLOAT,
tmin_index FLOAT, tmin_value FLOAT, tmax_index FLOAT, tmax_value FLOAT, tmin_index FLOAT, tmin_value FLOAT, tmax_index FLOAT, tmax_value FLOAT,
rmin_index FLOAT, rmin_value FLOAT, rmax_index FLOAT, rmax_value FLOAT, rmin_index FLOAT, rmin_value FLOAT, rmax_index FLOAT, rmax_value FLOAT,
freq_bottom_detection_index FLOAT, freq_bottom_detection_value STRING, freq_bottom_detection_index FLOAT, freq_bottom_detection_value STRING,
SNR_filter_value FLOAT, Nb_cells_to_average_BS_signal FLOAT SNR_filter_value FLOAT, Nb_cells_to_average_BS_signal FLOAT
)''' )'''
) )
@ -229,8 +259,8 @@ class UpdateTableForSave:
cur.execute('''INSERT into Settings(acoustic_data, temperature, cur.execute('''INSERT into Settings(acoustic_data, temperature,
tmin_index, tmin_value, tmax_index, tmax_value, tmin_index, tmin_value, tmax_index, tmax_value,
rmin_index, rmin_value, rmax_index, rmax_value, rmin_index, rmin_value, rmax_index, rmax_value,
freq_bottom_detection_index, freq_bottom_detection_value, freq_bottom_detection_index, freq_bottom_detection_value,
SNR_filter_value, Nb_cells_to_average_BS_signal) SNR_filter_value, Nb_cells_to_average_BS_signal)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.acoustic_data[i], stg.temperature, (stg.acoustic_data[i], stg.temperature,
stg.tmin[i][0], stg.tmin[i][1], stg.tmax[i][0], stg.tmax[i][1], stg.tmin[i][0], stg.tmin[i][1], stg.tmax[i][0], stg.tmax[i][1],
@ -252,29 +282,29 @@ class UpdateTableForSave:
cur.execute("DROP TABLE if exists SedimentsFile") cur.execute("DROP TABLE if exists SedimentsFile")
cur.execute("""CREATE TABLE SedimentsFile(ID INTEGER PRIMARY KEY AUTOINCREMENT, cur.execute("""CREATE TABLE SedimentsFile(ID INTEGER PRIMARY KEY AUTOINCREMENT,
path_fine STRING, path_fine STRING,
filename_fine STRING, filename_fine STRING,
radius_grain_fine BLOB, radius_grain_fine BLOB,
path_sand STRING, path_sand STRING,
filename_sand STRING, filename_sand STRING,
radius_grain_sand BLOB, radius_grain_sand BLOB,
time_column_label STRING, time_column_label STRING,
distance_from_bank_column_label STRING, distance_from_bank_column_label STRING,
depth_column_label STRING, depth_column_label STRING,
Ctot_fine_column_label STRING, Ctot_fine_column_label STRING,
D50_fine_column_label STRING, D50_fine_column_label STRING,
Ctot_sand_column_label STRING, Ctot_sand_column_label STRING,
D50_sand_column_label STRING D50_sand_column_label STRING
)""" )"""
) )
cur.execute('''INSERT into SedimentsFile(path_fine, filename_fine, radius_grain_fine, cur.execute('''INSERT into SedimentsFile(path_fine, filename_fine, radius_grain_fine,
path_sand, filename_sand, radius_grain_sand, path_sand, filename_sand, radius_grain_sand,
time_column_label, distance_from_bank_column_label, time_column_label, distance_from_bank_column_label,
depth_column_label, Ctot_fine_column_label, depth_column_label, Ctot_fine_column_label,
D50_fine_column_label, Ctot_sand_column_label, D50_fine_column_label, Ctot_sand_column_label,
D50_sand_column_label) D50_sand_column_label)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.path_fine, stg.filename_fine, stg.radius_grain_fine.tobytes(), (stg.path_fine, stg.filename_fine, stg.radius_grain_fine.tobytes(),
stg.path_sand, stg.filename_sand, stg.radius_grain_sand.tobytes(), stg.path_sand, stg.filename_sand, stg.radius_grain_sand.tobytes(),
@ -294,26 +324,26 @@ class UpdateTableForSave:
cur.execute("DROP TABLE if exists SedimentsData") cur.execute("DROP TABLE if exists SedimentsData")
cur.execute("""CREATE TABLE SedimentsData(ID INTEGER PRIMARY KEY AUTOINCREMENT, cur.execute("""CREATE TABLE SedimentsData(ID INTEGER PRIMARY KEY AUTOINCREMENT,
sample_fine_name STRING, sample_fine_name STRING,
sample_fine_index INTEGER, sample_fine_index INTEGER,
distance_from_bank_fine FLOAT, distance_from_bank_fine FLOAT,
depth_fine FLOAT, depth_fine FLOAT,
time_fine FLOAT, time_fine FLOAT,
Ctot_fine FLOAT, Ctot_fine FLOAT,
Ctot_fine_per_cent FLOAT, Ctot_fine_per_cent FLOAT,
D50_fine FLOAT, D50_fine FLOAT,
frac_vol_fine BLOB, frac_vol_fine BLOB,
frac_vol_fine_cumul BLOB, frac_vol_fine_cumul BLOB,
sample_sand_name STRING, sample_sand_name STRING,
sample_sand_index INTEGER, sample_sand_index INTEGER,
distance_from_bank_sand FLOAT, distance_from_bank_sand FLOAT,
depth_sand FLOAT, depth_sand FLOAT,
time_sand FLOAT, time_sand FLOAT,
Ctot_sand FLOAT, Ctot_sand FLOAT,
Ctot_sand_per_cent FLOAT, Ctot_sand_per_cent FLOAT,
D50_sand FLOAT, D50_sand FLOAT,
frac_vol_sand BLOB, frac_vol_sand BLOB,
frac_vol_sand_cumul BLOB frac_vol_sand_cumul BLOB
)""" )"""
) )
@ -321,7 +351,7 @@ class UpdateTableForSave:
for f in range(len(stg.sample_fine)): for f in range(len(stg.sample_fine)):
cur.execute('''INSERT into SedimentsData(sample_fine_name, sample_fine_index, distance_from_bank_fine, cur.execute('''INSERT into SedimentsData(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, depth_fine, time_fine, Ctot_fine, Ctot_fine_per_cent, D50_fine, frac_vol_fine,
frac_vol_fine_cumul, frac_vol_fine_cumul,
sample_sand_name, sample_sand_index, distance_from_bank_sand, 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, depth_sand, time_sand, Ctot_sand, Ctot_sand_per_cent, D50_sand, frac_vol_sand,
frac_vol_sand_cumul) frac_vol_sand_cumul)
@ -349,26 +379,26 @@ class UpdateTableForSave:
cur.execute("DROP TABLE if exists Calibration") cur.execute("DROP TABLE if exists Calibration")
cur.execute("""CREATE TABLE Calibration(ID INTEGER PRIMARY KEY AUTOINCREMENT, cur.execute("""CREATE TABLE Calibration(ID INTEGER PRIMARY KEY AUTOINCREMENT,
path_calibration_file STRING, path_calibration_file STRING,
filename_calibration_file STRING, filename_calibration_file STRING,
range_lin_interp BLOB, range_lin_interp BLOB,
M_profile_fine BLOB, M_profile_fine BLOB,
ks BLOB, ks BLOB,
sv BLOB, sv BLOB,
X_exponent BLOB, X_exponent BLOB,
alpha_s BLOB, alpha_s BLOB,
zeta BLOB, zeta BLOB,
FCB BLOB, FCB BLOB,
depth_real BLOB, depth_real BLOB,
lin_reg BLOB lin_reg BLOB
)""" )"""
) )
cur.execute('''INSERT into Calibration(path_calibration_file, filename_calibration_file, cur.execute('''INSERT into Calibration(path_calibration_file, filename_calibration_file,
range_lin_interp, M_profile_fine, range_lin_interp, M_profile_fine,
ks, sv, X_exponent, alpha_s, zeta, ks, sv, X_exponent, alpha_s, zeta,
FCB, depth_real, lin_reg) FCB, depth_real, lin_reg)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(stg.path_calibration_file, stg.filename_calibration_file, (stg.path_calibration_file, stg.filename_calibration_file,
stg.range_lin_interp.tobytes(), stg.M_profile_fine.tobytes(), stg.range_lin_interp.tobytes(), stg.M_profile_fine.tobytes(),
@ -390,17 +420,17 @@ class UpdateTableForSave:
cur.execute("DROP TABLE if exists Inversion") cur.execute("DROP TABLE if exists Inversion")
cur.execute("""CREATE TABLE Inversion(ID INTEGER PRIMARY KEY AUTOINCREMENT, cur.execute("""CREATE TABLE Inversion(ID INTEGER PRIMARY KEY AUTOINCREMENT,
J_cross_section_freq1 BLOB, J_cross_section_freq1 BLOB,
J_cross_section_freq2 BLOB, J_cross_section_freq2 BLOB,
VBI_cross_section BLOB, VBI_cross_section BLOB,
SSC_fine BLOB, SSC_fine BLOB,
SSC_sand BLOB SSC_sand BLOB
)""") )""")
for i in range(len(stg.SSC_fine)): for i in range(len(stg.SSC_fine)):
cur.execute('''INSERT into Inversion(J_cross_section_freq1, J_cross_section_freq2, cur.execute('''INSERT into Inversion(J_cross_section_freq1, J_cross_section_freq2,
VBI_cross_section, SSC_fine, SSC_sand) VBI_cross_section, SSC_fine, SSC_sand)
VALUES(?, ?, ?, ?, ?)''', VALUES(?, ?, ?, ?, ?)''',
(stg.J_cross_section[i][0].tobytes(), stg.J_cross_section[i][1].tobytes(), (stg.J_cross_section[i][0].tobytes(), stg.J_cross_section[i][1].tobytes(),
stg.VBI_cross_section[i].tobytes(), stg.SSC_fine[i].tobytes(), stg.SSC_sand[i].tobytes()) stg.VBI_cross_section[i].tobytes(), stg.SSC_fine[i].tobytes(), stg.SSC_sand[i].tobytes())
@ -417,6 +447,3 @@ class UpdateTableForSave:
# Close database connection # Close database connection
cnx.close() cnx.close()

103
View/acoustic_data_tab.py
View File

@ -21,11 +21,18 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QPushButton, QComboBox, QLineEdit, QLabel, from PyQt5.QtWidgets import (
QGridLayout, QTableView, QSpacerItem, QSizePolicy, QFileDialog, QMessageBox, QScrollArea, QWidget, QVBoxLayout, QHBoxLayout, QGroupBox,
QSlider, QMenu, QCheckBox) QPushButton, QComboBox, QLineEdit, QLabel,
QGridLayout, QTableView, QSpacerItem, QSizePolicy,
QFileDialog, QMessageBox, QScrollArea,
QSlider, QMenu, QCheckBox
)
from PyQt5.QtGui import QPixmap, QIcon from PyQt5.QtGui import QPixmap, QIcon
from PyQt5.QtCore import Qt, QCoreApplication, pyqtSignal, QEvent, QSize, QPropertyAnimation from PyQt5.QtCore import (
Qt, QCoreApplication, pyqtSignal, QEvent, QSize,
QPropertyAnimation
)
import numpy as np import numpy as np
import pandas as pd import pandas as pd
@ -35,7 +42,7 @@ from matplotlib.colors import LogNorm, CSS4_COLORS, BoundaryNorm
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolBar from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolBar
from os import path import os
from copy import deepcopy from copy import deepcopy
import locale import locale
@ -1232,71 +1239,76 @@ class AcousticDataTab(QWidget):
self.combobox_frequency_information.currentIndex()])) self.combobox_frequency_information.currentIndex()]))
def open_dialog_box(self): def open_dialog_box(self):
abs_params = [
(None, None),
("AQUAscat file", "Aquascat file (*.aqa)"),
("UBSediFlow file", "UBSediFlow file (*.udt)"),
]
# --- Open dialog box + choice directory and select file ---
if self.combobox_ABS_system_choice.currentIndex() == 0: system = self.combobox_ABS_system_choice.currentIndex()
if system == 0:
msgBox = QMessageBox() msgBox = QMessageBox()
msgBox.setWindowTitle("Download Error") msgBox.setWindowTitle("Download Error")
msgBox.setIcon(QMessageBox.Warning) msgBox.setIcon(QMessageBox.Warning)
msgBox.setText("Choose ABS system before download acoustic files") msgBox.setText("Choose ABS system before download acoustic files")
msgBox.setStandardButtons(QMessageBox.Ok) msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.exec() msgBox.exec()
elif self.combobox_ABS_system_choice.currentIndex() == 1: else:
abs_name, abs_file_type = abs_params[system]
filename = QFileDialog.getOpenFileNames(self, "AQUAscat file", filenames, _ = QFileDialog.getOpenFileNames(
[stg.path_BS_raw_data[-1] if self.fileListWidget.count() > 0 else ""][0], self, abs_name,
"Aquascat file (*.aqa)", [
options=QFileDialog.DontUseNativeDialog) stg.path_BS_raw_data[-1]
if self.fileListWidget.count() > 0
else ""
][0],
abs_file_type,
options=QFileDialog.DontUseNativeDialog
)
for n in filename[0]: if len(filenames) == 0:
return
stg.path_BS_raw_data.append(path.dirname(n)) for n in filenames:
stg.filename_BS_raw_data.append(path.basename(n)) stg.path_BS_raw_data.append(os.path.dirname(n))
stg.data_preprocessed.append(path.basename(n)) stg.filename_BS_raw_data.append(os.path.basename(n))
stg.data_preprocessed.append(os.path.basename(n))
elif self.combobox_ABS_system_choice.currentIndex() == 2: self.open_acoustic_data()
filename = QFileDialog.getOpenFileNames(self, "UBSediFlow file",
[stg.path_BS_raw_data[-1] if self.fileListWidget.count() > 0 else ""][0],
"UBSediFlow file (*.udt)",
options=QFileDialog.DontUseNativeDialog)
for n in filename[0]:
stg.path_BS_raw_data.append(path.dirname(n))
stg.filename_BS_raw_data.append(path.basename(n))
stg.data_preprocessed.append(path.basename(n))
def open_acoustic_data(self):
# --- Fill lineEdit with path and file names + load acoustic data --- # --- Fill lineEdit with path and file names + load acoustic data ---
# --- fill date, hour and measurements information + fill frequency combobox for bottom detection --- # --- fill date, hour and measurements information + fill frequency combobox for bottom detection ---
if self.combobox_ABS_system_choice.currentIndex() != 0: system = self.combobox_ABS_system_choice.currentIndex()
if system != 0:
try: try:
self.load_BS_acoustic_raw_data() self.load_BS_acoustic_raw_data()
except ValueError as e: except ValueError as e:
msgBox = QMessageBox() msgBox = QMessageBox()
msgBox.setWindowTitle("Download Error") msgBox.setWindowTitle("Download Error")
msgBox.setIcon(QMessageBox.Warning) msgBox.setIcon(QMessageBox.Warning)
msgBox.setText("Please select a file") msgBox.setText("Please select a file")
msgBox.setStandardButtons(QMessageBox.Ok) msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.exec() msgBox.exec()
else: else:
if self.fileListWidget.count() == 0: if self.fileListWidget.count() == 0:
for p, f in zip(stg.path_BS_raw_data,
for p, f in zip(stg.path_BS_raw_data, stg.filename_BS_raw_data): stg.filename_BS_raw_data):
self.fileListWidget.addFilenames([f]) self.fileListWidget.addFilenames([f])
self.fileListWidget.setToolTip(p) self.fileListWidget.setToolTip(p)
else: else:
for k in range(self.fileListWidget.count(),
for k in range(self.fileListWidget.count(), len(stg.filename_BS_raw_data), 1): len(stg.filename_BS_raw_data),
self.fileListWidget.addFilenames([stg.filename_BS_raw_data[k]]) 1):
self.fileListWidget.setToolTip(stg.path_BS_raw_data[k]) self.fileListWidget.addFilenames(
[stg.filename_BS_raw_data[k]]
)
self.fileListWidget.setToolTip(
stg.path_BS_raw_data[k]
)
self.fill_measurements_information_groupbox() self.fill_measurements_information_groupbox()
self.fill_table() self.fill_table()
@ -1304,7 +1316,11 @@ class AcousticDataTab(QWidget):
self.update_frequency_combobox() self.update_frequency_combobox()
self.water_attenuation() self.water_attenuation()
stg.acoustic_data = list(range(self.fileListWidget.count())) stg.acoustic_data = list(
range(
self.fileListWidget.count()
)
)
def rename_file_in_ListWidget(self, event): def rename_file_in_ListWidget(self, event):
@ -2719,4 +2735,3 @@ class AcousticDataTab(QWidget):
self.update_plot_profile() self.update_plot_profile()
self.fig_BS.canvas.draw_idle() self.fig_BS.canvas.draw_idle()

19
View/mainwindow.py
View File

@ -262,20 +262,33 @@ class Ui_MainWindow(object):
def save_as(self): def save_as(self):
CreateTableForSaveAs() CreateTableForSaveAs()
self.mainwindow.setWindowTitle("AcouSed - " + stg.filename_save_as + ".acd") self.mainwindow.setWindowTitle(
"AcouSed - " +
stg.filename_save_as
)
def save(self): def save(self):
UpdateTableForSave() UpdateTableForSave()
def open(self): def open(self):
ReadTableForOpen() reader = ReadTableForOpen()
if reader.opened:
self.mainwindow.open_study_update_tabs()
def load_calibration_constant_values(self): def load_calibration_constant_values(self):
cc_kt = CalibrationConstantKt() cc_kt = CalibrationConstantKt()
cc_kt.exec() cc_kt.exec()
def db_browser_for_sqlite(self): def db_browser_for_sqlite(self):
Popen(f"sqlitebrowser", shell=True) try:
Popen("sqlitebrowser")
except OSError as e:
msg_box = QtWidgets.QMessageBox()
msg_box.setWindowTitle("DB Browser for SQLite Error")
msg_box.setIcon(QtWidgets.QMessageBox.Critical)
msg_box.setText(f"DB Browser for SQLite Error:\n {str(e)}")
msg_box.setStandardButtons(QtWidgets.QMessageBox.Ok)
msg_box.exec()
def about_window(self): def about_window(self):
print("about") print("about")

47
View/note_tab.py
View File

@ -1,7 +1,8 @@
import sys from PyQt5.QtWidgets import (
QApplication, QWidget, QVBoxLayout, QHBoxLayout,
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QHBoxLayout, QTextEdit, QPushButton, QSpacerItem, \ QTextEdit, QPushButton, QSpacerItem, QSpinBox,
QSpinBox, QSizePolicy, QFontComboBox, QColorDialog QSizePolicy, QFontComboBox, QColorDialog
)
from PyQt5.QtGui import QPixmap, QIcon, QFont from PyQt5.QtGui import QPixmap, QIcon, QFont
from PyQt5.QtCore import Qt from PyQt5.QtCore import Qt
@ -189,27 +190,21 @@ class NoteTab(QWidget):
self.textEdit.setAlignment(Qt.AlignJustify) self.textEdit.setAlignment(Qt.AlignJustify)
def print_settings(self): def print_settings(self):
self.textEdit.setText(
"Acoustic data: \n\n"
f" ABS raw data file: {stg.path_BS_raw_data}/{stg.filename_BS_raw_data} \n"
f" ABS noise data file: {stg.path_BS_noise_data}/{stg.filename_BS_noise_data} \n"
"\n\n"
"------------------------------------------------------------------------- \n\n\n"
self.textEdit.setText("Acoustic data: \n\n" "Particle size data: \n"
f" ABS raw data file: {stg.path_BS_raw_data}/{stg.filename_BS_raw_data} \n" f" Fine sediments data file: {stg.path_fine}/{stg.filename_fine} \n"
f" ABS noise data file: {stg.path_BS_noise_data}/{stg.filename_BS_noise_data} \n" f" Sand sediments data file: {stg.path_sand}/{stg.filename_sand} \n"
"\n\n" "\n\n"
"------------------------------------------------------------------------- \n\n\n" "------------------------------------------------------------------------- \n\n\n"
)
"Particle size data: \n" # "Acoustic Inversion parameters: \n"
f" Fine sediments data file: {stg.fine_sediment_path}/{stg.fine_sediment_filename} \n" # f" frequencies to compute VBI: {stg.freq_text[int(stg.frequencies_to_compute_VBI[0, 0])]}, "
f" Sand sediments data file: {stg.sand_sediment_path}/{stg.sand_sediment_filename} \n" # f"{stg.freq_text[int(stg.frequencies_to_compute_VBI[1, 0])]} \n"
"\n\n" # f" frequency to compute SSC: {stg.freq_text[int(stg.frequency_to_compute_SSC[0])]}")
"------------------------------------------------------------------------- \n\n\n")
# "Acoustic Inversion parameters: \n"
# f" frequencies to compute VBI: {stg.freq_text[int(stg.frequencies_to_compute_VBI[0, 0])]}, "
# f"{stg.freq_text[int(stg.frequencies_to_compute_VBI[1, 0])]} \n"
# f" frequency to compute SSC: {stg.freq_text[int(stg.frequency_to_compute_SSC[0])]}")
# if __name__ == "__main__":
# app = QApplication(sys.argv)
# window = NoteTab()
# window.show()
# sys.exit(app.exec_())

18
main.py
View File

@ -33,7 +33,7 @@ logging.basicConfig(
) )
logger = logging.getLogger() logger = logging.getLogger()
logger.setLevel(logging.INFO) logger.setLevel(logging.DEBUG)
class MainApplication(QMainWindow): class MainApplication(QMainWindow):
@ -49,15 +49,18 @@ class MainApplication(QMainWindow):
height = size.height() height = size.height()
self.resize(int(PERCENT_SCREEN_SIZE*width), int(PERCENT_SCREEN_SIZE*height)) self.resize(int(PERCENT_SCREEN_SIZE*width), int(PERCENT_SCREEN_SIZE*height))
try: try:
self.read_table_open = ReadTableForOpen()
# ************************************************** # **************************************************
# -------------- Acoustic data tab --------------- # -------------- Acoustic data tab ---------------
self.acoustic_data_tab = AcousticDataTab(self.ui_mainwindow.tab1) self.acoustic_data_tab = AcousticDataTab(self.ui_mainwindow.tab1)
print("0 AcousticDataTab ", id(AcousticDataTab)) print("0 AcousticDataTab ", id(AcousticDataTab))
self.acoustic_data_tab.combobox_ABS_system_choice.editTextChanged.connect( self.acoustic_data_tab\
self.acoustic_data_tab.ABS_system_choice) .combobox_ABS_system_choice\
.editTextChanged\
.connect(
self.acoustic_data_tab.ABS_system_choice
)
# ************************************************** # **************************************************
# --------- Signal pre-processing data tab ---------- # --------- Signal pre-processing data tab ----------
@ -92,8 +95,6 @@ class MainApplication(QMainWindow):
# self.user_manual_tab = UserManualTab(self.ui_mainwindow.tab7) # self.user_manual_tab = UserManualTab(self.ui_mainwindow.tab7)
self.ui_mainwindow.actionOpen.triggered.connect(self.trig_open)
# ************************************************** # **************************************************
# ---------------- Text File Error ----------------- # ---------------- Text File Error -----------------
@ -106,9 +107,7 @@ class MainApplication(QMainWindow):
sortie.write(traceback.format_exc()) sortie.write(traceback.format_exc())
# traceback.TracebackException.from_exception(e).print(file=sortie) # traceback.TracebackException.from_exception(e).print(file=sortie)
def trig_open(self): def open_study_update_tabs(self):
self.read_table_open.open_file_dialog()
self.acoustic_data_tab.combobox_ABS_system_choice.setCurrentText(stg.ABS_name[0]) 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.acoustic_data_tab.fileListWidget.addFilenames(stg.filename_BS_raw_data)
@ -119,7 +118,6 @@ class MainApplication(QMainWindow):
self.sample_data_tab.lineEdit_fine_sediment.setToolTip(stg.path_fine) self.sample_data_tab.lineEdit_fine_sediment.setToolTip(stg.path_fine)
# self.sample_data_tab.fill_table_fine() # self.sample_data_tab.fill_table_fine()
if __name__ == '__main__': if __name__ == '__main__':
# print("sys.argv:", [arg for arg in sys.argv]) # print("sys.argv:", [arg for arg in sys.argv])
# app = MainApplication(sys.argv) # app = MainApplication(sys.argv)