152 lines
5.7 KiB
Python
152 lines
5.7 KiB
Python
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
import pandas as pd
|
|
import plotly.graph_objects as go
|
|
|
|
|
|
def check_list_sizes(interfaces, amplitudes, profondeur, position_debut, position_fin):
|
|
sizes = [len(interfaces), len(amplitudes), len(profondeur), len(position_debut), len(position_fin)]
|
|
if len(set(sizes)) > 1:
|
|
raise ValueError("Toutes les listes doivent avoir la même taille")
|
|
|
|
def check_positions(position_debut, position_fin):
|
|
for debut, fin in zip(position_debut, position_fin):
|
|
if debut > fin:
|
|
raise ValueError("Un élément de position_debut est plus grand que son élément associé dans position_fin")
|
|
|
|
def demi_sinusoidal(liste :list[int],debut, fin, amplitude):
|
|
liste_copy = liste.copy()
|
|
x = np.linspace(0, np.pi, fin-debut)
|
|
y = amplitude * np.sin(x)**12
|
|
y = y.astype(int)
|
|
liste_copy[debut:fin] = y
|
|
return liste_copy
|
|
|
|
def bruit_blanc_gaussien(liste,moyenne, ecart_type):
|
|
liste_copy = liste.copy()
|
|
bruit = np.random.normal(moyenne, ecart_type, len(liste))
|
|
bruit = bruit.astype(int)
|
|
bruit = np.abs(bruit)
|
|
liste_bruitee = liste_copy + bruit
|
|
return liste_bruitee
|
|
|
|
def Ascan (liste, interfaces, amplitudes, profondeur):
|
|
for interface, amplitude, profondeur in zip(interfaces, amplitudes, profondeur):
|
|
liste = demi_sinusoidal(liste, interface, interface + profondeur, amplitude)
|
|
liste = bruit_blanc_gaussien(liste, 0, 20)
|
|
return liste
|
|
|
|
def Bscan (liste, interfaces, amplitudes, profondeur, position_debut, position_fin, trainee):
|
|
Bscan = []
|
|
initial_amplitudes = amplitudes.copy()
|
|
for i in range(0, len(liste)):
|
|
for j in range(0, len(interfaces)):
|
|
if i < position_debut[j]:
|
|
if i > position_debut[j] - trainee:
|
|
amplitudes[j] = int((amplitudes[j] / trainee) * (i - position_debut[j] + trainee))
|
|
else:
|
|
amplitudes[j] = 0
|
|
if i > position_fin[j]:
|
|
if i < position_fin[j] + trainee:
|
|
amplitudes[j] = int((amplitudes[j] / trainee) * (position_fin[j] + trainee - i))
|
|
else:
|
|
amplitudes[j] = 0
|
|
# Générer le Ascan avec les amplitudes modifiées
|
|
liste = Ascan(liste, interfaces, amplitudes, profondeur)
|
|
Bscan.append(liste)
|
|
# Réinitialiser les amplitudes pour le prochain Ascan
|
|
liste = np.zeros(len(liste))
|
|
amplitudes = initial_amplitudes.copy()
|
|
|
|
return Bscan
|
|
|
|
def Cscan(liste,nombre_de_scans, interfaces, amplitudes,profondeur, position_debut, position_fin, trainee):
|
|
Cscan_liste = [] # Liste pour stocker chaque Bscan
|
|
|
|
# Générer des Bscans pour différents instants/conditions
|
|
for _ in range(nombre_de_scans):
|
|
Bscan_result = Bscan(np.zeros(len(liste)), interfaces, amplitudes, profondeur, position_debut, position_fin, trainee)
|
|
Cscan_liste.append(np.array(Bscan_result))
|
|
|
|
# Convertir la liste des Bscans en un array 3D
|
|
Cscan_array = np.stack(Cscan_liste, axis=0)
|
|
return Cscan_array
|
|
|
|
def main_func(liste,interfaces,amplitudes,profondeur,position_debut,position_fin,trainee) -> None:
|
|
check_list_sizes(interfaces, amplitudes, profondeur, position_debut, position_fin)
|
|
|
|
check_positions(position_debut, position_fin)
|
|
|
|
# Appeler la fonction Cscan pour générer le tableau 3D
|
|
#nombre_de_scans = 1 # Par exemple, générer 5 Bscans
|
|
#Cscan_3D = Cscan(liste,nombre_de_scans, interfaces, amplitudes, profondeur, position_debut, position_fin, trainee)
|
|
|
|
#print("Forme du tableau 3D Cscan:", Cscan_3D.shape)
|
|
|
|
|
|
Bscan_result = Bscan(liste, interfaces, amplitudes,profondeur, position_debut, position_fin, trainee)
|
|
|
|
Bscan_array = np.array(Bscan_result)
|
|
|
|
df_bscan = pd.DataFrame(Bscan_array)
|
|
|
|
# Afficher les premières lignes du DataFrame pour vérifier
|
|
print(df_bscan.head())
|
|
|
|
# Sauvegarder le DataFrame en CSV
|
|
df_bscan.to_csv("Bscan_data.csv", index=False)
|
|
|
|
# Utiliser imshow pour afficher Bscan sous forme de heatmap
|
|
plt.imshow(Bscan_array, aspect='auto', origin='lower', cmap='jet')
|
|
plt.colorbar() # Ajouter une barre de couleur pour représenter l'échelle des intensités
|
|
plt.title("Bscan Heatmap")
|
|
plt.xlabel("Profondeur scan")
|
|
plt.ylabel("Numéro de Ascan")
|
|
plt.show()
|
|
|
|
|
|
|
|
# Supposons que Bscan_result soit votre matrice 2D d'amplitudes
|
|
#np.random.seed(19680801)
|
|
#Bscan_result = np.random.uniform(0, 1, (50, 50))
|
|
|
|
seuil_amplitude = 200
|
|
|
|
# Préparation des données de coordonnées
|
|
x, y = np.meshgrid(range(Bscan_array.shape[1]), range(Bscan_array.shape[0]))
|
|
z = np.zeros(x.shape) # Tous les points sont au niveau z=0
|
|
|
|
# Aplatir les tableaux pour la visualisation
|
|
x, y, z = x.flatten(), y.flatten(), z.flatten()
|
|
amplitude = Bscan_array.flatten() # Utiliser les valeurs d'amplitude pour la couleur
|
|
|
|
|
|
# Création du nuage de points 3D interactif avec Plotly
|
|
fig = go.Figure(data=[go.Scatter3d(
|
|
x=x,
|
|
y=y,
|
|
z=z,
|
|
mode='markers',
|
|
marker=dict(
|
|
size=5,
|
|
color=amplitude, # La couleur varie avec l'amplitude
|
|
colorscale='Viridis', # Palette de couleurs
|
|
opacity=0.8,
|
|
colorbar=dict(title='Amplitude')
|
|
)
|
|
)])
|
|
|
|
# Mise à jour de la mise en page
|
|
fig.update_layout(title='Visualisation 3D des Amplitudes avec Bscan sur z=0',
|
|
scene=dict(
|
|
xaxis_title='X',
|
|
yaxis_title='Y',
|
|
zaxis_title='Z',
|
|
zaxis=dict(range=[-0.1, 0.1])), # Limite l'axe z pour mieux visualiser le plan z=0
|
|
margin=dict(l=0, r=0, b=0, t=0))
|
|
|
|
# Afficher la figure
|
|
fig.show()
|
|
|
|
|