AOT-biomaps 2.9.339__py3-none-any.whl → 2.9.373__py3-none-any.whl

AOT_biomaps/AOT_Acoustic/AcousticTools.py

@@ -217,3 +217,20 @@ def next_power_of_2(n):
     """Calculate the next power of 2 greater than or equal to n."""
     return int(2 ** np.ceil(np.log2(n)))
         
+def hex_to_binary_profile(hex_string, n_piezos=192):
+    hex_string = hex_string.strip().replace(" ", "").replace("\n", "")
+    if set(hex_string.lower()) == {'f'}:
+        return np.ones(n_piezos, dtype=int)
+    
+    try:
+        n_char = len(hex_string)
+        n_bits = n_char * 4
+        binary_str = bin(int(hex_string, 16))[2:].zfill(n_bits)
+        if len(binary_str) < n_piezos:
+             # Tronquer/padder en fonction de la taille réelle de la sonde
+             binary_str = binary_str.ljust(n_piezos, '0') 
+        elif len(binary_str) > n_piezos:
+             binary_str = binary_str[:n_piezos]
+        return np.array([int(b) for b in binary_str])
+    except ValueError:
+        return np.zeros(n_piezos, dtype=int)

AOT_biomaps/AOT_Acoustic/StructuredWave.py

@@ -2,6 +2,7 @@ from AOT_biomaps.Config import config
 from ._mainAcoustic import AcousticField
 from .AcousticEnums import WaveType
 from .AcousticTools import detect_space_0_and_space_1, getAngle
+from .AcousticTools import hex_to_binary_profile
 
 import os
 import numpy as np
@@ -156,7 +157,20 @@ class StructuredWave(AcousticField):
                 int: Decimation frequency.
             """
             try:
-                return 1/(self.pattern.space_0 + self.pattern.space_1)/self.params['element_width']
+                profile = hex_to_binary_profile(self.getName_field()[6:-4], self.params['num_elements'])
+
+                if set(self.getName_field()[6:-4].lower().replace(" ", "")) == {'f'}:
+                    fs_key = 0.0 # fs_key est en mm^-1 (0.0 mm^-1)
+                else:   
+                    ft_prof = np.fft.fft(profile)
+                    idx_max = np.argmax(np.abs(ft_prof[1:len(profile)//2])) + 1
+                    freqs = np.fft.fftfreq(len(profile), d=self.params['dx'])
+
+                    # freqs est en m^-1 car delta_x est en mètres.
+                    fs_m_inv = abs(freqs[idx_max]) 
+
+                    fs_key = fs_m_inv # Fréquence spatiale en mm^-1
+                return  int(fs_key / (1/(len(profile)*self.params['dx'])))
             except Exception as e:
                 print(f"Error calculating decimation frequency: {e}")
                 return None

AOT_biomaps/AOT_Acoustic/_mainAcoustic.py

@@ -93,6 +93,8 @@ class AcousticField(ABC):
                 'num_elements': params.acoustic['num_elements'],
                 'element_width': params.acoustic['element_width'],
                 'element_height': params.acoustic['element_height'],
+                'height_phantom': params.acoustic['phantom']['height'] if 'phantom' in params.acoustic and 'height' in params.acoustic['phantom'] else None,
+                'width_phantom': params.acoustic['phantom']['width'] if 'phantom' in params.acoustic and 'width' in params.acoustic['phantom'] else None,
                 'Xrange': params.general['Xrange'],
                 'Yrange': params.general['Yrange'],
                 'Zrange': params.general['Zrange'],
@@ -104,6 +106,7 @@ class AcousticField(ABC):
                 'Nx': int(np.round((params.general['Xrange'][1] - params.general['Xrange'][0])/params.general['dx'])),
                 'Ny': int(np.round((params.general['Yrange'][1] - params.general['Yrange'][0])/params.general['dy']))  if params.general['Yrange'] is not None else 1,
                 'Nz': int(np.round((params.general['Zrange'][1] - params.general['Zrange'][0])/params.general['dz'])),
+                'Nt': params.general['Nt'] if 'Nt' in params.general else None,
                 'probeWidth': params.acoustic['num_elements'] * params.acoustic['element_width'],
                 'IsAbsorbingMedium': params.acoustic['isAbsorbingMedium'],
             }
@@ -114,8 +117,11 @@ class AcousticField(ABC):
 
                 self.params['f_AQ'] = int(1/self.kgrid.dt)
             else:
-                Nt = ceil((self.params['Zrange'][1] - self.params['Zrange'][0])*float(params.acoustic['f_AQ']) / self.params['c0'])
-
+                if self.params['Nt'] is None:
+                    Nt = ceil((self.params['Zrange'][1] - self.params['Zrange'][0])*float(params.acoustic['f_AQ']) / self.params['c0'])
+                    self.params['Nt'] = Nt
+                else:
+                    Nt = self.params['Nt']
                 self.kgrid.setTime(Nt,1/float(params.acoustic['f_AQ']))
                 self.params['f_AQ'] = int(float(params.acoustic['f_AQ']))
 
@@ -505,13 +511,25 @@ class AcousticField(ABC):
         try:
             # --- 1. Grid setup ---
             dx = self.params['dx']
-            if dx >= self.params['element_width']*2:
+            if dx >= self.params['element_width']:
                 dx = self.params['element_width'] / 2
-                Nx = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / dx))
-                Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / dx))
+                if self.params['width_phantom'] is not None:
+                    Nx = int(np.round((self.params['width_phantom'])/dx))
+                else:
+                    Nx = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / dx))
+                if self.params['height_phantom'] is not None:
+                    Nz = int(np.round((self.params['height_phantom'])/dx))
+                else:
+                    Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / dx))
             else:
-                Nx = self.params['Nx']
-                Nz = self.params['Nz']
+                if self.params['width_phantom'] is not None:
+                    Nx = int(np.round((self.params['width_phantom'])/self.params['dx']))
+                else:
+                    Nx = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / self.params['dx']))
+                if self.params['height_phantom'] is not None:
+                    Nz = int(np.round((self.params['height_phantom'])/self.params['dz']))
+                else:
+                    Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / self.params['dz']))
 
             # --- 2. Time and space factors ---
             self.factorT = int(np.ceil(self.params['f_AQ'] / self.params['f_saving']))
@@ -530,17 +548,14 @@ class AcousticField(ABC):
             sensor.mask = np.ones((Nx, Nz))
 
             # --- 5. PML setup ---
-            total_size_x = next_power_of_2(Nx)
             total_size_z = next_power_of_2(Nz)
-            pml_x_size = (total_size_x - Nx) // 2
             pml_z_size = (total_size_z - Nz) // 2
-            pml_x_size = max(pml_x_size, 50)    # Ensure a minimum PML size of 50 grid points to avoid parasitic reflections
             pml_z_size = max(pml_z_size, 50)    # Ensure a minimum PML size of 50 grid points to avoid parasitic reflections
 
             # --- 6. Simulation options ---
             simulation_options = SimulationOptions(
                 pml_inside=False,
-                pml_size=[pml_x_size, pml_z_size],
+                pml_size=[0, pml_z_size],
                 use_sg=False,
                 save_to_disk=True,
                 input_filename=os.path.join(gettempdir(), "KwaveIN.h5"),
@@ -583,11 +598,23 @@ class AcousticField(ABC):
             dx = self.params['dx']
             if dx >= self.params['element_width']:
                 dx = self.params['element_width'] / 2
-                Nx = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / dx))
-                Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / dx))
+                if self.params['width_phantom'] is not None:
+                    Nx = int(np.round((self.params['width_phantom'])/dx))
+                else:
+                    Nx = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / dx))
+                if self.params['height_phantom'] is not None:
+                    Nz = int(np.round((self.params['height_phantom'])/dx))
+                else:
+                    Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / dx))
             else:
-                Nx = self.params['Nx']
-                Nz = self.params['Nz']
+                if self.params['width_phantom'] is not None:
+                    Nx = int(np.round((self.params['width_phantom'])/self.params['dx']))
+                else:
+                    Nx = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / self.params['dx']))
+                if self.params['height_phantom'] is not None:
+                    Nz = int(np.round((self.params['height_phantom'])/self.params['dz']))
+                else:
+                    Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / self.params['dz']))
 
             # --- 2. Time and space factors (common) ---
             factorT = int(np.ceil(self.params['f_AQ'] / self.params['f_saving']))

AOT_biomaps/AOT_Experiment/ExperimentTools.py

@@ -1,32 +1,22 @@
 import numpy as np
 
-def calc_mat_os(xm, fx, dx, bool_active_list, signal_type):
+def calc_mat_os(xm, fx, bool_active_list, signal_type):
+    """
+    xm : vecteur des positions réelles des éléments (en m)
+    fx : fréquence spatiale (en m^-1)
+    signal_type : 'cos' ou 'sin'
+    """
     num_els = len(xm)
-    
-    # Cas limite : Fréquence nulle (Décimation 0)
-    if fx == 0:
-        if signal_type == 'cos':
-            # cos(0) = 1 -> Tout est actif
-            mask = np.ones(num_els, dtype=bool)
-        else:
-            # sin(0) = 0 -> Tout est inactif
-            mask = np.zeros(num_els, dtype=bool)
+    num_cols = bool_active_list.shape[1]
+
+    if signal_type == 'cos':
+        mask = (np.cos(2 * np.pi * fx * xm) > 0).astype(float)
+    elif signal_type == 'sin':
+        mask = (np.sin(2 * np.pi * fx * xm) > 0).astype(float)
     else:
-        # Calcul normal pour fx > 0
-        half_period_elements = round(1 / (2 * fx * dx))
-        
-        # Sécurité : si fx est tellement grand que half_period < 1
-        half_period_elements = max(1, half_period_elements)
-        
-        indices = np.arange(num_els)
-        if signal_type == 'cos':
-            mask = ((indices // half_period_elements) % 2 == 0)
-        else:
-            # Déphasage de 90° pour le sinus : on décale d'une demi-demi-période
-            shift = half_period_elements // 2
-            mask = (((indices + shift) // half_period_elements) % 2 == 0)
-            
-    return np.tile(mask[:, np.newaxis], (1, bool_active_list.shape[1]))
+        mask = np.ones(num_els)  # Sécurité
+
+    return np.tile(mask[:, np.newaxis], (1, num_cols))
 
 def convert_to_hex_list(matrix):
     """

AOT_biomaps/AOT_Experiment/Tomography.py

@@ -18,6 +18,8 @@ class Tomography(Experiment):
         self.patterns = None
         self.theta = []
         self.decimations = []
+        self.ActiveList = []
+        self.DelayLaw = []
 
     # PUBLIC METHODS
     def check(self):
@@ -66,8 +68,11 @@ class Tomography(Experiment):
             self.AcousticFields = self._generateAcousticFields_STRUCT_CPU(fieldDataPath, show_log, nameBlock)
             for i in range(len(self.AcousticFields)):
                 profile = hex_to_binary_profile(self.AcousticFields[i].getName_field()[6:-4], self.params.acoustic['num_elements'])
+                self.ActiveList.append(profile)
                 angle = self.AcousticFields[i].angle
                 self.theta.append(angle)
+                Delay = 1000 * (1/self.params.acoustic['c0']) * np.sin(np.deg2rad(angle)) * np.arange(1, self.params.acoustic['num_elements']  + 1) * self.params.acoustic['element_width']
+                self.DelayLaw.append(Delay - np.min(Delay))
 
                 if set(self.AcousticFields[i].getName_field()[6:-4].lower().replace(" ", "")) == {'f'}:
                     fs_key = 0.0 # fs_key est en mm^-1 (0.0 mm^-1)
@@ -83,6 +88,7 @@ class Tomography(Experiment):
 
                 # fs = n * dfx  => n = fs / dfx with dfx = 1/(N*delta_x)
                 self.decimations.append(int(fs_key / (1/(len(profile)*self.params.general['dx']))))
+
         else:
             raise ValueError("Unsupported wave type.")
 
@@ -314,20 +320,8 @@ class Tomography(Experiment):
             raise ValueError("Either N (>=2) or both decimations and angles must be provided for pattern generation.")
       
     def saveAOsignals_matlab(self, filePath):
-        ActiveList = []
-        DelayLaw = []
-        c = self.params.acoustic['c0']
-        NbElemts = self.params.acoustic['num_elements'] 
-        pitch = self.params.acoustic['element_width']
-
-        for i in range(len(self.AcousticFields)):
-            profile = hex_to_binary_profile(self.AcousticFields[i].getName_field()[6:-4], NbElemts)
-            ActiveList.append(profile)
-            angle = self.AcousticFields[i].angle
-            Delay = 1000 * (1/c) * np.sin(np.deg2rad(angle)) * np.arange(1, NbElemts + 1) * pitch
-            DelayLaw.append(Delay - np.min(Delay))
 
-        savemat(filePath, {'data': self.AOsignal_withTumor, 'thetas': self.theta, 'decimations': self.decimations, 'ActiveList' : ActiveList, 'DelayLaw': DelayLaw})
+        savemat(filePath, {'data': self.AOsignal_withTumor, 'thetas': self.theta, 'decimations': self.decimations, 'ActiveList' : self.ActiveList, 'DelayLaw': self.DelayLaw})
 
     def selectAngles(self, angles):
 
@@ -346,6 +340,27 @@ class Tomography(Experiment):
         if self.AOsignal_withoutTumor is not None:
             self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, index]
         self.AcousticFields = newAcousticFields
+        self.theta = [field.angle for field in newAcousticFields]
+        self.decimations = [field.f_s for field in newAcousticFields]   
+
+    def selectDecimations(self, decimations):
+        if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signals are not initialized. Please load or generate the AO signals first.")
+        if self.AcousticFields is None or len(self.AcousticFields) == 0:
+            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+        newAcousticFields = []
+        index = []
+        for i, field in enumerate(self.AcousticFields):
+            if field.f_s in decimations:
+                newAcousticFields.append(field)
+                index.append(i)
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, index]
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, index]
+        self.AcousticFields = newAcousticFields
+        self.decimations = [field.f_s for field in newAcousticFields]   
+        self.theta = [field.angle for field in newAcousticFields]   
 
     def selectPatterns(self, pattern_names):
         if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
@@ -380,75 +395,73 @@ class Tomography(Experiment):
         self.AcousticFields = newAcousticFields
 
     def _genereate_patterns_from_decimations(self, decimations, angles):
-        if isinstance(decimations, list): decimations = np.array(decimations)
-        if isinstance(angles, list): angles = np.array(angles)
+        if isinstance(decimations, list):
+            decimations = np.array(decimations)
+        if isinstance(angles, list):
+            angles = np.array(angles)
 
         angles = np.sort(angles)
         decimations = np.sort(decimations)
 
         num_elements = self.params.acoustic['num_elements']
-        dx_mm = self.params.general['dx'] * 1e3
+        Width = self.params.acoustic['element_width']  # en m
+        kerf = self.params.acoustic.get('kerf', 0.00000)  # en m
+        Nactuators = self.params.acoustic['num_elements']
 
         # --- Calcul du nombre de Scans ---
         if 0 in decimations:
-            Nscans = 4 * angles.shape[0] * (decimations.shape[0] - 1) + angles.shape[0]
-            offSet = angles.shape[0]
+            Nscans = 4 * len(angles) * (len(decimations) - 1) + len(angles)
         else:
-            Nscans = 4 * angles.shape[0] * decimations.shape[0]
-            offSet = 0
+            Nscans = 4 * len(angles) * len(decimations)
 
         ActiveLIST = np.ones((num_elements, Nscans))
-        Xm = np.arange(1, num_elements + 1) * dx_mm
-        dFx = 1 / (num_elements * dx_mm)
 
-        # On traite séparément les décimations non nulles pour la boucle
+        # --- Calcul des positions centrées des éléments (en m) ---
+        Xc = (Width + (Nactuators - 1) * (kerf + Width)) / 2
+        Xm = np.array([Width * (i - 1) + Width / 2 - Xc for i in range(1, Nactuators + 1)])
+
+        # --- Gestion de l'onde plane (tous les piezo ON) au début ---
+        if 0 in decimations:
+            I_plane = np.arange(len(angles))
+            ActiveLIST[:, I_plane] = 1  # Tous les piezo ON pour les len(angles) premières colonnes
+
+        # --- Traitement des décimations non nulles ---
         active_decimations = decimations[decimations != 0]
+        dFx = 1 / (Nactuators * Width)  # fx de base (en m^-1)
 
         for i_dec in range(len(active_decimations)):
-            idx_base = (np.arange(len(angles))) + (i_dec * 4 * len(angles)) + offSet
-            
-            Icos   = idx_base
-            Incos  = idx_base + len(angles)
-            Isin   = idx_base + 2 * len(angles)
-            Insin  = idx_base + 3 * len(angles)
+            # Décalage des indices pour placer les motifs modulés après l'onde plane
+            I = np.arange(len(angles)) + len(angles) + (i_dec * 4 * len(angles))
 
-            fx = dFx * active_decimations[i_dec]
+            Icos   = I
+            Incos  = I + 1* len(angles)
+            Isin   = I + 3 * len(angles)
+            Insin  = I + 2 * len(angles)
 
-            # Remplissage des 4 phases
-            valid_icos = Icos[Icos < Nscans]
-            if valid_icos.size > 0:
-                ActiveLIST[:, valid_icos] = calc_mat_os(Xm, fx, dx_mm, ActiveLIST[:, valid_icos], 'cos')
-                if (Incos < Nscans).any():
-                    ActiveLIST[:, Incos[Incos < Nscans]] = 1 - ActiveLIST[:, valid_icos]
+            fx = dFx * active_decimations[i_dec]
 
-            valid_isin = Isin[Isin < Nscans]
-            if valid_isin.size > 0:
-                ActiveLIST[:, valid_isin] = calc_mat_os(Xm, fx, dx_mm, ActiveLIST[:, valid_isin], 'sin')
-                if (Insin < Nscans).any():
-                    ActiveLIST[:, Insin[Insin < Nscans]] = 1 - ActiveLIST[:, valid_isin]
+            # Appliquer les motifs modulés
+            ActiveLIST[:, Icos] = calc_mat_os(Xm, fx, ActiveLIST[:, Icos[:1]], 'cos')
+            ActiveLIST[:, Incos] = 1 - ActiveLIST[:, Icos]
+            ActiveLIST[:, Isin] = calc_mat_os(Xm, fx, ActiveLIST[:, Isin[:1]], 'sin')
+            ActiveLIST[:, Insin] = 1 - ActiveLIST[:, Isin]
 
         # --- Conversion au format attendu ---
-        # 1. On convertit toute la matrice en liste de strings Hexa
         hexa_list = convert_to_hex_list(ActiveLIST)
 
-        # 2. Fonction interne de formatage d'angle (pour coller à votre ancien code)
         def format_angle(a):
             return f"{'1' if a < 0 else '0'}{abs(a):02d}"
 
-        # 3. Construction de la liste de dictionnaires
         patterns = []
         print(f"Generating {Nscans} patterns from decimations and angles...")
         for i in range(Nscans):
-            # On retrouve l'angle correspondant à l'index i
-            # La logique est cyclique sur la taille de 'angles'
             angle_val = angles[i % len(angles)]
-            
             hex_pattern = hexa_list[i]
             pair = f"{hex_pattern}_{format_angle(angle_val)}"
             patterns.append({"fileName": pair})
 
         return patterns
-    
+ 
     def _generate_patterns(self, N,angles = None):
         def format_angle(a):
             return f"{'1' if a < 0 else '0'}{abs(a):02d}"