Update app.py

app.py

@@ -5,7 +5,6 @@ from PIL import Image
 import os
 
 # Try to load the Haar Cascade classifier for face detection
-# Handle the case where the file might not be found
 face_cascade = None
 cascade_paths = [
     "haarcascade_frontalface_default.xml",
@@ -29,7 +28,7 @@ if face_cascade is None or face_cascade.empty():
     print("Warning: Could not load Haar Cascade classifier. Face detection will be disabled.")
     face_cascade = None
 
-def process_image(image, effect_type):
+def process_image(image, click_x, click_y, effect_type):
     if image is None:
         return None, "Please upload an image first."
 
@@ -37,25 +36,52 @@ def process_image(image, effect_type):
     img_np_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
     processed_img_np_bgr = img_np_bgr.copy()
 
-    # Only try face detection if cascade is loaded
-    faces = []
-    if face_cascade is not None:
-        gray = cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2GRAY)
-        try:
-            faces = face_cascade.detectMultiScale(gray, 1.1, 4)
-        except Exception as e:
-            print(f"Face detection error: {e}")
-            faces = []
-
     status_message = ""
+    applied_to_region = False
+
+    # Prioritize clicked region if available
+    if click_x is not None and click_y is not None:
+        # Try to find a face near the click
+        faces = []
+        if face_cascade is not None:
+            gray = cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2GRAY)
+            try:
+                all_faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+                min_distance = float("inf")
+                target_face = None
+                for (fx, fy, fw, fh) in all_faces:
+                    face_center_x = fx + fw // 2
+                    face_center_y = fy + fh // 2
+                    distance = np.sqrt((face_center_x - click_x)**2 + (face_center_y - click_y)**2)
+                    if distance < min_distance and distance < 100: # Within 100 pixels of click
+                        min_distance = distance
+                        target_face = (fx, fy, fw, fh)
+                if target_face:
+                    faces.append(target_face)
+            except Exception as e:
+                print(f"Face detection error during click processing: {e}")
 
-    if len(faces) > 0:
-        # Apply effect to all detected faces
-        for (x, y, w, h) in faces:
+        if len(faces) > 0:
+            # Apply effect to the detected face near click
+            x, y, w, h = faces[0]
             roi = processed_img_np_bgr[y:y+h, x:x+w]
+            status_message = f"Applied {effect_type} effect to detected face near click."
+            applied_to_region = True
+        else:
+            # Apply effect to a general region around the click
+            region_size = 100
+            x1 = max(0, int(click_x - region_size // 2))
+            y1 = max(0, int(click_y - region_size // 2))
+            x2 = min(image.width, int(click_x + region_size // 2))
+            y2 = min(image.height, int(click_y + region_size // 2))
+
+            roi = processed_img_np_bgr[y1:y2, x1:x2]
+            status_message = f"Applied {effect_type} effect to clicked region."
+            applied_to_region = True
 
+        if applied_to_region:
             if effect_type == "blur":
-                processed_roi = cv2.GaussianBlur(roi, (35, 35), 0)
+                processed_roi = cv2.GaussianBlur(roi, (15, 15), 0)
             elif effect_type == "sharpen":
                 kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
                 processed_roi = cv2.filter2D(roi, -1, kernel)
@@ -68,44 +94,61 @@ def process_image(image, effect_type):
                 processed_roi = cv2.resize(temp, (w_roi, h_roi), interpolation=cv2.INTER_NEAREST)
             else:
                 processed_roi = roi
+            
+            if len(faces) > 0:
+                processed_img_np_bgr[y:y+h, x:x+w] = processed_roi
+            else:
+                processed_img_np_bgr[y1:y2, x1:x2] = processed_roi
 
-            processed_img_np_bgr[y:y+h, x:x+w] = processed_roi
-        
-        status_message = f"Applied {effect_type} effect to {len(faces)} detected face(s)."
-    else:
-        # Apply effect to center region if no faces detected
-        h, w = img_np_bgr.shape[:2]
-        center_x, center_y = w // 2, h // 2
-        region_size = min(200, w//3, h//3)
-        
-        x1 = max(0, center_x - region_size // 2)
-        y1 = max(0, center_y - region_size // 2)
-        x2 = min(w, center_x + region_size // 2)
-        y2 = min(h, center_y + region_size // 2)
-
-        roi = processed_img_np_bgr[y1:y2, x1:x2]
-
-        if effect_type == "blur":
-            processed_roi = cv2.GaussianBlur(roi, (15, 15), 0)
-        elif effect_type == "sharpen":
-            kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
-            processed_roi = cv2.filter2D(roi, -1, kernel)
-        elif effect_type == "grayscale":
-            processed_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
-            processed_roi = cv2.cvtColor(processed_roi, cv2.COLOR_GRAY2BGR)
-        elif effect_type == "pixelate":
-            h_roi, w_roi = roi.shape[:2]
-            temp = cv2.resize(roi, (w_roi//10, h_roi//10), interpolation=cv2.INTER_LINEAR)
-            processed_roi = cv2.resize(temp, (w_roi, h_roi), interpolation=cv2.INTER_NEAREST)
-        else:
-            processed_roi = roi
+    if not applied_to_region: # Fallback if no click or no specific region applied
+        # Apply effect to all detected faces if no click or no face near click
+        faces = []
+        if face_cascade is not None:
+            gray = cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2GRAY)
+            try:
+                faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+            except Exception as e:
+                print(f"Face detection error: {e}")
+                faces = []
 
-        processed_img_np_bgr[y1:y2, x1:x2] = processed_roi
-        
-        if face_cascade is None:
-            status_message = f"Applied {effect_type} effect to center region (face detection unavailable)."
+        if len(faces) > 0:
+            for (x, y, w, h) in faces:
+                roi = processed_img_np_bgr[y:y+h, x:x+w]
+
+                if effect_type == "blur":
+                    processed_roi = cv2.GaussianBlur(roi, (35, 35), 0)
+                elif effect_type == "sharpen":
+                    kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
+                    processed_roi = cv2.filter2D(roi, -1, kernel)
+                elif effect_type == "grayscale":
+                    processed_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+                    processed_roi = cv2.cvtColor(processed_roi, cv2.COLOR_GRAY2BGR)
+                elif effect_type == "pixelate":
+                    h_roi, w_roi = roi.shape[:2]
+                    temp = cv2.resize(roi, (w_roi//10, h_roi//10), interpolation=cv2.INTER_LINEAR)
+                    processed_roi = cv2.resize(temp, (w_roi, h_roi), interpolation=cv2.INTER_NEAREST)
+                else:
+                    processed_roi = roi
+
+                processed_img_np_bgr[y:y+h, x:x+w] = processed_roi
+            status_message = f"Applied {effect_type} effect to {len(faces)} detected face(s)."
         else:
-            status_message = f"No faces detected. Applied {effect_type} effect to center region."
+            # Apply effect to center region if no faces detected and no click
+            h, w = img_np_bgr.shape[:2]
+            center_x, center_y = w // 2, h // 2
+            region_size = min(200, w//3, h//3)
+            
+            x1 = max(0, center_x - region_size // 2)
+            y1 = max(0, center_y - region_size // 2)
+            x2 = min(w, center_x + region_size // 2)
+            y2 = min(h, center_y + region_size // 2)
+
+            roi = processed_img_np_bgr[y1:y2, x1:x1+roi.shape[1]] = processed_roi
+            
+            if face_cascade is None:
+                status_message = f"Applied {effect_type} effect to center region (face detection unavailable)."
+            else:
+                status_message = f"No faces detected. Applied {effect_type} effect to center region."
 
     img_pil = Image.fromarray(cv2.cvtColor(processed_img_np_bgr, cv2.COLOR_BGR2RGB))
     return img_pil, status_message
@@ -165,11 +208,12 @@ with gr.Blocks(css=css, title="AI Image Editor") as demo:
         <strong>Instructions:</strong>
         <ol>
             <li>Upload an image using the file uploader</li>
+            <li>Click on the image to select a region (optional)</li>
             <li>Choose an effect from the dropdown menu</li>
             <li>Click "Apply Effect" to process the image</li>
             <li>If face detection is available, use "Detect Faces" to see detected faces</li>
         </ol>
-        <em>Note: If face detection is available, effects will be applied to detected faces. Otherwise, effects will be applied to the center region.</em>
+        <em>Note: If you click on the image, the effect will be applied to the clicked region (prioritizing faces near the click). Otherwise, if face detection is available, effects will be applied to all detected faces. As a last resort, effects will be applied to the center region.</em>
     </div>
     """)
     
@@ -207,9 +251,20 @@ with gr.Blocks(css=css, title="AI Image Editor") as demo:
                 height=400
             )
 
+    # Store click coordinates
+    clicked_x = gr.State(None)
+    clicked_y = gr.State(None)
+
+    def get_coords(evt: gr.SelectData):
+        if evt.index is not None and len(evt.index) == 2:
+            return evt.index[0], evt.index[1]
+        return None, None
+
+    input_image.select(get_coords, None, [clicked_x, clicked_y])
+
     process_button.click(
         fn=process_image,
-        inputs=[input_image, effect_dropdown],
+        inputs=[input_image, clicked_x, clicked_y, effect_dropdown],
         outputs=[output_image, status_text]
     )