AOT-biomaps 2.9.138__py3-none-any.whl → 2.9.279__py3-none-any.whl

AOT_biomaps/AOT_Acoustic/AcousticTools.py

@@ -1,5 +1,6 @@
 from AOT_biomaps.Config import config
 
+from scipy.signal import hilbert
 import os
 import h5py
 import numpy as np
@@ -109,136 +110,55 @@ def reshape_field(field, factor, device=None):
     if isinstance(field, np.ndarray):
         return downsampled.cpu().numpy()
     else:
-        return downsampled
-
-
-def CPU_hilbert(signal, axis=0):
-    """
-    Compute the Hilbert transform of a real signal using NumPy.
-
-    Parameters:
-    - signal: Input real signal (numpy.ndarray).
-    - axis: Axis along which to compute the Hilbert transform.
-
-    Returns:
-    - analytic_signal: The analytic signal of the input.
-    """
-    fft_signal = np.fft.fftn(signal, axes=[axis])
-    h = np.zeros_like(signal)
-
-    if axis == 0:
-        h[0 : signal.shape[0] // 2 + 1, ...] = 1
-        h[signal.shape[0] // 2 + 1 :, ...] = 2
-    else:
-        raise ValueError("Axis not supported for this implementation.")
-
-    analytic_signal = np.fft.ifftn(fft_signal * h, axes=[axis])
-    return analytic_signal
-
-def GPU_hilbert(signal, axis=0):
-    """
-    Compute the Hilbert transform of a real signal using PyTorch.
-
-    Parameters:
-    - signal: Input real signal (torch.Tensor).
-    - axis: Axis along which to compute the Hilbert transform.
+        return downsampled.cpu().numpy()
 
-    Returns:
-    - analytic_signal: The analytic signal of the input.
+def calculate_envelope_squared(field):
     """
-    fft_signal = torch.fft.fftn(signal, dim=axis)
-    h = torch.zeros_like(signal)
-    if axis == 0:
-        h[0 : signal.shape[0] // 2 + 1, ...] = 1
-        h[signal.shape[0] // 2 + 1 :, ...] = 2
-    else:
-        raise ValueError("Axis not supported for this implementation.")
+    Calcule l'enveloppe au carré du champ acoustique en utilisant scipy.signal.hilbert (CPU uniquement).
 
-    analytic_signal = torch.fft.ifftn(fft_signal * h, dim=axis)
-    return analytic_signal
+    Args:
+        field: Champ acoustique (numpy.ndarray) de forme (T, X, Z) ou (T, X, Y, Z).
 
-def calculate_envelope_squared(field, isGPU):
-    """
-    Calculate the analytic envelope of the acoustic field using either CPU or GPU with PyTorch.
-    Parameters:
-        - field: Input acoustic field (numpy.ndarray or torch.Tensor).
-        - isGPU (bool): If True, use GPU for computation. Otherwise, use CPU.
     Returns:
-        - envelope (numpy.ndarray): The squared analytic envelope of the acoustic field.
+        envelope (numpy.ndarray): Enveloppe au carré du champ acoustique.
     """
     try:
         if field is None:
-            raise ValueError("Acoustic field is not generated. Please generate the field first.")
+            raise ValueError("Le champ acoustique n'est pas généré. Veuillez d'abord générer le champ.")
 
-        # Convert input to tensor (handle both numpy arrays and tensors)
-        if isinstance(field, np.ndarray):
-            acoustic_field = torch.from_numpy(field).to(dtype=torch.float32)
-        else:
-            acoustic_field = field.detach().clone().to(dtype=torch.float32)
-
-        # Handle GPU/CPU transfer
-        if isGPU:
-            if not torch.cuda.is_available():
-                print("CUDA is not available, falling back to CPU.")
-                isGPU = False
+        if not isinstance(field, np.ndarray):
+            if hasattr(field, 'cpu'):
+                field = field.cpu().numpy()  # Si c'est un tenseur PyTorch sur GPU/CPU
             else:
-                # Check GPU memory
-                free_memory = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0)
-                required_memory = acoustic_field.numel() * acoustic_field.element_size()
-                if free_memory < required_memory:
-                    print(f"GPU memory insufficient ({required_memory / (1024 ** 2):.2f} MB required, {free_memory / (1024 ** 2):.2f} MB free), falling back to CPU.")
-                    isGPU = False
-                else:
-                    acoustic_field = acoustic_field.cuda()
-
-        if len(acoustic_field.shape) not in [3, 4]:
-            raise ValueError("Input acoustic field must be a 3D or 4D array.")
-
-        def process_slice(slice_index):
-            """Calculate the envelope for a given slice of the acoustic field."""
-            slice_data = acoustic_field[slice_index]
-
-            if len(acoustic_field.shape) == 3:
-                if isGPU:
-                    return torch.abs(GPU_hilbert(slice_data, axis=0))**2
-                else:
-                    return torch.from_numpy(np.abs(CPU_hilbert(slice_data.cpu().numpy(), axis=0))**2).to(dtype=torch.float32)
-
-            elif len(acoustic_field.shape) == 4:
-                if isGPU:
-                    return torch.stack([
-                        torch.abs(GPU_hilbert(slice_data[:, y, z], axis=0))**2
-                        for y in range(slice_data.shape[1])
-                        for z in range(slice_data.shape[2])
-                    ]).reshape(slice_data.shape[1], slice_data.shape[2], -1).permute(2, 0, 1)
-                else:
-                    envelope = torch.zeros_like(slice_data)
-                    for y in range(slice_data.shape[1]):
-                        for z in range(slice_data.shape[2]):
-                            envelope[:, y, z] = torch.from_numpy(
-                                np.abs(CPU_hilbert(slice_data[:, y, z].cpu().numpy(), axis=0))**2
-                            )
-                    return envelope
-
-        # Process slices
-        num_slices = acoustic_field.shape[0]
-        slice_indices = range(num_slices)
-
-        if isGPU:
-            envelopes = [process_slice(i) for i in slice_indices]
-        else:
-            with ThreadPoolExecutor() as executor:
-                envelopes = list(executor.map(process_slice, slice_indices))
-
-        # Combine results
-        envelope = torch.stack(envelopes, axis=0)
-        return envelope.cpu().numpy() if isGPU else envelope.numpy()
+                field = np.array(field)  # Conversion générique
+
+        if len(field.shape) not in [3, 4]:
+            raise ValueError("Le champ acoustique doit être un tableau 3D (T, X, Z) ou 4D (T, X, Y, Z).")
+
+        # Calcul de l'enveloppe avec scipy.signal.hilbert
+        if len(field.shape) == 3:
+            T, X, Z = field.shape
+            envelope = np.zeros_like(field)
+            for x in range(X):
+                for z in range(Z):
+                    envelope[:, x, z] = np.abs(hilbert(field[:, x, z], axis=0)) ** 2
+        elif len(field.shape) == 4:
+            T, X, Y, Z = field.shape
+            envelope = np.zeros_like(field)
+            for x in range(X):
+                for y in range(Y):
+                    for z in range(Z):
+                        envelope[:, x, y, z] = np.abs(hilbert(field[:, x, y, z], axis=0)) ** 2
+                        
+
+        return envelope
 
     except Exception as e:
-        print(f"Error in calculate_envelope_squared method: {e}")
+        print(f"Erreur dans calculate_envelope_squared: {e}")
         raise
 
 
+
 def getPattern(pathFile):
     """
     Get the pattern from a file path.

AOT_biomaps/AOT_Acoustic/StructuredWave.py

@@ -292,8 +292,8 @@ class StructuredWave(AcousticField):
                 f"!number format := short float\n"
                 f"!number of bytes per pixel := 4\n"
                 f"scaling factor (mm/pixel) [1] := {self.params['dx'] * 1000}\n"
-                f"scaling factor (mm/pixel) [2] := {self.params['dx'] * 1000}\n"
-                f"scaling factor (s/pixel) [3] := {1 / self.params['f_AQ']}\n"
+                f"scaling factor (mm/pixel) [2] := {self.params['dz'] * 1000}\n"
+                f"scaling factor (s/pixel) [3] := {1 / self.params['f_saving']}\n"
                 f"first pixel offset (mm) [1] := {self.params['Xrange'][0] * 1e3}\n"
                 f"first pixel offset (mm) [2] := {self.params['Zrange'][0] * 1e3}\n"
                 f"first pixel offset (s) [3] := 0\n"

AOT_biomaps/AOT_Acoustic/_mainAcoustic.py

@@ -1,6 +1,6 @@
 import AOT_biomaps.Settings
 from AOT_biomaps.Config import config
-from AOT_biomaps.AOT_Acoustic.AcousticTools import calculate_envelope_squared, CPU_hilbert, loadmat
+from AOT_biomaps.AOT_Acoustic.AcousticTools import calculate_envelope_squared, loadmat
 from .AcousticTools import next_power_of_2, reshape_field
 from .AcousticEnums import TypeSim, Dim, FormatSave, WaveType
 
@@ -19,10 +19,12 @@ from kwave.kspaceFirstOrder3D import kspaceFirstOrder3D
 from kwave.kspaceFirstOrder2D import kspaceFirstOrder2D
 from kwave.options.simulation_options import SimulationOptions
 from kwave.options.simulation_execution_options import SimulationExecutionOptions
+from AOT_biomaps.Settings import Params
 
 from tempfile import gettempdir
 from math import ceil
 from abc import ABC, abstractmethod
+import logging
 
 
 
@@ -75,7 +77,7 @@ class AcousticField(ABC):
             print(f"Initialization error: {e}")
             raise
         if params != None:
-            if type(params) != AOT_biomaps.Settings.Params:
+            if type(params) != Params:
                 raise TypeError("params must be an instance of the Params class")
 
             self.params = {
@@ -225,6 +227,7 @@ class AcousticField(ABC):
         Generate the acoustic field based on the specified simulation type and parameters.
         """
         try:
+            logging.getLogger('root').setLevel(logging.ERROR)
             if self.params['typeSim'] == TypeSim.FIELD2.value:
                 raise NotImplementedError("FIELD2 simulation is not implemented yet.")
             elif self.params['typeSim'] == TypeSim.KWAVE.value:
@@ -233,10 +236,10 @@ class AcousticField(ABC):
                         field = self._generate_acoustic_field_KWAVE_2D(isGpu, show_log)
                     except Exception as e:
                         raise RuntimeError(f"Failed to generate 2D acoustic field: {e}")
-                    self.field = calculate_envelope_squared(field, isGpu)
+                    self.field = reshape_field(calculate_envelope_squared(field),[self.factorT, self.factorX, self.factorZ])
                 elif self.params["dim"] == Dim.D3.value:
                     field = self._generate_acoustic_field_KWAVE_3D(isGpu, show_log)
-                    self.field = calculate_envelope_squared(field, isGpu)
+                    self.field = reshape_field(calculate_envelope_squared(field),[self.factorT, self.factorX, self.factorZ])
             elif self.params['typeSim'] == TypeSim.HYDRO.value:
                 raise ValueError("Cannot generate field for Hydrophone simulation, load exciting acquisitions.")
             else:
@@ -265,7 +268,7 @@ class AcousticField(ABC):
             print(f"Error in save_field method: {e}")
             raise
 
-    def load_field(self, folderPath, formatSave=FormatSave.HDR_IMG):
+    def load_field(self, folderPath, formatSave=FormatSave.HDR_IMG, nameBlock=None):
         """
         Load the acoustic field from a file in the specified format.
 
@@ -286,7 +289,7 @@ class AcousticField(ABC):
                         raise NotImplementedError("3D KWAVE field loading is not implemented yet.")
                 elif formatSave.value == FormatSave.H5.value:
                     if self.params["dim"] == Dim.D2.value:
-                         self._load_field_h5(folderPath)
+                         self._load_field_h5(folderPath,nameBlock)
                     elif self.params["dim"] == Dim.D3.value:
                         raise NotImplementedError("H5 KWAVE field loading is not implemented yet.")
                 elif formatSave.value == FormatSave.NPY.value:
@@ -502,7 +505,7 @@ class AcousticField(ABC):
         try:
             # --- 1. Grid setup ---
             dx = self.params['dx']
-            if dx >= self.params['element_width']:
+            if dx >= self.params['element_width']*2:
                 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))
@@ -511,9 +514,9 @@ class AcousticField(ABC):
                 Nz = self.params['Nz']
 
             # --- 2. Time and space factors ---
-            factorT = int(np.ceil(self.params['f_AQ'] / self.params['f_saving']))
-            factorX = int(np.ceil(Nx / self.params['Nx']))
-            factorZ = int(np.ceil(Nz / self.params['Nz']))
+            self.factorT = int(np.ceil(self.params['f_AQ'] / self.params['f_saving']))
+            self.factorX = int(np.ceil(Nx / self.params['Nx']))
+            self.factorZ = int(np.ceil(Nz / self.params['Nz']))
 
             # --- 3. Grid and source initialization ---
             kgrid = kWaveGrid([Nx, Nz], [dx, dx])
@@ -531,6 +534,8 @@ class AcousticField(ABC):
             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(
@@ -549,7 +554,7 @@ class AcousticField(ABC):
             )
 
             # --- 7. Call specialized function to set up source.p_mask and source.p ---
-            self._SetUpSource(source, Nx, dx, factorT)
+            self._SetUpSource(source, Nx, dx, self.factorT)
 
             # --- 8. Run simulation ---
             sensor_data = kspaceFirstOrder2D(
@@ -563,10 +568,7 @@ class AcousticField(ABC):
 
             # --- 9. Post-process results ---
             data = sensor_data['p'].reshape(kgrid.Nt, Nz, Nx)
-            if factorT != 1 or factorX != 1 or factorZ != 1:
-                return reshape_field(data, [factorT, factorX, factorZ])
-            else:
-                return data
+            return data
             
         except Exception as e:
             print(f"Error generating 2D acoustic field: {e}")
@@ -653,7 +655,7 @@ class AcousticField(ABC):
         """
         pass
 
-    def _load_field_h5(self, filePath):
+    def _load_field_h5(self, filePath,nameBlock):
         """
         Load the 2D acoustic field from an H5 file.
 
@@ -664,8 +666,10 @@ class AcousticField(ABC):
         - field (numpy.ndarray): The loaded acoustic field.
         """
         try:
-            with h5py.File(filePath+self.getName_field()+".h5", 'r') as f:
-                self.field = f['data'][:]
+            if nameBlock is None:
+                nameBlock = 'data'
+            with h5py.File(os.path.join(filePath, self.getName_field()+".h5"), 'r') as f:
+                self.field = f[nameBlock][:]
         except Exception as e:
             print(f"Error in _load_field_h5 method: {e}")
             raise

AOT_biomaps/AOT_Experiment/Tomography.py

@@ -7,6 +7,8 @@ import psutil
 import numpy as np
 import matplotlib.pyplot as plt
 from tqdm import trange
+import h5py
+from scipy.io import loadmat
 
 class Tomography(Experiment):
     def __init__(self, **kwargs):
@@ -47,7 +49,7 @@ class Tomography(Experiment):
             return False, f"OpticImage phantom shape {self.OpticImage.phantom.shape} does not match AcousticFields shape {self.AcousticFields[0].field.shape[1:]}."
         return True, "Experiment is correctly initialized."
 
-    def generateAcousticFields(self, fieldDataPath=None, show_log=True):
+    def generateAcousticFields(self, fieldDataPath=None, show_log=True, nameBlock=None):
         """
         Generate the acoustic fields for simulation.
         Args:
@@ -57,7 +59,7 @@ class Tomography(Experiment):
             systemMatrix: A numpy array of the generated fields.
         """
         if self.TypeAcoustic.value == WaveType.StructuredWave.value:
-            self.AcousticFields = self._generateAcousticFields_STRUCT_CPU(fieldDataPath, show_log)
+            self.AcousticFields = self._generateAcousticFields_STRUCT_CPU(fieldDataPath, show_log, nameBlock)
         else:
             raise ValueError("Unsupported wave type.")
 
@@ -389,7 +391,7 @@ class Tomography(Experiment):
         return True
 
     # PRIVATE METHODS
-    def _generateAcousticFields_STRUCT_CPU(self, fieldDataPath=None, show_log=False):
+    def _generateAcousticFields_STRUCT_CPU(self, fieldDataPath=None, show_log=False, nameBlock=None):
         if self.patterns is None:
             raise ValueError("patterns is not initialized. Please load or generate the active list first.")
         listAcousticFields = []
@@ -415,7 +417,7 @@ class Tomography(Experiment):
             if pathField is not None and os.path.exists(pathField):
                 progress_bar.set_postfix_str(f"Loading field - {AcousticField.getName_field()} -- Memory used: {memory.percent}%")
                 try:
-                    AcousticField.load_field(fieldDataPath, self.FormatSave)
+                    AcousticField.load_field(fieldDataPath, self.FormatSave,nameBlock)
                 except:
                     progress_bar.set_postfix_str(f"Error loading field -> Generating field - {AcousticField.getName_field()} -- Memory used: {memory.percent}% ---- processing on {config.get_process().upper()} ----")
                     AcousticField.generate_field(show_log=show_log)
@@ -433,3 +435,71 @@ class Tomography(Experiment):
             listAcousticFields.append(AcousticField)
             progress_bar.set_postfix_str("")
         return listAcousticFields
+
+    def load_experimentalAO(self, pathAO, withTumor = True, h5name='AOsignal'):
+        """
+        Load experimental AO signals from specified file paths.
+        Args:
+            path_withTumor: Path to the AO signal with tumor.
+            path_withoutTumor: Path to the AO signal without tumor.
+        """
+        if not os.path.exists(pathAO):
+            raise FileNotFoundError(f"File {pathAO} not found.")
+
+        if pathAO.endswith('.npy'):
+            ao_signal = np.load(pathAO)
+        elif pathAO.endswith('.h5'):
+            with h5py.File(pathAO, 'r') as f:
+                if h5name not in f:
+                    raise KeyError(f"Dataset '{h5name}' not found in the HDF5 file.")
+                ao_signal = f[h5name][:]
+        elif pathAO.endswith('.mat'):
+            mat_data = loadmat(pathAO)
+            if h5name not in mat_data:
+                raise KeyError(f"Dataset '{h5name}' not found in the .mat file.")
+            ao_signal = mat_data[h5name]
+        elif pathAO.endswith('.hdr'):
+            ao_signal = self._loadAOSignal(pathAO)
+        else:
+            raise ValueError("Unsupported file format. Supported formats are: .npy, .h5, .mat, .hdr")
+        
+        if withTumor:
+            self.AOsignal_withTumor = ao_signal
+        else:
+            self.AOsignal_withoutTumor = ao_signal
+
+    def check_experimentalAO(self, activeListPath, withTumor=True):
+        """
+        Check if the experimental AO signals are correctly initialized.
+        """
+        if withTumor:
+            if self.AOsignal_withTumor is None:
+                raise ValueError("Experimental AOsignal with tumor is not initialized. Please load the experimental AO signal with tumor first.")
+        else:
+            if self.AOsignal_withoutTumor is None:
+                raise ValueError("Experimental AOsignal without tumor is not initialized. Please load the experimental AO signal without tumor first.")
+        if self.AcousticFields is not None:
+            # get min time shape between all AO signals
+            print()
+            
+            if self.AcousticFields[0].field.shape[0] > self.AOsignal_withTumor.shape[0]:
+                self.cutAcousticFields(max_t=self.AOsignal_withTumor.shape[0]/float(self.params.acoustic['f_saving']))
+            else:
+                for i in range(len(self.AcousticFields)):
+                    min_time_shape = min(self.AcousticFields[i].field.shape[0])
+                if withTumor:
+                    self.AOsignal_withTumor = self.AOsignal_withTumor[:min_time_shape, :]
+                else:
+                    self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:min_time_shape, :]
+
+            for field in self.AcousticFields:                        
+                if activeListPath is not None:
+                    with open(activeListPath, 'r') as file:
+                        lines = file.readlines()
+                        expected_name = lines[self.AcousticFields.index(field)].strip()
+                        nameField = field.getName_field()
+                        if nameField.startswith("field_"):
+                            nameField = nameField[len("field_"):]
+                        if nameField != expected_name:
+                            raise ValueError(f"Field name {nameField} does not match the expected name {expected_name} from the active list.")
+        print("Experimental AO signals are correctly initialized.")