minor algorithm changes

app.py

@@ -2,62 +2,42 @@ import cv2
 import numpy as np
 import gradio as gr
 
-def extract_outline(image, blur_level, block_size, c_value):
+def extract_outline(image):
     # Convert to grayscale
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
-    # Adjust Gaussian blur kernel size based on blur level
-    blur_kernel_size = (5 + (blur_level * 2), 5 + (blur_level * 2))  # Adjust kernel size for blur
+    # Set default Gaussian blur kernel size
+    blur_kernel_size = (5, 5)
     blurred = cv2.GaussianBlur(gray, blur_kernel_size, 0)
 
-    # Use adaptive thresholding with specified block size and constant
-    binary = cv2.adaptiveThreshold(blurred, 255, 
-                                   cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-                                   cv2.THRESH_BINARY_INV, 
-                                   blockSize=max(block_size, 3) | 1,  # Ensure block size is odd
-                                   C=c_value)
+    # Set default Canny edge detection thresholds
+    lower_threshold = 50
+    upper_threshold = 150
+    edges = cv2.Canny(blurred, lower_threshold, upper_threshold)
 
-    # Dilate the binary image to enhance primary structure
+    # Morphological operations to close gaps
     kernel = np.ones((3, 3), np.uint8)
-    dilated = cv2.dilate(binary, kernel, iterations=1)
+    closed_edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
 
     # Apply morphological thinning to get single-pixel-wide lines
-    thinned = cv2.ximgproc.thinning(dilated)
+    thinned = cv2.ximgproc.thinning(closed_edges)
 
-    # Invert colors to get a white background and black outline
+    # Invert colors for white background and black outline
     skeleton_on_white = cv2.bitwise_not(thinned)
 
     return skeleton_on_white
 
 # Define the Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## Basic Structure Outline Extractor")
-    gr.Markdown("Upload an image and adjust the sliders to control the amount of detail captured in the outline.")
+    gr.Markdown("## Basic Outline Extractor")
+    gr.Markdown("Upload an image to extract its outline with default settings.")
 
     with gr.Row():
         image_input = gr.Image(type="numpy", label="Input Image")
-        
-        with gr.Column():
-            blur_slider = gr.Slider(
-                minimum=0, maximum=5, value=2, step=1,
-                label="Gaussian Blur Level",
-                info="Higher values apply more blur to the image."
-            )
-            block_size_slider = gr.Slider(
-                minimum=3, maximum=21, value=11, step=2,
-                label="Adaptive Threshold Block Size",
-                info="Odd values control the size of the blocks for thresholding."
-            )
-            c_value_slider = gr.Slider(
-                minimum=0, maximum=20, value=5, step=1,
-                label="Adaptive Threshold Constant (C)",
-                info="Adjust the constant subtracted from the mean in adaptive thresholding."
-            )
-    
-    output_image = gr.Image(type="numpy", label="Output Outline Image")
-    
+        output_image = gr.Image(type="numpy", label="Output Outline Image")
+
     process_button = gr.Button("Generate Outline")
-    process_button.click(fn=extract_outline, inputs=[image_input, blur_slider, block_size_slider, c_value_slider], outputs=output_image)
+    process_button.click(fn=extract_outline, inputs=image_input, outputs=output_image)
 
 # Launch the Gradio app
 demo.launch()