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

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

@@ -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,10 +167,18 @@ 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 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]
@@ -179,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],
@@ -197,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],
@@ -217,7 +239,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]
@@ -284,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.339'
+__version__ = '2.9.373'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -183,6 +183,40 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

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

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

{aot_biomaps-2.9.339.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=r0H6FXsW0n-ethz4CgAmwp24IOM9OaxvBLKxLkZ0We0,4340
+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_Experiment/ExperimentTools.py,sha256=EyTIwgxTK-FqJYlhdjgirfWCSL1kTp-IOS0tTgiAVNA,3153
+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=3JlslI9GNZy-u0uYgf0u9qyaVAQki6cYTHhcGK33aFg,36747
+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=NKO7nE2Roq3E9HzMf_eJobm7rNQK1xzaQ0W9zXic9CY,11067
+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=-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=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.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,,
+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,,