AOT-biomaps 2.9.356__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/Tomography.py

@@ -340,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:
@@ -440,8 +461,7 @@ class Tomography(Experiment):
             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}"

AOT_biomaps/AOT_Recon/AnalyticRecon.py

@@ -18,91 +18,6 @@ class AnalyticRecon(Recon):
         self.Lc = Lc # in meters
         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):
         """
         This method is a placeholder for the analytic reconstruction process.
@@ -126,8 +41,13 @@ class AnalyticRecon(Recon):
         Parameters:
             analyticType: The type of analytic reconstruction to perform (default is iFOURIER).
         """
+        if withTumor:
+            AOsignal = self.experiment.AOsignal_withTumor
+        else:
+            AOsignal = self.experiment.AOsignal_withoutTumor
+
         d_t = 1 / float(self.experiment.params.acoustic['f_saving'])
-        t_array = np.arange(0, self.experiment.AOsignal_withTumor.shape[0])*d_t
+        t_array = np.arange(0, AOsignal.shape[0])*d_t
         Z = t_array * self.experiment.params.acoustic['c0']
         X_m = np.arange(0, self.experiment.params.acoustic['num_elements'])* self.experiment.params.general['dx']
         dfX = 1 / (X_m[1] - X_m[0]) / len(X_m)
@@ -135,7 +55,7 @@ class AnalyticRecon(Recon):
             self.AOsignal_demoldulated = self.parse_and_demodulate(withTumor=True)
             if self.analyticType == AnalyticType.iFOURIER:
                 self.reconPhantom = self._iFourierRecon(
-                    R = self.experiment.AOsignal_withTumor,
+                    R = AOsignal,
                     z = Z,    
                     X_m=X_m,
                     theta=self.experiment.theta,
@@ -148,7 +68,7 @@ class AnalyticRecon(Recon):
                     
             elif self.analyticType == AnalyticType.iRADON:
                 self.reconPhantom = self._iRadonRecon(
-                    R=self.experiment.AOsignal_withTumor,
+                    R=AOsignal,
                     z=Z,
                     X_m=X_m,
                     theta=self.experiment.theta,
@@ -165,7 +85,7 @@ class AnalyticRecon(Recon):
             self.AOsignal_demoldulated = self.parse_and_demodulate(withTumor=False)
             if self.analyticType == AnalyticType.iFOURIER:
                 self.reconLaser = self._iFourierRecon(
-                    R = self.experiment.AOsignal_withoutTumor,
+                    R = AOsignal    ,
                     z = Z,    
                     X_m=X_m,
                     theta=self.experiment.theta,
@@ -177,7 +97,7 @@ class AnalyticRecon(Recon):
                 )
             elif self.analyticType == AnalyticType.iRADON:
                 self.reconLaser = self._iRadonRecon(
-                    R=self.experiment.AOsignal_withoutTumor,
+                    R=AOsignal  ,
                     z=Z,
                     X_m=X_m,
                     theta=self.experiment.theta,
@@ -203,7 +123,14 @@ class AnalyticRecon(Recon):
         ActiveLIST,
         withTumor,
     ):
-        # --- 1. Préparation des données ---
+        """
+        Reconstruction d'image utilisant la méthode iFourier (GPU).
+        Normalisation physique complète incluse.
+        """
+
+        # ======================================================
+        # 1. Préparation GPU
+        # ======================================================
         R = cp.asarray(R)
         z = cp.asarray(z)
         X_m = cp.asarray(X_m)
@@ -211,28 +138,26 @@ class AnalyticRecon(Recon):
         decimation = cp.asarray(decimation)
         DelayLAWS = cp.asarray(DelayLAWS)
         ActiveLIST = cp.asarray(ActiveLIST)
-        # Normalisation DelayLAWS (ms → s si besoin)
-        DelayLAWS_s = cp.where(cp.max(DelayLAWS) > 1e-3, DelayLAWS / 1000.0, DelayLAWS)
-        # Regroupement tirs (décimation, angle)
-        ScanParam_cpu = cp.asnumpy(
-            cp.stack([decimation, cp.round(theta, 4)], axis=1)
-        )
 
-        _, ia_cpu, ib_cpu = np.unique(
-            ScanParam_cpu, axis=0, return_index=True, return_inverse=True
-        )
+        # Normalisation DelayLAWS (ms -> s si nécessaire)
+        DelayLAWS_s = cp.where(cp.max(DelayLAWS) > 1e-3, DelayLAWS / 1000.0, DelayLAWS)
 
+        # Regroupement tirs (CPU pour np.unique plus rapide)
+        ScanParam_cpu = cp.asnumpy(cp.stack([decimation, cp.round(theta, 4)], axis=1))
+        _, ia_cpu, ib_cpu = np.unique(ScanParam_cpu, axis=0, return_index=True, return_inverse=True)
         ia = cp.asarray(ia_cpu)
         ib = cp.asarray(ib_cpu)
 
- 
-        # --- 2. Structuration complexe ---
-        # add_sincos_gpu doit être l'équivalent GPU de add_sincos_cpu
+        # ======================================================
+        # 2. Structuration complexe
+        # ======================================================
         F_complex_cpu, theta_u_cpu, decim_u_cpu = add_sincos_cpu(
-        cp.asnumpy(R),
-        cp.asnumpy(decimation),
-        np.radians(cp.asnumpy(theta))
+            cp.asnumpy(R),
+            cp.asnumpy(decimation),
+            np.radians(cp.asnumpy(theta))
         )
+
+        # Calcul des centres de rotation
         M0 = EvalDelayLawOS_center(
             X_m,
             theta_u_cpu,
@@ -241,29 +166,38 @@ class AnalyticRecon(Recon):
             c
         )
 
-        # Transfert GPU (UNE FOIS)
+        # Transfert GPU
         F_complex = cp.asarray(F_complex_cpu)
         theta_u = cp.asarray(theta_u_cpu)
         decim_u = cp.asarray(decim_u_cpu)
+        M0_gpu = cp.asarray(M0)
 
+        # ======================================================
+        # 3. Paramètres de la grille
+        # ======================================================
         Nz = z.size
         Nx = X_m.size
         dx = X_m[1] - X_m[0]
-
         X_grid, Z_grid = cp.meshgrid(X_m, z)
         idx0_x = Nx // 2
-        # Angles uniques après compression
-        angles_group, ia_u, ib_u = cp.unique(
-            theta_u, return_index=True, return_inverse=True
-        )
+
+        # Angles uniques
+        angles_group, ia_u, ib_u = cp.unique(theta_u, return_index=True, return_inverse=True)
         Ntheta = angles_group.size
 
+        # Initialisation reconstruction
         I_final = cp.zeros((Nz, Nx), dtype=cp.complex64)
 
-        # --- 3. Boucle InverseFourierX ---
-        for i_ang in trange(Ntheta, desc=f"AOT-BioMaps -- Analytic Reconstruction Tomography: iFourier ({'with tumor' if withTumor else 'without tumor'})  ---- processing on single GPU ----", unit="angle"):
+        # ======================================================
+        # 4. Boucle Inverse Fourier X
+        # ======================================================
+        for i_ang in trange(
+            Ntheta,
+            desc=f"AOT-BioMaps -- iFourier ({'with tumor' if withTumor else 'without tumor'}) -- GPU",
+            unit="angle"
+        ):
 
-            # Grille (z, fx)
+            # Grille Fourier locale (z, fx)
             F_fx_z = cp.zeros((Nz, Nx), dtype=cp.complex64)
 
             # Indices correspondant à cet angle
@@ -278,7 +212,7 @@ class AnalyticRecon(Recon):
                 if 0 <= ip < Nx:
                     F_fx_z[:, ip] = trace_z
 
-                # Mapping négatif (symétrie hermitienne Matlab)
+                # Mapping négatif (symétrie hermitienne MATLAB)
                 if n != 0:
                     im = idx0_x - n
                     if 0 <= im < Nx:
@@ -289,21 +223,30 @@ class AnalyticRecon(Recon):
             # Correction DC
             F_fx_z[:, idx0_x] *= 0.5
 
-            # --- Inverse Fourier X (GPU) ---
+            # Inverse Fourier X (GPU) + facteur Nx pour correspondance MATLAB
             I_spatial = ifourierx_gpu(F_fx_z, dx) * Nx
 
-            # --- Rotation spatiale GPU ---
+            # Rotation spatiale autour du centre M0
             I_rot = rotate_theta_gpu(
                 X_grid,
                 Z_grid,
                 I_spatial,
                 -angles_group[i_ang],
-                M0[i_ang, :]
+                M0_gpu[i_ang, :]
             )
 
-            # Somme incohérente (OriginIm = sum)
+            # Somme incohérente
             I_final += I_rot
-        I_final /= Ntheta
+
+        # ======================================================
+        # 5. Normalisation physique finale
+        # ======================================================
+        Ntheta_total = len(theta_u)
+        Ntirs_complex = (R.shape[1] - Ntheta_total) / 4.0  # 4 phases par tir
+
+        I_final /= (Ntheta_total * Ntirs_complex)
+        I_final *= dx  # normalisation physique sur l’axe x
+
         return cp.real(I_final).get()
 
     def _iRadonRecon(
@@ -319,23 +262,24 @@ class AnalyticRecon(Recon):
         DelayLAWS,
         ActiveLIST,
         withTumor,
-):
+    ):
         """
         Reconstruction d'image utilisant la méthode iRadon.
-
-        :return: Image reconstruite.
+        Normalisation physique correcte (phases, angles, dz).
         """
-            
+
         # ======================================================
-        # 1. AddSinCos (structuration)
+        # 1. AddSinCos (structuration) — CPU volontairement
         # ======================================================
         theta = np.radians(theta)
         F_ct_kx, theta_u, decim_u = add_sincos_cpu(R, decimation, theta)
+
         ScanParam = np.stack([decimation, theta], axis=1)
         _, ia, _ = np.unique(ScanParam, axis=0, return_index=True, return_inverse=True)
+
         ActiveLIST = np.asarray(ActiveLIST).T
         DelayLAWS = np.asarray(DelayLAWS).T
-        ActiveLIST_unique = ActiveLIST[:,ia]
+        ActiveLIST_unique = ActiveLIST[:, ia]
 
         # ======================================================
         # 2. FFT z
@@ -343,8 +287,7 @@ class AnalyticRecon(Recon):
         z_gpu = cp.asarray(z)
         Fin = fourierz_gpu(z, F_ct_kx)
 
-
-        dz = float(z[1] - z[0])
+        dz = float(z[1] - z[0])                 # <<< Δz PHYSIQUE
         fz = cp.fft.fftshift(cp.fft.fftfreq(len(z), d=dz))
 
         Nz, Nk = Fin.shape
@@ -354,7 +297,7 @@ class AnalyticRecon(Recon):
         # ======================================================
         decim_gpu = cp.asarray(decim_u)
         I0 = decim_gpu == 0
-        F0 = Fin * I0[None, :]  # I0 broadcastée sur les lignes
+        F0 = Fin * I0[None, :]
 
         DEC, FZ = cp.meshgrid(decim_gpu, fz)
 
@@ -381,40 +324,53 @@ class AnalyticRecon(Recon):
         Xc = float(np.mean(X_m))
 
         # ======================================================
-        # 6. Calcul du centre M0 pour chaque angle
+        # 6. Centre de rotation M0
         # ======================================================
-        M0 = EvalDelayLawOS_center(X_m,theta, DelayLAWS[:, ia], ActiveLIST_unique, c)
+        M0 = EvalDelayLawOS_center(X_m, theta, DelayLAWS[:, ia], ActiveLIST_unique, c)
         M0_gpu = cp.asarray(M0)
 
         # ======================================================
         # 7. Rétroprojection
         # ======================================================
-        Irec_list = []
         Irec = cp.zeros_like(X, dtype=cp.complex64)
-        for i in trange(len(theta_u), desc=f"AOT-BioMaps -- Analytic Reconstruction Tomography: iRadon ({'with tumor' if withTumor else 'without tumor'})  ---- processing on single GPU ----", unit="angle"):
+
+        for i in trange(
+            len(theta_u),
+            desc=f"AOT-BioMaps -- iRadon ({'with tumor' if withTumor else 'without tumor'}) -- GPU",
+            unit="angle"
+        ):
             th = float(theta_u[i])
-            
-            # calcul de T, S, h0...
-            T = (X - M0_gpu[i,0]) * cp.sin(th) + (Z - M0_gpu[i,1]) * cp.cos(th) + M0_gpu[i,1]
-            S = (X - Xc) * cp.cos(th) - (Z - M0_gpu[i,1]) * cp.sin(th)
-            h0 = cp.exp(1j * 2*cp.pi * decim_u[i] * df0x * S)
-
-            # interpolation GPU
-            Tind = (T - z_gpu[0]) / (z_gpu[1] - z_gpu[0])
+
+            T = (X - M0_gpu[i, 0]) * cp.sin(th) + (Z - M0_gpu[i, 1]) * cp.cos(th) + M0_gpu[i, 1]
+            S = (X - Xc) * cp.cos(th) - (Z - M0_gpu[i, 1]) * cp.sin(th)
+            h0 = cp.exp(1j * 2 * cp.pi * decim_u[i] * df0x * S)
+
+            # interpolation linéaire en z
+            Tind = (T - z_gpu[0]) / dz
             i0 = cp.floor(Tind).astype(cp.int32)
             i1 = i0 + 1
-            i0 = cp.clip(i0, 0, Nz-1)
-            i1 = cp.clip(i1, 0, Nz-1)
+            i0 = cp.clip(i0, 0, Nz - 1)
+            i1 = cp.clip(i1, 0, Nz - 1)
             w = Tind - i0
 
-            proj_sup = (1-w)*Fsup[i0, i] + w*Fsup[i1, i]
-            proj_inf = (1-w)*Finf[i0, i] + w*Finf[i1, i]
+            proj_sup = (1 - w) * Fsup[i0, i] + w * Fsup[i1, i]
+            proj_inf = (1 - w) * Finf[i0, i] + w * Finf[i1, i]
+
+            # >>> SOMME BRUTE (correcte)
+            Irec += 2 * h0 * proj_sup + proj_inf
+
+        # ======================================================
+        # 8. NORMALISATION PHYSIQUE GLOBALE
+        # ======================================================
+
+        Ntheta = len(theta_u)
 
-            Irec += 2*h0*proj_sup + proj_inf
-            Irec /= i+1
-            # Ajouter à la liste
-            Irec_list.append(cp.real(Irec).get())
-            
+        # nombre de tirs complexes indépendants (4 phases)
+        Ntirs_complex = (R.shape[1] - Ntheta) / 4.0
 
-        return Irec_list
+        # normalisation finale
+        Irec /= (Ntheta * Ntirs_complex)
+        print(f"dz normalization: {dz}")
+        Irec *= dz
 
+        return cp.real(Irec).get()

AOT_biomaps/AOT_Recon/_mainRecon.py

@@ -1,12 +1,13 @@
 from AOT_biomaps.Config import config
-from AOT_biomaps.AOT_Experiment.Tomography import Tomography
+from AOT_biomaps.AOT_Experiment.Tomography import Tomography, hex_to_binary_profile
 from .ReconEnums import ReconType
-from .ReconTools import mse, ssim
+from .ReconTools import mse, ssim, get_phase_deterministic
 
 import os
 import numpy as np
 import matplotlib.pyplot as plt
 from abc import ABC, abstractmethod
+from tqdm import trange
 
 
 class Recon(ABC):
@@ -166,8 +167,14 @@ class Recon(ABC):
                 ssim_value = ssim(self.experiment.OpticImage.phantom, theta, data_range=data_range)
                 self.SSIM.append(ssim_value)
     
-
-    def show(self, withTumor=True, savePath=None):
+    def show(self, withTumor=True, savePath=None, scale='same'):
+        """
+        Display the reconstructed images.
+        Args:
+            withTumor (bool): If True, displays reconPhantom. If False, displays reconLaser. Default is True.
+            savePath (str): Path to save the figure. If None, the figure is not saved. Default is None.
+            scale (str): Scale for the aspect ratio of the plots. Default is 'same'. Options are 'same' or 'auto'.
+        """
         if withTumor:
             if self.reconPhantom is None:
                 raise ValueError("Reconstructed phantom with tumor is empty. Run reconstruction first.")
@@ -181,12 +188,19 @@ class Recon(ABC):
                 fig, axs = plt.subplots(1, 1, figsize=(10, 10))
             else:
                 fig, axs = plt.subplots(1, 2, figsize=(20, 10))
+                if scale == 'same':
+                    vmin = 0
+                    vmax = 1
+                elif scale == 'auto':
+                    vmin = np.min(self.experiment.OpticImage.phantom)
+                    vmax = np.max(self.experiment.OpticImage.phantom)
+                    
                 # Phantom original
                 im1 = axs[1].imshow(
                     self.experiment.OpticImage.phantom,
                     cmap='hot',
-                    vmin=0,
-                    vmax=1,
+                    vmin=vmin,
+                    vmax=vmax,
                     extent=(
                         self.experiment.params.general['Xrange'][0],
                         self.experiment.params.general['Xrange'][1],
@@ -199,12 +213,18 @@ class Recon(ABC):
                 axs[1].set_xlabel("x (mm)", fontsize=12)
                 axs[1].set_ylabel("z (mm)", fontsize=12)
                 axs[1].tick_params(axis='both', which='major', labelsize=8)
+            if scale == 'same':
+                vmin = 0
+                vmax = 1
+            elif scale == 'auto':
+                vmin = np.min(image)
+                vmax = np.max(image)
             # Phantom reconstruit
             im0 = axs[0].imshow(
                 image,
                 cmap='hot',
-                vmin=0,
-                vmax=1,
+                vmin=vmin,
+                vmax=vmax,
                 extent=(
                     self.experiment.params.general['Xrange'][0],
                     self.experiment.params.general['Xrange'][1],
@@ -288,4 +308,87 @@ class Recon(ABC):
 
         plt.show()
 
+    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

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.356'
+__version__ = '2.9.373'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -202,6 +202,23 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

{aot_biomaps-2.9.356.dist-info → aot_biomaps-2.9.373.dist-info}/METADATA

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

{aot_biomaps-2.9.356.dist-info → aot_biomaps-2.9.373.dist-info}/RECORD

@@ -1,17 +1,17 @@
 AOT_biomaps/Config.py,sha256=ghEOP1n8aO1pR-su13wMeAZAxZRfry5hH67NbtZ8SqI,3614
 AOT_biomaps/Settings.py,sha256=v8fPhnvvcfBJP29m1RLOTEr3jndGLGwbUiORXmsj2Bo,2853
-AOT_biomaps/__init__.py,sha256=prD0ZZNE6dc-NWf_N0QIPLTrsRD3fAtK78ptZscj3Yo,4374
+AOT_biomaps/__init__.py,sha256=fgpEUPXUQbaCtMxY_uHJtjrQTvQBwltYoAQtHk1zCuM,4408
 AOT_biomaps/AOT_Acoustic/AcousticEnums.py,sha256=s5kXa6jKzbS4btwbubrVcynLOr0yg5tth5vL_FGfbMk,1802
-AOT_biomaps/AOT_Acoustic/AcousticTools.py,sha256=h2sCtGVcDtyLtEF1q7sLZmuWivWmesVGUBPnW-ndQqc,7535
+AOT_biomaps/AOT_Acoustic/AcousticTools.py,sha256=7kuWIIGyzZPQrzRI0zVvdwNUp7qKUE67yCYOMzSb0Ug,8283
 AOT_biomaps/AOT_Acoustic/FocusedWave.py,sha256=3kGKKDx_3Msy5COYqIwzROPORGWvNjw8UsDanBfkMXE,11037
 AOT_biomaps/AOT_Acoustic/IrregularWave.py,sha256=yZhtxkR6zlciRcEpdTR0BAhvgQl40XHKFaF8f4VXarE,3035
 AOT_biomaps/AOT_Acoustic/PlaneWave.py,sha256=xza-rj5AUWDecLkGDxRcULrwZVWeBvGnEP2d51TyR04,1447
-AOT_biomaps/AOT_Acoustic/StructuredWave.py,sha256=jTLVlOhYLWJb5MxZPxhq3OFVlz2McoyMPBmfLvnekDU,18209
+AOT_biomaps/AOT_Acoustic/StructuredWave.py,sha256=DRTjD-zrmX12FHrvwOeEo-Rk1fHYm9gfCcebz4WhtXc,18930
 AOT_biomaps/AOT_Acoustic/__init__.py,sha256=t9M2rRqa_L9pk7W2FeELTkHEMuP4DBr4gBRldMqsQbg,491
-AOT_biomaps/AOT_Acoustic/_mainAcoustic.py,sha256=RdmhRF1i0KAlpsP7_wnZ7F4J27br3eUc4XR91Qq7C64,44158
+AOT_biomaps/AOT_Acoustic/_mainAcoustic.py,sha256=M0CKApSCuKiCupj9pf9uOEhuuzJVNSlLvhgTpBQN5Q8,46128
 AOT_biomaps/AOT_Experiment/ExperimentTools.py,sha256=aFvJw6J_jfFVTDFnG7J3a61SHEgORdZKZS0UI82VMaY,2637
 AOT_biomaps/AOT_Experiment/Focus.py,sha256=B2nBawmv-NG2AWJx9zgQ8GlN6aFB9FwTSqX-M-phKXg,3193
-AOT_biomaps/AOT_Experiment/Tomography.py,sha256=GGbXVUnRhvSRLL1QEg5ZgAhtWIg9RfH7aADJ5u-78HQ,36383
+AOT_biomaps/AOT_Experiment/Tomography.py,sha256=9mJDwV9WVphoX8drL7MgN3WhS6fjYwS6HWQD3x1CrVs,37625
 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,14 +21,14 @@ 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=uZp4Va9z04dG7neZFGAmmAUygs8JyfrDuOr1_lKIERc,16651
+AOT_biomaps/AOT_Recon/AnalyticRecon.py,sha256=z4VJtqL-atoZLflG7vQKHNeTXXjhYG_us8l0xfo5XsU,14514
 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=CV2BwdEwvNd3B02G5LYoKsRGlONwIupuv617S2AOWZE,25322
 AOT_biomaps/AOT_Recon/__init__.py,sha256=xs_argJqXKFl76xP7-jiUc1ynOEEtY7XZ0gDxD5uVZc,246
-AOT_biomaps/AOT_Recon/_mainRecon.py,sha256=MvDnfsiJ7v-UmtCFmA1vmKGzV9zd2xdnt27CAWBubko,13470
+AOT_biomaps/AOT_Recon/_mainRecon.py,sha256=hubU5SWEeAv94k_DNbdze4wfUeBw-4smboqRyzlmy_k,18058
 AOT_biomaps/AOT_Recon/AOT_Optimizers/DEPIERRO.py,sha256=qA1n722GLQJH3V8HcLr5q_GxEwBS_NRlIT3E6JZk-Ag,9479
 AOT_biomaps/AOT_Recon/AOT_Optimizers/LS.py,sha256=bCu1rKzFXPbYQ7jV3L3E_jVQpb6LIEC5MIlN1-mCNdY,22814
 AOT_biomaps/AOT_Recon/AOT_Optimizers/MAPEM.py,sha256=vQLCB0L4FSXJKn2_6kdIdWrI6WZ82KuqUh7CSqBGVuo,25766
@@ -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.356.dist-info/METADATA,sha256=eiJaF8-8bnGyUaK14BMcAiv645TibZb5uk8thsji2bE,700
-aot_biomaps-2.9.356.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aot_biomaps-2.9.356.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
-aot_biomaps-2.9.356.dist-info/RECORD,,
+aot_biomaps-2.9.373.dist-info/METADATA,sha256=pJCjnmUoIHGqV_s_popa7BNlrTn4LPP3h7mxRqlUiTQ,700
+aot_biomaps-2.9.373.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aot_biomaps-2.9.373.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
+aot_biomaps-2.9.373.dist-info/RECORD,,