Update app.py

app.py

@@ -4,11 +4,32 @@ import numpy as np
 from PIL import Image
 import os
 
-# Load the Haar Cascade classifier for face detection
-face_cascade_path = os.path.join(os.path.dirname(__file__), "haarcascade_frontalface_default.xml")
-face_cascade = cv2.CascadeClassifier(face_cascade_path)
+# 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",
+    "./haarcascade_frontalface_default.xml",
+    os.path.join(os.path.dirname(__file__), "haarcascade_frontalface_default.xml"),
+    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
+]
+
+for path in cascade_paths:
+    if os.path.exists(path):
+        face_cascade = cv2.CascadeClassifier(path)
+        if not face_cascade.empty():
+            print(f"Successfully loaded Haar Cascade from: {path}")
+            break
+        else:
+            print(f"Failed to load Haar Cascade from: {path}")
+    else:
+        print(f"File not found: {path}")
 
-def process_image(image, x, y, effect_type):
+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):
     if image is None:
         return None, "Please upload an image first."
 
@@ -16,55 +37,53 @@ def process_image(image, x, y, effect_type):
     img_np_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
     processed_img_np_bgr = img_np_bgr.copy()
 
-    gray = cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+    # 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 = []
 
-    target_roi = None
-    target_x, target_y, target_w, target_h = None, None, None, None
     status_message = ""
 
-    # Find the face closest to the clicked coordinates
-    if x is not None and y is not None:
-        min_distance = float('inf')
-        for (fx, fy, fw, fh) in faces:
-            # Calculate center of the face
-            face_center_x = fx + fw // 2
-            face_center_y = fy + fh // 2
-            distance = np.sqrt((face_center_x - x)**2 + (face_center_y - y)**2)
-            if distance < min_distance and distance < 100:  # Only consider faces within 100 pixels
-                min_distance = distance
-                target_x, target_y, target_w, target_h = fx, fy, fw, fh
-
-    if target_x is not None:
-        # Apply effect to the detected face
-        roi = processed_img_np_bgr[target_y:target_y+target_h, target_x:target_x+target_w]
-        status_message = f"Applied {effect_type} effect to detected face."
-
-        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, w = roi.shape[:2]
-            temp = cv2.resize(roi, (w//10, h//10), interpolation=cv2.INTER_LINEAR)
-            processed_roi = cv2.resize(temp, (w, h), interpolation=cv2.INTER_NEAREST)
-        else:
-            processed_roi = roi # No effect
-
-        processed_img_np_bgr[target_y:target_y+target_h, target_x:target_x+target_w] = processed_roi
-    elif x is not None and y is not None: # If no face detected near click, apply to a general region
-        region_size = 100
-        x1 = max(0, x - region_size // 2)
-        y1 = max(0, y - region_size // 2)
-        x2 = min(image.width, x + region_size // 2)
-        y2 = min(image.height, y + region_size // 2)
+    if len(faces) > 0:
+        # Apply effect to all detected faces
+        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:
+        # 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]
-        status_message = f"Applied {effect_type} effect to clicked region."
 
         if effect_type == "blur":
             processed_roi = cv2.GaussianBlur(roi, (15, 15), 0)
@@ -75,15 +94,18 @@ def process_image(image, x, y, effect_type):
             processed_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
             processed_roi = cv2.cvtColor(processed_roi, cv2.COLOR_GRAY2BGR)
         elif effect_type == "pixelate":
-            h, w = roi.shape[:2]
-            temp = cv2.resize(roi, (w//10, h//10), interpolation=cv2.INTER_LINEAR)
-            processed_roi = cv2.resize(temp, (w, h), interpolation=cv2.INTER_NEAREST)
+            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 # No effect
+            processed_roi = roi
 
-        processed_img_np_bgr[y1:y1+roi.shape[0], x1:x1+roi.shape[1]] = processed_roi
-    else:
-        status_message = "Please click on the image to select a region."
+        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)."
+        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
@@ -92,11 +114,18 @@ def detect_faces_only(image):
     if image is None:
         return None, "Please upload an image first."
     
+    if face_cascade is None:
+        return image, "Face detection is not available (Haar Cascade not loaded)."
+    
     img_np = np.array(image)
     img_np_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
     
     gray = cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+    
+    try:
+        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+    except Exception as e:
+        return image, f"Face detection error: {str(e)}"
     
     # Draw rectangles around detected faces
     for (x, y, w, h) in faces:
@@ -128,17 +157,19 @@ css = """
 with gr.Blocks(css=css, title="AI Image Editor") as demo:
     gr.HTML("<h1 class='main-header'>🎨 AI Image Editor (CPU-friendly)</h1>")
     
-    gr.HTML("""
+    face_detection_status = "✅ Face detection enabled" if face_cascade is not None else "⚠️ Face detection disabled (Haar Cascade not found)"
+    
+    gr.HTML(f"""
     <div class='instruction-text'>
+        <strong>Status:</strong> {face_detection_status}<br><br>
         <strong>Instructions:</strong>
         <ol>
             <li>Upload an image using the file uploader</li>
-            <li>Click on any part of the image to select a region</li>
             <li>Choose an effect from the dropdown menu</li>
-            <li>Click "Apply Effect" to process the selected region</li>
-            <li>Use "Detect Faces" to see all detected faces with blue rectangles</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: The app will prioritize faces near your click location, or apply effects to a general region if no face is detected nearby.</em>
+        <em>Note: If face detection is available, effects will be applied to detected faces. Otherwise, effects will be applied to the center region.</em>
     </div>
     """)
     
@@ -160,7 +191,8 @@ with gr.Blocks(css=css, title="AI Image Editor") as demo:
             
             with gr.Row():
                 process_button = gr.Button("✨ Apply Effect", variant="primary", size="lg")
-                detect_button = gr.Button("👤 Detect Faces", variant="secondary", size="lg")
+                if face_cascade is not None:
+                    detect_button = gr.Button("👤 Detect Faces", variant="secondary", size="lg")
             
             status_text = gr.Textbox(
                 label="📊 Status", 
@@ -175,26 +207,18 @@ 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):
-        return evt.index[0], evt.index[1]
-
-    input_image.select(get_coords, None, [clicked_x, clicked_y])
-
     process_button.click(
         fn=process_image,
-        inputs=[input_image, clicked_x, clicked_y, effect_dropdown],
+        inputs=[input_image, effect_dropdown],
         outputs=[output_image, status_text]
     )
     
-    detect_button.click(
-        fn=detect_faces_only,
-        inputs=[input_image],
-        outputs=[output_image, status_text]
-    )
+    if face_cascade is not None:
+        detect_button.click(
+            fn=detect_faces_only,
+            inputs=[input_image],
+            outputs=[output_image, status_text]
+        )
 
     gr.HTML("""
     <div style='text-align: center; margin-top: 20px; color: #6c757d;'>