image_processor_ui.py

import tkinter as tk
from tkinter import ttk, filedialog
from PIL import Image, ImageTk
import cv2
import numpy as np
from skimage.metrics import peak_signal_noise_ratio as psnr
from imgprc_withfreq import median_filter, gaussian_filter, wiener_filter, laplacian_filter, sobel_filter, inverse_filter

class ImageProcessorUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Image Processing Tool")
        self.root.geometry("1200x600")
        
        self.original_image = None
        self.processed_image = None
        self.current_image_path = None
        
        self.setup_ui()
        
    def setup_ui(self):
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        control_frame = ttk.LabelFrame(main_frame, text="Controls", padding="5")
        control_frame.grid(row=0, column=0, padx=5, pady=5, sticky="nw")
        
        # Load image button
        ttk.Button(control_frame, text="Load Image", command=self.load_image).grid(row=0, column=0, padx=5, pady=5)
        
        # Filter selection
        ttk.Label(control_frame, text="Select Filter:").grid(row=1, column=0, padx=5, pady=5)
        self.filter_var = tk.StringVar(value="median")
        filters = ttk.Frame(control_frame)
        filters.grid(row=2, column=0, padx=5, pady=5)
        
        filter_options = [
            ("Median", "median"),
            ("Gaussian", "gaussian"),
            ("Wiener", "wiener"),
            ("Laplacian", "laplacian"),
            ("Sobel", "sobel"),
            ("Inverse", "inverse")
        ]
        
        for i, (text, value) in enumerate(filter_options):
            row = i // 3
            col = i % 3
            ttk.Radiobutton(filters, text=text, value=value, 
                          variable=self.filter_var).grid(row=row, column=col, padx=5)
        
        self.params_frame = ttk.LabelFrame(control_frame, text="Parameters", padding="5")
        self.params_frame.grid(row=3, column=0, padx=5, pady=5, sticky="ew")
        
        self.threshold_var = tk.IntVar(value=30)
        self.kernel_size_var = tk.IntVar(value=3)
        self.mode_var = tk.StringVar(value="edge")
        
        # Parameter controls (hidden by default)
        self.threshold_scale = ttk.Scale(self.params_frame, from_=0, to=255, 
                                       variable=self.threshold_var, orient="horizontal")
        self.kernel_size_spin = ttk.Spinbox(self.params_frame, from_=3, to=7, 
                                          increment=2, textvariable=self.kernel_size_var)
        self.mode_combo = ttk.Combobox(self.params_frame, values=["edge", "sharpen"], 
                                     textvariable=self.mode_var)
        
        ttk.Button(control_frame, text="Apply Filter", command=self.apply_filter).grid(row=4, column=0, padx=5, pady=5)
        ttk.Button(control_frame, text="Save Image", command=self.save_image).grid(row=5, column=0, padx=5, pady=5)
        
        self.metrics_frame = ttk.LabelFrame(control_frame, text="Image Metrics", padding="5")
        self.metrics_frame.grid(row=6, column=0, padx=5, pady=5, sticky="ew")
        
        # Metrics labels
        self.psnr_label = ttk.Label(self.metrics_frame, text="PSNR: N/A")
        self.psnr_label.grid(row=0, column=0, padx=5, pady=2, sticky="w")
        
        self.mse_label = ttk.Label(self.metrics_frame, text="MSE: N/A")
        self.mse_label.grid(row=1, column=0, padx=5, pady=2, sticky="w")
        
        display_frame = ttk.Frame(main_frame)
        display_frame.grid(row=0, column=1, padx=5, pady=5)
        
        # Original image
        self.original_label = ttk.Label(display_frame, text="Original Image")
        self.original_label.grid(row=0, column=0, padx=5)
        self.original_display = ttk.Label(display_frame)
        self.original_display.grid(row=1, column=0, padx=5)
        
        # Processed image
        self.processed_label = ttk.Label(display_frame, text="Processed Image")
        self.processed_label.grid(row=0, column=1, padx=5)
        self.processed_display = ttk.Label(display_frame)
        self.processed_display.grid(row=1, column=1, padx=5)
        
        # Bind filter selection to parameter update
        self.filter_var.trace('w', self.update_parameters)
        
    def update_parameters(self, *args):
        for widget in self.params_frame.winfo_children():
            widget.grid_remove()
        
        method = self.filter_var.get()
        row = 0
        
        if method in ["laplacian", "sobel"]:
            ttk.Label(self.params_frame, text="Threshold:").grid(row=row, column=0, padx=5, pady=2)
            self.threshold_scale.grid(row=row, column=1, padx=5, pady=2)
            row += 1
            
        if method in ["median", "gaussian", "wiener", "laplacian"]:
            ttk.Label(self.params_frame, text="Kernel Size:").grid(row=row, column=0, padx=5, pady=2)
            self.kernel_size_spin.grid(row=row, column=1, padx=5, pady=2)
            row += 1
            
        if method == "laplacian":
            ttk.Label(self.params_frame, text="Mode:").grid(row=row, column=0, padx=5, pady=2)
            self.mode_combo.grid(row=row, column=1, padx=5, pady=2)
    
    def load_image(self):
        file_path = filedialog.askopenfilename(
            filetypes=[("Image files", "*.png *.jpg *.jpeg *.bmp *.tiff")]
        )
        if file_path:
            self.current_image_path = file_path
            self.original_image = cv2.imread(file_path)
            self.original_image = cv2.cvtColor(self.original_image, cv2.COLOR_BGR2RGB)
            self.display_image(self.original_image, self.original_display)
            
    def apply_filter(self):
        if self.original_image is None:
            return
            
        method = self.filter_var.get()
        kernel_size = self.kernel_size_var.get()
        
        if method == "median":
            self.processed_image = median_filter(self.original_image, kernel_size)
        elif method == "gaussian":
            self.processed_image = gaussian_filter(self.original_image, kernel_size)
        elif method == "wiener":
            self.processed_image = wiener_filter(self.original_image, kernel_size)
        elif method == "laplacian":
            self.processed_image = laplacian_filter(self.original_image, 
                                                  kernel_size=kernel_size,
                                                  mode=self.mode_var.get(),
                                                  threshold=self.threshold_var.get())
        elif method == "sobel":
            self.processed_image = sobel_filter(self.original_image, 
                                              threshold=self.threshold_var.get())
        elif method == "inverse":
            kernel_size = 5
            sigma = 1.0
            x, y = np.meshgrid(np.linspace(-2, 2, kernel_size), np.linspace(-2, 2, kernel_size))
            psf = np.exp(-(x**2 + y**2)/(2*sigma**2))
            psf = psf / psf.sum()
            self.processed_image = inverse_filter(self.original_image, psf, reg_param=0.01)
            
        self.display_image(self.processed_image, self.processed_display)
        self.calculate_metrics(self.original_image, self.processed_image)
        
    def save_image(self):
        if self.processed_image is None:
            return
            
        file_path = filedialog.asksaveasfilename(
            defaultextension=".png",
            filetypes=[("PNG files", "*.png"), ("JPEG files", "*.jpg"), ("All files", "*.*")]
        )
        if file_path:
            cv2.imwrite(file_path, cv2.cvtColor(self.processed_image, cv2.COLOR_RGB2BGR))
            
    def display_image(self, image, label, max_size=500):
        height, width = image.shape[:2]
        # Calculating scaling factor to fit within max_size
        scale = min(max_size/width, max_size/height)
        new_width = int(width * scale)
        new_height = int(height * scale)
        
        # Resize image
        image_resized = cv2.resize(image, (new_width, new_height))
        # Convert to PhotoImage
        image_tk = ImageTk.PhotoImage(Image.fromarray(image_resized))
        label.configure(image=image_tk)
        label.image = image_tk  

    def calculate_metrics(self, original, processed):
        """Calculate image quality metrics based on filter type."""
        method = self.filter_var.get()
        
        if method in ["laplacian", "sobel"]:
            # Convert original to grayscale since edges are grayscale
            # For edge detection, calculate both edge metrics and quality metrics
            # Convert processed back to 3-channel for comparison
            gray_orig = cv2.cvtColor(original, cv2.COLOR_RGB2GRAY)
            
            edge_percentage = (np.count_nonzero(processed) / processed.size) * 100
            avg_intensity = np.mean(processed[processed > 0]) if np.any(processed > 0) else 0
            
            processed_3ch = cv2.cvtColor(processed, cv2.COLOR_GRAY2RGB)
            
            # Calculate standard metrics using the 3-channel versions
            mse = np.mean((original.astype(float) - processed_3ch.astype(float)) ** 2)
            try:
                psnr_value = psnr(original, processed_3ch)
            except:
                psnr_value = 0
                
            self.psnr_label.config(text=f"PSNR: {psnr_value:.2f}dB")
            self.mse_label.config(text=f"MSE: {mse:.2f}")
            # self.psnr_label.config(text=f"Edge Coverage: {edge_percentage:.2f}% | PSNR: {psnr_value:.2f}dB")
            # self.mse_label.config(text=f"Avg Edge Intensity: {avg_intensity:.2f} | MSE: {mse:.2f}")
            
        elif method == "inverse":
            orig_norm = cv2.normalize(original.astype(float), None, 0, 255, cv2.NORM_MINMAX)
            proc_norm = cv2.normalize(processed.astype(float), None, 0, 255, cv2.NORM_MINMAX)
            
            mse = np.mean((orig_norm - proc_norm) ** 2)
            try:
                psnr_value = psnr(orig_norm.astype(np.uint8), proc_norm.astype(np.uint8))
            except:
                psnr_value = 0
                
            self.psnr_label.config(text=f"PSNR: {psnr_value:.2f} dB")
            self.mse_label.config(text=f"MSE: {mse:.2f}")
            
        else:
            try:
                psnr_value = psnr(original, processed)
            except:
                psnr_value = 0
                
            mse = np.mean((original.astype(float) - processed.astype(float)) ** 2)
            
            self.psnr_label.config(text=f"PSNR: {psnr_value:.2f} dB")
            self.mse_label.config(text=f"MSE: {mse:.2f}")

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