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

AOT_biomaps/AOT_Experiment/ExperimentTools.py

@@ -58,3 +58,22 @@ def convert_to_hex_list(matrix):
     # 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/AOT_Experiment/Tomography.py

@@ -2,19 +2,22 @@ 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
+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 = []
 
     # PUBLIC METHODS
     def check(self):
@@ -61,6 +64,25 @@ class Tomography(Experiment):
         """
         if self.TypeAcoustic.value == WaveType.StructuredWave.value:
             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'])
+                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']))))
         else:
             raise ValueError("Unsupported wave type.")
 
@@ -283,15 +305,29 @@ class Tomography(Experiment):
             list: Liste de strings au format "hex_angle".
         """
         if decimations is not None and angles is not None:
-            self._genereate_patterns_from_decimations(decimations, angles)
+            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.")
-        if not self._check_patterns(self.patterns):
-            raise ValueError("Generated patterns failed validation.")
-        
-    
+      
+    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})
 
     def selectAngles(self, angles):
 
@@ -401,6 +437,7 @@ class Tomography(Experiment):
 
         # 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'
@@ -639,6 +676,7 @@ class Tomography(Experiment):
                     AcousticField.save_field(fieldDataPath)
             listAcousticFields.append(AcousticField)
             progress_bar.set_postfix_str("")
+
         return listAcousticFields
 
     def load_experimentalAO(self, pathAO, withTumor = True, h5name='AOsignal'):

AOT_biomaps/AOT_Recon/AnalyticRecon.py

@@ -1,14 +1,107 @@
 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):
         super().__init__(**kwargs)
         self.reconType = ReconType.Analytic
         self.analyticType = analyticType
+        self.AOsignal_demoldulated = None
+
+
+
+    def parse_and_demodulate(self, withTumor=True):
+
+        if withTumor:
+            AOsignal = self.experiment.AOsignal_withTumor
+        else:
+            AOsignal = self.experiment.AOsignal_withoutTumor
+        delta_x = self.experiment.params.general['dx']  # en m 
+        n_piezos = self.experiment.params.acoustic['num_elements']
+        demodulated_data = {}
+        structured_buffer = {} 
+
+        for i in trange(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):
         """
@@ -34,6 +127,7 @@ class AnalyticRecon(Recon):
             analyticType: The type of analytic reconstruction to perform (default is iFOURIER).
         """
         if withTumor:
+            self.AOsignal_demoldulated = self.parse_and_demodulate(withTumor=True)
             if self.analyticType == AnalyticType.iFOURIER:
                 self.reconPhantom = self._iFourierRecon(self.experiment.AOsignal_withTumor)
             elif self.analyticType == AnalyticType.iRADON:
@@ -41,6 +135,7 @@ class AnalyticRecon(Recon):
             else:            
                 raise ValueError(f"Unknown analytic type: {self.analyticType}")
         else:
+            self.AOsignal_demoldulated = self.parse_and_demodulate(withTumor=False)
             if self.analyticType == AnalyticType.iFOURIER:
                 self.reconLaser = self._iFourierRecon(self.experiment.AOsignal_withoutTumor)
             elif self.analyticType == AnalyticType.iRADON:

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):
     """
@@ -483,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/__init__.py

@@ -85,7 +85,7 @@ from .AOT_Recon.AOT_PotentialFunctions.RelativeDifferences import *
 from .Config import config
 from .Settings import *
 
-__version__ = '2.9.323'
+__version__ = '2.9.339'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -170,6 +170,22 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

{aot_biomaps-2.9.323.dist-info → aot_biomaps-2.9.339.dist-info}/METADATA

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

{aot_biomaps-2.9.323.dist-info → aot_biomaps-2.9.339.dist-info}/RECORD

@@ -1,6 +1,6 @@
 AOT_biomaps/Config.py,sha256=ghEOP1n8aO1pR-su13wMeAZAxZRfry5hH67NbtZ8SqI,3614
 AOT_biomaps/Settings.py,sha256=v8fPhnvvcfBJP29m1RLOTEr3jndGLGwbUiORXmsj2Bo,2853
-AOT_biomaps/__init__.py,sha256=CzNrJamLw5SZZ9fGeXRnGrBUqSj90vh2wZx1792YWto,4308
+AOT_biomaps/__init__.py,sha256=r0H6FXsW0n-ethz4CgAmwp24IOM9OaxvBLKxLkZ0We0,4340
 AOT_biomaps/AOT_Acoustic/AcousticEnums.py,sha256=s5kXa6jKzbS4btwbubrVcynLOr0yg5tth5vL_FGfbMk,1802
 AOT_biomaps/AOT_Acoustic/AcousticTools.py,sha256=h2sCtGVcDtyLtEF1q7sLZmuWivWmesVGUBPnW-ndQqc,7535
 AOT_biomaps/AOT_Acoustic/FocusedWave.py,sha256=3kGKKDx_3Msy5COYqIwzROPORGWvNjw8UsDanBfkMXE,11037
@@ -9,9 +9,9 @@ AOT_biomaps/AOT_Acoustic/PlaneWave.py,sha256=xza-rj5AUWDecLkGDxRcULrwZVWeBvGnEP2
 AOT_biomaps/AOT_Acoustic/StructuredWave.py,sha256=jTLVlOhYLWJb5MxZPxhq3OFVlz2McoyMPBmfLvnekDU,18209
 AOT_biomaps/AOT_Acoustic/__init__.py,sha256=t9M2rRqa_L9pk7W2FeELTkHEMuP4DBr4gBRldMqsQbg,491
 AOT_biomaps/AOT_Acoustic/_mainAcoustic.py,sha256=RdmhRF1i0KAlpsP7_wnZ7F4J27br3eUc4XR91Qq7C64,44158
-AOT_biomaps/AOT_Experiment/ExperimentTools.py,sha256=BkHSX_foyyj5UrHZWQH5F9DGeV8o2fkp3euEbcvE4vA,2399
+AOT_biomaps/AOT_Experiment/ExperimentTools.py,sha256=EyTIwgxTK-FqJYlhdjgirfWCSL1kTp-IOS0tTgiAVNA,3153
 AOT_biomaps/AOT_Experiment/Focus.py,sha256=B2nBawmv-NG2AWJx9zgQ8GlN6aFB9FwTSqX-M-phKXg,3193
-AOT_biomaps/AOT_Experiment/Tomography.py,sha256=-7HfRDPchTRwxm0SObU_pGN3FH4HN6b1WJvLuacGzFU,34672
+AOT_biomaps/AOT_Experiment/Tomography.py,sha256=3JlslI9GNZy-u0uYgf0u9qyaVAQki6cYTHhcGK33aFg,36747
 AOT_biomaps/AOT_Experiment/__init__.py,sha256=H9zMLeBLA6uhbaHohAa-2u5mDDxqJi8oE5c6tShdQp8,308
 AOT_biomaps/AOT_Experiment/_mainExperiment.py,sha256=zSfuNrsz7nhiKrGIdK6CAXjlI2T6qYC5-JXHFgPNzhc,24674
 AOT_biomaps/AOT_Optic/Absorber.py,sha256=jEodzRy7gkEH-wbazVasRQiri0dU16BfapmR-qnTSvM,867
@@ -21,12 +21,12 @@ AOT_biomaps/AOT_Optic/__init__.py,sha256=HSUVhfz0NzwHHZZ9KP9Xyfu33IgP_rYJX86J-gE
 AOT_biomaps/AOT_Optic/_mainOptic.py,sha256=Wk63CcgWbU-ygMfjNK80islaUbGGJpTXgZY3_C2KQNY,8179
 AOT_biomaps/AOT_Recon/AOT_biomaps_kernels.cubin,sha256=JWy-bdtBTZdnNlDbJGZKwXyF-2u1wICtmlOC_YxEL6o,82528
 AOT_biomaps/AOT_Recon/AlgebraicRecon.py,sha256=CGBXZyYEZ3TOTFOKSt-h7NGuFbuI9PNr3YTWTbSLxDo,46832
-AOT_biomaps/AOT_Recon/AnalyticRecon.py,sha256=RaQ5AJ1HUmSct0BgjZ0GWSJg7SALCn3Q0laqj1yyhAE,7123
+AOT_biomaps/AOT_Recon/AnalyticRecon.py,sha256=NKO7nE2Roq3E9HzMf_eJobm7rNQK1xzaQ0W9zXic9CY,11067
 AOT_biomaps/AOT_Recon/BayesianRecon.py,sha256=RnnPa-tTcvirwiNPnCRZnSM4NWeEEltYET-piBbp34g,12671
 AOT_biomaps/AOT_Recon/DeepLearningRecon.py,sha256=RfVcEsi4GeGqJn0_SPxwQPQx6IQjin79WKh2UarMRLI,1383
 AOT_biomaps/AOT_Recon/PrimalDualRecon.py,sha256=JbFhxiyUoSTnlJgHbOWIfUUwhwfZoi39RJMnfkagegY,16504
 AOT_biomaps/AOT_Recon/ReconEnums.py,sha256=KAf55RqHAr2ilt6pxFrUBGQOn-7HA8NP6TyL-1FNiXo,19714
-AOT_biomaps/AOT_Recon/ReconTools.py,sha256=py1zKVEa0j7EfmcNZS2lpVQwzlkY6rRWsDQ8izWlme4,19872
+AOT_biomaps/AOT_Recon/ReconTools.py,sha256=-ZbzRHSzUprjzPRGCJeBiow_2AEvS2IzCSrv3XfzpLs,21307
 AOT_biomaps/AOT_Recon/__init__.py,sha256=xs_argJqXKFl76xP7-jiUc1ynOEEtY7XZ0gDxD5uVZc,246
 AOT_biomaps/AOT_Recon/_mainRecon.py,sha256=exoa2UBMfMHjemxAU9dW0mhEfsP6Oe1qjSfrTrgbIcY,13125
 AOT_biomaps/AOT_Recon/AOT_Optimizers/DEPIERRO.py,sha256=qA1n722GLQJH3V8HcLr5q_GxEwBS_NRlIT3E6JZk-Ag,9479
@@ -42,7 +42,7 @@ AOT_biomaps/AOT_Recon/AOT_PotentialFunctions/__init__.py,sha256=RwrJdLOFbAFBFnRx
 AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_CSR.py,sha256=RACc2P5oxmp0uPLAGnNj9mEtAxa_OlepNgCawKij3jI,12062
 AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py,sha256=ti3dZQsb_Uu62C7Bn65Z-yf-R5NKCFsmnBT5GlLd_HY,15138
 AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/__init__.py,sha256=8nou-hqjQjuCTLhoL5qv4EM_lMPFviAZAZKSPhi84jE,67
-aot_biomaps-2.9.323.dist-info/METADATA,sha256=9n72wEg-tUeIC9EWY6rFRJCpFwBOnly-3IQZSVdvLts,700
-aot_biomaps-2.9.323.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aot_biomaps-2.9.323.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
-aot_biomaps-2.9.323.dist-info/RECORD,,
+aot_biomaps-2.9.339.dist-info/METADATA,sha256=3XoTP8HukgXdJdBPQC66FjZ5q-SvOn5LhVETzFDXvfY,700
+aot_biomaps-2.9.339.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aot_biomaps-2.9.339.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
+aot_biomaps-2.9.339.dist-info/RECORD,,