AOT-biomaps 2.9.15__tar.gz → 2.9.354__tar.gz

aot_biomaps-2.9.354/AOT_biomaps/AOT_Acoustic/AcousticTools.py

@@ -0,0 +1,219 @@
+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-2.9.354/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-2.9.15 → aot_biomaps-2.9.354}/AOT_biomaps/AOT_Acoustic/PlaneWave.py

@@ -3,7 +3,7 @@ from .AcousticEnums import WaveType
 
 
 class PlaneWave(StructuredWave):
-    def __init__(self, angle, space_0 = 0, space_1 = 192, move_head_0_2tail = 0, move_tail_1_2head = 0, **kwargs):
+    def __init__(self, angle_deg, **kwargs):
         """
         Initialize the PlaneWave object.
 
@@ -12,7 +12,7 @@ class PlaneWave(StructuredWave):
             **kwargs: Additional keyword arguments.
         """
         try:
-            super().__init__(angle, space_0, space_1, move_head_0_2tail, move_tail_1_2head, **kwargs)
+            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}")