Update app.py

app.py

@@ -4,83 +4,62 @@ import numpy as np
 import io
 import tempfile
 import vtracer
-from skimage import color, filters
-from skimage.feature import canny
-from skimage.measure import shannon_entropy
+from skimage import color, filters, feature, morphology
+import cv2
 
-def analyze_image_and_update_settings(image):
-    """Automatically adjust settings based on image analysis."""
-    # Convert image to grayscale for analysis
+def preprocess_image(image, blur_radius, edge_enhance, edge_threshold, detail_level):
+    """Preprocess the image with advanced options before vectorization."""
+    
+    if blur_radius > 0:
+        image = image.filter(ImageFilter.GaussianBlur(blur_radius))
+    
+    # Convert to grayscale for edge detection
     gray_image = np.array(image.convert('L'))
+    
+    # Detail level settings
+    if detail_level == 'Very Low':
+        sigma = 3.0
+        morphology_size = 5
+    elif detail_level == 'Low':
+        sigma = 2.0
+        morphology_size = 4
+    elif detail_level == 'Medium':
+        sigma = 1.5
+        morphology_size = 3
+    elif detail_level == 'High':
+        sigma = 1.0
+        morphology_size = 2
+    else:  # Ultra
+        sigma = 0.5
+        morphology_size = 1
+    
+    if edge_enhance:
+        # Canny edge detection
+        edges = feature.canny(gray_image, sigma=sigma, low_threshold=edge_threshold)
+        
+        # Morphological operations to refine edges
+        edges = morphology.dilation(edges, morphology.square(morphology_size))
+        edges_img = Image.fromarray((edges * 255).astype(np.uint8))
+        
+        # Blend the edges with the original image
+        image = Image.blend(image.convert('RGB'), edges_img.convert('RGB'), alpha=0.5)
 
-    # Calculate basic metrics
-    entropy = shannon_entropy(gray_image)
-    edges = canny(gray_image, sigma=1.0).mean()  # Mean edge intensity
-
-    # Adjust parameters based on metrics
-    if entropy > 5.0:
-        color_mode = "Color"
-        blur_radius = 0
-        edge_enhance = True
-        edge_threshold = 2.0
-    else:
-        color_mode = "Binary"
-        blur_radius = 2
-        edge_enhance = False
-        edge_threshold = 1.0
-
-    hierarchical = "Stacked" if edges > 0.1 else "Cutout"
-    mode = "Spline" if edges > 0.15 else "Polygon"
-
-    filter_speckle = int(5 if edges > 0.12 else 15)
-    color_precision = int(8 if entropy > 4.5 else 10)
-    layer_difference = int(12 if edges > 0.2 else 20)
-    corner_threshold = int(60 if edges > 0.12 else 75)
-    length_threshold = float(5.0 if edges > 0.15 else 10.0)
-    max_iterations = int(15 if entropy > 4.5 else 10)
-    splice_threshold = int(50 if entropy > 4.0 else 70)
-    path_precision = int(10 if edges > 0.15 else 5)
-
-    return {
-        "blur_radius": blur_radius,
-        "edge_enhance": edge_enhance,
-        "edge_threshold": edge_threshold,
-        "color_mode": color_mode,
-        "hierarchical": hierarchical,
-        "mode": mode,
-        "filter_speckle": filter_speckle,
-        "color_precision": color_precision,
-        "layer_difference": layer_difference,
-        "corner_threshold": corner_threshold,
-        "length_threshold": length_threshold,
-        "max_iterations": max_iterations,
-        "splice_threshold": splice_threshold,
-        "path_precision": path_precision
-    }
-
-def update_settings_live(image):
-    """Update settings live based on image analysis."""
-    settings = analyze_image_and_update_settings(image)
-    return (settings["blur_radius"], settings["edge_enhance"], settings["edge_threshold"], 
-            settings["color_mode"], settings["hierarchical"], settings["mode"], 
-            settings["filter_speckle"], settings["color_precision"], settings["layer_difference"], 
-            settings["corner_threshold"], settings["length_threshold"], settings["max_iterations"], 
-            settings["splice_threshold"], settings["path_precision"])
-
-def convert_image(image, blur_radius, edge_enhance, edge_threshold, color_mode, hierarchical, mode, 
-                  filter_speckle, color_precision, layer_difference, corner_threshold, length_threshold,
-                  max_iterations, splice_threshold, path_precision):
-    """Converts an image to SVG using vtracer with customizable parameters."""
-
-    # Preprocess the image
-    image = preprocess_image(image, blur_radius, edge_enhance, edge_threshold)
+    return image
 
+def convert_image(image, blur_radius, edge_enhance, edge_threshold, detail_level, color_mode, 
+                  hierarchical, mode, filter_speckle, color_precision, layer_difference, 
+                  corner_threshold, length_threshold, max_iterations, splice_threshold, path_precision):
+    """Convert an image to SVG using vtracer with customizable and advanced parameters."""
+    
+    # Preprocess the image with additional detail level settings
+    image = preprocess_image(image, blur_radius, edge_enhance, edge_threshold, detail_level)
+    
     # Convert Gradio image to bytes for vtracer compatibility
     img_byte_array = io.BytesIO()
     image.save(img_byte_array, format='PNG')
     img_bytes = img_byte_array.getvalue()
-
-    # Perform the conversion with advanced settings
+    
+    # Perform the conversion
     svg_str = vtracer.convert_raw_image_to_svg(
         img_bytes,
         img_format='png',
@@ -96,86 +75,60 @@ def convert_image(image, blur_radius, edge_enhance, edge_threshold, color_mode,
         splice_threshold=int(splice_threshold),
         path_precision=int(path_precision)
     )
-
+    
     # Save the SVG string to a temporary file
     temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.svg')
     temp_file.write(svg_str.encode('utf-8'))
     temp_file.close()
-
+    
     # Display the SVG in the Gradio interface and provide the download link
     svg_html = f'<svg viewBox="0 0 {image.width} {image.height}">{svg_str}</svg>'
     return gr.HTML(svg_html), temp_file.name
 
-def preprocess_image(image, blur_radius, edge_enhance, edge_threshold):
-    """Applies advanced preprocessing steps to the image before tracing."""
-    if blur_radius > 0:
-        image = image.filter(ImageFilter.GaussianBlur(blur_radius))
-
-    if edge_enhance:
-        # Convert image to grayscale and apply edge detection
-        gray_image = np.array(image.convert('L'))
-        edges = canny(gray_image, sigma=edge_threshold)
-        edges_img = Image.fromarray((edges * 255).astype(np.uint8))
-        image = Image.blend(image.convert('RGB'), edges_img.convert('RGB'), alpha=0.5)
-
-    return image
-
 # Gradio interface
 iface = gr.Blocks()
 
 with iface:
-    gr.Markdown("# Advanced Image to SVG Conversion with Live Auto-Settings")
-    gr.Markdown("Upload an image and watch as the settings are automatically adjusted for the best output.")
-
+    gr.Markdown("# Advanced Image to SVG Converter")
+    gr.Markdown("Upload an image and customize the conversion parameters for high-quality vector results. This tool provides advanced options to analyze and vectorize images at a pixel level with various detail settings.")
+    
     with gr.Row():
         image_input = gr.Image(type="pil", label="Upload Image")
-        auto_settings_input = gr.Checkbox(value=False, label="Auto Settings")
-
-    blur_radius_input = gr.Slider(minimum=0, maximum=10, value=0, step=0.5, label="Blur Radius (for smoothing)")
-    edge_enhance_input = gr.Checkbox(value=False, label="AI Edge Enhance")
-    edge_threshold_input = gr.Slider(minimum=0.1, maximum=3.0, value=1.0, step=0.1, label="Edge Detection Threshold")
-    color_mode_input = gr.Radio(choices=["Color", "Binary"], value="Color", label="Color Mode")
-    hierarchical_input = gr.Radio(choices=["Stacked", "Cutout"], value="Stacked", label="Hierarchical")
-    mode_input = gr.Radio(choices=["Spline", "Polygon", "None"], value="Spline", label="Mode")
-    filter_speckle_input = gr.Slider(minimum=1, maximum=100, value=4, step=1, label="Filter Speckle")
-    color_precision_input = gr.Slider(minimum=1, maximum=100, value=6, step=1, label="Color Precision")
-    layer_difference_input = gr.Slider(minimum=1, maximum=100, value=16, step=1, label="Layer Difference")
-    corner_threshold_input = gr.Slider(minimum=1, maximum=100, value=60, step=1, label="Corner Threshold")
-    length_threshold_input = gr.Slider(minimum=1, maximum=100, value=4.0, step=0.5, label="Length Threshold")
-    max_iterations_input = gr.Slider(minimum=1, maximum=100, value=10, step=1, label="Max Iterations")
-    splice_threshold_input = gr.Slider(minimum=1, maximum=100, value=45, step=1, label="Splice Threshold")
-    path_precision_input = gr.Slider(minimum=1, maximum=100, value=8, step=1, label="Path Precision")
-
-    def auto_update(image, auto_settings):
-        if auto_settings:
-            return update_settings_live(image)
-        else:
-            return (gr.Slider.update(), gr.Checkbox.update(), gr.Slider.update(), gr.Radio.update(), 
-                    gr.Radio.update(), gr.Radio.update(), gr.Slider.update(), gr.Slider.update(), 
-                    gr.Slider.update(), gr.Slider.update(), gr.Slider.update(), gr.Slider.update(), 
-                    gr.Slider.update(), gr.Slider.update())
-
-    auto_settings_input.change(
-        fn=auto_update,
-        inputs=[image_input, auto_settings_input],
-        outputs=[
-            blur_radius_input, edge_enhance_input, edge_threshold_input, color_mode_input, hierarchical_input, 
-            mode_input, filter_speckle_input, color_precision_input, layer_difference_input, corner_threshold_input,
-            length_threshold_input, max_iterations_input, splice_threshold_input, path_precision_input
-        ]
-    )
-
+        blur_radius_input = gr.Slider(minimum=0, maximum=10, value=0, step=0.5, label="Blur Radius (for smoothing)")
+        edge_enhance_input = gr.Checkbox(value=False, label="AI Edge Enhance")
+        edge_threshold_input = gr.Slider(minimum=0.1, maximum=3.0, value=1.0, step=0.1, label="Edge Detection Threshold")
+        detail_level_input = gr.Radio(choices=["Very Low", "Low", "Medium", "High", "Ultra"], value="Medium", label="Detail Level")
+    
+    with gr.Row():
+        color_mode_input = gr.Radio(choices=["Color", "Binary"], value="Color", label="Color Mode")
+        hierarchical_input = gr.Radio(choices=["Stacked", "Cutout"], value="Stacked", label="Hierarchical")
+        mode_input = gr.Radio(choices=["Spline", "Polygon", "None"], value="Spline", label="Mode")
+    
+    with gr.Row():
+        filter_speckle_input = gr.Slider(minimum=1, maximum=100, value=4, step=1, label="Filter Speckle")
+        color_precision_input = gr.Slider(minimum=1, maximum=100, value=6, step=1, label="Color Precision")
+        layer_difference_input = gr.Slider(minimum=1, maximum=100, value=16, step=1, label="Layer Difference")
+    
+    with gr.Row():
+        corner_threshold_input = gr.Slider(minimum=1, maximum=100, value=60, step=1, label="Corner Threshold")
+        length_threshold_input = gr.Slider(minimum=1, maximum=100, value=4.0, step=0.5, label="Length Threshold")
+        max_iterations_input = gr.Slider(minimum=1, maximum=100, value=10, step=1, label="Max Iterations")
+    
+    with gr.Row():
+        splice_threshold_input = gr.Slider(minimum=1, maximum=100, value=45, step=1, label="Splice Threshold")
+        path_precision_input = gr.Slider(minimum=1, maximum=100, value=8, step=1, label="Path Precision")
+    
     convert_button = gr.Button("Convert Image to SVG")
     svg_output = gr.HTML(label="SVG Output")
     download_output = gr.File(label="Download SVG")
-
+    
     convert_button.click(
         fn=convert_image,
         inputs=[
-            image_input, blur_radius_input, edge_enhance_input, edge_threshold_input, color_mode_input, 
-            hierarchical_input, mode_input, filter_speckle_input, color_precision_input, layer_difference_input, 
-            corner_threshold_input, length_threshold_input, max_iterations_input, splice_threshold_input, 
-            path_precision_input
+            image_input, blur_radius_input, edge_enhance_input, edge_threshold_input, detail_level_input,
+            color_mode_input, hierarchical_input, mode_input, filter_speckle_input, color_precision_input,
+            layer_difference_input, corner_threshold_input, length_threshold_input, max_iterations_input,
+            splice_threshold_input, path_precision_input
         ],
         outputs=[svg_output, download_output]
     )