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

AOT_biomaps/AOT_Recon/PrimalDualRecon.py

@@ -1,22 +1,32 @@
 from AOT_biomaps.AOT_Recon.AlgebraicRecon import AlgebraicRecon
-from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType
+from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType, SMatrixType
 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):
+    def __init__(self, alpha, beta, theta=1.0, L=None, k_security=0.8, use_power_method=True, auto_alpha_gamma=0.05, apply_positivity_clamp=True, tikhonov_as_gradient=False, use_laplacian=True, laplacian_beta_scale=1.0,  **kwargs):
         super().__init__(**kwargs)
         self.reconType = ReconType.Convex
+        self.alpha = alpha               # TV regularization parameter (if None, alpha is auto-scaled)
+        self.beta=beta # Tikhonov regularization parameter  
         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
+        self.k_security=k_security
+        self.use_power_method=use_power_method
+        self.auto_alpha_gamma=auto_alpha_gamma    # gamma for auto alpha: alpha = gamma * data_term / tv_term
+        self.apply_positivity_clamp=apply_positivity_clamp
+        self.tikhonov_as_gradient=tikhonov_as_gradient  # if True, apply -tau*2*beta*x instead of prox multiplicative
+        self.use_laplacian=use_laplacian      # enable Laplacian (Hessian scalar) penalty
+        self.laplacian_beta_scale=laplacian_beta_scale # multiply beta for laplacian term if you want separate scaling
 
     def run(self, processType=ProcessType.PYTHON, withTumor=True):
         """
@@ -48,24 +58,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,122 +79,179 @@ 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}")
-
-    def _convexReconPython(self, withTumor):
-        if withTumor:
-            y=self.experiment.AOsignal_withTumor
-
-        else:
-            y=self.experiment.AOsignal_withoutTumor
+                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,show_logs=True):
         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
-                    )
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
+                )
             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
-                    )
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withoutTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
+                )
         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
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
                 )
             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
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withoutTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
                 )
         else:
             raise ValueError(f"Optimizer value must be CP_TV or CP_KL, got {self.optimizer}")

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

@@ -1,9 +1,11 @@
 import os
+from AOT_biomaps.AOT_Recon.AOT_SparseSMatrix import SparseSMatrix_CSR, SparseSMatrix_SELL
 import torch
 import numpy as np
+import pycuda.driver as drv
 from numba import njit, prange
 from torch_sparse import coalesce
-import torch.nn.functional as F
+from scipy.signal.windows import hann
 
 def load_recon(hdr_path):
     """
@@ -78,7 +80,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 +152,82 @@ 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)
+    """
+    Calcule la mémoire requise (en Go) pour :
+    - SMatrix : Matrice (np.ndarray, CuPy CSR, SparseSMatrix_CSR ou SparseSMatrix_SELL)
+    - y : vecteur (NumPy ou CuPy, float32)
+
+    Args:
+        SMatrix: Matrix object (np.ndarray, cpsparse.csr_matrix, SparseSMatrix_CSR, or SparseSMatrix_SELL)
+        y: Vector (float32)
+    """
+    total_bytes = 0
+
+    # --- 1. Memory for SMatrix ---
+    
+    # 1.1. Custom Sparse Matrix (SELL/CSR)
+    if isinstance(SMatrix, (SparseSMatrix_SELL, SparseSMatrix_CSR)):
+        # We rely on the getMatrixSize method, which we fixed to track all host/GPU bytes.
+        # This is the most reliable way to estimate memory for custom GPU-backed structures.
+        try:
+            matrix_size_gb = SMatrix.getMatrixSize()
+            if isinstance(matrix_size_gb, dict) and 'error' in matrix_size_gb:
+                raise ValueError(f"SMatrix allocation error: {matrix_size_gb['error']}")
+            
+            # Convert GB back to bytes (1 GB = 1024^3 bytes)
+            size_SMatrix = matrix_size_gb * (1024 ** 3)
+            total_bytes += size_SMatrix
+            print(f"SMatrix (Custom Sparse) size: {matrix_size_gb:.3f} GB")
+
+        except AttributeError:
+            raise AttributeError("Custom Sparse Matrix must implement the getMatrixSize() method.")
+    
+    # 1.2. NumPy Dense Array (Standard)
+    elif isinstance(SMatrix, np.ndarray):
+        # Dense NumPy array (float32)
+        size_SMatrix = SMatrix.nbytes
+        total_bytes += size_SMatrix
+        print(f"SMatrix (NumPy Dense) size: {size_SMatrix / (1024 ** 3):.3f} GB")
+
+    # 1.3. CuPy CSR Matrix (Standard Sparse CuPy)
+    # Note: Requires CuPy to be imported, which is usually done outside this function.
+    # Assuming 'cpsparse.csr_matrix' is available in the environment if this path is taken.
+    elif 'cupy.sparse' in str(type(SMatrix)): # Using string check for type safety outside CuPy context
+        # CuPy CSR matrix structure: data (float32), indices (int32), indptr (int32)
+        nnz = SMatrix.nnz
+        num_rows = SMatrix.shape[0]
+        size_data = nnz * 4        # float32 = 4 bytes
+        size_indices = nnz * 4     # int32 = 4 bytes
+        size_indptr = (num_rows + 1) * 4 # int32 = 4 bytes
+        size_SMatrix = size_data + size_indices + size_indptr
+        total_bytes += size_SMatrix
+        print(f"SMatrix (CuPy CSR) size: {size_SMatrix / (1024 ** 3):.3f} GB")
+
+    else:
+        raise ValueError("SMatrix must be a np.ndarray, cpsparse.csr_matrix, or a custom SparseSMatrix object (CSR/SELL).")
+
+    # --- 2. Memory for Vector y ---
+    
+    # Check if y is a CuPy array or NumPy array (assuming float32 based on docstring)
+    if hasattr(y, 'nbytes'):
+        size_y = y.nbytes
+        total_bytes += size_y
+        print(f"Vector y size: {size_y / (1024 ** 3):.3f} GB")
+    else:
+        # Fallback if object doesn't expose nbytes (e.g., custom buffer), but usually array objects do.
+        raise ValueError("Vector y must be an array type exposing the .nbytes attribute.")
+
 
-    # Calculate total memory requirement in GB
-    total_memory = (num_elements_SMatrix + num_elements_y + num_elements_theta) * 32 / 8 / 1024**3
-    return total_memory
+    # --- 3. Final Result ---
+    return total_bytes / (1024 ** 3)
 
-def check_gpu_memory(device_index, required_memory):
+
+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 +334,156 @@ 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
+
+def compute_TV_cpu(x, Z, X, isotropic=False):
+    """
+    Compute total variation of x (1D flattened of shape Z*X).
+    isotropic=False -> anisotropic (sum |dx| + |dy|)
+    isotropic=True -> isotropic sqrt(dx^2 + dy^2)
+    """
+    x2d = x.reshape(Z, X)
+    dx = np.diff(x2d, axis=1)
+    dy = np.diff(x2d, axis=0)
+    if isotropic:
+        # pad to original size for consistent measure (we only need sum of norms)
+        mags = np.sqrt(dx**2 + dy**2)
+        return float(np.sum(mags))
+    else:
+        return float(np.sum(np.abs(dx)) + np.sum(np.abs(dy)))
+
+def get_apodization_vector_gpu(matrix_sparse_obj):
+    """
+    Génère un vecteur de fenêtrage 2D (Hanning) pour l'apodisation 
+    de la matrice système A et le transfère sur le GPU.
+    Ce vecteur doit être multiplié par les colonnes de A (pixels Z*X).
+    """
+    Z = matrix_sparse_obj.Z
+    X = matrix_sparse_obj.X
+    
+    # 1. Génération des fenêtres 1D sur l'axe X et Z
+    # Forte apodisation latérale (X) pour cibler l'artefact de bordure.
+    fenetre_x = hann(X).astype(np.float32)
+    
+    # Fenêtre uniforme en profondeur (Z), car l'artefact est surtout latéral.
+    fenetre_z = np.ones(Z, dtype=np.float32)
+    
+    # 2. Création de la matrice de fenêtre 2D (Z, X)
+    fenetre_2d = np.outer(fenetre_z, fenetre_x)
+    
+    # 3. Vectorisation (Z*X)
+    fenetre_vectorisee = fenetre_2d.flatten()
+    
+    # 4. Transfert sur GPU (mémoire contiguë)
+    fenetre_gpu = drv.mem_alloc(fenetre_vectorisee.nbytes)
+    drv.memcpy_htod(fenetre_gpu, fenetre_vectorisee)
+    
+    print(f"✅ Vecteur de fenêtrage (Z*X={Z*X}) généré et transféré sur GPU.")
+    
+    return fenetre_gpu
+
+def _call_axpby(axpby_kernel, out_ptr, x_ptr, y_ptr, a, b, N, stream, block):
+    grid = ((int(N) + block - 1) // block, 1, 1)
+    axpby_kernel(out_ptr, x_ptr, y_ptr,
+                    np.float32(a), np.float32(b),
+                    np.int32(N),
+                    block=(block, 1, 1), grid=grid, stream=stream)
+
+def _call_minus_axpy(minus_kernel, out_ptr, z_ptr, a, N, stream, block):
+    grid = ((int(N) + block - 1) // block, 1, 1)
+    minus_kernel(out_ptr, z_ptr, np.float32(a), np.int32(N),
+                    block=(block, 1, 1), grid=grid, stream=stream)
+
+def power_method_estimate_L__SELL(SMatrix, stream, n_it=20, block_size=256):
+    """Estimate ||A||^2 using power method (uses your projection/backprojection kernels)."""
+    TN = int(SMatrix.N * SMatrix.T)
+    ZX = int(SMatrix.Z * SMatrix.X)
+    proj = SMatrix.sparse_mod.get_function("projection_kernel__SELL")
+    back = SMatrix.sparse_mod.get_function("backprojection_kernel__SELL")
+    TN_i = np.int32(TN)
+    ZX_i = np.int32(ZX)
+    slice_h = np.int32(SMatrix.slice_height)
+    grid_rows = ((TN + block_size - 1) // block_size, 1, 1)
+    block_1D = (block_size, 1, 1)
+
+    dtype = np.float32
+    x_host = np.random.randn(ZX).astype(dtype)
+    x_host /= np.linalg.norm(x_host) + 1e-12
+    x_gpu = drv.mem_alloc(x_host.nbytes)
+    drv.memcpy_htod_async(x_gpu, x_host, stream)
+    q_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize)
+    ATq_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+    ATq_host = np.empty(ZX, dtype=dtype)
+
+    for _ in range(n_it):
+        proj(q_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                x_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+        drv.memset_d32_async(ATq_gpu, 0, ZX, stream)
+        back(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                q_gpu, ATq_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+        stream.synchronize()
+        drv.memcpy_dtoh(ATq_host, ATq_gpu)
+        norm = np.linalg.norm(ATq_host)
+        if norm < 1e-12:
+            break
+        x_host = ATq_host / norm
+        drv.memcpy_htod_async(x_gpu, x_host, stream)
+    # final Rayleigh quotient
+    proj(q_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+            x_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+    drv.memset_d32_async(ATq_gpu, 0, ZX, stream)
+    back(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+            q_gpu, ATq_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+    stream.synchronize()
+    drv.memcpy_dtoh(ATq_host, ATq_gpu)
+    L_sq = float(np.dot(x_host, ATq_host))
+    for g in (x_gpu, q_gpu, ATq_gpu):
+        try:
+            g.free()
+        except:
+            pass
+    return max(L_sq, 1e-6)

AOT_biomaps/AOT_Recon/__init__.py

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