AOT-biomaps 2.1.3__py3-none-any.whl → 2.9.233__py3-none-any.whl

AOT_biomaps/AOT_Acoustic/AcousticEnums.py

@@ -0,0 +1,64 @@
+from enum import Enum
+
+class TypeSim(Enum):
+    """
+    Enum for the type of simulation to be performed.
+
+    Selection of simulation types:
+    - KWAVE: k-Wave simulation.
+    - FIELD2: Field II simulation.
+    - HYDRO: Hydrophone acquisition.
+    """
+    KWAVE = 'k-wave'
+    """k-Wave simulation."""
+
+    FIELD2 = 'Field2'
+    """Field II simulation."""
+
+    HYDRO = 'Hydrophone'
+    """Hydrophone acquisition."""
+
+class Dim(Enum):
+    """
+    Enum for the dimension of the acoustic field.
+
+    Selection of dimensions:
+    - D2: 2D field.
+    - D3: 3D field.
+    """
+    D2 = '2D'
+    """2D field."""
+    D3 = '3D'
+    """3D field."""
+
+class FormatSave(Enum):
+    """
+    Enum for different file formats to save the acoustic field.
+
+    Selection of file formats:
+    - HDR_IMG: Interfile format (.hdr and .img).
+    - H5: HDF5 format (.h5).
+    - NPY: NumPy format (.npy).
+    """
+    HDR_IMG = '.hdr'
+    """Interfile format (.hdr and .img)."""
+    H5 = '.h5'
+    """HDF5 format (.h5)."""
+    NPY = '.npy'
+    """NumPy format (.npy)."""
+
+class WaveType(Enum):
+    """
+    Enum for different types of acoustic waves.
+
+    Selection of wave types:
+    - FocusedWave: A wave type where the energy is focused at a specific point.
+    - StructuredWave: A wave type characterized by a specific pattern or structure.
+    - PlaneWave: A wave type where the wavefronts are parallel and travel in a single direction.
+    """
+    FocusedWave = 'focus'
+    """A wave type where the energy is focused at a specific point."""
+    StructuredWave = 'structured'
+    """A wave type characterized by a specific pattern or structure."""
+    PlaneWave = 'plane'
+    """A wave type where the wavefronts are parallel and travel in a single direction."""

AOT_biomaps/AOT_Acoustic/AcousticTools.py

@@ -0,0 +1,221 @@
+from AOT_biomaps.Config import config
+
+from scipy.signal import hilbert
+import os
+import h5py
+import numpy as np
+import torch
+from concurrent.futures import ThreadPoolExecutor
+
+def loadmat(param_path_mat):
+    """
+    Charge un fichier .mat (format HDF5) sans SciPy.
+    Args:
+        param_path_mat: Chemin vers le fichier .mat.
+    Returns:
+        Dictionnaire contenant les variables du fichier.
+    """
+    with h5py.File(param_path_mat, 'r') as f:
+        data = {}
+        for key in f.keys():
+            # Récupère les données et convertit en numpy array si nécessaire
+            item = f[key]
+            if isinstance(item, h5py.Dataset):
+                data[key] = item[()]  # Convertit en numpy array
+            elif isinstance(item, h5py.Group):
+                # Pour les structures MATLAB (nested)
+                data[key] = {}
+                for subkey in item:
+                    data[key][subkey] = item[subkey][()]
+    return data
+
+def reshape_field(field, factor, device=None):
+    """
+    Downsample a 3D or 4D field using PyTorch interpolation (auto-detects GPU/CPU).
+    Args:
+        field: Input field (numpy array or torch.Tensor).
+        factor: Downsampling factor (tuple of ints).
+        device: Force device ('cpu' or 'cuda'). If None, auto-detects GPU.
+    Returns:
+        Downsampled field (same type as input: numpy array or torch.Tensor).
+    """
+    # Check input
+    if field is None:
+        raise ValueError("Acoustic field is not generated. Please generate the field first.")
+
+    # Auto-detect device if not specified
+    if device is None:
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    else:
+        device = device.lower()
+        if device not in ['cpu', 'cuda']:
+            raise ValueError("Device must be 'cpu' or 'cuda'.")
+
+    # Convert to torch.Tensor if needed
+    if isinstance(field, np.ndarray):
+        field = torch.from_numpy(field)
+    elif not isinstance(field, torch.Tensor):
+        raise TypeError("Input must be a numpy array or torch.Tensor.")
+
+    # Move to the target device
+    field = field.to(device)
+
+    # Add batch and channel dimensions (required by torch.interpolate)
+    if len(factor) == 3:
+        if field.dim() != 3:
+            raise ValueError("Expected 3D field.")
+        field = field.unsqueeze(0).unsqueeze(0)  # (1, 1, D, H, W)
+
+        # Calculate new shape
+        new_shape = [
+            field.shape[2] // factor[0],
+            field.shape[3] // factor[1],
+            field.shape[4] // factor[2]
+        ]
+
+        # Trilinear interpolation
+        downsampled = torch.nn.functional.interpolate(
+            field,
+            size=new_shape,
+            mode='trilinear',
+            align_corners=True
+        )
+        downsampled = downsampled.squeeze(0).squeeze(0)  # Remove batch/channel dims
+
+    elif len(factor) == 4:
+        if field.dim() != 4:
+            raise ValueError("Expected 4D field.")
+        field = field.unsqueeze(0).unsqueeze(0)  # (1, 1, T, D, H, W)
+
+        new_shape = [
+            field.shape[2] // factor[0],
+            field.shape[3] // factor[1],
+            field.shape[4] // factor[2],
+            field.shape[5] // factor[3]
+        ]
+
+        # Tetra-linear interpolation
+        downsampled = torch.nn.functional.interpolate(
+            field,
+            size=new_shape,
+            mode='trilinear',  # PyTorch uses 'trilinear' for both 3D and 4D
+            align_corners=True
+        )
+        downsampled = downsampled.squeeze(0).squeeze(0)
+
+    else:
+        raise ValueError("Unsupported dimension. Only 3D and 4D fields are supported.")
+
+    # Convert back to numpy if input was numpy
+    if isinstance(field, np.ndarray):
+        return downsampled.cpu().numpy()
+    else:
+        return downsampled.cpu().numpy()
+
+def calculate_envelope_squared(field):
+    """
+    Calcule l'enveloppe au carré du champ acoustique en utilisant scipy.signal.hilbert (CPU uniquement).
+
+    Args:
+        field: Champ acoustique (numpy.ndarray) de forme (T, X, Z) ou (T, X, Y, Z).
+
+    Returns:
+        envelope (numpy.ndarray): Enveloppe au carré du champ acoustique.
+    """
+    try:
+        if field is None:
+            raise ValueError("Le champ acoustique n'est pas généré. Veuillez d'abord générer le champ.")
+
+        if not isinstance(field, np.ndarray):
+            if hasattr(field, 'cpu'):
+                field = field.cpu().numpy()  # Si c'est un tenseur PyTorch sur GPU/CPU
+            else:
+                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"Erreur dans calculate_envelope_squared: {e}")
+        raise
+
+
+
+def getPattern(pathFile):
+    """
+    Get the pattern from a file path.
+
+    Args:
+        pathFile (str): Path to the file containing the pattern.
+
+    Returns:
+        str: The pattern string.
+    """
+    try:
+        # Pattern between first _ and last _
+        pattern = os.path.basename(pathFile).split('_')[1:-1]
+        pattern_str = ''.join(pattern)
+        return pattern_str
+    except Exception as e:
+        print(f"Error reading pattern from file: {e}")
+        return None
+    
+def detect_space_0_and_space_1(hex_string):
+    binary_string = bin(int(hex_string, 16))[2:].zfill(len(hex_string) * 4)
+    
+    # Trouver la plus longue séquence de 0 consécutifs
+    zeros_groups = [len(s) for s in binary_string.split('1')]
+    space_0 = max(zeros_groups) if zeros_groups else 0
+
+    # Trouver la plus longue séquence de 1 consécutifs
+    ones_groups = [len(s) for s in binary_string.split('0')]
+    space_1 = max(ones_groups) if ones_groups else 0
+
+    return space_0, space_1
+
+def getAngle(pathFile):
+    """
+    Get the angle from a file path.
+
+    Args:
+        pathFile (str): Path to the file containing the angle.
+
+    Returns:
+        int: The angle in degrees.
+    """
+    try:
+        # Angle between last _ and .
+        angle_str = os.path.basename(pathFile).split('_')[-1].replace('.', '')
+        if angle_str.startswith('0'):
+            angle_str = angle_str[1:]
+        elif angle_str.startswith('1'):
+            angle_str = '-' + angle_str[1:]
+        else:
+            raise ValueError("Invalid angle format in file name.")
+        return int(angle_str)
+    except Exception as e:
+        print(f"Error reading angle from file: {e}")
+        return None
+
+def next_power_of_2(n):
+    """Calculate the next power of 2 greater than or equal to n."""
+    return int(2 ** np.ceil(np.log2(n)))
+        

AOT_biomaps/AOT_Acoustic/FocusedWave.py

@@ -0,0 +1,244 @@
+from ._mainAcoustic import AcousticField
+from .AcousticEnums import WaveType
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+
+class FocusedWave(AcousticField):
+
+    def __init__(self, focal_line, **kwargs):
+        """
+        Initialize the FocusedWave object.
+
+        Parameters:
+        - focal_line (tuple): The focal line coordinates (x) in meters.
+        - **kwargs: Additional keyword arguments for AcousticField initialization.
+        """
+        super().__init__(**kwargs)
+        self.waveType = WaveType.FocusedWave
+        self.kgrid.setTime(int(self.kgrid.Nt*2),self.kgrid.dt) # Extend the time grid to allow for delays
+        self.focal_line = focal_line
+        self.delayedSignal = self._apply_delay()
+
+    def getName_field(self):
+        """
+        Generate the name for the field file based on the focal line.
+
+        Returns:
+            str: File name for the system matrix file.
+        """
+        try:
+            return f"field_focused_X{self.focal_line*1000:.2f}"
+        except Exception as e:
+            print(f"Error generating file name: {e}")
+            return None
+
+    def _apply_delay(self, dx=None):
+        try:
+            if dx is None:
+                dx = self.params['dx']
+
+            # 1. Grid and element setup (utilise les paramètres utilisateur)
+            element_width_grid_points = int(round(self.params['element_width'] / dx))
+            total_grid_points = self.params['num_elements'] * element_width_grid_points
+            element_positions = np.linspace(
+                self.params['Xrange'][0] + self.params['element_width']/2,
+                self.params['Xrange'][1] - self.params['element_width'],
+                self.params['num_elements']
+            )
+
+            # 2. Select active elements (utilise les paramètres utilisateur)
+            center_idx = np.argmin(np.abs(element_positions - self.focal_line))
+            half_N = self.params['N_piezoFocal'] // 2
+            start_idx = max(0, center_idx - half_N)
+            end_idx = min(self.params['num_elements'] - 1, center_idx + half_N - 1)
+            active_elements = np.arange(start_idx, end_idx + 1)
+            active_element_positions = element_positions[active_elements]
+
+            # 3. Calculate relative positions
+            x_rel = active_element_positions - self.focal_line
+            a = np.max(np.abs(x_rel))
+
+            # 4. Calculate the parabolic delays (utilise les paramètres utilisateur)
+            tau_max = (a**2) / (2 * self.params['Foc'] * self.params['c0'])
+            delays = tau_max * (1 - (x_rel / a)**2)
+
+            # 5. Force the delays at the edges to be zero
+            tau_edge = delays[0]
+            delays -= tau_edge
+
+            # 6. Convert delays to samples
+            delay_samples = np.round(delays / self.kgrid.dt).astype(int)
+            max_delay_samples = np.max(delay_samples)
+            print(f"Max delay (samples): {max_delay_samples}")
+
+            # 7. Initialize output
+            delayed_signals = np.zeros((total_grid_points, len(self.burst) + max_delay_samples))
+
+            # 8. Apply delays
+            for elem_idx, elem_delay in zip(active_elements, delay_samples):
+                start_grid = elem_idx * element_width_grid_points
+                end_grid = start_grid + element_width_grid_points
+                for grid_idx in range(start_grid, end_grid):
+                    if elem_delay >= 0 and elem_delay + len(self.burst) <= delayed_signals.shape[1]:
+                        delayed_signals[grid_idx, elem_delay:elem_delay + len(self.burst)] = self.burst
+
+            return delayed_signals
+
+        except Exception as e:
+            print(f"Error applying delay: {e}")
+            return None
+
+ 
+    def plot_delay(self):
+        """
+        Plot the time of the maximum of each delayed signal to visualize the wavefront.
+        """
+        try:
+            # Find the index of the maximum for each delayed signal
+            max_indices = np.argmax(self.delayedSignal, axis=1)
+            element_indices = np.linspace(0, self.params['num_elements'] - 1, self.delayedSignal.shape[0])
+            # Convert indices to time
+            max_times = max_indices / self.params['f_AQ'] * 1e6
+
+            # Détermine la valeur minimale des temps de maximum (pour les éléments actifs)
+            min_active_time = np.min(max_times[max_times > 0])
+
+            # Plot the times of the maxima
+            plt.figure(figsize=(10, 6))
+            plt.plot(element_indices, max_times, 'o-')
+            plt.title('Time of Maximum for Each Delayed Signal')
+            plt.xlabel('Transducer Element Index')
+            plt.ylabel('Time of Maximum (µs)')
+            plt.grid(True)
+
+            # Ajuste l'échelle de l'axe Y pour commencer à la valeur minimale des éléments actifs
+            plt.ylim(bottom=min_active_time * 0.95)  # Ajoute une marge de 5% pour plus de lisibilité
+            plt.show()
+        except Exception as e:
+            print(f"Error plotting max times: {e}")
+
+    def _SetUpSource(self, source, Nx, dx, factorT):
+        """
+        Set up source for both 2D and 3D focused waves.
+        """
+        element_width_grid_points = int(round(self.params['element_width'] / dx))
+
+        if source.p_mask.ndim == 2:
+            # --- 2D ---
+            element_positions = np.linspace(
+                self.params['Xrange'][0] + self.params['element_width'] / 2,
+                self.params['Xrange'][1] - self.params['element_width'] / 2,
+                self.params['num_elements']
+            )
+            center_idx = np.argmin(np.abs(element_positions - self.focal_line))
+            start_idx = max(0, center_idx - self.params['N_piezoFocal'] // 2)
+            end_idx = min(self.params['num_elements'] - 1, start_idx + self.params['N_piezoFocal'] - 1)
+            selected_indices = np.arange(start_idx, end_idx + 1)
+
+            current_position = (Nx - self.params['num_elements'] * element_width_grid_points) // 2
+            active_grid_indices = []
+            for i in range(self.params['num_elements']):
+                x_start = current_position
+                x_end = current_position + element_width_grid_points
+                if i in selected_indices:
+                    source.p_mask[x_start:x_end, 0] = 1
+                    active_grid_indices.extend(range(x_start, x_end))
+                current_position += element_width_grid_points
+
+            delayed_signals = self._apply_delay(dx=dx) if factorT != 1 else self.delayedSignal
+            source.p = float(self.params['voltage']) * float(self.params['sensitivity']) * delayed_signals[active_grid_indices, :]
+
+        elif source.p_mask.ndim == 3:
+            # --- 3D ---
+            center_index_x = Nx // 2
+            center_index_y = self.params['Ny'] // 2
+
+            for i in range(self.params['num_elements']):
+                x_pos = center_index_x - (self.params['num_elements'] // 2) * element_width_grid_points + i * element_width_grid_points
+                source.p_mask[x_pos, center_index_y, 0] = 1
+
+            delayed_signals = self._apply_delay()
+            source.p = float(self.params['voltage']) * float(self.params['sensitivity']) * delayed_signals.T
+
+    def _save2D_HDR_IMG(self, filePath):
+        """
+        Save the acoustic field to .img and .hdr files.
+
+        Parameters:
+        - filePath (str): Path to the folder where files will be saved.
+        """
+        try:
+            t_ex = 1 / self.params['f_US']
+            x_focal, z_focal = self.focal_point
+
+            # Define file names (img and hdr)
+            file_name = f"field_focused_{x_focal:.2f}_{z_focal:.2f}"
+
+            img_path = os.path.join(filePath, file_name + ".img")
+            hdr_path = os.path.join(filePath, file_name + ".hdr")
+
+            # Save the acoustic field to the .img file
+            with open(img_path, "wb") as f_img:
+                self.field.astype('float32').tofile(f_img)
+
+            # Generate headerFieldGlob
+            headerFieldGlob = (
+                f"!INTERFILE :=\n"
+                f"modality : AOT\n"
+                f"voxels number transaxial: {self.field.shape[2]}\n"
+                f"voxels number transaxial 2: {self.field.shape[1]}\n"
+                f"voxels number axial: {1}\n"
+                f"field of view transaxial: {(self.params['Xrange'][1] - self.params['Xrange'][0]) * 1000}\n"
+                f"field of view transaxial 2: {(self.params['Zrange'][1] - self.params['Zrange'][0]) * 1000}\n"
+                f"field of view axial: {1}\n"
+            )
+
+            # Generate header
+            header = (
+                f"!INTERFILE :=\n"
+                f"!imaging modality := AOT\n\n"
+                f"!GENERAL DATA :=\n"
+                f"!data offset in bytes := 0\n"
+                f"!name of data file := system_matrix/{file_name}.img\n\n"
+                f"!GENERAL IMAGE DATA\n"
+                f"!total number of images := {self.field.shape[0]}\n"
+                f"imagedata byte order := LITTLEENDIAN\n"
+                f"!number of frame groups := 1\n\n"
+                f"!STATIC STUDY (General) :=\n"
+                f"number of dimensions := 3\n"
+                f"!matrix size [1] := {self.field.shape[2]}\n"
+                f"!matrix size [2] := {self.field.shape[1]}\n"
+                f"!matrix size [3] := {self.field.shape[0]}\n"
+                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"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"
+                f"data rescale offset := 0\n"
+                f"data rescale slope := 1\n"
+                f"quantification units := 1\n\n"
+                f"!SPECIFIC PARAMETERS :=\n"
+                f"focal point (x, z) := {x_focal}, {z_focal}\n"
+                f"number of US transducers := {self.params['num_elements']}\n"
+                f"delay (s) := 0\n"
+                f"us frequency (Hz) := {self.params['f_US']}\n"
+                f"excitation duration (s) := {t_ex}\n"
+                f"!END OF INTERFILE :=\n"
+            )
+
+            # Save the .hdr file
+            with open(hdr_path, "w") as f_hdr:
+                f_hdr.write(header)
+
+            with open(os.path.join(filePath, "field.hdr"), "w") as f_hdr2:
+                f_hdr2.write(headerFieldGlob)
+        except Exception as e:
+            print(f"Error saving HDR/IMG files: {e}")
+ 

AOT_biomaps/AOT_Acoustic/IrregularWave.py

@@ -0,0 +1,66 @@
+from AOT_biomaps.AOT_Acoustic._mainAcoustic import AcousticField
+from .AcousticEnums import WaveType, TypeSim
+
+import numpy as np
+
+class IrregularWave(AcousticField):
+    """
+    Class for irregular wave types, inheriting from AcousticField.
+    This class is a placeholder for future implementation of irregular wave types.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.waveType = WaveType.IrregularWave
+        self.params = {
+            'typeSim': TypeSim.IRREGULAR.value,
+        }
+
+    def getName_field(self):
+        raise NotImplementedError("getName_field method not implemented for IrregularWave.")
+    
+    def  _generate_diverse_structurations(self,num_elements, num_sequences, num_frequencies):
+        """
+        Génère num_sequences structurations irrégulières ON/OFF pour une sonde de num_elements éléments.
+        Chaque structuration contient exactement num_frequencies fréquences spatiales distinctes.
+
+        :param num_elements: Nombre total d'éléments piézoélectriques de la sonde.
+        :param num_sequences: Nombre total de structurations générées.
+        :param num_frequencies: Nombre de fréquences spatiales distinctes par structuration.
+        :return: Matrice de structuration de taille (num_sequences, num_elements)
+        """
+        
+        # Définition des fréquences spatiales disponibles
+        max_freq = num_elements // 2  # Nyquist limit
+        available_frequencies = np.arange(1, max_freq + 1)  # Fréquences possibles
+        
+        # Matrice des structurations
+        structurations = np.zeros((num_sequences, num_elements), dtype=int)
+        
+        # Sélectionner des fréquences uniques pour chaque structuration
+        chosen_frequencies = []
+        for _ in range(num_sequences):
+            freqs = np.random.choice(available_frequencies, size=num_frequencies, replace=False)
+            chosen_frequencies.append(freqs)
+
+            # Construire la structuration correspondante
+            structuration = np.zeros(num_elements)
+            for f in freqs:
+                structuration += np.cos(2 * np.pi * f * np.arange(num_elements) / num_elements)  # Ajouter la fréquence
+            
+            structuration = np.where(structuration >= 0, 1, 0)  # Binarisation ON/OFF
+            structurations[_] = structuration
+        
+        return structurations, chosen_frequencies
+    
+    def getName_field(self):
+        raise NotImplementedError("getName_field method not implemented for IrregularWave.")
+
+    def _generate_2Dacoustic_field_KWAVE(self):
+        raise NotImplementedError("2D acoustic field generation not implemented for IrregularWave.")
+
+    def _generate_3Dacoustic_field_KWAVE(self):
+        raise NotImplementedError("3D acoustic field generation not implemented for IrregularWave.")
+
+    def _save2D_HDR_IMG(self, filePath):
+        raise NotImplementedError("HDR/IMG saving not implemented for IrregularWave.")

AOT_biomaps/AOT_Acoustic/PlaneWave.py

@@ -0,0 +1,43 @@
+from .StructuredWave import StructuredWave
+from .AcousticEnums import WaveType
+
+
+class PlaneWave(StructuredWave):
+    def __init__(self, angle_deg, **kwargs):
+        """
+        Initialize the PlaneWave object.
+
+        Args:
+            angle_deg (float): Angle in degrees.
+            **kwargs: Additional keyword arguments.
+        """
+        try:
+            super().__init__(angle_deg=angle_deg, fileName=None, space_0=0, space_1=192, move_head_0_2tail=0, move_tail_1_2head=0, **kwargs)
+            self.waveType = WaveType.PlaneWave
+        except Exception as e:
+            print(f"Error initializing PlaneWave: {e}")
+            raise 
+
+    def _check_angle(self):
+        """
+        Check if the angle is within the valid range.
+
+        Raises:
+            ValueError: If the angle is not between -20 and 20 degrees.
+        """
+        if self.angle < -20 or self.angle > 20:
+            raise ValueError("Angle must be between -20 and 20 degrees.")
+
+    def getName_field(self):
+        """
+        Generate the list of system matrix .hdr file paths for this wave.
+
+        Returns:
+            str: File path for the system matrix .hdr file.
+        """
+        try:
+            angle_str = self._format_angle()
+            return f"field_{self.pattern.activeList}_{angle_str}"
+        except Exception as e:
+            print(f"Error generating file path: {e}")
+            return None