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

AOT_biomaps/AOT_Optic/_mainOptic.py

@@ -0,0 +1,204 @@
+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.
+        :param params: Configuration parameters for the phantom.
+        """
+        try:
+            absorber_params = params.optic['absorbers']
+            self.absorbers = [Absorber(**a) for a in absorber_params] if absorber_params else []
+            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 __str__(self):
+        """
+        Returns a string representation of the Phantom object,
+        including its laser and absorber parameters.
+        :return: String representing the Phantom object.
+        """
+        try:
+            # Laser attributes
+            laser_attrs = {
+                'shape': self.laser.shape.name.capitalize(),
+                'center': self.laser.center,
+                '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:
+                absorber_lines.append(f"  - name: \"{absorber.name}\"")
+                absorber_lines.append(f"    type: \"{absorber.type}\"")
+                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__} |"
+            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.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)
+            plt.tick_params(axis='both', which='major', labelsize=20)
+            plt.title('Optical Phantom with Absorbers')
+            plt.show()
+        except Exception as e:
+            raise RuntimeError(f"Error plotting phantom: {e}")
+
+    def show_ROI(self):
+        """
+        Displays the optical image with ROIs and average intensities.
+        Calls find_ROI() if self.maskList is empty.
+        """
+        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'
+            )
+            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}")

AOT_biomaps/AOT_Recon/AOT_Optimizers/DEPIERRO.py

@@ -0,0 +1,191 @@
+from AOT_biomaps.AOT_Recon.ReconEnums import PotentialType
+from AOT_biomaps.AOT_Recon.ReconTools import _build_adjacency_sparse, calculate_memory_requirement, check_gpu_memory
+from AOT_biomaps.Config import config
+
+import warnings
+import numpy as np
+import torch
+from tqdm import trange
+
+if config.get_process() == 'gpu':
+    try:
+        from torch_scatter import scatter
+    except ImportError:
+        raise ImportError("torch_scatter and torch_sparse are required for GPU processing. Please install them using 'pip install torch-scatter torch-sparse' with correct link (follow instructions https://github.com/LucasDuclos/AcoustoOpticTomography/edit/main/README.md).")
+
+def DEPIERRO(
+        SMatrix,
+        y, 
+        numIterations,
+        beta,
+        sigma,
+        isSavingEachIteration,
+        withTumor, 
+        max_saves, 
+        show_logs):
+        """
+        This method implements the DEPIERRO algorithm using either CPU or single-GPU PyTorch acceleration.
+        Multi-GPU and Multi-CPU modes are not implemented for this algorithm.
+        """
+        try:
+            tumor_str = "WITH" if withTumor else "WITHOUT"
+            # Auto-select device and method
+            if device is None:
+                if torch.cuda.is_available() and check_gpu_memory(config.select_best_gpu(), calculate_memory_requirement(SMatrix, y), show_logs=show_logs):
+                    device = torch.device(f"cuda:{config.select_best_gpu()}")
+                    use_gpu = True
+                else:
+                    device = torch.device("cpu")
+                    use_gpu = False
+            else:
+                use_gpu = device.type == "cuda"
+            # Dispatch to the appropriate implementation
+            if use_gpu:
+                return _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs)
+            else:
+                return _DEPIERRO_CPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs)
+        except Exception as e:
+            print(f"Error in MLEM: {type(e).__name__}: {e}")
+            return None, None
+
+def _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True):
+    # Conversion des données en tenseurs PyTorch (float64)
+    A_matrix_torch = torch.tensor(SMatrix, dtype=torch.float64, device=device)
+    y_torch = torch.tensor(y, dtype=torch.float64, device=device)
+    # Dimensions
+    T, Z, X, N = SMatrix.shape
+    J = Z * X
+    # Redimensionnement des matrices
+    A_flat = A_matrix_torch.permute(0, 3, 1, 2).reshape(T * N, J)
+    y_flat = y_torch.reshape(-1)
+    # Initialisation de theta
+    theta_0 = torch.ones((Z, X), dtype=torch.float64, device=device)
+    matrix_theta_torch = [theta_0.clone()]  # Clone pour éviter les références
+    I_reconMatrix = [theta_0.cpu().numpy()]
+    # Facteur de normalisation
+    normalization_factor = A_matrix_torch.sum(dim=(0, 3))
+    normalization_factor_flat = normalization_factor.reshape(-1)
+    # Construction de la matrice d'adjacence
+    adj_index, adj_values = _build_adjacency_sparse(Z, X, device=device, dtype=torch.float64)
+    # Description pour la barre de progression
+    description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: DE PIERRO (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()}"
+    # Configuration pour la sauvegarde des itérations
+    saved_indices = [0]
+
+    # Calculate save indices
+    if numIterations <= max_saves:
+        save_indices = list(range(numIterations))
+    else:
+        step = numIterations // max_saves
+        save_indices = list(range(0, numIterations, step))
+        if save_indices[-1] != numIterations - 1:
+            save_indices.append(numIterations - 1)
+
+    # Boucle principale MAP-EM
+    iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+    for it in iterator:
+        theta_p = matrix_theta_torch[-1]
+        theta_p_flat = theta_p.reshape(-1)
+        # Étape 1 : Projection avant
+        q_flat = A_flat @ theta_p_flat
+        q_flat = q_flat + torch.finfo(torch.float64).tiny  # Évite la division par zéro
+        # Étape 2 : Estimation de l'erreur
+        e_flat = y_flat / q_flat
+        # Étape 3 : Rétroprojection de l'erreur
+        c_flat = A_flat.T @ e_flat
+        # Étape 4 : Mise à jour multiplicative (EM)
+        theta_EM_p_flat = theta_p_flat * c_flat
+        # Étape 5 : Calcul de W_j et gamma_j
+        W_j = scatter(adj_values, adj_index[0], dim=0, dim_size=J, reduce='sum') * (1.0 / (sigma**2))
+        theta_k = theta_p_flat[adj_index[1]]
+        weighted_theta_k = theta_k * adj_values
+        gamma_j = theta_p_flat * W_j + scatter(weighted_theta_k, adj_index[0], dim=0, dim_size=J, reduce='sum')
+        # Étape 6 : Mise à jour de De Pierro (résolution quadratique)
+        A_coeff = 2 * beta * W_j
+        B = -beta * gamma_j + normalization_factor_flat
+        C = -theta_EM_p_flat
+        discriminant = B**2 - 4 * A_coeff * C
+        discriminant = torch.clamp(discriminant, min=0)
+        theta_p_plus_1_flat = (-B + torch.sqrt(discriminant)) / (2 * A_coeff + torch.finfo(torch.float64).tiny)
+        theta_p_plus_1_flat = torch.clamp(theta_p_plus_1_flat, min=0)
+        # Étape 7 : Mise à jour de theta
+        theta_next = theta_p_plus_1_flat.reshape(Z, X)
+        matrix_theta_torch.append(theta_next)  # Ajoute la nouvelle itération
+        # Sauvegarde conditionnelle
+        if isSavingEachIteration and it in save_indices:
+            I_reconMatrix.append(theta_next.cpu().numpy())
+            saved_indices.append(it)
+        # Libération mémoire partielle (optionnel, à ajuster selon besoin)
+        del theta_p_flat, q_flat, e_flat, c_flat, theta_EM_p_flat, theta_p_plus_1_flat
+        torch.cuda.empty_cache()
+
+    # Libération finale des tenseurs GPU
+    del A_matrix_torch, y_torch, A_flat, y_flat, normalization_factor, normalization_factor_flat
+    torch.cuda.empty_cache()
+    # Retour du résultat
+    if isSavingEachIteration:
+        return I_reconMatrix, saved_indices
+    else:
+        return matrix_theta_torch[-1].cpu().numpy(), None
+
+def _DEPIERRO_CPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True):
+    try:
+        if beta is None or sigma is None:
+            raise ValueError("Depierro95 optimizer requires beta and sigma parameters.")
+
+        A_matrix = np.array(SMatrix, dtype=np.float32)
+        y_array = np.array(y, dtype=np.float32)
+        T, Z, X, N = SMatrix.shape
+        J = Z * X
+        A_flat = A_matrix.transpose(0, 3, 1, 2).reshape(T * N, Z * X)
+        y_flat = y_array.reshape(-1)
+        theta_0 = np.ones((Z, X), dtype=np.float32)
+        matrix_theta = [theta_0]
+        I_reconMatrix = [theta_0.copy()]
+        saved_indices = [0]
+        normalization_factor = A_matrix.sum(axis=(0, 3))
+        normalization_factor_flat = normalization_factor.reshape(-1)
+        adj_index, adj_values = _build_adjacency_sparse(Z, X)
+
+        # Calculate save indices
+        if numIterations <= max_saves:
+            save_indices = list(range(numIterations))
+        else:
+            step = numIterations // max_saves
+            save_indices = list(range(0, numIterations, step))
+            if save_indices[-1] != numIterations - 1:
+                save_indices.append(numIterations - 1)
+
+        description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: DE PIERRO (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
+
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+        for it in iterator:
+            theta_p = matrix_theta[-1]
+            theta_p_flat = theta_p.reshape(-1)
+            q_flat = np.dot(A_flat, theta_p_flat)
+            e_flat = y_flat / (q_flat + np.finfo(np.float32).tiny)
+            c_flat = np.dot(A_flat.T, e_flat)
+            theta_EM_p_flat = theta_p_flat * c_flat
+            alpha_j = normalization_factor_flat
+            W_j = np.bincount(adj_index[0], weights=adj_values, minlength=J) * (1.0 / sigma**2)
+            theta_k = theta_p_flat[adj_index[1]]
+            weighted_theta_k = theta_k * adj_values
+            gamma_j = theta_p_flat * W_j + np.bincount(adj_index[0], weights=weighted_theta_k, minlength=J)
+            A = 2 * beta * W_j
+            B = -beta * gamma_j + alpha_j
+            C = -theta_EM_p_flat
+            theta_p_plus_1_flat = (-B + np.sqrt(B**2 - 4 * A * C)) / (2 * A + np.finfo(np.float32).tiny)
+            theta_p_plus_1_flat = np.clip(theta_p_plus_1_flat, a_min=0, a_max=None)
+            theta_next = theta_p_plus_1_flat.reshape(Z, X)
+            matrix_theta[-1] = theta_next
+            if isSavingEachIteration and it in save_indices:
+                I_reconMatrix.append(theta_next.copy())
+                saved_indices.append(it)
+
+        if isSavingEachIteration:
+            return I_reconMatrix, saved_indices
+        else:
+            return I_reconMatrix[-1], None
+    except Exception as e:
+        print(f"An error occurred in _DEPIERRO_CPU: {e}")
+        return None, None

AOT_biomaps/AOT_Recon/AOT_Optimizers/LS.py

@@ -0,0 +1,106 @@
+from AOT_biomaps.Config import config
+import torch
+import numpy as np
+from tqdm import trange
+from AOT_biomaps.AOT_Recon.ReconTools import calculate_memory_requirement, check_gpu_memory
+
+def LS(
+    SMatrix,
+    y,
+    numIterations=5000,
+    alpha=1e-3,
+    isSavingEachIteration=True,
+    withTumor=True,
+    device=None,
+    max_saves=5000,
+    show_logs=True
+):
+    """
+    Least Squares reconstruction using Projected Gradient Descent (PGD) with non-negativity constraint.
+    Currently only implements the stable GPU version.
+    """
+    tumor_str = "WITH" if withTumor else "WITHOUT"
+    # Force GPU usage for now
+    if device is None:
+        if torch.cuda.is_available() and check_gpu_memory(config.select_best_gpu(), calculate_memory_requirement(SMatrix, y), show_logs=show_logs):
+            raise RuntimeError("CUDA is required for this implementation.")
+        device = torch.device(f"cuda:{config.select_best_gpu()}")
+    else:
+        if device.type != "cuda":
+            raise RuntimeError("Only GPU implementation is available for now.")
+    return _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves, show_logs=show_logs)
+
+def _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves=5000, show_logs=True):
+    """
+    Stable GPU implementation of LS using projected gradient descent with diagonal preconditioner.
+    """
+    device = torch.device(f"cuda:{config.select_best_gpu()}")
+    T, Z, X, N = SMatrix.shape
+    ZX = Z * X
+    TN = T * N
+    # 1. Conversion et normalisation
+    A_flat = torch.from_numpy(SMatrix).to(device=device, dtype=torch.float32).permute(0, 3, 1, 2).reshape(TN, ZX)
+    y_flat = torch.from_numpy(y).to(device=device, dtype=torch.float32).reshape(TN)
+    norm_A = A_flat.max()
+    norm_y = y_flat.max()
+    A_flat.div_(norm_A + 1e-8)
+    y_flat.div_(norm_y + 1e-8)
+    # 2. Initialisation
+    lambda_k = torch.zeros(ZX, device=device)
+    lambda_history = [] if isSavingEachIteration else None
+    saved_indices = []  # Pour stocker les indices des itérations sauvegardées
+
+    # Calculate save indices
+    if numIterations <= max_saves:
+        save_indices = list(range(numIterations))
+    else:
+        step = numIterations // max_saves
+        save_indices = list(range(0, numIterations, step))
+        if save_indices[-1] != numIterations - 1:
+            save_indices.append(numIterations - 1)
+
+    # Préconditionneur diagonal
+    diag_AAT = torch.sum(A_flat ** 2, dim=0)
+    M_inv = 1.0 / torch.clamp(diag_AAT, min=1e-6)
+    # Pré-allocation des tenseurs
+    r_k = torch.empty_like(y_flat)
+    AT_r = torch.empty(ZX, device=device)
+    description = f"AOT-BioMaps -- Stable LS Reconstruction ---- {tumor_str} TUMOR ---- GPU {torch.cuda.current_device()}"
+
+    iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+    for it in iterator:
+        # Calcul du résidu (inplace)
+        torch.matmul(A_flat, lambda_k, out=r_k)
+        r_k = y_flat - r_k
+        if isSavingEachIteration and it in save_indices:
+            lambda_history.append(lambda_k.clone().reshape(Z, X) * (norm_y / norm_A))
+            saved_indices.append(it)
+
+        # Gradient préconditionné (inplace)
+        torch.matmul(A_flat.T, r_k, out=AT_r)
+        AT_r *= M_inv
+        # Mise à jour avec pas fixe et projection (inplace)
+        lambda_k.add_(AT_r, alpha=alpha)
+        lambda_k.clamp_(min=0)
+
+    # 3. Dénormalisation
+    lambda_final = lambda_k.reshape(Z, X) * (norm_y / norm_A)
+    # Free memory
+    del A_flat, y_flat, r_k, AT_r
+    torch.cuda.empty_cache()
+    if isSavingEachIteration:
+        return [t.cpu().numpy() for t in lambda_history], saved_indices
+    else:
+        return lambda_final.cpu().numpy(), None
+
+def _LS_GPU_opti(*args, **kwargs):
+    raise NotImplementedError("Only _LS_GPU_stable is implemented for now.")
+
+def _LS_GPU_multi(*args, **kwargs):
+    raise NotImplementedError("Only _LS_GPU_stable is implemented for now.")
+
+def _LS_CPU_opti(*args, **kwargs):
+    raise NotImplementedError("Only _LS_GPU_stable is implemented for now.")
+
+def _LS_CPU_basic(*args, **kwargs):
+    raise NotImplementedError("Only _LS_GPU_stable is implemented for now.")