Update app.py

app.py

@@ -3,10 +3,9 @@ import cv2
 import numpy as np
 import matplotlib.pyplot as plt
 
-
-# -----------------------------
+# =========================================================
 # KERNELS
-# -----------------------------
+# =========================================================
 kernels = {
     "Blur": np.ones((3, 3), np.float32) / 9,
 
@@ -42,92 +41,207 @@ kernels = {
 }
 
 
-# -----------------------------
-# MAIN FUNCTION
-# -----------------------------
+# =========================================================
+# IMAGE PROCESSING
+# =========================================================
 def process_image(image, kernel_name):
 
-    # Convert RGB → Grayscale
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    if image is None:
+        return None
 
-    # Get selected kernel
-    kernel = kernels[kernel_name]
+    # Convert RGB → BGR for OpenCV
+    image_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
 
-    # Apply convolution
-    filtered = cv2.filter2D(gray, -1, kernel)
+    # Grayscale
+    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
+
+    # Gaussian Blur
+    gaussian = cv2.GaussianBlur(gray, (5, 5), 0)
 
     # Histogram Equalization
     equalized = cv2.equalizeHist(gray)
 
-    # Thresholding
+    # Binary Threshold
     _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
 
-    # Edge Detection
+    # Adaptive Threshold
+    adaptive = cv2.adaptiveThreshold(
+        gray,
+        255,
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY,
+        11,
+        2
+    )
+
+    # Canny Edge Detection
     canny = cv2.Canny(gray, 100, 200)
 
-    # -----------------------------
-    # VISUALIZATION FIGURE
-    # -----------------------------
-    fig, axs = plt.subplots(2, 3, figsize=(12, 8))
+    # Kernel Filtering
+    kernel = kernels[kernel_name]
+    filtered = cv2.filter2D(gray, -1, kernel)
+
+    # Laplacian
+    laplacian = cv2.Laplacian(gray, cv2.CV_64F)
+    laplacian = np.uint8(np.absolute(laplacian))
+
+    # Sobel Combined
+    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+
+    sobel_combined = cv2.magnitude(sobelx, sobely)
+    sobel_combined = np.uint8(sobel_combined)
 
+    # =========================================================
+    # HISTOGRAM
+    # =========================================================
+    hist = cv2.calcHist([gray], [0], None, [256], [0, 256])
+
+    # =========================================================
+    # VISUALIZATION
+    # =========================================================
+    fig, axs = plt.subplots(3, 4, figsize=(18, 12))
+
+    fig.suptitle(
+        "Kernel Matrix & CNN Preprocessing Visualization",
+        fontsize=20,
+        fontweight='bold'
+    )
+
+    # ---------------- ORIGINAL ----------------
     axs[0, 0].imshow(image)
     axs[0, 0].set_title("Original Image")
     axs[0, 0].axis("off")
 
+    # ---------------- GRAYSCALE ----------------
     axs[0, 1].imshow(gray, cmap='gray')
     axs[0, 1].set_title("Grayscale")
     axs[0, 1].axis("off")
 
-    axs[0, 2].imshow(filtered, cmap='gray')
-    axs[0, 2].set_title(f"{kernel_name} Output")
+    # ---------------- GAUSSIAN ----------------
+    axs[0, 2].imshow(gaussian, cmap='gray')
+    axs[0, 2].set_title("Gaussian Blur")
     axs[0, 2].axis("off")
 
+    # ---------------- FILTERED ----------------
+    axs[0, 3].imshow(filtered, cmap='gray')
+    axs[0, 3].set_title(f"{kernel_name} Kernel")
+    axs[0, 3].axis("off")
+
+    # ---------------- EQUALIZED ----------------
     axs[1, 0].imshow(equalized, cmap='gray')
     axs[1, 0].set_title("Histogram Equalization")
     axs[1, 0].axis("off")
 
+    # ---------------- BINARY ----------------
     axs[1, 1].imshow(binary, cmap='gray')
     axs[1, 1].set_title("Binary Threshold")
     axs[1, 1].axis("off")
 
-    axs[1, 2].imshow(canny, cmap='gray')
-    axs[1, 2].set_title("Canny Edge Detection")
+    # ---------------- ADAPTIVE ----------------
+    axs[1, 2].imshow(adaptive, cmap='gray')
+    axs[1, 2].set_title("Adaptive Threshold")
     axs[1, 2].axis("off")
 
+    # ---------------- CANNY ----------------
+    axs[1, 3].imshow(canny, cmap='gray')
+    axs[1, 3].set_title("Canny Edge Detection")
+    axs[1, 3].axis("off")
+
+    # ---------------- SOBEL ----------------
+    axs[2, 0].imshow(sobel_combined, cmap='gray')
+    axs[2, 0].set_title("Sobel Magnitude")
+    axs[2, 0].axis("off")
+
+    # ---------------- LAPLACIAN ----------------
+    axs[2, 1].imshow(laplacian, cmap='gray')
+    axs[2, 1].set_title("Laplacian")
+    axs[2, 1].axis("off")
+
+    # ---------------- HISTOGRAM ----------------
+    axs[2, 2].plot(hist)
+    axs[2, 2].set_title("Pixel Intensity Histogram")
+    axs[2, 2].set_xlim([0, 256])
+
+    # ---------------- KERNEL MATRIX ----------------
+    axs[2, 3].imshow(kernel, cmap='coolwarm')
+
+    axs[2, 3].set_title(f"{kernel_name} Matrix")
+
+    for i in range(kernel.shape[0]):
+        for j in range(kernel.shape[1]):
+            axs[2, 3].text(
+                j,
+                i,
+                str(kernel[i, j]),
+                ha='center',
+                va='center',
+                color='black',
+                fontsize=12,
+                fontweight='bold'
+            )
+
+    axs[2, 3].set_xticks([])
+    axs[2, 3].set_yticks([])
+
     plt.tight_layout()
 
     return fig
 
 
-# -----------------------------
-# GRADIO UI
-# -----------------------------
-demo = gr.Interface(
-    fn=process_image,
-
-    inputs=[
-        gr.Image(type="numpy", label="Upload Image"),
+# =========================================================
+# UI
+# =========================================================
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown(
+        """
+        # 🧠 Kernel Matrix & CNN Visualization Lab
+        
+        Upload an image to visualize:
+        - Convolution Kernels
+        - CNN Preprocessing
+        - Edge Detection
+        - Histogram Equalization
+        - Sobel & Laplacian Features
+        - Thresholding
+        - Feature Extraction
+        
+        Built using OpenCV + Gradio
+        """
+    )
+
+    with gr.Row():
+
+        input_image = gr.Image(
+            type="numpy",
+            label="Upload Image"
+        )
 
-        gr.Dropdown(
+        kernel_dropdown = gr.Dropdown(
             choices=list(kernels.keys()),
             value="Edge Detection",
             label="Select Kernel"
         )
-    ],
-
-    outputs=gr.Plot(label="Visualization"),
-
-    title="Kernel Matrix Visualization for Image Processing",
-
-    description="""
-Upload an image and visualize:
-- Grayscale conversion
-- Convolution kernels
-- Edge detection
-- Thresholding
-- Histogram Equalization
-- CNN-style preprocessing
-"""
-)
+
+    output_plot = gr.Plot(label="Visualization Output")
+
+    # =========================================================
+    # AUTO SUBMIT WHEN IMAGE UPLOADED
+    # =========================================================
+    input_image.change(
+        fn=process_image,
+        inputs=[input_image, kernel_dropdown],
+        outputs=output_plot
+    )
+
+    # =========================================================
+    # AUTO UPDATE WHEN DROPDOWN CHANGES
+    # =========================================================
+    kernel_dropdown.change(
+        fn=process_image,
+        inputs=[input_image, kernel_dropdown],
+        outputs=output_plot
+    )
 
 demo.launch()