main.py

import sys
import time
import numpy as np
import cv2
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import matplotlib.pyplot as plt
from skimage.util import random_noise
from skimage.metrics import peak_signal_noise_ratio as compute_psnr
from skimage.metrics import structural_similarity as compute_ssim
from skimage.restoration import denoise_tv_bregman, denoise_tv_chambolle
from PIL import Image, ImageTk

# =============================================================================
# SECTION : RESTAURATION PAR TOTAL VARIATION (TV) - LE CŒUR DU PROJET
# =============================================================================
def total_variation_restoration(f, lambda_val=0.5, dt=0.2, num_iter=100, epsilon=1e-5):
    """
    Restauration d'image basée sur l'équation d'Euler-Lagrange de la Variation Totale (TV).
    Modèle d'énergie : E(u) = \int ||\nabla u|| + (\lambda/2) \int (u - f)^2
    
    Paramètres :
    - f : Image d'entrée (bruitée), de forme 2D (niveaux de gris), valeurs [0, 1].
    - lambda_val : Coefficient de fidélité (\lambda). Plus il est grand, moins le lissage
                   est fort (restant fidèle à l'image d'entrée).
    - dt : Pas temporel. Doit être petit (CFL constraint) pour la stabilité.
    - num_iter : Nombre d'itérations de la descente de gradient.
    - epsilon : Facteur de régularisation pour éviter la division par 0 à |grad| -> 0.
    """
    # Si l'image est en couleur, on applique la TV canal par canal
    if len(f.shape) == 3:
        canaux_restaure = []
        for i in range(3):
            # Restaure chaque canal séparément
            canal = total_variation_restoration(f[:, :, i], lambda_val, dt, num_iter, epsilon)
            canaux_restaure.append(canal)
        return np.stack(canaux_restaure, axis=-1)

    # Conversion en float64 pour une précision maximale pendant les calculs
    u = np.array(f, dtype=np.float64, copy=True)
    f_float = np.array(f, dtype=np.float64, copy=True)
    
    for _ in range(num_iter):
        # 1. Calcul des gradients spatiaux par différences finies en avant (Forward Differences)
        # u_x : dérivée selon l'axe horizontal, u_y : selon l'axe vertical
        u_x = np.hstack([np.diff(u, axis=1), np.zeros((u.shape[0], 1))])
        u_y = np.vstack([np.diff(u, axis=0), np.zeros((1, u.shape[1]))])
        
        # Norme du gradient régularisée par epsilon
        norm_grad = np.sqrt(u_x**2 + u_y**2 + epsilon**2)
        
        # 2. Vecteurs normés
        p_x = u_x / norm_grad
        p_y = u_y / norm_grad
        
        # 3. Calcul de la divergence de p par différences finies en arrière (Backward Differences)
        # div_x = p_x[i,j] - p_x[i,j-1] (backward selon x/axis=1)
        div_x = np.hstack([p_x[:, 0:1], np.diff(p_x, axis=1)])
        # div_y = p_y[i,j] - p_y[i-1,j] (backward selon y/axis=0)  
        div_y = np.vstack([p_y[0:1, :], np.diff(p_y, axis=0)])
        
        divergence = div_x + div_y
        
        # 4. Mise à jour de (u) selon la descente de gradient
        u = u + dt * (divergence - lambda_val * (u - f_float))
        
    # S'assurer que l'image de sortie reste dans un espace d'intensité valide [0, 1]
    return np.clip(u, 0.0, 1.0)


# =============================================================================
# UTILITAIRES ET MÉTRIQUES
# =============================================================================
def compute_snr(original, restored):
    """Calcule le Signal-to-Noise Ratio (SNR)"""
    original_float = original.astype(np.float64)
    restored_float = restored.astype(np.float64)
    
    signal_power = np.sum(original_float**2)
    noise_power = np.sum((original_float - restored_float)**2)
    
    if noise_power == 0:
        return float('inf')
    return 10 * np.log10(signal_power / noise_power)


def show_3d_surface(image, title="Surface 3D des Intensités"):
    """ Affiche l'image comme une surface 3D topographique """
    import matplotlib.pyplot as plt
    
    if image is None:
        return

    # S'il y a 3 canaux (couleur), on convertit en niveaux de gris pour la vue 3D
    if len(image.shape) == 3:
        image_gray = cv2.cvtColor((image * 255).astype(np.uint8), cv2.COLOR_RGB2GRAY) / 255.0
    else:
        image_gray = image

    # Réduit la taille pour optimiser les performances d'affichage 3D de matplot
    max_dim = 150
    h, w = image_gray.shape
    if h > max_dim or w > max_dim:
        scale = max_dim / max(h, w)
        image_gray = cv2.resize(image_gray, (int(w * scale), int(h * scale)))

    fig = plt.figure(figsize=(8, 6))
    ax = fig.add_subplot(111, projection='3d')
    X, Y = np.meshgrid(np.arange(image_gray.shape[1]), np.arange(image_gray.shape[0]))
    
    # Inversion de l'axe Y pour correspondre au sens conventionnel des images (0 en haut)
    surf = ax.plot_surface(X, -Y, image_gray, cmap='viridis', linewidth=0, antialiased=True)
    fig.colorbar(surf, ax=ax, shrink=0.5, aspect=5)
    ax.set_title(title)
    
    # Rendre l'affichage matplotlib interactif et récurrent
    plt.show()


# =============================================================================
# INTERFACE GRAPHIQUE (GUI TKINTER)
# =============================================================================
class ImageRestorationApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Restauration TV - Total Variation Image Denoising")
        self.root.geometry("1400x900")
        self.root.minsize(1200, 700)
        
        # Données de travail
        self.img_original = None
        self.img_working = None
        self.img_filtered = None
        self.img_restored = None
        self.img_bregman = None
        self.img_chambolle = None
        self.last_method = "TV"
        self.noise_applied = False  # Flag pour tracker si le bruit a été appliqué
        
        # Zoom et affichage
        self.zoom_level = 1.0
        self.max_zoom = 3.0
        self.min_zoom = 0.5
        self.image_labels = {}
        self.image_frames = {}
        
        # Historique des métriques par méthode (dernière valeur pour chaque)
        self.metrics_history = {
            "TV Custom": {"time": None, "psnr": None, "snr": None, "ssim": None},
            "TV Bregman": {"time": None, "psnr": None, "snr": None, "ssim": None},
            "TV Chambolle": {"time": None, "psnr": None, "snr": None, "ssim": None},
            "Gaussian Blur": {"time": None, "psnr": None, "snr": None, "ssim": None},
            "Median Blur": {"time": None, "psnr": None, "snr": None, "ssim": None},
        }
        self.metrics_log_widgets = {}
        
        self.setup_ui()

    def setup_ui(self):
        # === PANED WINDOW PRINCIPAL ===
        self.main_pane = tk.PanedWindow(self.root, orient=tk.HORIZONTAL, bg="#bdc3c7", sashwidth=5, relief=tk.FLAT)
        self.main_pane.pack(fill=tk.BOTH, expand=True)

        # === PANNEAU GAUCHE : Contrôles ===
        self._setup_left_panel()

        # === PANNEAU DROIT : Affichage des images ===
        self._setup_right_panel()

    def _setup_left_panel(self):
        """Configuration du panneau de contrôle gauche."""
        self.left_outer_frame = tk.Frame(self.main_pane, width=320, bg="#f8f9fa")
        self.main_pane.add(self.left_outer_frame, minsize=280)
        
        # Scrollbar pour le panneau gauche
        left_scroll = tk.Scrollbar(self.left_outer_frame, orient=tk.VERTICAL)
        left_scroll.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.left_canvas = tk.Canvas(self.left_outer_frame, yscrollcommand=left_scroll.set, 
                                      width=300, highlightthickness=0, bg="#f8f9fa")
        self.left_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        left_scroll.config(command=self.left_canvas.yview)
        
        self.left_frame = tk.Frame(self.left_canvas, padx=12, pady=12, bg="#f8f9fa")
        self.left_canvas.create_window((0, 0), window=self.left_frame, anchor="nw")
        
        self.left_frame.bind("<Configure>", 
                             lambda e: self.left_canvas.configure(scrollregion=self.left_canvas.bbox("all")))
        self.left_canvas.bind("<Configure>", 
                              lambda e: self.left_canvas.itemconfig(1, width=e.width))

        # Titre
        tk.Label(self.left_frame, text="⚙️ CONFIGURATION", font=("Segoe UI", 14, "bold"), 
                 fg="#2c3e50", bg="#f8f9fa").pack(pady=(0, 15))

        # --- SECTION FICHIERS ---
        self._create_section(self.left_frame, "📂 Fichiers", self._create_file_controls)

        # --- SECTION DÉGRADATION ---
        self._create_section(self.left_frame, "🌪️ Dégradation", self._create_noise_controls)

        # --- SECTION FILTRES ---
        self._create_section(self.left_frame, "🛡️ Filtres", self._create_filter_controls)

        # --- SECTION TV ---
        self._create_section(self.left_frame, "🚀 Algorithmes TV", self._create_tv_controls)

        # --- ESPACE FLEXIBLE POUSSANT LE BOUTON VERS LE BAS ---
        tk.Frame(self.left_frame, bg="#f8f9fa").pack(fill=tk.BOTH, expand=True)

        # --- BOUTON QUITTER (toujours en bas du sidebar) ---
        tk.Frame(self.left_frame, height=10, bg="#f8f9fa").pack()
        btn_exit = tk.Button(self.left_frame, text="🚪 Quitter l'Application", bg="#d63031", fg="white",
                             font=("Arial", 10, "bold"), relief=tk.FLAT, command=self.root.quit)
        btn_exit.pack(fill=tk.X, pady=5)
        self.apply_hover_effect(btn_exit, "#d63031", "#b22222")

    def _create_section(self, parent, title, content_func):
        """Crée une section pliable avec titre."""
        frame = tk.LabelFrame(parent, text=f" {title} ", font=("Arial", 9, "bold"), 
                              padx=10, pady=8, fg="#34495e", bg="#f8f9fa")
        frame.pack(fill=tk.X, pady=5)
        content_func(frame)

    def _create_file_controls(self, parent):
        btn_load = tk.Button(parent, text="Charger une Image", bg="#1abc9c", fg="white",
                             font=("Arial", 10, "bold"), relief=tk.FLAT, command=self.load_image)
        btn_load.pack(fill=tk.X)
        self.apply_hover_effect(btn_load, "#1abc9c", "#16a085")

    def _create_noise_controls(self, parent):
        tk.Label(parent, text="Type:", bg="#f8f9fa").pack(anchor=tk.W)
        self.noise_type = ttk.Combobox(parent, values=["gaussian", "s&p", "poisson", "speckle", "flou gaussien", "motion blur"], 
                                        state="readonly", width=25)
        self.noise_type.set("gaussian")
        self.noise_type.pack(fill=tk.X, pady=(0, 8))

        tk.Label(parent, text="Intensité:", bg="#f8f9fa").pack(anchor=tk.W)
        self.noise_var = tk.Scale(parent, from_=0.01, to=0.5, resolution=0.01, 
                                  orient=tk.HORIZONTAL, bg="#f8f9fa", highlightthickness=0)
        self.noise_var.set(0.05)
        self.noise_var.pack(fill=tk.X, pady=(0, 8))

        btn_noise = tk.Button(parent, text="Appliquer le Bruit", bg="#34495e", fg="white",
                              font=("Arial", 9, "bold"), relief=tk.FLAT, command=self.apply_noise)
        btn_noise.pack(fill=tk.X)
        self.apply_hover_effect(btn_noise, "#34495e", "#2c3e50")

    def _create_filter_controls(self, parent):
        self.opencv_filter = ttk.Combobox(parent, values=["Gaussian Blur", "Median Blur"], 
                                          state="readonly", width=25)
        self.opencv_filter.set("Gaussian Blur")
        self.opencv_filter.pack(fill=tk.X, pady=(0, 8))

        btn_filter = tk.Button(parent, text="Appliquer Filtre", bg="#7f8c8d", fg="white",
                               font=("Arial", 9, "bold"), relief=tk.FLAT, command=self.apply_opencv_filter)
        btn_filter.pack(fill=tk.X)
        self.apply_hover_effect(btn_filter, "#7f8c8d", "#636e72")

    def _create_tv_controls(self, parent):
        params = [
            ("Fidélité (λ):", "lambda_scale", 0.0, 5.0, 0.1, 0.5),
            ("Pas (dt):", "dt_scale", 0.01, 0.25, 0.01, 0.2),
            ("Itérations:", "iter_scale", 10, 500, 10, 100),
        ]
        for label, attr, from_, to, res, val in params:
            tk.Label(parent, text=label, bg="#f8f9fa").pack(anchor=tk.W)
            scale = tk.Scale(parent, from_=from_, to=to, resolution=res,
                             orient=tk.HORIZONTAL, bg="#f8f9fa", highlightthickness=0)
            scale.set(val)
            scale.pack(fill=tk.X, pady=(0, 5))
            setattr(self, attr, scale)

        # Boutons TV
        for text, color, hover, cmd in [
            ("TV Custom", "#e74c3c", "#c0392b", self.apply_tv_restoration),
            ("TV Bregman", "#e67e22", "#d35400", self.apply_tv_bregman),
            ("TV Chambolle", "#2980b9", "#2471a3", self.apply_tv_chambolle),
        ]:
            btn = tk.Button(parent, text=text, bg=color, fg="white",
                            font=("Arial", 9, "bold"), relief=tk.FLAT, command=cmd)
            btn.pack(fill=tk.X, pady=2)
            self.apply_hover_effect(btn, color, hover)

    def _create_zoom_controls(self, parent):
        """Contrôles de zoom exclusifs par boutons - OBSOLETE, déplacé dans _setup_3d_controls."""
        pass

    def _setup_right_panel(self):
        """Configuration du panneau d'affichage droit."""
        self.right_frame = tk.Frame(self.main_pane, bg="#f5f5f5")
        self.main_pane.add(self.right_frame, minsize=700)

        # --- MÉTRIQUES ---
        self._setup_metrics_bar()

        # --- CONTRÔLES 3D ---
        self._setup_3d_controls()

        # --- ZONE D'AFFICHAGE DES IMAGES ---
        self._setup_image_display()

    def _setup_metrics_bar(self):
        """Barre des métriques en haut."""
        self.metrics_frame = tk.Frame(self.right_frame, bg="#ecf0f1", pady=8)
        self.metrics_frame.pack(fill=tk.X, padx=10, pady=(10, 5))

        metrics = [
            ("⏱️ Temps", "lbl_val_time", "#9b59b6"),
            ("📈 PSNR", "lbl_val_psnr", "#3498db"),
            ("🔊 SNR", "lbl_val_snr", "#e67e22"),
            ("✨ SSIM", "lbl_val_ssim", "#2ecc71"),
        ]

        self.metric_cards = {}
        for title, attr, color in metrics:
            # Card container avec log expander
            card_container = tk.Frame(self.metrics_frame, bg="white", highlightbackground=color,
                                      highlightthickness=2)
            card_container.pack(side=tk.LEFT, expand=True, fill=tk.BOTH, padx=4)
            
            # Partie valeur actuelle
            card = tk.Frame(card_container, bg="white", padx=12, pady=6)
            card.pack(fill=tk.X)
            tk.Label(card, text=title, font=("Arial", 8, "bold"), fg=color, bg="white").pack(anchor=tk.W)
            lbl = tk.Label(card, text="—", font=("Consolas", 12, "bold"), fg="#2d3436", bg="white")
            lbl.pack(anchor=tk.W)
            setattr(self, attr, lbl)
            
            # Bouton expand pour l'historique
            metric_key = attr.replace("lbl_val_", "")
            self.metrics_log_widgets[metric_key] = {"container": card_container, "log_frame": None, "visible": False}
            
            btn_expand = tk.Button(card, text="▼ Historique", font=("Arial", 7), 
                                   bg="#ecf0f1", fg="#7f8c8d", relief=tk.FLAT,
                                   command=lambda mk=metric_key: self._toggle_metrics_log(mk))
            btn_expand.pack(anchor=tk.W, pady=(4, 0))
            self.metric_cards[metric_key] = card_container

    def _setup_3d_controls(self):
        """Boutons de visualisation 3D et Zoom."""
        vis_frame = tk.LabelFrame(self.right_frame, text=" 👁️ Visualisation 3D & Zoom ",
                                  font=("Arial", 9, "bold"), bg="#f5f5f5", padx=8, pady=5)
        vis_frame.pack(fill=tk.X, padx=10, pady=5)

        # Container principal horizontal
        main_frame = tk.Frame(vis_frame, bg="#f5f5f5")
        main_frame.pack(fill=tk.X)

        # Partie gauche: Boutons 3D
        btn_frame = tk.Frame(main_frame, bg="#f5f5f5")
        btn_frame.pack(side=tk.LEFT, fill=tk.X, expand=True)

        views = [
            ("Originale", lambda: self.img_original, "#34495e", "#2c3e50"),
            ("Bruitée", lambda: self.img_working, "#f39c12", "#e67e22"),
            ("TV Custom", lambda: self.img_restored, "#e74c3c", "#c0392b"),
            ("TV Bregman", lambda: self.img_bregman, "#d35400", "#a04000"),
            ("TV Chambolle", lambda: self.img_chambolle, "#2980b9", "#2471a3"),
        ]

        for text, img_getter, color, hover in views:
            btn = tk.Button(btn_frame, text=text, bg=color, fg="white",
                            font=("Arial", 8, "bold"), relief=tk.FLAT, padx=10, pady=5,
                            command=lambda g=img_getter, t=text: show_3d_surface(g(), f"3D - {t}"))
            btn.pack(side=tk.LEFT, padx=3)
            self.apply_hover_effect(btn, color, hover)

        # Partie droite: Zoom controls
        zoom_frame = tk.Frame(main_frame, bg="#f5f5f5")
        zoom_frame.pack(side=tk.RIGHT, padx=(20, 0))

        tk.Label(zoom_frame, text="Zoom:", font=("Arial", 9, "bold"),
                 bg="#f5f5f5", fg="#2c3e50").pack(side=tk.LEFT, padx=(0, 8))

        self.zoom_label = tk.Label(zoom_frame, text="100%", font=("Consolas", 10, "bold"),
                                   bg="#f5f5f5", fg="#2c3e50", width=4)
        self.zoom_label.pack(side=tk.LEFT, padx=(0, 5))

        btn_zoom_out = tk.Button(zoom_frame, text="−", bg="#95a5a6", fg="white",
                                 font=("Arial", 9, "bold"), width=3, relief=tk.FLAT,
                                 command=lambda: self._change_zoom(-0.25))
        btn_zoom_out.pack(side=tk.LEFT, padx=2)
        self.apply_hover_effect(btn_zoom_out, "#95a5a6", "#7f8c8d")

        btn_zoom_in = tk.Button(zoom_frame, text="+", bg="#95a5a6", fg="white",
                                font=("Arial", 9, "bold"), width=3, relief=tk.FLAT,
                                command=lambda: self._change_zoom(0.25))
        btn_zoom_in.pack(side=tk.LEFT, padx=2)
        self.apply_hover_effect(btn_zoom_in, "#95a5a6", "#7f8c8d")

        btn_reset = tk.Button(zoom_frame, text="⟲", bg="#bdc3c7", fg="white",
                              font=("Arial", 9, "bold"), width=3, relief=tk.FLAT,
                              command=self._reset_zoom)
        btn_reset.pack(side=tk.LEFT, padx=2)
        self.apply_hover_effect(btn_reset, "#bdc3c7", "#95a5a6")

    def _setup_image_display(self):
        """Zone d'affichage dynamique des images avec scrollbars H+V."""
        # Frame conteneur principal pour le canvas et les scrollbars
        display_frame = tk.Frame(self.right_frame, bg="#f5f5f5")
        display_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)

        # Grid layout pour les scrollbars
        display_frame.grid_rowconfigure(0, weight=1)  # Canvas expand
        display_frame.grid_rowconfigure(1, weight=0, minsize=20)  # H scrollbar fixed height
        display_frame.grid_columnconfigure(0, weight=1)  # Canvas expand
        display_frame.grid_columnconfigure(1, weight=0, minsize=20)  # V scrollbar fixed width

        # Scrollbar vertical (droite)
        self.v_scroll = tk.Scrollbar(display_frame, orient=tk.VERTICAL)
        self.v_scroll.grid(row=0, column=1, sticky="ns")

        # Scrollbar horizontal (bas)
        self.h_scroll = tk.Scrollbar(display_frame, orient=tk.HORIZONTAL)
        self.h_scroll.grid(row=1, column=0, sticky="ew")

        # Canvas principal avec les deux scrollbars
        self.display_canvas = tk.Canvas(display_frame, bg="#e8e8e8", highlightthickness=1,
                                        highlightbackground="#bdc3c7",
                                        xscrollcommand=self.h_scroll.set,
                                        yscrollcommand=self.v_scroll.set)
        self.display_canvas.grid(row=0, column=0, sticky="nsew")

        # Configurer les commandes des scrollbars
        self.h_scroll.config(command=self.display_canvas.xview)
        self.v_scroll.config(command=self.display_canvas.yview)

        # Frame conteneur pour les images
        self.images_container = tk.Frame(self.display_canvas, bg="#e8e8e8")
        self.canvas_window = self.display_canvas.create_window((0, 0), window=self.images_container,
                                                               anchor="nw")

        # Configuration du scrollregion quand le contenu change
        self.images_container.bind("<Configure>",
                                   lambda e: self.display_canvas.configure(
                                       scrollregion=self.display_canvas.bbox("all")))

        # Dictionnaire des slots d'images
        self.image_slots = {}
        self._create_image_slots()

    def _create_image_slots(self):
        """Crée les slots d'images dynamiques (visibles uniquement si données présentes)."""
        slot_configs = [
            ("original", "1. Originale", "#1abc9c"),
            ("noised", "2. Bruitée", "#f39c12"),
            ("filtered", "3. Filtée", "#7f8c8d"),
            ("tv_custom", "4. TV Custom", "#e74c3c"),
            ("tv_bregman", "5. TV Bregman", "#e67e22"),
            ("tv_chambolle", "6. TV Chambolle", "#2980b9"),
        ]

        for key, title, color in slot_configs:
            slot = self._create_image_slot(self.images_container, key, title, color)
            self.image_slots[key] = slot
            # Masqué par défaut
            slot["frame"].pack_forget()

    def _create_image_slot(self, parent, key, title, color):
        """Crée un slot d'image individuel avec taille adaptative."""
        frame = tk.Frame(parent, bg="white", highlightbackground=color, highlightthickness=2)
        
        # Titre
        header = tk.Frame(frame, bg=color, height=25)
        header.pack(fill=tk.X)
        tk.Label(header, text=title, font=("Arial", 9, "bold"), fg="white", bg=color).pack(pady=2)

        # Canvas pour l'image - taille initiale, s'adapte à l'image
        img_canvas = tk.Canvas(frame, bg="#f5f5f5", highlightthickness=0)
        img_canvas.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        return {"frame": frame, "canvas": img_canvas, "key": key, "title": title}

    def _change_zoom(self, delta):
        """Change le niveau de zoom."""
        new_zoom = self.zoom_level + delta
        if self.min_zoom <= new_zoom <= self.max_zoom:
            self.zoom_level = new_zoom
            self.zoom_label.config(text=f"{int(self.zoom_level * 100)}%")
            self._refresh_image_display()

    def _reset_zoom(self):
        """Réinitialise le zoom."""
        self.zoom_level = 1.0
        self.zoom_label.config(text="100%")
        self._refresh_image_display()

    def _refresh_image_display(self):
        """Rafraîchit l'affichage des images avec le zoom actuel."""
        images_map = {
            "original": self.img_original,
            "noised": self.img_working,
            "filtered": self.img_filtered,
            "tv_custom": self.img_restored,
            "tv_bregman": self.img_bregman,
            "tv_chambolle": self.img_chambolle,
        }

        for key, slot in self.image_slots.items():
            img_data = images_map[key]
            canvas = slot["canvas"]
            
            if img_data is not None:
                self._display_image_in_canvas(canvas, img_data)
            else:
                canvas.delete("all")
                # Canvas de taille fixe quand aucune image
                canvas.config(width=200, height=200)
                canvas.create_text(100, 100, text="Aucune image", fill="#95a5a6", font=("Arial", 10))
        
        # Forcer la mise à jour du scrollregion pour permettre le défilement horizontal après zoom
        self.display_canvas.after(10, self._update_scrollregion)

    def _update_scrollregion(self):
        """Met à jour le scrollregion du canvas principal."""
        self.display_canvas.configure(scrollregion=self.display_canvas.bbox("all"))

    def _display_image_in_canvas(self, canvas, img_data):
        """Affiche une image dans un canvas en adaptant le cadre à la taille originale de l'image."""
        canvas.delete("all")
        
        # Conversion pour PIL
        if len(img_data.shape) == 3:
            img_pil = Image.fromarray((img_data * 255).astype(np.uint8))
        else:
            img_pil = Image.fromarray((img_data * 255).astype(np.uint8), mode='L').convert('RGB')

        # Taille originale de l'image
        orig_w, orig_h = img_pil.size
        
        # Taille de base pour l'affichage (max 400px pour éviter les images trop grandes)
        max_display_size = 400
        
        # Calculer les dimensions en gardant le ratio d'aspect
        if orig_w > orig_h:
            display_w = min(orig_w, max_display_size)
            display_h = int(display_w * orig_h / orig_w)
        else:
            display_h = min(orig_h, max_display_size)
            display_w = int(display_h * orig_w / orig_h)
        
        # Appliquer le zoom
        final_w = int(display_w * self.zoom_level)
        final_h = int(display_h * self.zoom_level)
        
        # Redimensionner l'image
        img_resized = img_pil.resize((final_w, final_h), Image.LANCZOS)
        img_tk = ImageTk.PhotoImage(img_resized)
        
        # Garder référence pour éviter garbage collection
        canvas.image = img_tk
        
        # Configurer le canvas à la taille de l'image redimensionnée
        canvas.config(width=final_w, height=final_h, 
                      scrollregion=(0, 0, final_w, final_h))
        
        # Afficher l'image
        canvas.create_image(0, 0, anchor=tk.NW, image=img_tk)

    def _update_visible_images(self):
        """Met à jour quels slots d'images sont visibles selon les données disponibles."""
        visibility_map = {
            "original": self.img_original is not None,
            "noised": self.img_working is not None and self.noise_applied,
            "filtered": self.img_filtered is not None,
            "tv_custom": self.img_restored is not None,
            "tv_bregman": self.img_bregman is not None,
            "tv_chambolle": self.img_chambolle is not None,
        }

        # Masquer tous d'abord
        for slot in self.image_slots.values():
            slot["frame"].pack_forget()

        # Afficher ceux qui ont des données
        visible_slots = [k for k, v in visibility_map.items() if v]
        
        for key in visible_slots:
            self.image_slots[key]["frame"].pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)

        self._refresh_image_display()

    def update_plots(self):
        """Met à jour l'affichage des images (méthode legacy, délégation vers nouveau système)."""
        self._update_visible_images()

    def apply_hover_effect(self, button, normal_color, hover_color):
        """Ajoute un effet de changement de couleur au survol."""
        button.bind("<Enter>", lambda e: button.config(bg=hover_color))
        button.bind("<Leave>", lambda e: button.config(bg=normal_color))

    def calculate_and_display_metrics(self, restored, exec_time=None):
        if self.img_original is None:
            return

        is_color = len(self.img_original.shape) == 3

        # Scikit-image paramètre channel_axis pour gérer la couleur ou pas
        ch_axis = -1 if is_color else None

        p_val = compute_psnr(self.img_original, restored, data_range=1.0)
        s_val = compute_ssim(self.img_original, restored, data_range=1.0, channel_axis=ch_axis)
        snr_val = compute_snr(self.img_original, restored)

        # Mettre à jour les cartes individuelles
        self.lbl_val_time.config(text=f"{exec_time:.3f} s" if exec_time else "N/A")
        self.lbl_val_psnr.config(text=f"{p_val:.2f} dB")
        self.lbl_val_snr.config(text=f"{snr_val:.2f} dB")
        self.lbl_val_ssim.config(text=f"{s_val:.4f}")
        
        # Stocker dans l'historique pour la méthode actuelle
        if self.last_method in self.metrics_history:
            self.metrics_history[self.last_method]["time"] = f"{exec_time:.3f} s" if exec_time else "N/A"
            self.metrics_history[self.last_method]["psnr"] = f"{p_val:.2f} dB"
            self.metrics_history[self.last_method]["snr"] = f"{snr_val:.2f} dB"
            self.metrics_history[self.last_method]["ssim"] = f"{s_val:.4f}"
            # Rafraîchir les logs si visibles
            self._refresh_metrics_logs()


    def _toggle_metrics_log(self, metric_key):
        """Affiche/cache le panneau d'historique pour une métrique."""
        widget_info = self.metrics_log_widgets[metric_key]
        container = widget_info["container"]
        
        if widget_info["visible"]:
            # Cacher
            if widget_info["log_frame"]:
                widget_info["log_frame"].pack_forget()
            widget_info["visible"] = False
        else:
            # Afficher
            if widget_info["log_frame"] is None:
                # Créer le frame de log
                log_frame = tk.Frame(container, bg="#f8f9fa", padx=8, pady=4)
                widget_info["log_frame"] = log_frame
                
                # En-têtes des colonnes
                header = tk.Frame(log_frame, bg="#f8f9fa")
                header.pack(fill=tk.X)
                tk.Label(header, text="Méthode", font=("Arial", 7, "bold"), 
                         bg="#f8f9fa", fg="#34495e", width=12).pack(side=tk.LEFT)
                tk.Label(header, text="Valeur", font=("Arial", 7, "bold"), 
                         bg="#f8f9fa", fg="#34495e").pack(side=tk.LEFT)
                
                # Lignes des méthodes
                widget_info["log_rows"] = {}
                methods = ["TV Custom", "TV Bregman", "TV Chambolle", "Gaussian Blur", "Median Blur"]
                for method in methods:
                    row = tk.Frame(log_frame, bg="#f8f9fa")
                    row.pack(fill=tk.X, pady=1)
                    tk.Label(row, text=method, font=("Arial", 7), 
                             bg="#f8f9fa", fg="#7f8c8d", width=12).pack(side=tk.LEFT)
                    val_lbl = tk.Label(row, text="—", font=("Consolas", 7), 
                                       bg="#f8f9fa", fg="#2d3436")
                    val_lbl.pack(side=tk.LEFT)
                    widget_info["log_rows"][method] = val_lbl
            
            widget_info["log_frame"].pack(fill=tk.X, pady=(0, 4))
            widget_info["visible"] = True
            self._refresh_metrics_logs()
    
    def _refresh_metrics_logs(self):
        """Rafraîchit les valeurs dans tous les panneaux d'historique visibles."""
        metric_map = {"time": "time", "psnr": "psnr", "snr": "snr", "ssim": "ssim"}
        
        for metric_key, widget_info in self.metrics_log_widgets.items():
            if widget_info["visible"] and "log_rows" in widget_info:
                data_key = metric_map.get(metric_key)
                for method, lbl in widget_info["log_rows"].items():
                    value = self.metrics_history[method].get(data_key, "—")
                    lbl.config(text=value if value else "—")

    # ================== ACTIONS CONTROLLER ================== #

    def load_image(self):
        filepath = filedialog.askopenfilename(filetypes=[("Images", "*.png *.jpg *.jpeg *.bmp")])
        if not filepath:
            return
            
        # OpenCV charge en BGR
        img = cv2.imread(filepath)
        if img is None:
            messagebox.showerror("Erreur", "Impossible de lire l'image.")
            return
            
        # Convertir en RGB
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        
        # Demander si gris ou pas (simplifier pour le projet: on permet couleur et niveaux de gris)
        # Mais TV classique est géniale en gris.
        # Demandons juste de travailler en normal avec possibilité de conversion.
        # Automatiquement on normalise entre 0 et 1
        self.img_original = img.astype(np.float64) / 255.0
        self.img_working = self.img_original.copy()
        self.img_filtered = None
        self.img_restored = None
        self.img_bregman = None
        self.img_chambolle = None
        self.noise_applied = False  # Réinitialiser le flag
        
        # Réinitialiser les cartes de métriques
        for lbl in [self.lbl_val_time, self.lbl_val_psnr, self.lbl_val_snr, self.lbl_val_ssim]:
            lbl.config(text="N/A")
        
        self.update_plots()

    def apply_noise(self):
        if self.img_original is None:
            messagebox.showwarning("Attention", "Chargez d'abord une image.")
            return
            
        noise_name = self.noise_type.get()
        variance = self.noise_var.get()
        
        if noise_name == "gaussian":
            noisy = random_noise(self.img_original, mode='gaussian', var=variance**2)
        elif noise_name == "s&p":
            noisy = random_noise(self.img_original, mode='s&p', amount=variance)
        elif noise_name == "poisson":
            noisy = random_noise(self.img_original, mode='poisson')
        elif noise_name == "speckle":
            noisy = random_noise(self.img_original, mode='speckle', var=variance**2)
        elif noise_name == "flou gaussien":
            # Mapper la variance (0.01 à 0.50) sur une taille de kernel (3 à 51)
            ksize = int(variance * 100)
            if ksize % 2 == 0:
                ksize += 1
            ksize = max(3, ksize)
            noisy = cv2.GaussianBlur(self.img_original, (ksize, ksize), 0)
        elif noise_name == "motion blur":
            ksize = int(variance * 100)
            ksize = max(3, ksize)
            # Matrice de ligne horizontale pour le mouvement
            kernel_mb = np.zeros((ksize, ksize))
            kernel_mb[int((ksize-1)/2), :] = np.ones(ksize)
            kernel_mb = kernel_mb / ksize
            noisy = cv2.filter2D(self.img_original, -1, kernel_mb)
            noisy = np.clip(noisy, 0.0, 1.0)
            
        self.img_working = noisy
        self.img_filtered = None
        self.img_restored = None
        self.noise_applied = True  # Marquer que le bruit a été appliqué
        self._update_visible_images()

    def apply_opencv_filter(self):
        "Baseline classique : filtres d'OpenCV appliqués sur l'image travaillée."
        if self.img_working is None:
            return
            
        filter_name = self.opencv_filter.get()
        # On reconvertit en [0, 255] uint8 pour OpenCV
        img_uint8 = (self.img_working * 255).astype(np.uint8)
        
        start_time = time.time()
        
        if filter_name == "Gaussian Blur":
            restored = cv2.GaussianBlur(img_uint8, (5, 5), 0)
        elif filter_name == "Median Blur":
            restored = cv2.medianBlur(img_uint8, 5)
            
        end_time = time.time()
        
        self.img_filtered = restored.astype(np.float64) / 255.0
        self.last_method = filter_name
        self.calculate_and_display_metrics(self.img_filtered, exec_time=(end_time - start_time))
        self._update_visible_images()

    def apply_tv_restoration(self):
        """Lance l'algorithme de Variation Totale (notre implémentation)."""
        if self.img_working is None:
            messagebox.showwarning("Attention", "Aucune dégradation appliquée ou image manquante.")
            return
            
        lam = self.lambda_scale.get()
        dt = self.dt_scale.get()
        iters = self.iter_scale.get()
        
        # Pour informer l'utilisateur car le calcul peut bloquer la GUI (on pourrait Threader, on reste simple)
        self.root.config(cursor="watch")
        self.root.update()
        
        start_time = time.time()
        
        try:
            self.img_restored = total_variation_restoration(self.img_working, lambda_val=lam, dt=dt, num_iter=iters)
            end_time = time.time()
            
            self.last_method = "TV Custom"
            self.calculate_and_display_metrics(self.img_restored, exec_time=(end_time - start_time))
            self._update_visible_images()
        except Exception as e:
            messagebox.showerror("Erreur TV", f"Erreur pendant la restauration TV Custom: {e}")
        finally:
            self.root.config(cursor="")

    def apply_tv_bregman(self):
        """Lance l'algorithme TV Bregman de scikit-image."""
        if self.img_working is None:
            messagebox.showwarning("Attention", "Chargez une image et appliquez du bruit.")
            return
            
        lam = self.lambda_scale.get()
        iters = self.iter_scale.get()
        
        # Mapping lambda (fidélité) -> weight (régularisation pour skimage)
        # On utilise une relation inverse pour que 'plus de fidélité' = 'moins de smoothing'
        weight_sk = 0.5 / (lam + 1e-5)
        
        # Gérer le cas couleur
        is_color = len(self.img_working.shape) == 3
        ch_axis = -1 if is_color else None

        self.root.config(cursor="watch")
        self.root.update()
        
        start_time = time.time()
        try:
            self.img_bregman = denoise_tv_bregman(self.img_working, weight=weight_sk, max_num_iter=iters, channel_axis=ch_axis)
            end_time = time.time()
            
            self.last_method = "TV Bregman"
            self.calculate_and_display_metrics(self.img_bregman, exec_time=(end_time - start_time))
            self._update_visible_images()
        except Exception as e:
            messagebox.showerror("Erreur Bregman", f"Erreur TV Bregman: {e}")
        finally:
            self.root.config(cursor="")

    def apply_tv_chambolle(self):
        """Lance l'algorithme TV Chambolle de scikit-image."""
        if self.img_working is None:
            messagebox.showwarning("Attention", "Chargez une image et appliquez du bruit.")
            return
            
        lam = self.lambda_scale.get()
        
        # Mapping lambda (fidélité) -> weight (régularisation pour skimage)
        weight_sk = 0.1 / (lam + 1e-5)
        
        is_color = len(self.img_working.shape) == 3
        ch_axis = -1 if is_color else None

        self.root.config(cursor="watch")
        self.root.update()
        
        start_time = time.time()
        try:
            # Chambolle ne prend pas le nombre d'itérations du slider directement car il interne à skimage
            self.img_chambolle = denoise_tv_chambolle(self.img_working, weight=weight_sk, channel_axis=ch_axis)
            end_time = time.time()
            
            self.last_method = "TV Chambolle"
            self.calculate_and_display_metrics(self.img_chambolle, exec_time=(end_time - start_time))
            self._update_visible_images()
        except Exception as e:
            messagebox.showerror("Erreur Chambolle", f"Erreur TV Chambolle: {e}")
        finally:
            self.root.config(cursor="")


if __name__ == "__main__":
    root = tk.Tk()
    app = ImageRestorationApp(root)
    root.mainloop()