AOT-biomaps 2.9.74__tar.gz → 2.9.232__tar.gz

{aot_biomaps-2.9.74 → aot_biomaps-2.9.232}/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-2.9.74 → aot_biomaps-2.9.232}/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-2.9.74 → aot_biomaps-2.9.232}/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,16 +514,14 @@ 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])
             kgrid.setTime(self.kgrid.Nt, 1 / self.params['f_AQ'])
 
-            print(f"Grid size: Nx={Nx}, Nz={Nz}, dx={dx*1000:.3f} mm, dt={kgrid.dt*1e9:.3f} ns, Nt={kgrid.Nt}, f_AQ={self.params['f_AQ']/1e6:.2f} MHz")
-
             source = kSource()
             source.p_mask = np.zeros((Nx, Nz))
 
@@ -533,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(
@@ -551,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(
@@ -565,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}")
@@ -655,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.
 
@@ -666,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