AOT-biomaps 2.9.312__tar.gz → 2.9.332__tar.gz

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps/AOT_Acoustic/AcousticTools.py

@@ -157,8 +157,6 @@ def calculate_envelope_squared(field):
         print(f"Erreur dans calculate_envelope_squared: {e}")
         raise
 
-
-
 def getPattern(pathFile):
     """
     Get the pattern from a file path.

aot_biomaps-2.9.332/AOT_biomaps/AOT_Experiment/ExperimentTools.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+def calc_mat_os(xm, fx, dx, bool_active_list, signal_type):
+    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)
+    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]))
+
+def convert_to_hex_list(matrix):
+    """
+    Convertit une matrice binaire en liste de strings hexa (paquets de 4 bits).
+    Chaque colonne devient une chaîne de caractères.
+    """
+    n_els, n_scans = matrix.shape
+    
+    # 1. Padding pour s'assurer que n_els est multiple de 4
+    remainder = n_els % 4
+    if remainder != 0:
+        padding = np.zeros((4 - remainder, n_scans))
+        matrix = np.vstack([matrix, padding])
+    
+    # 2. Reshape pour isoler des blocs de 4 bits (nibbles)
+    # Shape résultante : (Nombre de blocs, 4 bits, Nombre de scans)
+    blocks = matrix.reshape(-1, 4, n_scans)
+    
+    # 3. Calcul de la valeur décimale de chaque bloc (0 à 15)
+    # On considère le premier élément comme le bit de poids faible (LSB)
+    weights = np.array([1, 2, 4, 8]).reshape(1, 4, 1)
+    dec_values = np.sum(blocks * weights, axis=1).astype(int)
+    
+    # 4. Conversion en caractères Hexadécimaux
+    # On définit la table de conversion pour la rapidité
+    hex_table = np.array(list("0123456789abcdef"))
+    hex_matrix = hex_table[dec_values]
+    
+    # 5. Assemblage des chaînes (de l'élément N vers 0 pour l'ordre Shift Register standard)
+    return ["".join(hex_matrix[::-1, col]) for col in range(n_scans)]
+
+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-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps/AOT_Experiment/Tomography.py

@@ -2,18 +2,43 @@ from ._mainExperiment import Experiment
 from AOT_biomaps.AOT_Acoustic.AcousticEnums import WaveType
 from AOT_biomaps.AOT_Acoustic.StructuredWave import StructuredWave
 from AOT_biomaps.Config import config
+from AOT_biomaps.AOT_Experiment.ExperimentTools import calc_mat_os, convert_to_hex_list, hex_to_binary_profile
 import os
 import psutil
 import numpy as np
 import matplotlib.pyplot as plt
 from tqdm import trange
 import h5py
-from scipy.io import loadmat
+from scipy.io import loadmat, savemat
+
 
 class Tomography(Experiment):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.patterns = None
+        self.theta = []
+        self.decimations = []
+    
+
+        for i in range(len(self.AcousticFields)):
+            profile = hex_to_binary_profile(self.AcousticFields[i].getName_field()[6:-4], self.params.acoustic['num_elements'])
+            angle = self.AcousticFields[i].angle
+            self.theta.append(angle)
+
+            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)
+            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.general['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
+
+            # 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']))))
 
     # PUBLIC METHODS
     def check(self):
@@ -273,7 +298,7 @@ class Tomography(Experiment):
                     line = f"({coords}, {angles})\n"
                     file.write(line)
 
-    def generateActiveList(self, N):
+    def generateActiveList(self, N = None, decimations = None, angles = None):
         """
         Génère une liste de patterns d'activation équilibrés et réguliers.
         Args:
@@ -281,13 +306,153 @@ class Tomography(Experiment):
         Returns:
             list: Liste de strings au format "hex_angle".
         """
-        if N < 1:
-            raise ValueError("N must be a positive integer.")
-        self.patterns = self._generate_patterns(N)
-        if not self._check_patterns(self.patterns):
-            raise ValueError("Generated patterns failed validation.")
+        if decimations is not None and angles is not None:
+            self.patterns = self._genereate_patterns_from_decimations(decimations, angles)
+        elif N is not None and N > 1:
+            self.patterns = self._generate_patterns(N)
+            if not self._check_patterns(self.patterns):
+                raise ValueError("Generated patterns failed validation.")
+        else:
+            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['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})
+
+    def selectAngles(self, angles):
+
+        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.angle in angles:
+                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
+
+    def selectPatterns(self, pattern_names):
+        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.pattern.activeList in pattern_names:
+                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
+
+    def selectRandom(self,N):
+        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.")
+        if N > len(self.AcousticFields):
+            raise ValueError("N is larger than the number of available AcousticFields.")
+        indices = np.random.choice(len(self.AcousticFields), size=N, replace=False)
+        newAcousticFields = [self.AcousticFields[i] for i in indices]
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, indices]    
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, indices]
+        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)
+
+        angles = np.sort(angles)
+        decimations = np.sort(decimations)
+
+        num_elements = self.params.acoustic['num_elements']
+        dx_mm = self.params.general['dx'] * 1e3
+
+        # --- 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]
+        else:
+            Nscans = 4 * angles.shape[0] * decimations.shape[0]
+            offSet = 0
+
+        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
+        active_decimations = decimations[decimations != 0]
+
+        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)
+
+            fx = dFx * active_decimations[i_dec]
+
+            # 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]
+
+            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]
+
+        # --- 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})
 
-    def _generate_patterns(self, N):
+        return patterns
+    
+    def _generate_patterns(self, N,angles = None):
         def format_angle(a):
             return f"{'1' if a < 0 else '0'}{abs(a):02d}"
 
@@ -298,7 +463,13 @@ class Tomography(Experiment):
             return hex_string
 
         num_elements = self.params.acoustic['num_elements']
-        angle_choices = list(range(-20, 21))
+        if angles is None:
+            angle_choices = list(range(-20, 21))
+        else:
+            # convert np.array to list if necessary
+            if isinstance(angles, np.ndarray):
+                angles = angles.tolist()
+            angle_choices = angles
 
         # 1. Trouver TOUS les diviseurs PAIRS de num_elements (y compris num_elements)
         divs = [d for d in range(2, num_elements + 1) if num_elements % d == 0 and d % 2 == 0]
@@ -390,6 +561,80 @@ class Tomography(Experiment):
 
         return True
 
+    def applyApodisation(self, alpha=0.3, divergence_deg=0.5):
+        """
+        Applique une apodisation dynamique sur les champs acoustiques stockés dans l'objet.
+        L'apodisation suit l'angle d'émission et la divergence naturelle du faisceau pour
+        supprimer les lobes de diffraction (artefacts de bord) sans toucher au signal utile.
+        Args:
+            probe_width (float): Largeur physique active de la sonde (ex: 40e-3 pour 40mm).
+            alpha (float): Paramètre de Tukey (0.0=rectangle, 1.0=hann). 0.3 est un bon compromis.
+            divergence_deg (float): Angle d'ouverture du masque pour suivre l'élargissement du faisceau.
+                                    0.0 = Droit, 0.5 = Légère ouverture (conseillé).
+        """
+        print(f"Applying apodization (Alpha={alpha}, Div={divergence_deg}°) on {len(self.AcousticFields)} fields...")
+        
+        probe_width = self.params.acoustic['num_elements'] * self.params.acoustic['element_width']
+
+        for i in trange(len(self.AcousticFields), desc="Apodisation"):
+            # 1. Récupération des données et de l'angle
+            field = self.AcousticFields[i].field  # Peut être (Z, X) ou (Time, Z, X)
+            angle = self.AcousticFields[i].angle  # L'angle de l'onde plane
+
+            # 2. Récupération ou construction des axes physiques
+            nz, nx = field.shape[-2:]
+
+            if hasattr(self, 'x_axis') and self.x_axis is not None:
+                x_axis = self.x_axis
+            else:
+                # Génération par défaut centrée sur 0 (ex: -20mm à +20mm)
+                x_axis = np.linspace(-probe_width/2, probe_width/2, nx)
+
+            if hasattr(self, 'z_axis') and self.z_axis is not None:
+                z_axis = self.z_axis
+            else:
+                # Génération par défaut (ex: 0 à 40mm, basé sur un pitch standard ou arbitraire)
+                estimated_depth = 40e-3  # Valeur arbitraire si inconnue
+                z_axis = np.linspace(0, estimated_depth, nz)
+
+            # 3. Préparation des grilles pour le masque
+            Z, X = np.meshgrid(z_axis, x_axis, indexing='ij')
+
+            # 4. Calcul de la géométrie orientée (Steering)
+            angle_rad = np.deg2rad(angle)
+            X_aligned = X - Z * np.tan(angle_rad)
+
+            # 5. Calcul de la largeur dynamique du masque (Divergence)
+            div_rad = np.deg2rad(divergence_deg)
+            current_half_width = (probe_width / 2.0) + Z * np.tan(div_rad)
+
+            # 6. Normalisation et création du masque Tukey
+            X_norm = np.divide(X_aligned, current_half_width, out=np.zeros_like(X_aligned), where=current_half_width!=0)
+
+            mask = np.zeros_like(X_norm)
+            plateau_threshold = 1.0 * (1 - alpha)
+
+            # Zone centrale (plateau = 1)
+            mask[np.abs(X_norm) <= plateau_threshold] = 1.0
+
+            # Zone de transition (cosinus)
+            transition_indices = (np.abs(X_norm) > plateau_threshold) & (np.abs(X_norm) <= 1.0)
+            if np.any(transition_indices):
+                x_trans = np.abs(X_norm[transition_indices]) - plateau_threshold
+                width_trans = 1.0 * alpha
+                mask[transition_indices] = 0.5 * (1 + np.cos(np.pi * x_trans / width_trans))
+
+            # 7. Application du masque (Gestion 2D vs 3D)
+            if field.ndim == 3:
+                field_apodized = field * mask[np.newaxis, :, :]
+            else:
+                field_apodized = field * mask
+
+            # 8. Mise à jour de l'objet
+            self.AcousticFields[i].field = field_apodized
+
+        print("Apodisation done.")
+
     # PRIVATE METHODS
     def _generateAcousticFields_STRUCT_CPU(self, fieldDataPath=None, show_log=False, nameBlock=None):
         if self.patterns is None:

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps/AOT_Recon/AOT_Optimizers/MLEM.py

@@ -547,4 +547,5 @@ def MLEM_sparseSELL_pycuda(
             try:
                 SMatrix.ctx.pop()
             except Exception:
-                pass
+                pass
+            

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps/AOT_Recon/AnalyticRecon.py

@@ -1,8 +1,13 @@
 from ._mainRecon import Recon
 from .ReconEnums import ReconType, AnalyticType, ProcessType
+from AOT_biomaps.AOT_Experiment.Tomography import hex_to_binary_profile
+from .ReconTools import get_phase_deterministic
 
 import numpy as np
 from tqdm import trange
+import torch
+import tqdm
+
 
 class AnalyticRecon(Recon):
     def __init__(self, analyticType, **kwargs):
@@ -10,6 +15,94 @@ class AnalyticRecon(Recon):
         self.reconType = ReconType.Analytic
         self.analyticType = analyticType
 
+
+
+    def parse_and_demodulate(self, withTumor=True):
+
+        if withTumor:
+            AOsignal = self.experiment.AOsignal_withTumor
+        else:
+            AOsignal = self.experiment.AOsignal_withoutTumor
+        delta_x = self.params.acoustic['dx']  # en m 
+        n_piezos = self.params.acoustic['num_elements']
+        demodulated_data = {}
+        structured_buffer = {} 
+
+        for i in tqdm(range(len(self.experiment.AcousticFields)), desc="Demodulating AO signals"):
+            label = self.experiment.AcousticFields[i].getName_field()
+            
+            parts = label.split("_")
+            hex_pattern = parts[0]
+            angle_code = parts[-1]
+            
+            # Angle
+            if angle_code.startswith("1"):
+                angle_deg = -int(angle_code[1:])
+            else:
+                angle_deg = int(angle_code)
+            angle_rad = np.deg2rad(angle_deg)
+            
+            # Onde Plane (f_s = 0)
+            if set(hex_pattern.lower().replace(" ", "")) == {'f'}:
+                fs_key = 0.0 # fs_key est en mm^-1 (0.0 mm^-1)
+                demodulated_data[(fs_key, angle_rad)] = np.array(AOsignal[i])
+                continue
+                
+            # Onde Structurée
+            profile = hex_to_binary_profile(hex_pattern, n_piezos)
+            
+            # Calcul FS (Fréquence de Structuration)
+            ft_prof = np.fft.fft(profile)
+            # On regarde uniquement la partie positive non DC
+            idx_max = np.argmax(np.abs(ft_prof[1:len(profile)//2])) + 1
+            freqs = np.fft.fftfreq(len(profile), d=delta_x)
+            
+            # freqs est en m^-1 car delta_x est en mètres.
+            fs_m_inv = abs(freqs[idx_max]) 
+            
+            # *** CORRECTION 1: Conversion de f_s en mm^-1 (mm^-1 est utilisé dans iRadon) ***
+            fs_key = fs_m_inv / 1000.0 # Fréquence spatiale en mm^-1
+
+            
+            if fs_key == 0: continue
+
+            # Calcul de la Phase (Shift)
+            phase = get_phase_deterministic(profile)
+            
+            # Stockage par (fs, theta) et phase
+            key = (fs_key, angle_rad)
+            if key not in structured_buffer:
+                structured_buffer[key] = {}
+            
+            # La moyenne est nécessaire si plusieurs acquisitions ont la même phase (pour le SNR) 
+            if phase in structured_buffer[key]:
+                structured_buffer[key][phase] = (structured_buffer[key][phase] + np.array(AOsignal[i])) / 2
+            else:
+                structured_buffer[key][phase] = np.array(AOsignal[i])
+
+
+        
+        for (fs, theta), phases in structured_buffer.items():
+            s0 = phases.get(0.0, 0)
+            s_pi_2 = phases.get(np.pi/2, 0)
+            s_pi = phases.get(np.pi, 0)
+            s_3pi_2 = phases.get(3*np.pi/2, 0)
+
+            # Assurer que les zéros sont des vecteurs de la bonne taille
+            example = next(val for val in phases.values() if not isinstance(val, int))
+            if isinstance(s0, int): s0 = np.zeros_like(example)
+            if isinstance(s_pi, int): s_pi = np.zeros_like(example)
+            if isinstance(s_pi_2, int): s_pi_2 = np.zeros_like(example)
+            if isinstance(s_3pi_2, int): s_3pi_2 = np.zeros_like(example)
+
+            real = s0 - s_pi
+            imag = s_pi_2 - s_3pi_2 
+            
+            
+            demodulated_data[(fs, theta)] = (real - 1j * imag) / (2/np.pi)
+
+        return demodulated_data
+
     def run(self, processType = ProcessType.PYTHON, withTumor= True):
         """
         This method is a placeholder for the analytic reconstruction process.

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps/AOT_Recon/ReconTools.py

@@ -6,6 +6,7 @@ import pycuda.driver as drv
 from numba import njit, prange
 from torch_sparse import coalesce
 from scipy.signal.windows import hann
+from itertools import groupby
 
 def load_recon(hdr_path):
     """
@@ -221,7 +222,6 @@ def calculate_memory_requirement(SMatrix, y):
     # --- 3. Final Result ---
     return total_bytes / (1024 ** 3)
 
-
 def check_gpu_memory(device_index, required_memory, show_logs=True):
     """Check if enough memory is available on the specified GPU."""
     free_memory, _ = torch.cuda.mem_get_info(f"cuda:{device_index}")
@@ -252,7 +252,6 @@ def _backward_projection(SMatrix, e_p, c_p):
                     total += SMatrix[_t, _z, _x, _n] * e_p[_t, _n]
             c_p[_z, _x] = total
 
-
 def _build_adjacency_sparse(Z, X, device, corner=(0.5 - np.sqrt(2) / 4) / np.sqrt(2), face=0.5 - np.sqrt(2) / 4,dtype=torch.float32):
     rows, cols, weights = [], [], []
     for z in range(Z):
@@ -273,7 +272,6 @@ def _build_adjacency_sparse(Z, X, device, corner=(0.5 - np.sqrt(2) / 4) / np.sqr
     index, values = coalesce(index, values, m=Z*X, n=Z*X)
     return index, values
 
-
 def power_method(P, PT, data, Z, X, n_it=10):
     x = torch.randn(Z * X, device=data.device)
     x = x / torch.norm(x)
@@ -486,4 +484,48 @@ def power_method_estimate_L__SELL(SMatrix, stream, n_it=20, block_size=256):
             g.free()
         except:
             pass
-    return max(L_sq, 1e-6)
+    return max(L_sq, 1e-6)
+
+def get_phase_deterministic(profile):
+    """
+    Détermine la phase en se basant sur la valeur initiale (0 ou 1) et l'état
+    de décalage (is_shifted) de la séquence binaire.
+    
+    ATTENTION: Cette fonction est conservée mais la logique est souvent simplifiée
+    en pratique si les labels garantissent les phases 0, pi/2, pi, 3pi/2.
+    """
+    runs = [(k, sum(1 for _ in g)) for k, g in groupby(profile)]
+    if not runs: return 0.0
+    
+    nominal_half_period = max([r[1] for r in runs]) 
+    if nominal_half_period == 0: return 0.0
+
+    first_val = runs[0][0] # 0 ou 1
+    first_len = runs[0][1] 
+    # Détection de cycle 50%
+    is_shifted = (0.3 < first_len / nominal_half_period < 0.7) 
+    
+    # --- LOGIQUE DE MAPPAGE DE PHASE SIMPLIFIÉE (idx 1 à 4) ---
+    
+    if first_val == 0: 
+        if is_shifted:
+            idx = 3 # C1/C3 décalé (phi_1 ou phi_3)
+        else:
+            idx = 4 # C2/C4 non décalé
+    else: # first_val == 1
+        if is_shifted:
+            idx = 1 # C1/C3 décalé (phi_1 ou phi_3)
+        else:
+            idx = 2 # C2/C4 non décalé
+
+    # On utilise les phases de quadrature 0, pi/2, pi, 3pi/2 
+    if idx == 1:
+        phase = 0
+    elif idx == 2 :
+        phase = np.pi/2
+    elif idx == 3 :
+        phase = np.pi
+    elif idx == 4 :
+        phase = 3*np.pi/2
+            
+    return phase

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps/__init__.py

@@ -85,7 +85,7 @@ from .AOT_Recon.AOT_PotentialFunctions.RelativeDifferences import *
 from .Config import config
 from .Settings import *
 
-__version__ = '2.9.312'
+__version__ = '2.9.332'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -156,6 +156,26 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AOT_biomaps
-Version: 2.9.312
+Version: 2.9.332
 Summary: Acousto-Optic Tomography
 Home-page: https://github.com/LucasDuclos/AcoustoOpticTomography
 Author: Lucas Duclos

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/AOT_biomaps.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ AOT_biomaps/AOT_Acoustic/PlaneWave.py
 AOT_biomaps/AOT_Acoustic/StructuredWave.py
 AOT_biomaps/AOT_Acoustic/__init__.py
 AOT_biomaps/AOT_Acoustic/_mainAcoustic.py
+AOT_biomaps/AOT_Experiment/ExperimentTools.py
 AOT_biomaps/AOT_Experiment/Focus.py
 AOT_biomaps/AOT_Experiment/Tomography.py
 AOT_biomaps/AOT_Experiment/__init__.py

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AOT_biomaps
-Version: 2.9.312
+Version: 2.9.332
 Summary: Acousto-Optic Tomography
 Home-page: https://github.com/LucasDuclos/AcoustoOpticTomography
 Author: Lucas Duclos

{aot_biomaps-2.9.312 → aot_biomaps-2.9.332}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='AOT_biomaps',
-    version='2.9.312',
+    version='2.9.332',
     packages=find_packages(),
     include_package_data=True,
     
@@ -314,6 +314,26 @@ setup(
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+