Update app.py

app.py

@@ -81,43 +81,29 @@ def apply_pixelate(img_np):
     temp = cv2.resize(img_np, (w // pixel_size, h // pixel_size), interpolation=cv2.INTER_NEAREST)
     return cv2.resize(temp, (w, h), interpolation=cv2.INTER_NEAREST)
 
-# --- New Advanced Filters ---
+# --- Advanced Filters ---
 
 def apply_hdr_effect(img_np):
     """Simulates an HDR effect by enhancing details."""
     if img_np is None: return None
-    # Using cv2.detailEnhance for a quick and effective HDR-like look
     return cv2.detailEnhance(img_np, sigma_s=12, sigma_r=0.15)
 
 def apply_color_splash(img_np, hex_color):
     """Keeps a selected color and converts the rest of the image to grayscale."""
     if img_np is None: return None
-    # Convert hex to RGB
     h = hex_color.lstrip('#')
     rgb_color = tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
-    
-    # Convert image and color to HSV
     hsv_img = cv2.cvtColor(img_np, cv2.COLOR_RGB2HSV)
     hsv_color = cv2.cvtColor(np.uint8([[rgb_color]]), cv2.COLOR_RGB2HSV)[0][0]
-
-    # Define a color range in HSV. Hue tolerance is important.
     hue_tolerance = 10
     lower_bound = np.array([max(0, hsv_color[0] - hue_tolerance), 50, 50])
     upper_bound = np.array([min(179, hsv_color[0] + hue_tolerance), 255, 255])
-    
-    # Create the mask and its inverse
     mask = cv2.inRange(hsv_img, lower_bound, upper_bound)
     mask_inv = cv2.bitwise_not(mask)
-    
-    # Create grayscale version of the image
     gray_img = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
     gray_img_3_channel = cv2.cvtColor(gray_img, cv2.COLOR_GRAY2RGB)
-    
-    # Isolate the colored parts and the grayscale parts
     colored_part = cv2.bitwise_and(img_np, img_np, mask=mask)
     grayscale_part = cv2.bitwise_and(gray_img_3_channel, gray_img_3_channel, mask=mask_inv)
-    
-    # Combine the two parts
     return cv2.add(colored_part, grayscale_part)
 
 def apply_sunburst_glow(img_np):
@@ -125,33 +111,24 @@ def apply_sunburst_glow(img_np):
     if img_np is None: return None
     gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
     minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(gray)
-    
     overlay = img_np.copy()
-    
-    # Draw star-like rays from the brightest point
     for i in range(12):
-        angle = i * 30 * np.pi / 180 # 30 degrees per line
+        angle = i * 30 * np.pi / 180
         length = np.random.randint(int(maxVal/2), int(maxVal*1.5))
         pt2_x = int(maxLoc[0] + length * np.cos(angle))
         pt2_y = int(maxLoc[1] + length * np.sin(angle))
         cv2.line(overlay, maxLoc, (pt2_x, pt2_y), (255, 255, 220), 1)
-        
-    # Add a soft glow
     glow = cv2.GaussianBlur(overlay, (0,0), sigmaX=30, sigmaY=30)
-    
-    # Blend the original image with the glow
     return cv2.addWeighted(img_np, 0.8, glow, 0.4, 0)
 
 def apply_dreamy_glow(img_np):
     """Adds a soft, dreamy glow effect to the image."""
     if img_np is None: return None
-    # Create a blurred version of the image
     blurred = cv2.GaussianBlur(img_np, (0,0), sigmaX=15, sigmaY=15)
-    # Blend using addWeighted to simulate a 'Screen' blend mode
     return cv2.addWeighted(img_np, 1.0, blurred, 0.6, 0)
 
 
-# --- Face Effect Functions (Unchanged) ---
+# --- Face Effect Functions ---
 def _create_sunglasses_mask():
     sunglasses = Image.new('RGBA', (300, 100), (0, 0, 0, 0))
     draw = ImageDraw.Draw(sunglasses)
@@ -257,11 +234,14 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
     gr.Markdown("# Advanced Image & Face Filter Studio", elem_id="title")
     gr.Markdown("Apply classic, artistic, and face-aware effects to your images.", elem_id="subtitle")
 
-    filters_old = ["None", "Grayscale", "Sepia", "Invert", "Posterize", "Solarize"]
-    filters_new = ["None", "Vignette", "Contour", "Sharpen"]
-    filters_artistic = ["None", "Cartoon", "Sketch", "Pixelate"]
-    filters_face = ["None", "Sunglasses", "Plumber", "Elf Hero", "Cowboy Hat", "Crown"]
-    filters_advanced = ["None", "HDR Effect", "Color Splash", "Sunburst Glow", "Dreamy Glow"]
+    # Consolidate all filter lists into one for a single radio component
+    filters_old = ["Grayscale", "Sepia", "Invert", "Posterize", "Solarize"]
+    filters_new = ["Vignette", "Contour", "Sharpen"]
+    filters_artistic = ["Cartoon", "Sketch", "Pixelate"]
+    filters_advanced = ["HDR Effect", "Color Splash", "Sunburst Glow", "Dreamy Glow"]
+    filters_face = ["Sunglasses", "Plumber", "Elf Hero", "Cowboy Hat", "Crown"]
+    
+    all_filters = ["None"] + filters_old + filters_new + filters_artistic + filters_advanced + filters_face
 
     with gr.Row(equal_height=False):
         with gr.Column(scale=2):
@@ -269,16 +249,8 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
         
         with gr.Column(scale=1):
             gr.Markdown("### Filter Controls")
-            with gr.Accordion("Old School", open=True):
-                radio_old = gr.Radio(filters_old, label="Filter", value="None")
-            with gr.Accordion("New School", open=True):
-                radio_new = gr.Radio(filters_new, label="Filter", value="None")
-            with gr.Accordion("Artistic", open=True):
-                radio_artistic = gr.Radio(filters_artistic, label="Filter", value="None")
-            with gr.Accordion("Advanced (May be slow)", open=True):
-                radio_advanced = gr.Radio(filters_advanced, label="Filter", value="None")
-            with gr.Accordion("Face Effects", open=True):
-                radio_face = gr.Radio(filters_face, label="Filter", value="None")
+            # A single radio component for all filters
+            filter_radio = gr.Radio(all_filters, label="Select a Filter", value="None")
             
             color_picker = gr.ColorPicker(label="Color to Keep (for Color Splash)", value="#FF0000", visible=False)
             apply_button = gr.Button("Apply Filter", variant="primary")
@@ -286,45 +258,24 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
         with gr.Column(scale=2):
             output_image = gr.Image(label="Filtered Output")
 
-    all_radios = [radio_old, radio_new, radio_artistic, radio_advanced, radio_face]
-    
-    def master_update_function(img, r_old, r_new, r_art, r_adv, r_face, splash_color):
+    # Simplified update function that takes the single filter selection
+    def master_update_function(img, selected_filter, splash_color):
         """This function is the single point of truth for applying filters."""
-        # Find the single active filter. The logic assumes only one is selected at a time.
-        active_filter = next((f for f in [r_old, r_new, r_art, r_adv, r_face] if f != "None"), "None")
+        # Process the image with the selected filter
+        processed_img = process_image(img, selected_filter, splash_color)
         
-        # Process the image
-        processed_img = process_image(img, active_filter, splash_color)
-        
-        # Determine visibility of the color picker
-        color_picker_visibility = gr.update(visible=True) if active_filter == "Color Splash" else gr.update(visible=False)
+        # Determine visibility of the color picker based on the single filter selection
+        color_picker_visibility = gr.update(visible=True) if selected_filter == "Color Splash" else gr.update(visible=False)
         
         return processed_img, color_picker_visibility
 
-    # This function resets other radio buttons. It's crucial for the UX.
-    def create_reset_function(radios_to_reset):
-        def reset_func():
-            return [gr.update(value="None") for _ in radios_to_reset]
-        return reset_func
-
-    # --- CORRECTED EVENT HANDLING ---
-    # The key is chaining the UI reset with the image processing using .then()
-    for i, radio in enumerate(all_radios):
-        other_radios = [r for j, r in enumerate(all_radios) if i != j]
-        
-        # When a radio's value changes:
-        # 1. First, create and trigger a function to reset all other radio groups.
-        #    The .change() method returns an event listener object.
-        # 2. THEN, chain the main update function to that event listener object.
-        radio.change(fn=create_reset_function(other_radios), inputs=None, outputs=other_radios, queue=False).then(
-            fn=master_update_function, 
-            inputs=[input_image] + all_radios + [color_picker], 
-            outputs=[output_image, color_picker]
-        )
-
-    # Connect the Apply button and image upload/change events to the master function as well
-    trigger_inputs = [input_image] + all_radios + [color_picker]
+    # --- SIMPLIFIED EVENT HANDLING ---
+    # Define the inputs and outputs for the master function
+    trigger_inputs = [input_image, filter_radio, color_picker]
     trigger_outputs = [output_image, color_picker]
+
+    # Connect all triggers to the single update function
+    filter_radio.change(master_update_function, inputs=trigger_inputs, outputs=trigger_outputs)
     apply_button.click(master_update_function, inputs=trigger_inputs, outputs=trigger_outputs)
     input_image.change(master_update_function, inputs=trigger_inputs, outputs=trigger_outputs)
     color_picker.change(master_update_function, inputs=trigger_inputs, outputs=trigger_outputs)