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

AOT_biomaps/AOT_Recon/AnalyticRecon.py

@@ -0,0 +1,154 @@
+from ._mainRecon import Recon
+from .ReconEnums import ReconType, AnalyticType, ProcessType
+
+import numpy as np
+from tqdm import trange
+
+class AnalyticRecon(Recon):
+    def __init__(self, analyticType, **kwargs):
+        super().__init__(**kwargs)
+        self.reconType = ReconType.Analytic
+        self.analyticType = analyticType
+
+    def run(self, processType = ProcessType.PYTHON, withTumor= True):
+        """
+        This method is a placeholder for the analytic reconstruction process.
+        It currently does not perform any operations but serves as a template for future implementations.
+        """
+        if(processType == ProcessType.CASToR):
+            raise NotImplementedError("CASToR analytic reconstruction is not implemented yet.")
+        elif(processType == ProcessType.PYTHON):
+            self._analyticReconPython(withTumor)
+        else:
+            raise ValueError(f"Unknown analytic reconstruction type: {processType}")
+        
+    def checkExistingFile(self, date = None):
+        raise NotImplementedError("checkExistingFile method is not implemented yet.")
+
+    def _analyticReconPython(self,withTumor):
+        """
+        This method is a placeholder for the analytic reconstruction process in Python.
+        It currently does not perform any operations but serves as a template for future implementations.
+        
+        Parameters:
+            analyticType: The type of analytic reconstruction to perform (default is iFOURIER).
+        """
+        if withTumor:
+            if self.analyticType == AnalyticType.iFOURIER:
+                self.reconPhantom = self._iFourierRecon(self.experiment.AOsignal_withTumor)
+            elif self.analyticType == AnalyticType.iRADON:
+                self.reconPhantom = self._iRadonRecon(self.experiment.AOsignal_withTumor)
+            else:            
+                raise ValueError(f"Unknown analytic type: {self.analyticType}")
+        else:
+            if self.analyticType == AnalyticType.iFOURIER:
+                self.reconLaser = self._iFourierRecon(self.experiment.AOsignal_withoutTumor)
+            elif self.analyticType == AnalyticType.iRADON:
+                self.reconLaser = self._iRadonRecon(self.experiment.AOsignal_withoutTumor)
+            else:            
+                raise ValueError(f"Unknown analytic type: {self.analyticType}")
+    
+    def _iFourierRecon(self, AOsignal):
+        """
+        Reconstruction d'image utilisant la transformation de Fourier inverse.
+
+        :param AOsignal: Signal dans le domaine temporel.
+        :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
+
+        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),)
+
+            # 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)
+
+            # 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
+
+        return np.abs(I_rec)
+
+    def _iRadonRecon(self, AOsignal):
+        """
+        Reconstruction d'image utilisant la méthode iRadon.
+
+        :return: Image reconstruite.
+        """
+        @staticmethod
+        def trapz(y, x):
+            """Compute the trapezoidal rule for integration."""
+            return np.sum((y[:-1] + y[1:]) * (x[1:] - x[:-1]) / 2)
+
+        # Initialisation de l'image reconstruite
+        I_rec = np.zeros((len(self.experiment.OpticImage.laser.x), len(self.experiment.OpticImage.laser.z)), dtype=complex)
+
+        # Transformation de Fourier du signal
+        s_tilde = np.fft.fft(AOsignal, axis=0)
+
+        # Extraction des angles et des fréquences spatiales
+        theta = [acoustic_field.angle for acoustic_field in self.experiment.AcousticFields]
+        f_s = [acoustic_field.f_s for acoustic_field in self.experiment.AcousticFields]
+
+        # Calcul des coordonnées transformées et intégrales
+        with trange(len(theta) * 2, desc="AOT-BioMaps -- Analytic Reconstruction Tomography: iRadon") as pbar:
+            for i in range(len(theta)):
+                pbar.set_description("AOT-BioMaps -- Analytic Reconstruction Tomography: iRadon (Processing frequency contributions)  ---- processing on single CPU ----")
+                th = theta[i]
+                x_prime = self.experiment.OpticImage.x[:, np.newaxis] * np.cos(th) - self.experiment.OpticImage.z[np.newaxis, :] * np.sin(th)
+                z_prime = self.experiment.OpticImage.z[np.newaxis, :] * np.cos(th) + self.experiment.OpticImage.x[:, np.newaxis] * np.sin(th)
+
+                # Première intégrale : partie réelle
+                for j in range(len(f_s)):
+                    fs = f_s[j]
+                    integrand = s_tilde[i, j] * np.exp(2j * np.pi * (x_prime * fs + z_prime * fs))
+                    integral = self.trapz(integrand * fs, fs)
+                    I_rec += 2 * np.real(integral)
+                pbar.update(1)
+
+            for i in range(len(theta)):
+                pbar.set_description("AOT-BioMaps -- Analytic Reconstruction Tomography: iRadon (Processing central contributions)  ---- processing on single CPU ----")
+                th = theta[i]
+                x_prime = self.experiment.OpticImage.x[:, np.newaxis] * np.cos(th) - self.experiment.OpticImage.z[np.newaxis, :] * np.sin(th)
+                z_prime = self.experiment.OpticImage.z[np.newaxis, :] * np.cos(th) + self.experiment.OpticImage.x[:, np.newaxis] * np.sin(th)
+
+                # Filtrer les fréquences spatiales pour ne garder que celles inférieures ou égales à f_s_max
+                filtered_f_s = np.array([fs for fs in f_s if fs <= self.f_s_max])
+                integrand = s_tilde[i, np.where(np.array(f_s) == 0)[0][0]] * np.exp(2j * np.pi * z_prime * filtered_f_s)
+                integral = self.trapz(integrand * filtered_f_s, filtered_f_s)
+                I_rec += integral
+                pbar.update(1)
+
+        return np.abs(I_rec)

AOT_biomaps/AOT_Recon/BayesianRecon.py

@@ -0,0 +1,230 @@
+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, MAPEM_STOP, DEPIERRO
+from AOT_biomaps.Config import config
+
+import warnings
+import numpy as np
+import os
+from datetime import datetime
+
+class BayesianRecon(AlgebraicRecon):
+    """
+    This class implements the Bayesian reconstruction process.
+    It currently does not perform any operations but serves as a template for future implementations.
+    """
+    def __init__(self, 
+                opti = OptimizerType.PGC,
+                potentialFunction = PotentialType.HUBER_PIECEWISE,  
+                beta=None, 
+                delta=None, 
+                gamma=None, 
+                sigma=None,
+                corner = (0.5-np.sqrt(2)/4)/np.sqrt(2),
+                face = 0.5-np.sqrt(2)/4, 
+                **kwargs):
+        super().__init__(**kwargs)
+        self.reconType = ReconType.Bayesian
+        self.potentialFunction = potentialFunction
+        self.optimizer = opti
+        self.beta = beta           
+        self.delta = delta          # typical value is 0.1
+        self.gamma = gamma          # typical value is 0.01
+        self.sigma = sigma          # typical value is 1.0
+        self.corner = corner        # typical value is (0.5-np.sqrt(2)/4)/np.sqrt(2)
+        self.face = face            # typical value is 0.5-np.sqrt(2)/4 
+
+        if not isinstance(self.potentialFunction, PotentialType):
+            raise TypeError(f"Potential functions must be of type PotentialType, got {type(self.potentialFunction)}")  
+
+    def checkExistingFile(self, date = None):
+        """
+        Check if the reconstruction file already exists, based on current instance parameters.
+
+        Args:
+            withTumor (bool): If True, checks the phantom file; otherwise, checks the laser file.
+            overwrite (bool): If False, returns False if the file exists.
+
+        Returns:
+            tuple: (bool: whether to save, str: the filepath)
+        """
+        if self.saveDir is None:
+            raise ValueError("Save directory is not specified.")
+
+        # Construction du chemin du fichier
+        if date is None:
+            date = datetime.now().strftime("%d%m")
+
+        opt_name = self.optimizer.value
+        pot_name = self.potentialFunction.value
+        dir_name = f'results_{date}_{opt_name}_{pot_name}'
+
+        if self.optimizer == OptimizerType.PPGMLEM:
+            dir_name += f'_Beta_{self.beta}_Delta_{self.delta}_Gamma_{self.gamma}_Sigma_{self.sigma}'
+        elif self.optimizer in (OptimizerType.PGC, OptimizerType.DEPIERRO95):
+            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(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, filePath=None, show_logs=True):
+        """
+        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
+            recon_key = 'reconPhantom' if withTumor else 'reconLaser'
+            recon_path = filePath
+            if not os.path.exists(recon_path):
+                raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
+            # 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:
+                # 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):
+                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 {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_{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_{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]
+                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}_{pot_name}')
+                if optimizer == OptimizerType.PPGMLEM:
+                    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_{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}.")
+            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:
+                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}")
+
+    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.
+        """
+        if(processType == ProcessType.CASToR):
+            self._bayesianReconCASToR(withTumor)
+        elif(processType == ProcessType.PYTHON):
+            self._bayesianReconPython(withTumor)
+        else:
+            raise ValueError(f"Unknown Bayesian reconstruction type: {processType}")
+        
+    def _bayesianReconCASToR(self, show_logs, withTumor):
+        raise NotImplementedError("CASToR Bayesian reconstruction is not implemented yet.")
+
+    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 = 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 = 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 = 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 = 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 = 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 = 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}")

AOT_biomaps/AOT_Recon/DeepLearningRecon.py

@@ -0,0 +1,35 @@
+from AOT_biomaps.AOT_Recon._mainRecon import Recon
+from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType
+
+
+class DeepLearningRecon(Recon):
+    """
+    This class implements the deep learning reconstruction process.
+    It currently does not perform any operations but serves as a template for future implementations.
+    """
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.reconType = ReconType.DeepLearning
+        self.model = None  # Placeholder for the deep learning model
+        self.theta_matrix = []
+
+    def run(self, processType=ProcessType.PYTHON):
+        """
+        This method is a placeholder for the deep learning reconstruction process.
+        It currently does not perform any operations but serves as a template for future implementations.
+        """
+        if(processType == ProcessType.CASToR):
+            self._deepLearningReconCASToR()
+        elif(processType == ProcessType.PYTHON):
+            self._deepLearningReconPython()
+        else:
+            raise ValueError(f"Unknown deep learning reconstruction type: {processType}")
+
+    def _deepLearningReconCASToR(self):
+        pass
+
+    def _deepLearningReconPython(self):
+        pass
+
+    def checkExistingFile(self, date = None):
+        raise NotImplementedError("checkExistingFile method is not implemented yet.")

AOT_biomaps/AOT_Recon/PrimalDualRecon.py

@@ -0,0 +1,210 @@
+from AOT_biomaps.AOT_Recon.AlgebraicRecon import AlgebraicRecon
+from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType
+from AOT_biomaps.AOT_Recon.AOT_Optimizers import CP_KL, CP_TV
+from AOT_biomaps.AOT_Recon.ReconEnums import OptimizerType
+
+import os
+from datetime import datetime
+import numpy as np
+import re
+
+class PrimalDualRecon(AlgebraicRecon):
+    """
+    This class implements the convex reconstruction process.
+    It currently does not perform any operations but serves as a template for future implementations.
+    """
+    def __init__(self, theta=1.0, L=None, **kwargs):
+        super().__init__(**kwargs)
+        self.reconType = ReconType.Convex
+        self.theta = theta # relaxation parameter (between 1 and 2)
+        self.L = L # norme spectrale de l'opérateur linéaire défini par les matrices P et P^T
+
+    def run(self, processType=ProcessType.PYTHON, withTumor=True):
+        """
+        This method is a placeholder for the convex reconstruction process.
+        It currently does not perform any operations but serves as a template for future implementations.
+        """
+        if(processType == ProcessType.CASToR):
+            self._convexReconCASToR(withTumor)
+        elif(processType == ProcessType.PYTHON):
+            self._convexReconPython(withTumor)
+        else:
+            raise ValueError(f"Unknown convex reconstruction type: {processType}")
+
+    def _convexReconCASToR(self, withTumor):
+        raise NotImplementedError("CASToR convex reconstruction is not implemented yet.")
+
+
+    def checkExistingFile(self, date = None):
+        """
+        Check if the file already exists, based on current instance parameters.
+        Returns:
+            tuple: (bool: whether to save, str: the filepath)
+        """
+        if date is None:
+            date = datetime.now().strftime("%d%m")
+        results_dir = os.path.join(
+            self.saveDir,
+            f'results_{date}_{self.optimizer.value}_Alpha_{self.alpha}_Theta_{self.theta}_L_{self.L}'
+        )
+        os.makedirs(results_dir, exist_ok=True)
+
+        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, filePath=None, show_logs=True):
+        """
+        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: 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
+            recon_key = 'reconPhantom' if withTumor else 'reconLaser'
+            recon_path = filePath
+            if not os.path.exists(recon_path):
+                raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
+            # 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:
+                # 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):
+                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 {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.")
+            # Determine optimizer name for path matching
+            opt_name = optimizer.value if optimizer is not None else self.optimizer.value
+            # 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:
+                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}')
+                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}.")
+            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:
+                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 self.optimizer == OptimizerType.CP_TV:
+            if withTumor:
+                self.reconPhantom, self.indices = CP_TV(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                    )
+            else:
+                self.reconLaser, self.indices = CP_TV(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withoutTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                    )
+        elif self.optimizer == OptimizerType.CP_KL:
+            if withTumor:
+                self.reconPhantom, self.indices = CP_KL(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                )
+            else:
+                self.reconLaser, self.indices = CP_KL(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withoutTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                )
+        else:
+            raise ValueError(f"Optimizer value must be CP_TV or CP_KL, got {self.optimizer}")
+
+            
+
+
+
+