Create app.py

app.py

@@ -0,0 +1,643 @@
+import gradio as gr
+import cv2
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+import io
+
+def create_histogram(image, title="Histogram"):
+    """Create histogram for grayscale or RGB image"""
+    fig, ax = plt.subplots(figsize=(8, 4))
+    
+    if len(image.shape) == 2:  # Grayscale
+        hist = cv2.calcHist([image], [0], None, [256], [0, 256])
+        ax.plot(hist, color='black')
+        ax.set_xlim([0, 256])
+        ax.set_xlabel('Pixel Intensity')
+        ax.set_ylabel('Frequency')
+        ax.set_title(title)
+        ax.grid(True, alpha=0.3)
+    else:  # RGB
+        colors = ('r', 'g', 'b')
+        for i, color in enumerate(colors):
+            hist = cv2.calcHist([image], [i], None, [256], [0, 256])
+            ax.plot(hist, color=color, label=color.upper())
+        ax.set_xlim([0, 256])
+        ax.set_xlabel('Pixel Intensity')
+        ax.set_ylabel('Frequency')
+        ax.set_title(title)
+        ax.legend()
+        ax.grid(True, alpha=0.3)
+    
+    # Convert plot to image
+    buf = io.BytesIO()
+    plt.tight_layout()
+    plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
+    buf.seek(0)
+    plot_image = Image.open(buf)
+    plt.close()
+    
+    return np.array(plot_image)
+
+
+def get_pixel_info(image, x, y):
+    """Get detailed pixel information"""
+    if image is None:
+        return "No image loaded"
+    
+    h, w = image.shape[:2]
+    if x < 0 or x >= w or y < 0 or y >= h:
+        return "Click within image bounds"
+    
+    if len(image.shape) == 2:  # Grayscale
+        pixel_value = image[y, x]
+        info = f"""
+**Pixel Information at ({x}, {y})**
+- **Gray Value**: {pixel_value}
+- **Image Size**: {w} x {h}
+"""
+    else:  # RGB
+        b, g, r = image[y, x]
+        info = f"""
+**Pixel Information at ({x}, {y})**
+- **RGB**: ({r}, {g}, {b})
+- **Hex**: #{r:02x}{g:02x}{b:02x}
+- **Image Size**: {w} x {h}
+"""
+    return info
+
+
+def apply_clahe(image, clip_limit, tile_size):
+    """Apply CLAHE with adjustable parameters"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Convert to grayscale if RGB
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+    
+    # Apply CLAHE
+    clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(tile_size, tile_size))
+    result = clahe.apply(gray)
+    
+    # Create histograms
+    hist_before = create_histogram(gray, "Histogram - Before CLAHE")
+    hist_after = create_histogram(result, "Histogram - After CLAHE")
+    
+    # Convert back to RGB for display
+    result_rgb = cv2.cvtColor(result, cv2.COLOR_GRAY2RGB)
+    gray_rgb = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
+    
+    info = f"""
+### CLAHE Applied
+- **Clip Limit**: {clip_limit}
+- **Tile Size**: {tile_size}x{tile_size}
+- **Effect**: Enhances local contrast by equalizing histograms in small tiles
+- **Use Case**: Improves visibility in shadowed or low-contrast regions
+"""
+    
+    return result_rgb, hist_before, hist_after, info
+
+
+def apply_gaussian_blur(image, kernel_size, sigma):
+    """Apply Gaussian blur with adjustable parameters"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Ensure kernel size is odd
+    if kernel_size % 2 == 0:
+        kernel_size += 1
+    
+    result = cv2.GaussianBlur(image, (kernel_size, kernel_size), sigma)
+    
+    info = f"""
+### Gaussian Blur Applied
+- **Kernel Size**: {kernel_size}x{kernel_size}
+- **Sigma**: {sigma}
+- **Effect**: Smooths image by averaging pixels with Gaussian weights
+- **Use Case**: Noise reduction, preparing for edge detection
+"""
+    
+    return result, info
+
+
+def apply_bilateral_filter(image, diameter, sigma_color, sigma_space):
+    """Apply bilateral filter with adjustable parameters"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Convert to grayscale for processing
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+    
+    result = cv2.bilateralFilter(gray, diameter, sigma_color, sigma_space)
+    
+    # Convert back to RGB
+    result_rgb = cv2.cvtColor(result, cv2.COLOR_GRAY2RGB)
+    
+    info = f"""
+### Bilateral Filter Applied
+- **Diameter**: {diameter}
+- **Sigma Color**: {sigma_color}
+- **Sigma Space**: {sigma_space}
+- **Effect**: Edge-preserving smoothing filter
+- **Use Case**: Noise reduction while keeping edges sharp
+"""
+    
+    return result_rgb, info
+
+
+def apply_median_filter(image, kernel_size):
+    """Apply median filter"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Ensure kernel size is odd
+    if kernel_size % 2 == 0:
+        kernel_size += 1
+    
+    result = cv2.medianBlur(image, kernel_size)
+    
+    info = f"""
+### Median Filter Applied
+- **Kernel Size**: {kernel_size}x{kernel_size}
+- **Effect**: Replaces each pixel with median of surrounding pixels
+- **Use Case**: Excellent for removing salt-and-pepper noise
+"""
+    
+    return result, info
+
+
+def apply_morphology(image, operation, kernel_size, iterations):
+    """Apply morphological operations"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Convert to grayscale
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+    
+    # Create kernel
+    kernel = np.ones((kernel_size, kernel_size), np.uint8)
+    
+    # Apply operation
+    if operation == "Erosion":
+        result = cv2.erode(gray, kernel, iterations=iterations)
+        desc = "Shrinks white regions, removes small white noise"
+    elif operation == "Dilation":
+        result = cv2.dilate(gray, kernel, iterations=iterations)
+        desc = "Expands white regions, fills small holes"
+    elif operation == "Opening":
+        result = cv2.morphologyEx(gray, cv2.MORPH_OPEN, kernel, iterations=iterations)
+        desc = "Erosion followed by dilation, removes small white noise"
+    elif operation == "Closing":
+        result = cv2.morphologyEx(gray, cv2.MORPH_CLOSE, kernel, iterations=iterations)
+        desc = "Dilation followed by erosion, fills small holes"
+    elif operation == "Gradient":
+        result = cv2.morphologyEx(gray, cv2.MORPH_GRADIENT, kernel)
+        desc = "Difference between dilation and erosion, shows outlines"
+    else:
+        result = gray
+        desc = "No operation"
+    
+    # Convert back to RGB
+    result_rgb = cv2.cvtColor(result, cv2.COLOR_GRAY2RGB)
+    
+    info = f"""
+### Morphological Operation: {operation}
+- **Kernel Size**: {kernel_size}x{kernel_size}
+- **Iterations**: {iterations}
+- **Effect**: {desc}
+"""
+    
+    return result_rgb, info
+
+
+def apply_edge_detection(image, method, threshold1, threshold2):
+    """Apply edge detection methods"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Convert to grayscale
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+    
+    if method == "Canny":
+        edges = cv2.Canny(gray, threshold1, threshold2)
+        desc = "Multi-stage edge detection algorithm"
+    elif method == "Sobel":
+        sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=5)
+        sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=5)
+        edges = np.sqrt(sobelx**2 + sobely**2)
+        edges = np.uint8(edges / edges.max() * 255)
+        desc = "Gradient-based edge detection"
+    elif method == "Laplacian":
+        edges = cv2.Laplacian(gray, cv2.CV_64F)
+        edges = np.uint8(np.abs(edges))
+        desc = "Second derivative edge detection"
+    else:
+        edges = gray
+        desc = "No operation"
+    
+    # Convert to RGB
+    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
+    
+    info = f"""
+### Edge Detection: {method}
+- **Method**: {desc}
+- **Threshold 1**: {threshold1}
+- **Threshold 2**: {threshold2}
+"""
+    
+    return edges_rgb, info
+
+
+def apply_color_space(image, color_space):
+    """Convert to different color spaces"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    if color_space == "RGB":
+        result = image
+        desc = "Standard Red-Green-Blue color space"
+    elif color_space == "HSV":
+        result = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+        desc = "Hue-Saturation-Value: Separates color from intensity"
+    elif color_space == "LAB":
+        result = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+        desc = "Perceptually uniform color space"
+    elif color_space == "Grayscale":
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        result = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
+        desc = "Single channel intensity image"
+    elif color_space == "YCrCb":
+        result = cv2.cvtColor(image, cv2.COLOR_RGB2YCrCb)
+        desc = "Luma and chroma components"
+    else:
+        result = image
+        desc = "No conversion"
+    
+    # Create histogram
+    hist = create_histogram(result if color_space != "Grayscale" else gray, f"Histogram - {color_space}")
+    
+    info = f"""
+### Color Space: {color_space}
+- **Description**: {desc}
+"""
+    
+    return result, hist, info
+
+
+def apply_thresholding(image, method, threshold_value, max_value):
+    """Apply different thresholding methods"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Convert to grayscale
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+    
+    if method == "Binary":
+        _, result = cv2.threshold(gray, threshold_value, max_value, cv2.THRESH_BINARY)
+        desc = "Pixels > threshold become max_value, others become 0"
+    elif method == "Binary Inverse":
+        _, result = cv2.threshold(gray, threshold_value, max_value, cv2.THRESH_BINARY_INV)
+        desc = "Inverse of binary threshold"
+    elif method == "Truncate":
+        _, result = cv2.threshold(gray, threshold_value, max_value, cv2.THRESH_TRUNC)
+        desc = "Pixels > threshold become threshold value"
+    elif method == "To Zero":
+        _, result = cv2.threshold(gray, threshold_value, max_value, cv2.THRESH_TOZERO)
+        desc = "Pixels < threshold become 0"
+    elif method == "Otsu":
+        _, result = cv2.threshold(gray, 0, max_value, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        desc = "Automatic threshold calculation using Otsu's method"
+    elif method == "Adaptive Mean":
+        result = cv2.adaptiveThreshold(gray, max_value, cv2.ADAPTIVE_THRESH_MEAN_C, 
+                                      cv2.THRESH_BINARY, 11, 2)
+        desc = "Threshold calculated for small regions using mean"
+    elif method == "Adaptive Gaussian":
+        result = cv2.adaptiveThreshold(gray, max_value, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                      cv2.THRESH_BINARY, 11, 2)
+        desc = "Threshold calculated for small regions using Gaussian weights"
+    else:
+        result = gray
+        desc = "No thresholding"
+    
+    # Convert to RGB
+    result_rgb = cv2.cvtColor(result, cv2.COLOR_GRAY2RGB)
+    
+    info = f"""
+### Thresholding: {method}
+- **Threshold Value**: {threshold_value}
+- **Max Value**: {max_value}
+- **Effect**: {desc}
+"""
+    
+    return result_rgb, info
+
+
+def analyze_image_stats(image):
+    """Provide detailed statistical analysis"""
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        channels = cv2.split(image)
+        
+        stats = f"""
+### Image Statistics
+
+**Dimensions**: {image.shape[1]} x {image.shape[0]} pixels
+
+**RGB Channel Statistics**:
+- **Red**: Mean={np.mean(channels[0]):.2f}, Std={np.std(channels[0]):.2f}, Min={np.min(channels[0])}, Max={np.max(channels[0])}
+- **Green**: Mean={np.mean(channels[1]):.2f}, Std={np.std(channels[1]):.2f}, Min={np.min(channels[1])}, Max={np.max(channels[1])}
+- **Blue**: Mean={np.mean(channels[2]):.2f}, Std={np.std(channels[2]):.2f}, Min={np.min(channels[2])}, Max={np.max(channels[2])}
+
+**Grayscale Statistics**:
+- **Mean Intensity**: {np.mean(gray):.2f}
+- **Standard Deviation**: {np.std(gray):.2f}
+- **Min Value**: {np.min(gray)}
+- **Max Value**: {np.max(gray)}
+- **Median**: {np.median(gray):.2f}
+
+**Brightness Assessment**: {"Dark" if np.mean(gray) < 85 else "Medium" if np.mean(gray) < 170 else "Bright"}
+**Contrast Assessment**: {"Low" if np.std(gray) < 30 else "Medium" if np.std(gray) < 60 else "High"}
+"""
+    else:
+        stats = f"""
+### Image Statistics
+
+**Dimensions**: {image.shape[1]} x {image.shape[0]} pixels
+
+**Grayscale Statistics**:
+- **Mean Intensity**: {np.mean(image):.2f}
+- **Standard Deviation**: {np.std(image):.2f}
+- **Min Value**: {np.min(image)}
+- **Max Value**: {np.max(image)}
+- **Median**: {np.median(image):.2f}
+
+**Brightness Assessment**: {"Dark" if np.mean(image) < 85 else "Medium" if np.mean(image) < 170 else "Bright"}
+**Contrast Assessment**: {"Low" if np.std(image) < 30 else "Medium" if np.std(image) < 60 else "High"}
+"""
+    
+    return stats
+
+
+# Create Gradio Interface
+with gr.Blocks(title="Image Preprocessing Analyzer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🔬 Image Preprocessing Analyzer
+    ### Understand Image Processing at Pixel Level
+    
+    Upload an image and explore various preprocessing techniques with real-time parameter adjustments.
+    See histograms, pixel-level information, and understand how each filter affects your image.
+    """)
+    
+    with gr.Row():
+        input_image = gr.Image(label="Upload Image", type="pil", height=400)
+        original_hist = gr.Image(label="Original Histogram")
+    
+    with gr.Row():
+        stats_output = gr.Markdown(label="Image Statistics")
+    
+    # Update stats when image is loaded
+    input_image.change(
+        fn=lambda img: (analyze_image_stats(img), create_histogram(np.array(img), "Original Histogram")) if img else ("No image", None),
+        inputs=[input_image],
+        outputs=[stats_output, original_hist]
+    )
+    
+    with gr.Tabs():
+        # CLAHE Tab
+        with gr.TabItem("🎨 CLAHE (Contrast Enhancement)"):
+            gr.Markdown("""
+            **CLAHE** (Contrast Limited Adaptive Histogram Equalization) enhances local contrast.
+            Adjust parameters to see how it affects different image regions.
+            """)
+            
+            with gr.Row():
+                clahe_clip = gr.Slider(0.5, 10.0, value=2.0, step=0.5, label="Clip Limit")
+                clahe_tile = gr.Slider(2, 32, value=8, step=2, label="Tile Size")
+            
+            clahe_btn = gr.Button("Apply CLAHE", variant="primary")
+            
+            with gr.Row():
+                clahe_output = gr.Image(label="Result")
+                clahe_hist_before = gr.Image(label="Histogram - Before")
+            
+            with gr.Row():
+                clahe_hist_after = gr.Image(label="Histogram - After")
+                clahe_info = gr.Markdown()
+            
+            clahe_btn.click(
+                fn=apply_clahe,
+                inputs=[input_image, clahe_clip, clahe_tile],
+                outputs=[clahe_output, clahe_hist_before, clahe_hist_after, clahe_info]
+            )
+        
+        # Smoothing Filters Tab
+        with gr.TabItem("🌊 Smoothing Filters"):
+            filter_type = gr.Radio(
+                ["Gaussian Blur", "Bilateral Filter", "Median Filter"],
+                value="Gaussian Blur",
+                label="Filter Type"
+            )
+            
+            with gr.Row():
+                with gr.Column():
+                    # Gaussian parameters
+                    gauss_kernel = gr.Slider(1, 31, value=5, step=2, label="Kernel Size (Gaussian)")
+                    gauss_sigma = gr.Slider(0, 10, value=0, step=0.5, label="Sigma (Gaussian)")
+                
+                with gr.Column():
+                    # Bilateral parameters
+                    bilat_diameter = gr.Slider(1, 15, value=9, step=2, label="Diameter (Bilateral)")
+                    bilat_sigma_color = gr.Slider(1, 150, value=75, step=5, label="Sigma Color (Bilateral)")
+                    bilat_sigma_space = gr.Slider(1, 150, value=75, step=5, label="Sigma Space (Bilateral)")
+                
+                with gr.Column():
+                    # Median parameters
+                    median_kernel = gr.Slider(1, 31, value=5, step=2, label="Kernel Size (Median)")
+            
+            smooth_btn = gr.Button("Apply Filter", variant="primary")
+            
+            with gr.Row():
+                smooth_output = gr.Image(label="Result")
+                smooth_info = gr.Markdown()
+            
+            def apply_smoothing(image, filter_type, gk, gs, bd, bsc, bss, mk):
+                if filter_type == "Gaussian Blur":
+                    return apply_gaussian_blur(image, gk, gs)
+                elif filter_type == "Bilateral Filter":
+                    return apply_bilateral_filter(image, bd, bsc, bss)
+                else:
+                    return apply_median_filter(image, mk)
+            
+            smooth_btn.click(
+                fn=apply_smoothing,
+                inputs=[input_image, filter_type, gauss_kernel, gauss_sigma, 
+                       bilat_diameter, bilat_sigma_color, bilat_sigma_space, median_kernel],
+                outputs=[smooth_output, smooth_info]
+            )
+        
+        # Edge Detection Tab
+        with gr.TabItem("📐 Edge Detection"):
+            edge_method = gr.Radio(
+                ["Canny", "Sobel", "Laplacian"],
+                value="Canny",
+                label="Edge Detection Method"
+            )
+            
+            with gr.Row():
+                edge_thresh1 = gr.Slider(0, 255, value=50, step=5, label="Threshold 1")
+                edge_thresh2 = gr.Slider(0, 255, value=150, step=5, label="Threshold 2")
+            
+            edge_btn = gr.Button("Detect Edges", variant="primary")
+            
+            with gr.Row():
+                edge_output = gr.Image(label="Result")
+                edge_info = gr.Markdown()
+            
+            edge_btn.click(
+                fn=apply_edge_detection,
+                inputs=[input_image, edge_method, edge_thresh1, edge_thresh2],
+                outputs=[edge_output, edge_info]
+            )
+        
+        # Morphological Operations Tab
+        with gr.TabItem("🔲 Morphological Operations"):
+            morph_op = gr.Radio(
+                ["Erosion", "Dilation", "Opening", "Closing", "Gradient"],
+                value="Closing",
+                label="Operation"
+            )
+            
+            with gr.Row():
+                morph_kernel = gr.Slider(1, 21, value=3, step=2, label="Kernel Size")
+                morph_iter = gr.Slider(1, 5, value=1, step=1, label="Iterations")
+            
+            morph_btn = gr.Button("Apply Operation", variant="primary")
+            
+            with gr.Row():
+                morph_output = gr.Image(label="Result")
+                morph_info = gr.Markdown()
+            
+            morph_btn.click(
+                fn=apply_morphology,
+                inputs=[input_image, morph_op, morph_kernel, morph_iter],
+                outputs=[morph_output, morph_info]
+            )
+        
+        # Color Spaces Tab
+        with gr.TabItem("🎨 Color Spaces"):
+            color_space = gr.Radio(
+                ["RGB", "HSV", "LAB", "YCrCb", "Grayscale"],
+                value="RGB",
+                label="Color Space"
+            )
+            
+            color_btn = gr.Button("Convert Color Space", variant="primary")
+            
+            with gr.Row():
+                color_output = gr.Image(label="Result")
+                color_hist = gr.Image(label="Histogram")
+            
+            color_info = gr.Markdown()
+            
+            color_btn.click(
+                fn=apply_color_space,
+                inputs=[input_image, color_space],
+                outputs=[color_output, color_hist, color_info]
+            )
+        
+        # Thresholding Tab
+        with gr.TabItem("⚫⚪ Thresholding"):
+            thresh_method = gr.Radio(
+                ["Binary", "Binary Inverse", "Truncate", "To Zero", "Otsu", 
+                 "Adaptive Mean", "Adaptive Gaussian"],
+                value="Binary",
+                label="Thresholding Method"
+            )
+            
+            with gr.Row():
+                thresh_value = gr.Slider(0, 255, value=127, step=1, label="Threshold Value")
+                thresh_max = gr.Slider(0, 255, value=255, step=1, label="Max Value")
+            
+            thresh_btn = gr.Button("Apply Threshold", variant="primary")
+            
+            with gr.Row():
+                thresh_output = gr.Image(label="Result")
+                thresh_info = gr.Markdown()
+            
+            thresh_btn.click(
+                fn=apply_thresholding,
+                inputs=[input_image, thresh_method, thresh_value, thresh_max],
+                outputs=[thresh_output, thresh_info]
+            )
+    
+    # Documentation
+    with gr.Accordion("📚 Filter Documentation", open=False):
+        gr.Markdown("""
+        ### Filter Explanations
+        
+        #### CLAHE (Contrast Limited Adaptive Histogram Equalization)
+        - **Purpose**: Enhance local contrast in images
+        - **How it works**: Divides image into tiles and equalizes histogram in each tile
+        - **Clip Limit**: Controls contrast enhancement (higher = more enhancement)
+        - **Tile Size**: Size of local regions (smaller = more local adaptation)
+        - **Use Case**: Medical imaging, underwater images, shadowed regions
+        
+        #### Gaussian Blur
+        - **Purpose**: Smooth images and reduce noise
+        - **How it works**: Weighted average of neighboring pixels using Gaussian function
+        - **Kernel Size**: Larger = more blur
+        - **Sigma**: Standard deviation of Gaussian (0 = auto-calculated)
+        - **Use Case**: Preprocessing for edge detection, noise reduction
+        
+        #### Bilateral Filter
+        - **Purpose**: Edge-preserving smoothing
+        - **How it works**: Averages pixels but preserves edges by considering both spatial and color distance
+        - **Diameter**: Size of pixel neighborhood
+        - **Sigma Color**: How much color difference matters
+        - **Sigma Space**: How much spatial distance matters
+        - **Use Case**: Noise reduction while keeping edges sharp
+        
+        #### Median Filter
+        - **Purpose**: Remove salt-and-pepper noise
+        - **How it works**: Replaces each pixel with median of surrounding pixels
+        - **Kernel Size**: Size of neighborhood
+        - **Use Case**: Impulse noise removal
+        
+        #### Morphological Operations
+        - **Erosion**: Shrinks white regions, removes small noise
+        - **Dilation**: Expands white regions, fills small holes
+        - **Opening**: Erosion then dilation, removes small objects
+        - **Closing**: Dilation then erosion, fills small holes
+        - **Gradient**: Difference between dilation and erosion, shows boundaries
+        
+        #### Edge Detection
+        - **Canny**: Multi-stage algorithm, best overall edge detector
+        - **Sobel**: Gradient-based, sensitive to horizontal/vertical edges
+        - **Laplacian**: Second derivative, sensitive to rapid intensity changes
+        
+        #### Thresholding
+        - **Binary**: Simple cutoff threshold
+        - **Otsu**: Automatically finds optimal threshold
+        - **Adaptive**: Different thresholds for different regions
+        """)
+
+if __name__ == "__main__":
+    demo.launch()