AOT-biomaps 2.9.333__py3-none-any.whl → 2.9.356__py3-none-any.whl

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,27 +18,8 @@ class Tomography(Experiment):
         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']))))
+        self.ActiveList = []
+        self.DelayLaw = []
 
     # PUBLIC METHODS
     def check(self):
@@ -85,6 +66,29 @@ 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'])
+                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)
+                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.")
 
@@ -314,23 +318,10 @@ class Tomography(Experiment):
                 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})
+        savemat(filePath, {'data': self.AOsignal_withTumor, 'thetas': self.theta, 'decimations': self.decimations, 'ActiveList' : self.ActiveList, 'DelayLaw': self.DelayLaw})
 
     def selectAngles(self, angles):
 
@@ -383,74 +374,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):
@@ -679,6 +669,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,35 +1,35 @@
 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
+from .ReconTools import fourierz_gpu, get_phase_deterministic, add_sincos_cpu, EvalDelayLawOS_center, ifourierx_gpu, rotate_theta_gpu, filter_radon_gpu, ifourierz_gpu  
 
 import numpy as np
 from tqdm import trange
-import torch
-import tqdm
+import cupy as cp
 
 
 class AnalyticRecon(Recon):
-    def __init__(self, analyticType, **kwargs):
+    def __init__(self, analyticType, Lc = None,**kwargs):
         super().__init__(**kwargs)
         self.reconType = ReconType.Analytic
         self.analyticType = analyticType
+        if self.analyticType == AnalyticType.iRADON and Lc is None:
+            raise ValueError("Lc parameter must be provided for iRADON analytic reconstruction.")
+        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.params.acoustic['dx']  # en m 
-        n_piezos = self.params.acoustic['num_elements']
+        delta_x = self.experiment.params.general['dx']  # en m 
+        n_piezos = self.experiment.params.acoustic['num_elements']
         demodulated_data = {}
         structured_buffer = {} 
 
-        for i in tqdm(range(len(self.experiment.AcousticFields)), desc="Demodulating AO signals"):
+        for i in trange(len(self.experiment.AcousticFields), desc="Demodulating AO signals"):   
             label = self.experiment.AcousticFields[i].getName_field()
             
             parts = label.split("_")
@@ -46,7 +46,7 @@ class AnalyticRecon(Recon):
             # 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])
+                demodulated_data[(fs_key, angle_rad)] = np.array(AOsignal[:,i])
                 continue
                 
             # Onde Structurée
@@ -77,9 +77,9 @@ class AnalyticRecon(Recon):
             
             # 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
+                structured_buffer[key][phase] = (structured_buffer[key][phase] + np.array(AOsignal[:,i])) / 2
             else:
-                structured_buffer[key][phase] = np.array(AOsignal[i])
+                structured_buffer[key][phase] = np.array(AOsignal[:,i])
 
 
         
@@ -98,11 +98,10 @@ class AnalyticRecon(Recon):
 
             real = s0 - s_pi
             imag = s_pi_2 - s_3pi_2 
-            
-            
+              
             demodulated_data[(fs, theta)] = (real - 1j * imag) / (2/np.pi)
-            self.AOsignal_demoldulated = demodulated_data
-
+            
+        return demodulated_data
 
     def run(self, processType = ProcessType.PYTHON, withTumor= True):
         """
@@ -127,107 +126,295 @@ class AnalyticRecon(Recon):
         Parameters:
             analyticType: The type of analytic reconstruction to perform (default is iFOURIER).
         """
+        d_t = 1 / float(self.experiment.params.acoustic['f_saving'])
+        t_array = np.arange(0, self.experiment.AOsignal_withTumor.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)
         if withTumor:
+            self.AOsignal_demoldulated = self.parse_and_demodulate(withTumor=True)
             if self.analyticType == AnalyticType.iFOURIER:
-                self.reconPhantom = self._iFourierRecon(self.experiment.AOsignal_withTumor)
+                self.reconPhantom = self._iFourierRecon(
+                    R = self.experiment.AOsignal_withTumor,
+                    z = Z,    
+                    X_m=X_m,
+                    theta=self.experiment.theta,
+                    decimation=self.experiment.decimations,
+                    c=self.experiment.params.acoustic['c0'],
+                    DelayLAWS=self.experiment.DelayLaw,
+                    ActiveLIST=self.experiment.ActiveList,
+                    withTumor=True,
+                )
+                    
             elif self.analyticType == AnalyticType.iRADON:
-                self.reconPhantom = self._iRadonRecon(self.experiment.AOsignal_withTumor)
+                self.reconPhantom = self._iRadonRecon(
+                    R=self.experiment.AOsignal_withTumor,
+                    z=Z,
+                    X_m=X_m,
+                    theta=self.experiment.theta,
+                    decimation=self.experiment.decimations,
+                    df0x=dfX,
+                    Lc =self.Lc,
+                    c=self.experiment.params.acoustic['c0'],
+                    DelayLAWS=self.experiment.DelayLaw,
+                    ActiveLIST=self.experiment.ActiveList,
+                    withTumor=True)
             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)
+                self.reconLaser = self._iFourierRecon(
+                    R = self.experiment.AOsignal_withoutTumor,
+                    z = Z,    
+                    X_m=X_m,
+                    theta=self.experiment.theta,
+                    decimation=self.experiment.decimations,
+                    c=self.experiment.params.acoustic['c0'],
+                    DelayLAWS=self.experiment.DelayLaw,
+                    ActiveLIST=self.experiment.ActiveList,
+                    withTumor=False,
+                )
             elif self.analyticType == AnalyticType.iRADON:
-                self.reconLaser = self._iRadonRecon(self.experiment.AOsignal_withoutTumor)
+                self.reconLaser = self._iRadonRecon(
+                    R=self.experiment.AOsignal_withoutTumor,
+                    z=Z,
+                    X_m=X_m,
+                    theta=self.experiment.theta,
+                    decimation=self.experiment.decimations,
+                    df0x=dfX,
+                    Lc = self.Lc,
+                    c=self.experiment.params.acoustic['c0'],
+                    DelayLAWS=self.experiment.DelayLaw,
+                    ActiveLIST=self.experiment.ActiveList,
+                    withTumor=False)
             else:            
                 raise ValueError(f"Unknown analytic type: {self.analyticType}")
     
-    def _iFourierRecon(self, AOsignal):
-        """
-        Reconstruction d'image utilisant la transformation de Fourier inverse.
-        :param AOsignal: Signal dans le domaine temporel (shape: N_t, N_theta).
-        :return: Image reconstruite dans le domaine spatial.
-        """
-        theta = np.array([af.angle for af in self.experiment.AcousticFields])
-        f_s = np.array([af.f_s for af in self.experiment.AcousticFields])
-        dt = self.experiment.dt
-        f_t = np.fft.fftfreq(AOsignal.shape[0], d=dt)  # fréquences temporelles
-        x = self.experiment.OpticImage.laser.x
-        z = self.experiment.OpticImage.laser.z
-        X, Z = np.meshgrid(x, z, indexing='ij')  # grille spatiale (Nx, Nz)
-
-        # Transformée de Fourier du signal
-        s_tilde = np.fft.fft(AOsignal, axis=0)  # shape: (N_t, N_theta)
-
-        # Initialisation de l'image reconstruite
-        I_rec = np.zeros((len(x), len(z)), dtype=complex)
-
-        # Boucle sur les angles
-        for i, th in enumerate(trange(len(theta), desc="AOT-BioMaps -- iFourier Reconstruction")):
-            # Coordonnées tournées
-            X_prime = X * np.cos(th) + Z * np.sin(th)
-            Z_prime = -X * np.sin(th) + Z * np.cos(th)
-
-            # Pour chaque fréquence temporelle f_t[j]
-            for j in range(len(f_t)):
-                # Phase: exp(2jπ (X_prime * f_s[i] + Z_prime * f_t[j]))
-                phase = 2j * np.pi * (X_prime * f_s[i] + Z_prime * f_t[j])
-                # Contribution de cette fréquence
-                I_rec += s_tilde[j, i] * np.exp(phase) * dt  # Pondération par dt pour l'intégration
-
-        # Normalisation
-        I_rec /= len(theta)
-        return np.abs(I_rec)
-
-
-    def _iRadonRecon(self, AOsignal):
+    def _iFourierRecon(
+        self,
+        R,
+        z, 
+        X_m, 
+        theta, 
+        decimation,  
+        c, 
+        DelayLAWS, 
+        ActiveLIST,
+        withTumor,
+    ):
+        # --- 1. Préparation des données ---
+        R = cp.asarray(R)
+        z = cp.asarray(z)
+        X_m = cp.asarray(X_m)
+        theta = cp.asarray(theta)
+        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
+        )
+
+        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
+        F_complex_cpu, theta_u_cpu, decim_u_cpu = add_sincos_cpu(
+        cp.asnumpy(R),
+        cp.asnumpy(decimation),
+        np.radians(cp.asnumpy(theta))
+        )
+        M0 = EvalDelayLawOS_center(
+            X_m,
+            theta_u_cpu,
+            DelayLAWS_s.T[:, ia],
+            ActiveLIST.T[:, ia],
+            c
+        )
+
+        # Transfert GPU (UNE FOIS)
+        F_complex = cp.asarray(F_complex_cpu)
+        theta_u = cp.asarray(theta_u_cpu)
+        decim_u = cp.asarray(decim_u_cpu)
+
+        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
+        )
+        Ntheta = angles_group.size
+
+        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"):
+
+            # Grille (z, fx)
+            F_fx_z = cp.zeros((Nz, Nx), dtype=cp.complex64)
+
+            # Indices correspondant à cet angle
+            indices = cp.where(ib_u == i_ang)[0]
+
+            for idx in indices:
+                n = int(decim_u[idx])
+                trace_z = F_complex[:, idx]
+
+                # Mapping positif
+                ip = idx0_x + n
+                if 0 <= ip < Nx:
+                    F_fx_z[:, ip] = trace_z
+
+                # Mapping négatif (symétrie hermitienne Matlab)
+                if n != 0:
+                    im = idx0_x - n
+                    if 0 <= im < Nx:
+                        col_conj = cp.zeros(Nz, dtype=cp.complex64)
+                        col_conj[1:] = cp.conj(trace_z[:-1])
+                        F_fx_z[:, im] = col_conj
+
+            # Correction DC
+            F_fx_z[:, idx0_x] *= 0.5
+
+            # --- Inverse Fourier X (GPU) ---
+            I_spatial = ifourierx_gpu(F_fx_z, dx) * Nx
+
+            # --- Rotation spatiale GPU ---
+            I_rot = rotate_theta_gpu(
+                X_grid,
+                Z_grid,
+                I_spatial,
+                -angles_group[i_ang],
+                M0[i_ang, :]
+            )
+
+            # Somme incohérente (OriginIm = sum)
+            I_final += I_rot
+        I_final /= Ntheta
+        return cp.real(I_final).get()
+
+    def _iRadonRecon(
+        self,
+        R, 
+        z, 
+        X_m,
+        theta, 
+        decimation,
+        df0x,
+        Lc,
+        c,
+        DelayLAWS,
+        ActiveLIST,
+        withTumor,
+):
         """
         Reconstruction d'image utilisant la méthode iRadon.
 
         :return: Image reconstruite.
         """
-        @staticmethod
-        def trapz(y, x):
-            """Compute the trapezoidal rule for integration."""
-            return np.sum((y[:-1] + y[1:]) * (x[1:] - x[:-1]) / 2)
-
-        # Initialisation de l'image reconstruite
-        I_rec = np.zeros((len(self.experiment.OpticImage.laser.x), len(self.experiment.OpticImage.laser.z)), dtype=complex)
-
-        # Transformation de Fourier du signal
-        s_tilde = np.fft.fft(AOsignal, axis=0)
-
-        # Extraction des angles et des fréquences spatiales
-        theta = [acoustic_field.angle for acoustic_field in self.experiment.AcousticFields]
-        f_s = [acoustic_field.f_s for acoustic_field in self.experiment.AcousticFields]
-
-        # Calcul des coordonnées transformées et intégrales
-        with trange(len(theta) * 2, desc="AOT-BioMaps -- Analytic Reconstruction Tomography: iRadon") as pbar:
-            for i in range(len(theta)):
-                pbar.set_description("AOT-BioMaps -- Analytic Reconstruction Tomography: iRadon (Processing frequency contributions)  ---- processing on single CPU ----")
-                th = theta[i]
-                x_prime = self.experiment.OpticImage.x[:, np.newaxis] * np.cos(th) - self.experiment.OpticImage.z[np.newaxis, :] * np.sin(th)
-                z_prime = self.experiment.OpticImage.z[np.newaxis, :] * np.cos(th) + self.experiment.OpticImage.x[:, np.newaxis] * np.sin(th)
-
-                # Première intégrale : partie réelle
-                for j in range(len(f_s)):
-                    fs = f_s[j]
-                    integrand = s_tilde[i, j] * np.exp(2j * np.pi * (x_prime * fs + z_prime * fs))
-                    integral = self.trapz(integrand * fs, fs)
-                    I_rec += 2 * np.real(integral)
-                pbar.update(1)
-
-            for i in range(len(theta)):
-                pbar.set_description("AOT-BioMaps -- Analytic Reconstruction Tomography: iRadon (Processing central contributions)  ---- processing on single CPU ----")
-                th = theta[i]
-                x_prime = self.experiment.OpticImage.x[:, np.newaxis] * np.cos(th) - self.experiment.OpticImage.z[np.newaxis, :] * np.sin(th)
-                z_prime = self.experiment.OpticImage.z[np.newaxis, :] * np.cos(th) + self.experiment.OpticImage.x[:, np.newaxis] * np.sin(th)
-
-                # Filtrer les fréquences spatiales pour ne garder que celles inférieures ou égales à f_s_max
-                filtered_f_s = np.array([fs for fs in f_s if fs <= self.f_s_max])
-                integrand = s_tilde[i, np.where(np.array(f_s) == 0)[0][0]] * np.exp(2j * np.pi * z_prime * filtered_f_s)
-                integral = self.trapz(integrand * filtered_f_s, filtered_f_s)
-                I_rec += integral
-                pbar.update(1)
-
-        return np.abs(I_rec)
+            
+        # ======================================================
+        # 1. AddSinCos (structuration)
+        # ======================================================
+        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]
+
+        # ======================================================
+        # 2. FFT z
+        # ======================================================
+        z_gpu = cp.asarray(z)
+        Fin = fourierz_gpu(z, F_ct_kx)
+
+
+        dz = float(z[1] - z[0])
+        fz = cp.fft.fftshift(cp.fft.fftfreq(len(z), d=dz))
+
+        Nz, Nk = Fin.shape
+
+        # ======================================================
+        # 3. Filtrage OS exact
+        # ======================================================
+        decim_gpu = cp.asarray(decim_u)
+        I0 = decim_gpu == 0
+        F0 = Fin * I0[None, :]  # I0 broadcastée sur les lignes
+
+        DEC, FZ = cp.meshgrid(decim_gpu, fz)
+
+        Hinf = cp.abs(FZ) < cp.abs(DEC) * df0x
+        Hsup = FZ >= 0
+
+        Fc = 1 / Lc
+        FILTER = filter_radon_gpu(fz, Fc)[:, None]
+
+        Finf = F0 * FILTER[:, :F0.shape[1]] * Hinf[:, :F0.shape[1]]
+        Fsup = Fin * FILTER * Hsup
+
+        # ======================================================
+        # 4. Retour espace z
+        # ======================================================
+        Finf = ifourierz_gpu(z, Finf)
+        Fsup = ifourierz_gpu(z, Fsup)
+
+        # ======================================================
+        # 5. Grille image
+        # ======================================================
+        X_gpu = cp.asarray(X_m)
+        X, Z = cp.meshgrid(X_gpu, z_gpu)
+        Xc = float(np.mean(X_m))
+
+        # ======================================================
+        # 6. Calcul du centre M0 pour chaque angle
+        # ======================================================
+        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"):
+            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])
+            i0 = cp.floor(Tind).astype(cp.int32)
+            i1 = i0 + 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]
+
+            Irec += 2*h0*proj_sup + proj_inf
+            Irec /= i+1
+            # Ajouter à la liste
+            Irec_list.append(cp.real(Irec).get())
+            
+
+        return Irec_list
+

AOT_biomaps/AOT_Recon/ReconTools.py

@@ -7,6 +7,8 @@ from numba import njit, prange
 from torch_sparse import coalesce
 from scipy.signal.windows import hann
 from itertools import groupby
+import cupy as cp
+from cupyx.scipy.ndimage import map_coordinates
 
 def load_recon(hdr_path):
     """
@@ -528,4 +530,163 @@ def get_phase_deterministic(profile):
     elif idx == 4 :
         phase = 3*np.pi/2
             
-    return phase
+    return phase
+
+def add_sincos_cpu(R, decimation, theta):
+    decimation = np.asarray(decimation)
+    theta = np.asarray(theta)
+
+    ScanParam = np.stack([decimation, theta], axis=1)
+    uniq, ia, ib = np.unique(ScanParam, axis=0, return_index=True, return_inverse=True)
+
+    theta_u = uniq[:,1]
+    decim_u = uniq[:,0]
+
+    theta0 = np.unique(theta_u)
+    N0 = len(theta0)
+
+    Rg = np.asarray(R)
+    Nz = Rg.shape[0]
+    Nk = N0 + (Rg.shape[1] - N0)//4
+
+    Iout = np.zeros((Nz, Nk), dtype=np.complex64)
+    # fx = 0 (onde plane)
+    Iout[:, :N0] = Rg[:, :N0]
+
+    k = N0
+    for i in range(N0, len(ia)):
+        idx = np.where(ib == i)[0]
+        h1, h2, h3, h4 = Rg[:, idx].T
+        Iout[:, k] = ((h1 - h2) - 1j*(h3 - h4)) / 2
+        k += 1
+
+    return Iout, theta_u, decim_u
+
+def fourierz_gpu(z, X):
+    dz = float(z[1] - z[0])
+    Nz = X.shape[0]
+
+    return cp.fft.fftshift(
+        cp.fft.fft(
+            cp.fft.ifftshift(X, axes=0),
+            axis=0
+        ),
+        axes=0
+    ) * (Nz * dz)
+
+def ifourierz_gpu(z, X):
+    dz = float(z[1] - z[0])
+    Nz = X.shape[0]
+
+    return cp.fft.ifftshift(
+        cp.fft.ifft(
+            cp.fft.fftshift(X, axes=0),
+            axis=0
+        ),
+        axes=0
+    ) * (1 / dz)
+
+def ifourierx_gpu(F_fx_z, dx):
+    """
+    Inverse Fourier along X (axis=1), Matlab-compatible
+    F_fx_z : (Nz, Nx) complex cupy array
+    dx : scalar (spacing in x)
+    """
+
+    return (
+        cp.fft.ifftshift(
+            cp.fft.ifft(
+                cp.fft.fftshift(F_fx_z, axes=1),
+                axis=1
+            ),
+            axes=1
+        ) * (1.0 / dx)
+    )
+
+def EvalDelayLawOS_center(X_m, theta, DelayLAWS, ActiveLIST, c):
+    """
+    Retourne le centre de rotation C pour chaque angle
+    X_m : positions des éléments de la sonde
+    DelayLAWS : delays en secondes (chaque colonne = angle, chaque ligne = élément)
+    ActiveLIST : masque des éléments actifs (1 = actif)
+    c : vitesse du son
+    """
+    Nangle = DelayLAWS.shape[1]
+    C = np.zeros((Nangle, 2))
+    
+    ct = DelayLAWS * c  # convert seconds to distance
+
+    for i in range(Nangle):
+        active_idx = np.where(ActiveLIST[:, i] == 1)[0]
+        if len(active_idx) == 0:
+            continue
+
+
+        angle_i = np.round(theta[i], 5)
+        # unit vector orthogonal to wavefront
+        u = np.array([np.sin(angle_i), np.cos(angle_i)])
+
+        # initial positions X0, Z0
+        X0 = X_m - u[0] * ct[:, i]
+        Z0 = 0 - u[1] * ct[:, i]
+
+        if Z0[-1] - Z0[0] != 0:
+            C[i, 0] = (Z0[-1]*X0[0] - Z0[0]*X0[-1]) / (Z0[-1] - Z0[0])
+            C[i, 1] = 0
+
+    return C
+
+def rotate_theta_gpu(X, Z, Iin, theta, C):
+    """
+    GPU equivalent of RotateTheta.m
+    X, Z, Iin : cupy arrays (Nz, Nx)
+    theta : scalar (float)
+    C : (2,) array-like
+    """
+
+    # --- Translation ---
+    X_rel = X - C[0]
+    Z_rel = Z - C[1]
+
+    c = cp.cos(theta)
+    s = cp.sin(theta)
+
+    # --- Rotation (Matlab convention) ---
+    Xout = c * X_rel + s * Z_rel
+    Zout = -s * X_rel + c * Z_rel
+
+    # Back to original frame
+    Xout += C[0]
+    Zout += C[1]
+
+    # --- Conversion coordonnées -> indices ---
+    # Grille régulière supposée
+    dx = X[0, 1] - X[0, 0]
+    dz = Z[1, 0] - Z[0, 0]
+
+    x0 = X[0, 0]
+    z0 = Z[0, 0]
+
+    ix = (Xout - x0) / dx
+    iz = (Zout - z0) / dz
+
+    # --- Interpolation bilinéaire GPU ---
+    # map_coordinates attend (ndim, Npoints)
+    coords = cp.stack([iz.ravel(), ix.ravel()])
+
+    Iout = map_coordinates(
+        Iin,
+        coords,
+        order=1,          # bilinear
+        mode='constant',
+        cval=0.0
+    )
+
+    return Iout.reshape(Iin.shape)
+
+def filter_radon_gpu(fz, Fc):
+    FILTER = cp.abs(fz)
+    FILTER = cp.where(cp.abs(fz) > Fc, 0, FILTER)
+    FILTER *= cp.exp(-2 * cp.abs(fz / Fc)**10)
+    return FILTER
+

AOT_biomaps/AOT_Recon/_mainRecon.py

@@ -169,7 +169,9 @@ class Recon(ABC):
 
     def show(self, withTumor=True, savePath=None):
         if withTumor:
-            if self.reconPhantom is None or self.reconPhantom == []:
+            if self.reconPhantom is None:
+                raise ValueError("Reconstructed phantom with tumor is empty. Run reconstruction first.")
+            if isinstance(self.reconPhantom, (list, tuple)) and len(self.reconPhantom) == 0:
                 raise ValueError("Reconstructed phantom with tumor is empty. Run reconstruction first.")
             if isinstance(self.reconPhantom, list):
                 image = self.reconPhantom[-1]
@@ -217,7 +219,9 @@ class Recon(ABC):
             axs[0].tick_params(axis='both', which='major', labelsize=8)
             axs[0].tick_params(axis='y', which='both', left=False, right=False, labelleft=False)
         else:
-            if self.reconLaser is None or self.reconLaser == []:
+            if self.reconLaser is None:
+                raise ValueError("Reconstructed laser without tumor is empty. Run reconstruction first.")
+            if isinstance(self.reconLaser, (list, tuple)) and len(self.reconLaser) == 0:
                 raise ValueError("Reconstructed laser without tumor is empty. Run reconstruction first.")
             if isinstance(self.reconLaser, list):
                 image = self.reconLaser[-1]

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.333'
+__version__ = '2.9.356'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -177,6 +177,29 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

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

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

{aot_biomaps-2.9.333.dist-info → aot_biomaps-2.9.356.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=KTexXkgmJ_3hKllZPzxJIRkrNj2plmep-xD4ANfDxao,4328
+AOT_biomaps/__init__.py,sha256=prD0ZZNE6dc-NWf_N0QIPLTrsRD3fAtK78ptZscj3Yo,4374
 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=EyTIwgxTK-FqJYlhdjgirfWCSL1kTp-IOS0tTgiAVNA,3153
+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=87tdUjYJbrNU2S3FT7pCsnB4jFEYZQFqD4o_FBKekkc,36689
+AOT_biomaps/AOT_Experiment/Tomography.py,sha256=GGbXVUnRhvSRLL1QEg5ZgAhtWIg9RfH7aADJ5u-78HQ,36383
 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=9MNztNRZuF8zM1WfJh1GaTC8b7UDb_iuh0T0LGwycUY,10905
+AOT_biomaps/AOT_Recon/AnalyticRecon.py,sha256=uZp4Va9z04dG7neZFGAmmAUygs8JyfrDuOr1_lKIERc,16651
 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=-ZbzRHSzUprjzPRGCJeBiow_2AEvS2IzCSrv3XfzpLs,21307
+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=exoa2UBMfMHjemxAU9dW0mhEfsP6Oe1qjSfrTrgbIcY,13125
+AOT_biomaps/AOT_Recon/_mainRecon.py,sha256=MvDnfsiJ7v-UmtCFmA1vmKGzV9zd2xdnt27CAWBubko,13470
 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.333.dist-info/METADATA,sha256=bnzNzvd1PZh5qMbP_pSbFR59oQ8YUrW4fYQmhKhY0Uo,700
-aot_biomaps-2.9.333.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aot_biomaps-2.9.333.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
-aot_biomaps-2.9.333.dist-info/RECORD,,
+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,,