AOT-biomaps 2.9.186__py3-none-any.whl → 2.9.261__py3-none-any.whl

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
@@ -66,25 +66,18 @@ class BayesianRecon(AlgebraicRecon):
             dir_name += f'_Beta_{self.beta}_Sigma_{self.sigma}'
 
         results_dir = os.path.join(self.saveDir, dir_name)
+        if not os.path.exists(results_dir):
+            os.makedirs(results_dir)
 
-        if os.path.exists(results_dir):
+        if os.path.exists(os.path.join(results_dir,"indices.npy")):
             return (True, results_dir)
 
         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
@@ -92,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]
@@ -149,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.
@@ -187,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/PrimalDualRecon.py

@@ -6,6 +6,7 @@ from AOT_biomaps.AOT_Recon.ReconEnums import OptimizerType
 import os
 from datetime import datetime
 import numpy as np
+import re
 
 class PrimalDualRecon(AlgebraicRecon):
     """
@@ -48,24 +49,20 @@ class PrimalDualRecon(AlgebraicRecon):
         )
         os.makedirs(results_dir, exist_ok=True)
 
-        if os.path.exists(results_dir):
+        if os.path.exists(os.path.join(results_dir,"indices.npy")):
             return (True, results_dir)
 
         return (False, results_dir)
 
-
-
-    def load(self, withTumor=True, results_date=None, optimizer=None, alpha=None, theta=None, L=None, filePath=None):
+    def load(self, withTumor=True, results_date=None, optimizer=None, filePath=None, show_logs=True):
         """
-        Load the reconstruction results and indices and store them in self.
+        Load the reconstruction results (reconPhantom or reconLaser) and indices as lists of 2D np arrays into self.
+        If the loaded file is a 3D array, it is split into a list of 2D arrays.
         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.
-            alpha (float): Alpha parameter to match the saved directory. If None, uses the current alpha of the instance.
-            theta (float): Theta parameter to match the saved directory. If None, uses the current theta of the instance.
-            L (float): L parameter to match the saved directory. If None, uses the current L of the instance.
-            filePath (str): Optional. If provided, loads directly from this path (overrides saveDir and results_date).
+            withTumor: If True, loads reconPhantom (with tumor), else reconLaser (without tumor).
+            results_date: Date string (format "ddmm") to specify which results to load. If None, uses the most recent date in saveDir.
+            optimizer: Optimizer name (as string or enum) to filter results. If None, uses the current optimizer of the instance.
+            filePath: Optional. If provided, loads directly from this path (overrides saveDir and results_date).
         """
         if filePath is not None:
             # Mode chargement direct depuis un fichier
@@ -73,73 +70,86 @@ class PrimalDualRecon(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 les données
+            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" ou "reconIndices.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")
-            if not os.path.exists(indices_path):
-                indices_path = os.path.join(base_dir, 'reconIndices.npy')  # Alternative
-
+                # 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)
+                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
             else:
                 self.indices = None
-
-            print(f"Loaded reconstruction results and indices from {recon_path}")
+            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 if not provided
+            # Determine optimizer name for path matching
             opt_name = optimizer.value if optimizer is not None else self.optimizer.value
-
-            # Build the directory path
+            # Find the most recent results directory if no date is specified
+            dir_pattern = f'results_*_{opt_name}'
+            if opt_name == OptimizerType.CP_TV.value or opt_name == OptimizerType.CP_KL.value:
+                dir_pattern += f'_Alpha_{self.alpha}_Theta_{self.theta}_L_{self.L}'
             if results_date is None:
-                dir_pattern = f'results_*_{opt_name}_Alpha_{alpha if alpha is not None else self.alpha}_Theta_{theta if theta is not None else self.theta}_L_{L if L is not None else self.L}'
                 dirs = [d for d in os.listdir(self.saveDir) if os.path.isdir(os.path.join(self.saveDir, d)) and dir_pattern in d]
                 if not dirs:
                     raise FileNotFoundError(f"No matching results directory found for pattern '{dir_pattern}' in {self.saveDir}.")
                 dirs.sort(reverse=True)  # Most recent first
                 results_dir = os.path.join(self.saveDir, dirs[0])
             else:
-                results_dir = os.path.join(self.saveDir, f'results_{results_date}_{opt_name}_Alpha_{alpha if alpha is not None else self.alpha}_Theta_{theta if theta is not None else self.theta}_L_{L if L is not None else self.L}')
+                results_dir = os.path.join(self.saveDir, f'results_{results_date}_{opt_name}')
+                if opt_name == OptimizerType.CP_TV.value or opt_name == OptimizerType.CP_KL.value:
+                    results_dir += f'_Alpha_{self.alpha}_Theta_{self.theta}_L_{self.L}'
                 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)
+            # 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)
-
-            # Load saved indices
-            indices_path = os.path.join(results_dir, 'reconIndices.npy')
-            if not os.path.exists(indices_path):
-                raise FileNotFoundError(f"No indices file found at {indices_path}.")
-
-            self.indices = np.load(indices_path, allow_pickle=True)
-
-            print(f"Loaded reconstruction results and indices from {results_dir}")
+                if withTumor:
+                    self.reconPhantom = data
+                else:
+                    self.reconLaser = data
+            # Try to load saved indices (if file exists)
+            indices_path = os.path.join(results_dir, 'indices.npy')
+            if os.path.exists(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
+            else:
+                self.indices = None
+            if show_logs:
+                print(f"Loaded reconstruction results and indices from {results_dir}")
 
     def _convexReconPython(self, withTumor):
-        if withTumor:
-            y=self.experiment.AOsignal_withTumor
-
-        else:
-            y=self.experiment.AOsignal_withoutTumor
-
         if self.optimizer == OptimizerType.CP_TV:
             if withTumor:
                 self.reconPhantom, self.indices = CP_TV(

AOT_biomaps/AOT_Recon/ReconEnums.py

@@ -354,8 +354,33 @@ class NoiseType(Enum):
     - None: No noise is applied.
     """
     POISSON = 'poisson'
-    """Poisson noise, typically used for emission data."""
+    """Poisson noise."""
     GAUSSIAN = 'gaussian'
-    """Gaussian noise, typically used for transmission data."""
+    """Gaussian noise."""
     None_ = 'none'
     """No noise is applied."""
+
+class SMatrixType(Enum):
+    """
+    Enum for different sparsing methods used in reconstructions.
+    
+    Selection of sparsing methods:
+    - Thresholding: Sparsing based on a threshold value.
+    - TopK: Sparsing by retaining the top K values.
+    - None: No sparsing is applied.
+    """
+    DENSE = 'DENSE'
+    """No sparsing is applied."""
+    CSR = 'CSR'
+    """Sparsing based on a threshold value."""
+    COO = 'COO'
+    """Sparsing by retaining the top K values."""
+    SELL = 'SELL'
+    """Sparsing using sell C sigma method.
+    Optimized variant of ELLPACK, dividing the matrix into fixed-size "chunks" of `C` rows.
+    Non-zero elements are sorted by column within each chunk to improve memory coalescing on GPUs.
+    Rows are padded with zeros to align their length to the longest row in the chunk.
+    ** Ref : Kreutzer, M., Hager, G., Wellein, G., Fehske, H., & Bishop, A. R. (2014).
+          "A Unified Sparse Matrix Data Format for Efficient General Sparse Matrix-Vector Multiply on Modern Processors".
+          ACM Transactions on Mathematical Software, 41(2), 1–24. DOI: 10.1145/2592376.
+    """

AOT_biomaps/AOT_Recon/ReconTools.py

@@ -3,7 +3,7 @@ import torch
 import numpy as np
 from numba import njit, prange
 from torch_sparse import coalesce
-import torch.nn.functional as F
+import cupyx.scipy.sparse as cpsparse
 
 def load_recon(hdr_path):
     """
@@ -78,7 +78,7 @@ def load_recon(hdr_path):
     rescale_offset = float(header.get('data rescale offset', 0))
     image = image * rescale_slope + rescale_offset
     
-    return image.T
+    return image
 
 def mse(y_true, y_pred):
     """
@@ -150,20 +150,46 @@ def ssim(img1, img2, win_size=7, k1=0.01, k2=0.03, L=1.0):
     return np.mean(ssim_map)
 
 def calculate_memory_requirement(SMatrix, y):
-    """Calculate the memory requirement for the given matrices in GB."""
-    num_elements_SMatrix = SMatrix.size
-    num_elements_y = y.size
-    num_elements_theta = SMatrix.shape[1] * SMatrix.shape[2]  # Assuming theta has shape (Z, X)
-
-    # Calculate total memory requirement in GB
-    total_memory = (num_elements_SMatrix + num_elements_y + num_elements_theta) * 32 / 8 / 1024**3
-    return total_memory
+    """
+    Calcule la mémoire requise (en Go) pour :
+    - SMatrix : np.ndarray (dense) ou cpsparse.csr_matrix (sparse)
+    - y : vecteur (NumPy ou CuPy, float32)
 
-def check_gpu_memory(device_index, required_memory):
+    Args:
+        SMatrix: np.ndarray ou cpsparse.csr_matrix
+        y: vecteur (float32)
+    """
+    # 1. Mémoire pour SMatrix
+    if isinstance(SMatrix, cpsparse.csr_matrix):
+        # Matrice CSR CuPy
+        nnz = SMatrix.nnz
+        num_cols = SMatrix.shape[1]
+        size_SMatrix = nnz * (4 + 4) + (num_cols + 1) * 4  # data (float32) + indices (int32) + indptr (int32)
+    elif isinstance(SMatrix, np.ndarray):
+        # Tableau NumPy dense (float32)
+        size_SMatrix = SMatrix.nbytes
+    else:
+        raise ValueError("SMatrix doit être un np.ndarray ou une matrice CSR CuPy.")
+
+    # 2. Mémoire pour y (float32)
+    if hasattr(y, 'nbytes'):
+        size_y = y.nbytes
+    else:
+        size_y = np.prod(y.shape) * 4  # float32
+
+    # Total en Go
+    total_bytes = size_SMatrix + size_y
+    total_GB = total_bytes / 1024**3
+
+    return total_GB
+
+
+def check_gpu_memory(device_index, required_memory, show_logs=True):
     """Check if enough memory is available on the specified GPU."""
-    free_memory, total_memory = torch.cuda.mem_get_info(f"cuda:{device_index}")
+    free_memory, _ = torch.cuda.mem_get_info(f"cuda:{device_index}")
     free_memory_gb = free_memory / 1024**3
-    print(f"Free memory on GPU {device_index}: {free_memory_gb:.2f} GB, Required memory: {required_memory:.2f} GB")
+    if show_logs:
+        print(f"Free memory on GPU {device_index}: {free_memory_gb:.2f} GB, Required memory: {required_memory:.2f} GB")
     return free_memory_gb >= required_memory
 
 @njit(parallel=True)
@@ -270,3 +296,48 @@ def prox_F_star(y, sigma, a):
 def prox_G(x, tau, K):
     return torch.clamp(x - tau * K, min=0)
 
+def filter_radon(f, N, filter_type, Fc):
+    """
+    Implémente les filtres pour la rétroprojection filtrée (iRadon).
+    Inspirée de la fonction MATLAB FilterRadon de Mamouna Bocoum.
+
+    Paramètres :
+    ------------
+    f : np.ndarray
+        Vecteur des fréquences (ex: f_t ou f_z).
+    N : int
+        Taille du filtre (longueur de f).
+    filter_type : str
+        Type de filtre : 'ram-lak', 'shepp-logan', 'cosine', 'hamming', 'hann'.
+    Fc : float
+        Fréquence de coupure.
+
+    Retourne :
+    -----------
+    FILTER : np.ndarray
+        Filtre appliqué aux fréquences.
+    """
+    FILTER = np.abs(f)
+
+    if filter_type == 'ram-lak':
+        pass  # FILTER = |f| (déjà calculé)
+    elif filter_type == 'shepp-logan':
+        # Évite la division par zéro
+        with np.errstate(divide='ignore', invalid='ignore'):
+            FILTER = FILTER * (np.sinc(2 * f / (2 * Fc)))  # sin(2πf/(2Fc))/(2πf/(4Fc)) = sinc(2f/(2Fc))
+        FILTER[np.isnan(FILTER)] = 1.0  # Pour f=0
+    elif filter_type == 'cosine':
+        FILTER = FILTER * np.cos(2 * np.pi * f / (4 * Fc))
+    elif filter_type == 'hamming':
+        FILTER = FILTER * (0.54 + 0.46 * np.cos(2 * np.pi * f / Fc))
+    elif filter_type == 'hann':
+        FILTER = FILTER * (1 + np.cos(2 * np.pi * f / (4 * Fc))) / 2
+    else:
+        raise ValueError(f"Type de filtre inconnu : {filter_type}")
+
+    # Coupure des fréquences au-delà de Fc
+    FILTER[np.abs(f) > Fc] = 0
+    # Atténuation exponentielle (optionnelle, comme dans le code MATLAB)
+    FILTER = FILTER * np.exp(-2 * (np.abs(f) / Fc)**10)
+
+    return FILTER

AOT_biomaps/AOT_Recon/__init__.py

@@ -9,3 +9,4 @@ from .ReconTools import *
 
 
 
+