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

AOT_biomaps/AOT_Experiment/_mainExperiment.py

@@ -56,6 +56,7 @@ class Experiment(ABC):
         pass
 
     def cutAcousticFields(self, max_t, min_t=0):
+
         max_t = float(max_t)
         min_t = float(min_t)
 
@@ -111,11 +112,7 @@ class Experiment(ABC):
                 raise ValueError("noiseType must be either 'gaussian' or 'poisson'.")
             noisy_signal = np.clip(noisy_signal, a_min=0, a_max=None)  # Assurer que le signal reste non négatif
             noiseSignals[:, i] = noisy_signal
-
-        if withTumor:
-            self.AOsignal_withTumor = noiseSignals
-        else:
-            self.AOsignal_withoutTumor = noiseSignals
+        return noiseSignals
 
     def reduceDims(self, mode='avg'):
         """
@@ -157,6 +154,16 @@ class Experiment(ABC):
         for param in ['dx', 'dy', 'dz']:
             convert_and_update(self.params.general, param, lambda x: x * 2)
 
+    def normalizeAOsignals(self, withTumor=True):
+        if withTumor and self.AOsignal_withTumor is None:
+            raise ValueError("AO signal with tumor is not generated. Please generate it first.")
+        if not withTumor and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signal without tumor is not generated. Please generate it first.")
+        if withTumor:
+            self.AOsignal_withTumor = self.AOsignal_withTumor - np.min(self.AOsignal_withTumor)/(np.max(self.AOsignal_withTumor)-np.min(self.AOsignal_withTumor))
+        else:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor - np.min(self.AOsignal_withoutTumor)/(np.max(self.AOsignal_withoutTumor)-np.min(self.AOsignal_withoutTumor))
+
     def saveAcousticFields(self, save_directory):
         progress_bar = trange(len(self.AcousticFields), desc="Saving Acoustic Fields")
         for i in progress_bar:
@@ -233,67 +240,97 @@ class Experiment(ABC):
         return ani
 
     def generateAOsignal(self, withTumor=True, AOsignalDataPath=None):
-        if self.AcousticFields is None:
-            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
-
-        if self.OpticImage is None:
-            raise ValueError("OpticImage is not initialized. Please generate the phantom first.")
 
         if AOsignalDataPath is not None:
             if not os.path.exists(AOsignalDataPath):
                 raise FileNotFoundError(f"AO file {AOsignalDataPath} not found.")
-            AOmatrix = self._load_AOSignal(AOsignalDataPath)
-            if AOmatrix.shape[0] != self.AcousticFields[0].field.shape[0]:
-                print(f"AO signal shape {AOmatrix.shape} does not match the expected shape {self.AcousticFields[0].field.shape}. Generating corrected AO signal to match...")
+            if withTumor:
+                self.AOsignal_withTumor = self._loadAOSignal(AOsignalDataPath)
+                if self.AOsignal_withTumor.shape[0] != self.AcousticFields[0].field.shape[0]:
+                    print(f"AO signal shape {self.AOsignal_withTumor.shape} does not match the expected shape {self.AcousticFields[0].field.shape}. Resizing Acoustic fields...")
+                    self.cutAcousticFields(max_t=self.AOsignal_withTumor.shape[0] / float(self.params.acoustic['f_saving']), min_t=0)
             else:
-                return AOmatrix
-
-        if not all(field.field.shape == self.AcousticFields[0].field.shape for field in self.AcousticFields):
-            minShape = min([field.field.shape[0] for field in self.AcousticFields])
-            self.cutAcousticFields(minShape * self.params['fs_aq'])
-        else:
-            shape_field = self.AcousticFields[0].field.shape
-
-        AOsignal = np.zeros((shape_field[0], len(self.AcousticFields)), dtype=np.float32)
-
-        if withTumor:
-            description = "Generating AO Signal with Tumor"
-        else:
-            description = "Generating AO Signal without Tumor"
+                self.AOsignal_withoutTumor = self._loadAOSignal(AOsignalDataPath)
+                if self.AOsignal_withoutTumor.shape[0] != self.AcousticFields[0].field.shape[0]:
+                    print(f"AO signal shape {self.AOsignal_withoutTumor.shape} does not match the expected shape {self.AcousticFields[0].field.shape}. Resizing Acoustic fields...")
+                    self.cutAcousticFields(max_t=self.AOsignal_withoutTumor.shape[0] / float(self.params.acoustic['f_saving']), min_t=0)
+        else:    
+            if self.AcousticFields is None:
+                raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+
+            if self.OpticImage is None:
+                raise ValueError("OpticImage is not initialized. Please generate the phantom first.")
+            
+            if not all(field.field.shape == self.AcousticFields[0].field.shape for field in self.AcousticFields):
+                minShape = min([field.field.shape[0] for field in self.AcousticFields])
+                self.cutAcousticFields(max_t=minShape * self.params['fs_aq'])
+            else:
+                shape_field = self.AcousticFields[0].field.shape
 
-        for i in trange(len(self.AcousticFields), desc=description):
-            for t in range(self.AcousticFields[i].field.shape[0]):
-                if withTumor:
-                    interaction = self.OpticImage.phantom * self.AcousticFields[i].field[t, :, :]
-                else:
-                    interaction = self.OpticImage.laser.intensity * self.AcousticFields[i].field[t, :, :]
-                AOsignal[t, i] = np.sum(interaction)
+            AOsignal = np.zeros((shape_field[0], len(self.AcousticFields)), dtype=np.float32)
 
-        if withTumor:
-            self.AOsignal_withTumor = AOsignal
-        else:
-            self.AOsignal_withoutTumor = AOsignal
+            if withTumor:
+                description = "Generating AO Signal with Tumor"
+            else:
+                description = "Generating AO Signal without Tumor"
+
+            for i in trange(len(self.AcousticFields), desc=description):
+                for t in range(self.AcousticFields[i].field.shape[0]):
+                    if withTumor:
+                        interaction = self.OpticImage.phantom * self.AcousticFields[i].field[t, :, :]
+                    else:
+                        interaction = self.OpticImage.laser.intensity * self.AcousticFields[i].field[t, :, :]
+                    AOsignal[t, i] = np.sum(interaction)
+
+            if withTumor:
+                self.AOsignal_withTumor = AOsignal
+            else:
+                self.AOsignal_withoutTumor = AOsignal
 
     @staticmethod
-    def _loadAOSignal(cdh_file):
-        with open(cdh_file, "r") as file:
-            cdh_content = file.readlines()
-
-        n_events = int([line.split(":")[1].strip() for line in cdh_content if "Number of events" in line][0])
-        n_acquisitions = int([line.split(":")[1].strip() for line in cdh_content if "Number of acquisitions per event" in line][0])
-
-        AOsignal_matrix = np.zeros((n_events, n_acquisitions), dtype=np.float32)
-
-        with open(cdh_file.replace(".cdh", ".cdf"), "rb") as file:
-            for event in range(n_events):
-                num_elements = int([line.split(":")[1].strip() for line in cdh_content if "Number of US transducers" in line][0])
-                hex_length = (num_elements + 3) // 4
-                file.read(hex_length // 2)
-
-                signal = np.frombuffer(file.read(n_acquisitions * 4), dtype=np.float32)
-                AOsignal_matrix[event, :] = signal
-
-        return AOsignal_matrix
+    def _loadAOSignal(AOsignalPath):
+        if AOsignalPath.endswith(".cdh"):
+            with open(AOsignalPath, "r") as file:
+                cdh_content = file.readlines()
+            
+            cdf_path = AOsignalPath.replace(".cdh", ".cdf")
+
+            # Extraire les paramètres depuis le fichier .cdh
+            n_scans = int([line.split(":")[1].strip() for line in cdh_content if "Number of events" in line][0])
+            n_acquisitions_per_event = int([line.split(":")[1].strip() for line in cdh_content if "Number of acquisitions per event" in line][0])
+            num_elements = int([line.split(":")[1].strip() for line in cdh_content if "Number of US transducers" in line][0])
+
+            # Initialisation des structures
+            AO_signal = np.zeros((n_acquisitions_per_event, n_scans), dtype=np.float32)
+            active_lists = []
+            angles = []
+
+            # Lecture du fichier binaire
+            with open(cdf_path, "rb") as file:
+                for j in trange(n_scans, desc="Lecture des événements"):
+                    # Lire l'activeList : 48 caractères hex = 24 bytes
+                    active_list_bytes = file.read(24)
+                    active_list_hex = active_list_bytes.hex()
+                    active_lists.append(active_list_hex)
+
+                    # Lire l'angle (1 byte signé)
+                    angle_byte = file.read(1)
+                    angle = np.frombuffer(angle_byte, dtype=np.int8)[0]
+                    angles.append(angle)
+
+                    # Lire le signal AO (float32)
+                    data = np.frombuffer(file.read(n_acquisitions_per_event * 4), dtype=np.float32)
+                    if len(data) != n_acquisitions_per_event:
+                        raise ValueError(f"Erreur à l'événement {j} : attendu {n_acquisitions_per_event}, obtenu {len(data)}")
+                    AO_signal[:, j] = data
+
+            return AO_signal
+
+
+        elif AOsignalPath.endswith(".npy"):
+            return np.load(AOsignalPath)  # Supposé déjà au bon format
+        else:
+            raise ValueError("Format de fichier non supporté. Utilisez .cdh/.cdf ou .npy.")
 
     def saveAOsignals_Castor(self, save_directory, withTumor=True):
         if withTumor:
@@ -319,12 +356,12 @@ class Experiment(ABC):
                 fileID.write(AO_signal[:, j].astype(np.float32).tobytes())
 
         header_content = (
-            f"Data filename: AOSignals.cdf\n"
+            f"Data filename: {'AOSignals_withTumor.cdf' if withTumor else 'AOSignals_withoutTumor.cdf'}\n"
             f"Number of events: {nScan}\n"
-            f"Number of acquisitions per event: {AO_signal.shape[1]}\n"
+            f"Number of acquisitions per event: {AO_signal.shape[0]}\n"
             f"Start time (s): 0\n"
             f"Duration (s): 1\n"
-            f"Acquisition frequency (Hz): {1/self.AcousticFields[0].kgrid.dt}\n"
+            f"Acquisition frequency (Hz): {self.params.acoustic['f_saving']}\n"
             f"Data mode: histogram\n"
             f"Data type: AOT\n"
             f"Number of US transducers: {self.params.acoustic['num_elements']}"
@@ -475,18 +512,15 @@ class Experiment(ABC):
         plt.close(fig)
         return ani
 
-    def showPhantom(self):
+    def showPhantom(self, withROI=False):
         """
         Displays the optical phantom with absorbers.
         """
         try:
-            plt.imshow(self.OpticImage.phantom, extent=(self.OpticImage.laser.x[0], self.OpticImage.laser.x[-1] + 1, self.OpticImage.laser.z[-1], self.OpticImage.laser.z[0]), aspect='equal', cmap='hot')
-            plt.colorbar(label='Intensity')
-            plt.xlabel('X (mm)', fontsize=20)
-            plt.ylabel('Z (mm)', fontsize=20)
-            plt.tick_params(axis='both', which='major', labelsize=20)
-            plt.title('Optical Phantom with Absorbers')
-            plt.show()
+            if withROI:
+                self.OpticImage.show_ROI()
+            else:
+                self.OpticImage.show_phantom()
         except Exception as e:
             raise RuntimeError(f"Error plotting phantom: {e}")
         

AOT_biomaps/AOT_Optic/_mainOptic.py

@@ -1,14 +1,15 @@
 from .Laser import Laser
 from .Absorber import Absorber
-
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.patches as patches
+from mpl_toolkits.axes_grid1 import make_axes_locatable
 
 class Phantom:
     """
     Class to apply absorbers to a laser field in the XZ plane.
     """
+
     def __init__(self, params):
         """
         Initializes the phantom with the given parameters.
@@ -20,27 +21,13 @@ class Phantom:
             self.laser = Laser(params)
             self.phantom = self._apply_absorbers()
             self.phantom = np.transpose(self.phantom)
+            self.laser.intensity = np.transpose(self.laser.intensity)
+            self.maskList = None  # List to store ROI masks
         except KeyError as e:
             raise ValueError(f"Missing parameter: {e}")
         except Exception as e:
             raise RuntimeError(f"Error initializing Phantom: {e}")
 
-    def _apply_absorbers(self):
-        """
-        Applies the absorbers to the laser field.
-        :return: Intensity matrix of the phantom with applied absorbers.
-        """
-        try:
-            X, Z = np.meshgrid(self.laser.x, self.laser.z, indexing='ij')
-            intensity = np.copy(self.laser.intensity)
-            for absorber in self.absorbers:
-                r2 = (X - absorber.center[0] * 1000)**2 + (Z - absorber.center[1] * 1000)**2
-                absorption = -absorber.amplitude * np.exp(-r2 / (absorber.radius * 1000)**2)
-                intensity += absorption
-            return np.clip(intensity, 0, None)
-        except Exception as e:
-            raise RuntimeError(f"Error applying absorbers: {e}")
-
     def __str__(self):
         """
         Returns a string representation of the Phantom object,
@@ -55,6 +42,7 @@ class Phantom:
                 'w0': self.laser.w0,
             }
             laser_attr_lines = [f"  {k}: {v}" for k, v in laser_attrs.items()]
+
             # Absorber attributes
             absorber_lines = []
             for absorber in self.absorbers:
@@ -63,27 +51,79 @@ class Phantom:
                 absorber_lines.append(f"    center: {absorber.center}")
                 absorber_lines.append(f"    radius: {absorber.radius}")
                 absorber_lines.append(f"    amplitude: {absorber.amplitude}")
+
             # Define borders and titles
             border = "+" + "-" * 40 + "+"
-            title = f"| Type : {self.__class__.__name__} |"
+            title = f"| Type: {self.__class__.__name__} |"
             laser_title = "| Laser Parameters |"
             absorber_title = "| Absorbers |"
+
             # Assemble the final result
             result = f"{border}\n{title}\n{border}\n{laser_title}\n{border}\n"
             result += "\n".join(laser_attr_lines)
             result += f"\n{border}\n{absorber_title}\n{border}\n"
             result += "\n".join(absorber_lines)
             result += f"\n{border}"
+
             return result
         except Exception as e:
             raise RuntimeError(f"Error generating string representation: {e}")
+        
+    def find_ROI(self):
+        """
+        Computes binary masks for each ROI and stores them in self.maskList.
+        :return: True if pixels are detected in any ROI, False otherwise.
+        """
+        try:
+            X_mm, Z_mm = np.meshgrid(self.laser.x, self.laser.z, indexing='xy')
+            assert self.phantom.shape == X_mm.shape, (
+                f"Shape mismatch: phantom={self.phantom.shape}, grid={X_mm.shape}"
+            )
+            self.maskList = []  # Reset the list
+            roi_found = False
+
+            for absorber in self.absorbers:
+                center_x_mm = absorber.center[0] * 1000  # Convert to mm
+                center_z_mm = absorber.center[1] * 1000  # Convert to mm
+                radius_mm = absorber.radius * 1000  # Convert to mm
+
+                # Create mask for this ROI
+                mask_i = (X_mm - center_x_mm)**2 + (Z_mm - center_z_mm)**2 <= radius_mm**2
+                self.maskList.append(mask_i)
+
+        except Exception as e:
+            raise RuntimeError(f"Error in find_ROI: {e}")
+
+    def _apply_absorbers(self):
+        """
+        Applies the absorbers to the laser field.
+        :return: Intensity matrix of the phantom with applied absorbers.
+        """
+        try:
+            X, Z = np.meshgrid(self.laser.x, self.laser.z, indexing='ij')
+            intensity = np.copy(self.laser.intensity)
+
+            for absorber in self.absorbers:
+                r2 = (X - absorber.center[0] * 1000)**2 + (Z - absorber.center[1] * 1000)**2
+                absorption = -absorber.amplitude * np.exp(-r2 / (absorber.radius * 1000)**2)
+                intensity += absorption
+
+            return np.clip(intensity, 0, None)
+        except Exception as e:
+            raise RuntimeError(f"Error applying absorbers: {e}")
 
     def show_phantom(self):
         """
         Displays the optical phantom with absorbers.
         """
         try:
-            plt.imshow(self.phantom, extent=(self.laser.x[0], self.laser.x[-1] + 1, self.laser.z[-1], self.laser.z[0]), aspect='equal', cmap='hot')
+            plt.figure(figsize=(6, 6))
+            plt.imshow(
+                self.phantom,
+                extent=(self.laser.x[0], self.laser.x[-1] + 1, self.laser.z[-1], self.laser.z[0]),
+                aspect='equal',
+                cmap='hot'
+            )
             plt.colorbar(label='Intensity')
             plt.xlabel('X (mm)', fontsize=20)
             plt.ylabel('Z (mm)', fontsize=20)
@@ -95,44 +135,70 @@ class Phantom:
 
     def show_ROI(self):
         """
-        Displays the optical image with regions of interest (ROIs) highlighted.
-        This method overlays dashed green circles on the optical image to indicate the regions of interest defined by the absorbers.
-        It also calculates and prints the average intensity within these regions.
+        Displays the optical image with ROIs and average intensities.
+        Calls find_ROI() if self.maskList is empty.
         """
-        X, Z = np.meshgrid(self.laser.x, self.laser.z, indexing='ij')
-        # --- Plot the optical image and overlay the regions of interest ---
-        _, ax = plt.subplots(figsize=(5, 5))
-        # Plot the optical intensity image
-        _ = ax.imshow(self.phantom,
-                        extent=(self.laser.x[0]*1000, self.laser.x[-1]*1000, self.laser.z[-1]*1000, self.laser.z[0]*1000),
-                        aspect='equal', cmap='hot')
-        # Overlay dashed green circles for each region of interest
-        for region in self.absorbers:
-            circle = patches.Circle(
-                (region.center[0] * 1000, region.center[1] * 1000),  # Convert to mm
-                region.radius * 1000,
-                edgecolor='limegreen', facecolor='none', linewidth=0.8, linestyle='--', alpha=0.8
+        try:
+            if not self.maskList:
+                self.find_ROI()
+
+            fig, ax = plt.subplots(figsize=(6, 6))
+            im = ax.imshow(
+                self.phantom,
+                extent=(
+                    np.min(self.laser.x), np.max(self.laser.x),
+                    np.max(self.laser.z), np.min(self.laser.z)
+                ),
+                aspect='equal',
+                cmap='hot'
             )
-            ax.add_patch(circle)
-        ax.set_title("Optical image with regions of interest")
-        ax.set_xlabel("x (mm)")
-        ax.set_ylabel("z (mm)")
-        ax.tick_params(axis='both', which='major')
-        plt.show()
-        # --- Create a mask for the regions of interest and calculate average intensity ---
-        # Initialize an empty mask for the regions
-        ROI_mask = np.zeros_like(X, dtype=bool)
-        # Iterate over the regions to create and combine masks
-        for region in self.absorbers:
-            cx, cz = region.center
-            r = region.radius
-            # Calculate squared distance from the center
-            dist_sq = (X - cx)**2 + (Z - cz)**2
-            # Create mask for points within the current region
-            current_mask = dist_sq <= r**2
-            # Combine with the overall region mask
-            ROI_mask = np.logical_or(ROI_mask, current_mask)
-        # Extract intensity values in the regions of interest and compute the average
-        region_intensity_values = self.phantom[ROI_mask]
-        average_intensity = np.mean(region_intensity_values)
-        print("Average intensity in regions of interest:", average_intensity)
+            divider = make_axes_locatable(ax)
+            cax = divider.append_axes("right", size="5%", pad=0.05)
+            plt.colorbar(im, cax=cax, label='Intensity')
+
+            # Draw ROIs
+            for i, absorber in enumerate(self.absorbers):
+                center_x_mm = absorber.center[0] * 1000  # Convert to mm
+                center_z_mm = absorber.center[1] * 1000  # Convert to mm
+                radius_mm = absorber.radius * 1000  # Convert to mm
+
+                circle = patches.Circle(
+                    (center_x_mm, center_z_mm),
+                    radius_mm,
+                    edgecolor='limegreen',
+                    facecolor='none',
+                    linewidth=2
+                )
+                ax.add_patch(circle)
+                ax.text(
+                    center_x_mm,
+                    center_z_mm - 2,
+                    str(i + 1),
+                    color='limegreen',
+                    ha='center',
+                    va='center',
+                    fontsize=12,
+                    fontweight='bold'
+                )
+
+            # Global mask (union of all ROIs)
+            ROI_mask = np.zeros_like(self.phantom, dtype=bool)
+            for mask in self.maskList:
+                ROI_mask |= mask
+
+            roi_values = self.phantom[ROI_mask]
+            if roi_values.size == 0:
+                print("❌ NO PIXELS IN ROIs! Check positions:")
+                for i, abs in enumerate(self.absorbers):
+                    print(f"  Absorber {i}: center=({abs.center[0]*1000:.3f}, {abs.center[1]*1000:.3f}) mm")
+                    print(f"          radius={abs.radius*1000:.3f} mm")
+            else:
+                print(f"✅ Average intensity in ROIs: {np.mean(roi_values):.4f}")
+
+            ax.set_xlabel('x (mm)')
+            ax.set_ylabel('z (mm)')
+            ax.set_title('Phantom with ROIs')
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            raise RuntimeError(f"Error in show_ROI: {e}")