AOT-biomaps 2.9.176__py3-none-any.whl → 2.9.300__py3-none-any.whl

AOT_biomaps/AOT_Recon/AnalyticRecon.py

@@ -22,7 +22,7 @@ class AnalyticRecon(Recon):
         else:
             raise ValueError(f"Unknown analytic reconstruction type: {processType}")
         
-    def checkExistingFile(self, withTumor, date):
+    def checkExistingFile(self, date = None):
         raise NotImplementedError("checkExistingFile method is not implemented yet.")
 
     def _analyticReconPython(self,withTumor):
@@ -51,56 +51,41 @@ class AnalyticRecon(Recon):
     def _iFourierRecon(self, AOsignal):
         """
         Reconstruction d'image utilisant la transformation de Fourier inverse.
-
-        :param AOsignal: Signal dans le domaine temporel.
+        :param AOsignal: Signal dans le domaine temporel (shape: N_t, N_theta).
         :return: Image reconstruite dans le domaine spatial.
         """
-        # Signal dans le domaine fréquentiel (FFT sur l'axe temporel)
-        s_tilde = np.fft.fft(AOsignal, axis=0)
-
-        theta = np.array([af.angle for af in self.experiment.AcousticFields])  # angles (N_theta,)
-        f_s = np.array([af.f_s for af in self.experiment.AcousticFields])  # spatial freqs (N_theta,)
-        f_t = np.fft.fftfreq(AOsignal.shape[0], d=self.experiment.dt)  # temporal freqs
-
+        theta = np.array([af.angle for af in self.experiment.AcousticFields])
+        f_s = np.array([af.f_s for af in self.experiment.AcousticFields])
+        dt = self.experiment.dt
+        f_t = np.fft.fftfreq(AOsignal.shape[0], d=dt)  # fréquences temporelles
         x = self.experiment.OpticImage.laser.x
         z = self.experiment.OpticImage.laser.z
-        X, Z = np.meshgrid(x, z, indexing='ij')  # shape (Nx, Nz)
-
-        N_theta = len(theta)
-        I_rec = np.zeros((len(x), len(z)), dtype=complex)
-
-        for i, th in enumerate(trange(N_theta, desc="AOT-BioMaps -- Analytic Recontruction Tomography : iFourier (Processing projection) ---- processing on single CPU ----")):
-            fs = f_s[i]
-
-            # Projection des coordonnées dans le repère tourné
-            x_prime = X * np.cos(th) + Z * np.sin(th)
-            z_prime = -X * np.sin(th) + Z * np.cos(th)
-
-            # Signal spectral pour cet angle (1D pour chaque f_t)
-            s_angle = s_tilde[:, i]  # shape (len(f_t),)
+        X, Z = np.meshgrid(x, z, indexing='ij')  # grille spatiale (Nx, Nz)
 
-            # Grille 2D des fréquences
-            F_t, F_s = np.meshgrid(f_t, [fs], indexing='ij')  # F_t: (len(f_t), 1), F_s: (1, 1)
+        # Transformée de Fourier du signal
+        s_tilde = np.fft.fft(AOsignal, axis=0)  # shape: (N_t, N_theta)
 
-            # Phase : exp(2iπ(x' f_s + z' f_t)) = (x_prime * f_s + z_prime * f_t)
-            phase = 2j * np.pi * (x_prime[:, :, None] * fs + z_prime[:, :, None] * f_t[None, None, :])
-
-            # reshape s_angle to (len(f_t), 1, 1)
-            s_angle = s_angle[:, None, None]
-
-            # Contribution de cet angle
-            integrand = s_angle * np.exp(phase)
-
-            # Intégration sur f_t (somme discrète)
-            I_theta = np.sum(integrand, axis=0)
-
-            # Ajout à la reconstruction
-            I_rec += I_theta
-
-        I_rec /= N_theta
+        # Initialisation de l'image reconstruite
+        I_rec = np.zeros((len(x), len(z)), dtype=complex)
 
+        # Boucle sur les angles
+        for i, th in enumerate(trange(len(theta), desc="AOT-BioMaps -- iFourier Reconstruction")):
+            # Coordonnées tournées
+            X_prime = X * np.cos(th) + Z * np.sin(th)
+            Z_prime = -X * np.sin(th) + Z * np.cos(th)
+
+            # Pour chaque fréquence temporelle f_t[j]
+            for j in range(len(f_t)):
+                # Phase: exp(2jπ (X_prime * f_s[i] + Z_prime * f_t[j]))
+                phase = 2j * np.pi * (X_prime * f_s[i] + Z_prime * f_t[j])
+                # Contribution de cette fréquence
+                I_rec += s_tilde[j, i] * np.exp(phase) * dt  # Pondération par dt pour l'intégration
+
+        # Normalisation
+        I_rec /= len(theta)
         return np.abs(I_rec)
 
+
     def _iRadonRecon(self, AOsignal):
         """
         Reconstruction d'image utilisant la méthode iRadon.

AOT_biomaps/AOT_Recon/BayesianRecon.py

@@ -1,7 +1,7 @@
 from AOT_biomaps.AOT_Recon.AlgebraicRecon import AlgebraicRecon
 from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, OptimizerType, PotentialType, ProcessType
 from .ReconTools import check_gpu_memory, calculate_memory_requirement
-from .AOT_Optimizers import MAPEM, DEPIERRO
+from .AOT_Optimizers import MAPEM, MAPEM_STOP, DEPIERRO
 from AOT_biomaps.Config import config
 
 import warnings
@@ -38,7 +38,7 @@ class BayesianRecon(AlgebraicRecon):
         if not isinstance(self.potentialFunction, PotentialType):
             raise TypeError(f"Potential functions must be of type PotentialType, got {type(self.potentialFunction)}")  
 
-    def checkExistingFile(self, withTumor, date):
+    def checkExistingFile(self, date = None):
         """
         Check if the reconstruction file already exists, based on current instance parameters.
 
@@ -66,27 +66,18 @@ class BayesianRecon(AlgebraicRecon):
             dir_name += f'_Beta_{self.beta}_Sigma_{self.sigma}'
 
         results_dir = os.path.join(self.saveDir, dir_name)
-        recon_key = 'reconPhantom' if withTumor else 'reconLaser'
-        recon_filepath = os.path.join(results_dir, f'{recon_key}.npy')
+        if not os.path.exists(results_dir):
+            os.makedirs(results_dir)
 
-        if os.path.exists(recon_filepath):
-            return (True, recon_filepath)
+        if os.path.exists(os.path.join(results_dir,"indices.npy")):
+            return (True, results_dir)
 
-        return (False, recon_filepath)
+        return (False, results_dir)
 
-    def load(self, withTumor=True, results_date=None, optimizer=None, potential_function=None, beta=None, delta=None, gamma=None, sigma=None, filePath=None):
+    def load(self, withTumor=True, results_date=None, optimizer=None, potential_function=None, filePath=None, show_logs=True):
         """
-        Load the reconstruction results and indices for Bayesian reconstruction and store them in self.
-        Args:
-            withTumor (bool): If True, loads the reconstruction with tumor; otherwise, loads the reconstruction without tumor.
-            results_date (str): Date string (format "ddmm") to specify which results to load. If None, uses the most recent date in saveDir.
-            optimizer (OptimizerType): Optimizer type to filter results. If None, uses the current optimizer of the instance.
-            potential_function (PotentialType): Potential function type to filter results. If None, uses the current potential function of the instance.
-            beta (float): Beta parameter to match the saved directory. If None, skips this filter.
-            delta (float): Delta parameter to match the saved directory. If None, skips this filter.
-            gamma (float): Gamma parameter to match the saved directory. If None, skips this filter.
-            sigma (float): Sigma parameter to match the saved directory. If None, skips this filter.
-            filePath (str): Optional. If provided, loads directly from this path (overrides saveDir and results_date).
+        Load the reconstruction results and indices as lists of 2D np arrays for Bayesian reconstruction and store them in self.
+        If the loaded file is a 3D array, it is split into a list of 2D arrays.
         """
         if filePath is not None:
             # Mode chargement direct depuis un fichier
@@ -94,53 +85,55 @@ class BayesianRecon(AlgebraicRecon):
             recon_path = filePath
             if not os.path.exists(recon_path):
                 raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
-
-            if withTumor:
-                self.reconPhantom = np.load(recon_path, allow_pickle=True)
+            # Charge le fichier (3D ou liste de 2D)
+            data = np.load(recon_path, allow_pickle=True)
+            # Découpe en liste de 2D si c'est un tableau 3D
+            if isinstance(data, np.ndarray) and data.ndim == 3:
+                if withTumor:
+                    self.reconPhantom = [data[i, :, :] for i in range(data.shape[0])]
+                else:
+                    self.reconLaser = [data[i, :, :] for i in range(data.shape[0])]
             else:
-                self.reconLaser = np.load(recon_path, allow_pickle=True)
-
-            # Essayer de charger les indices (fichier avec suffixe "_indices.npy")
-            base_dir, file_name = os.path.split(recon_path)
-            file_base, _ = os.path.splitext(file_name)
-            indices_path = os.path.join(base_dir, f"{file_base}_indices.npy")
+                # Sinon, suppose que c'est déjà une liste de 2D
+                if withTumor:
+                    self.reconPhantom = data
+                else:
+                    self.reconLaser = data
+            # Essayer de charger les indices
+            base_dir, _ = os.path.split(recon_path)
+            indices_path = os.path.join(base_dir, 'indices.npy')
             if os.path.exists(indices_path):
-                self.indices = np.load(indices_path, allow_pickle=True)
-            else:
-                indices_path = os.path.join(base_dir, 'reconIndices.npy')  # Alternative
-                if os.path.exists(indices_path):
-                    self.indices = np.load(indices_path, allow_pickle=True)
+                indices_data = np.load(indices_path, allow_pickle=True)
+                if isinstance(indices_data, np.ndarray) and indices_data.ndim == 3:
+                    self.indices = [indices_data[i, :, :] for i in range(indices_data.shape[0])]
                 else:
-                    self.indices = None
-
-            print(f"Loaded reconstruction results and indices from {recon_path}")
+                    self.indices = indices_data
+            else:
+                self.indices = None
+            if show_logs:
+                print(f"Loaded reconstruction results and indices from {recon_path}")
         else:
             # Mode chargement depuis le répertoire de résultats
             if self.saveDir is None:
                 raise ValueError("Save directory is not specified. Please set saveDir before loading.")
-
             # Use current optimizer and potential function if not provided
             opt_name = optimizer.value if optimizer is not None else self.optimizer.value
             pot_name = potential_function.value if potential_function is not None else self.potentialFunction.value
-
             # Build the base directory pattern
             dir_pattern = f'results_*_{opt_name}_{pot_name}'
-
             # Add parameters to the pattern based on the optimizer
             if optimizer is None:
                 optimizer = self.optimizer
-
             if optimizer == OptimizerType.PPGMLEM:
-                beta_str = f'_Beta_{beta if beta is not None else self.beta}'
-                delta_str = f'_Delta_{delta if delta is not None else self.delta}'
-                gamma_str = f'_Gamma_{gamma if gamma is not None else self.gamma}'
-                sigma_str = f'_Sigma_{sigma if sigma is not None else self.sigma}'
+                beta_str = f'_Beta_{self.beta}'
+                delta_str = f'_Delta_{self.delta}'
+                gamma_str = f'_Gamma_{self.gamma}'
+                sigma_str = f'_Sigma_{self.sigma}'
                 dir_pattern += f'{beta_str}{delta_str}{gamma_str}{sigma_str}'
             elif optimizer in (OptimizerType.PGC, OptimizerType.DEPIERRO95):
-                beta_str = f'_Beta_{beta if beta is not None else self.beta}'
-                sigma_str = f'_Sigma_{sigma if sigma is not None else self.sigma}'
+                beta_str = f'_Beta_{self.beta}'
+                sigma_str = f'_Sigma_{self.sigma}'
                 dir_pattern += f'{beta_str}{sigma_str}'
-
             # Find the most recent results directory if no date is specified
             if results_date is None:
                 dirs = [d for d in os.listdir(self.saveDir) if os.path.isdir(os.path.join(self.saveDir, d)) and dir_pattern in d]
@@ -151,33 +144,40 @@ class BayesianRecon(AlgebraicRecon):
             else:
                 results_dir = os.path.join(self.saveDir, f'results_{results_date}_{opt_name}_{pot_name}')
                 if optimizer == OptimizerType.PPGMLEM:
-                    results_dir += f'_Beta_{beta if beta is not None else self.beta}_Delta_{delta if delta is not None else self.delta}_Gamma_{gamma if gamma is not None else self.gamma}_Sigma_{sigma if sigma is not None else self.sigma}'
+                    results_dir += f'_Beta_{self.beta}_Delta_{self.delta}_Gamma_{self.gamma}_Sigma_{self.sigma}'
                 elif optimizer in (OptimizerType.PGC, OptimizerType.DEPIERRO95):
-                    results_dir += f'_Beta_{beta if beta is not None else self.beta}_Sigma_{sigma if sigma is not None else self.sigma}'
+                    results_dir += f'_Beta_{self.beta}_Sigma_{self.sigma}'
                 if not os.path.exists(results_dir):
                     raise FileNotFoundError(f"Directory {results_dir} does not exist.")
-
             # Load reconstruction results
             recon_key = 'reconPhantom' if withTumor else 'reconLaser'
             recon_path = os.path.join(results_dir, f'{recon_key}.npy')
             if not os.path.exists(recon_path):
                 raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
-
-            if withTumor:
-                self.reconPhantom = np.load(recon_path, allow_pickle=True)
+            data = np.load(recon_path, allow_pickle=True)
+            if isinstance(data, np.ndarray) and data.ndim == 3:
+                if withTumor:
+                    self.reconPhantom = [data[i, :, :] for i in range(data.shape[0])]
+                else:
+                    self.reconLaser = [data[i, :, :] for i in range(data.shape[0])]
             else:
-                self.reconLaser = np.load(recon_path, allow_pickle=True)
-
-            # Load saved indices
-            indices_path = os.path.join(results_dir, 'reconIndices.npy')
+                if withTumor:
+                    self.reconPhantom = data
+                else:
+                    self.reconLaser = data
+            # Load saved indices as list of 2D arrays
+            indices_path = os.path.join(results_dir, 'indices.npy')
             if not os.path.exists(indices_path):
                 raise FileNotFoundError(f"No indices file found at {indices_path}.")
+            indices_data = np.load(indices_path, allow_pickle=True)
+            if isinstance(indices_data, np.ndarray) and indices_data.ndim == 3:
+                self.indices = [indices_data[i, :, :] for i in range(indices_data.shape[0])]
+            else:
+                self.indices = indices_data
+            if show_logs:
+                print(f"Loaded reconstruction results and indices from {results_dir}")
 
-            self.indices = np.load(indices_path, allow_pickle=True)
-
-            print(f"Loaded reconstruction results and indices from {results_dir}")
-
-    def run(self, processType=ProcessType.PYTHON, withTumor=True):
+    def run(self, processType=ProcessType.PYTHON, withTumor=True, show_logs=True):
         """
         This method is a placeholder for the Bayesian reconstruction process.
         It currently does not perform any operations but serves as a template for future implementations.
@@ -189,109 +189,42 @@ class BayesianRecon(AlgebraicRecon):
         else:
             raise ValueError(f"Unknown Bayesian reconstruction type: {processType}")
         
-    def _bayesianReconCASToR(self, withTumor):
+    def _bayesianReconCASToR(self, show_logs, withTumor):
         raise NotImplementedError("CASToR Bayesian reconstruction is not implemented yet.")
 
-    def _bayesianReconPython(self, withTumor):
-
+    def _bayesianReconPython(self, show_logs, withTumor):
         if withTumor:
             if self.experiment.AOsignal_withTumor is None:
                 raise ValueError("AO signal with tumor is not available. Please generate AO signal with tumor the experiment first in the experiment object.")
             if self.optimizer.value ==  OptimizerType.PPGMLEM.value:
-                self.reconPhantom, self.indices = self._MAPEM_STOP(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
+                self.reconPhantom, self.indices = MAPEM_STOP(
+                    SMatrix=self.SMatrix, 
+                    y=self.experiment.AOsignal_withTumor, 
+                    Omega=self.potentialFunction,
+                    beta=self.beta,
+                    delta=self.delta,
+                    gamma=self.gamma,
+                    sigma=self.sigma,
+                    numIterations=self.numIterations,
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    withTumor=withTumor,
+                    device=self.device,
+                    max_saves=5000,
+                    show_logs=True)
             elif self.optimizer.value == OptimizerType.PGC.value:
-                self.reconPhantom, self.indices = self._MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
+                self.reconPhantom, self.indices = MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor, show_logs=show_logs)
             elif self.optimizer.value == OptimizerType.DEPIERRO95.value:
-                self.reconPhantom, self.indices = self._DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
+                self.reconPhantom, self.indices = DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor, show_logs=show_logs)
             else:
                 raise ValueError(f"Unknown optimizer type: {self.optimizer.value}")
         else:
             if self.experiment.AOsignal_withoutTumor is None:
                 raise ValueError("AO signal without tumor is not available. Please generate AO signal without tumor the experiment first in the experiment object.")
             if self.optimizer.value ==  OptimizerType.PPGMLEM.value:
-                self.reconLaser, self.indices = self._MAPEM_STOP(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
+                self.reconLaser, self.indices = MAPEM_STOP(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor, show_logs=show_logs)
             elif self.optimizer.value == OptimizerType.PGC.value:
-                self.reconLaser, self.indices = self._MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
+                self.reconLaser, self.indices = MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor, show_logs=show_logs)
             elif self.optimizer.value == OptimizerType.DEPIERRO95.value:
-                self.reconLaser, self.indices = self._DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
+                self.reconLaser, self.indices = DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor, show_logs=show_logs)
             else:
-                raise ValueError(f"Unknown optimizer type: {self.optimizer.value}")
-
-    def _MAPEM_STOP(self, SMatrix, y, withTumor):
-        """
-        This method implements the MAPEM_STOP algorithm using either CPU or single-GPU PyTorch acceleration.
-        Multi-GPU and Multi-CPU modes are not implemented for this algorithm.
-        """
-        result = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                try:
-                    result = MAPEM._MAPEM_GPU_STOP(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                except Exception as e:
-                    warnings.warn(f"Falling back to CPU implementation due to an error in GPU implementation: {e}")
-            else:
-                warnings.warn("Insufficient GPU memory for single GPU MAPEM_STOP. Falling back to CPU.")
-
-        if result is None:
-            try:
-                result = MAPEM._MAPEM_CPU_STOP(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            except Exception as e:
-                warnings.warn(f"An error occurred in CPU implementation: {e}")
-                result = None
-
-        return result
-
-    def _MAPEM(self, SMatrix, y, withTumor):
-        """
-        This method implements the MAPEM algorithm using either CPU or single-GPU PyTorch acceleration.
-        Multi-GPU and Multi-CPU modes are not implemented for this algorithm.
-        """
-        result = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                try:
-                    result = MAPEM._MAPEM_GPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                except Exception as e:
-                    warnings.warn(f"Falling back to CPU implementation due to an error in GPU implementation: {e}")
-            else:
-                warnings.warn("Insufficient GPU memory for single GPU MAPEM. Falling back to CPU.")
-
-        if result is None:
-            try:
-                result = MAPEM._MAPEM_CPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            except Exception as e:
-                warnings.warn(f"An error occurred in CPU implementation: {e}")
-                result = None
-
-        return result
-
-    def _DEPIERRO(self, SMatrix, y, withTumor):
-        """
-        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.
-        """
-        result = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                try:
-                    result = DEPIERRO._DEPIERRO_GPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                except Exception as e:
-                    warnings.warn(f"Falling back to CPU implementation due to an error in GPU implementation: {e}")
-            else:
-                warnings.warn("Insufficient GPU memory for single GPU DEPIERRO. Falling back to CPU.")
-
-        if result is None:
-            try:
-                result = DEPIERRO._DEPIERRO_CPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            except Exception as e:
-                warnings.warn(f"An error occurred in CPU implementation: {e}")
-                result = None
-
-        return result
-
+                raise ValueError(f"Unknown optimizer type: {self.optimizer.value}")

AOT_biomaps/AOT_Recon/DeepLearningRecon.py

@@ -31,5 +31,5 @@ class DeepLearningRecon(Recon):
     def _deepLearningReconPython(self):
         pass
 
-    def checkExistingFile(self, withTumor, date):
+    def checkExistingFile(self, date = None):
         raise NotImplementedError("checkExistingFile method is not implemented yet.")