Update app.py

app.py

@@ -1,105 +1,207 @@
-# app.py
-
 import gradio as gr
-import torch
-from diffusers import AutoPipelineForInpainting
+import cv2
+import numpy as np
 from PIL import Image
-import time
-
-# --- Model Loading (Final, Most Stable Version) ---
-print("Loading the definitive model for low-RAM CPU environment...")
-# We are using the more modern and reliable SD 2.0 Inpainting model.
-# This model is better packaged and less prone to loading errors.
-model_id = "stabilityai/stable-diffusion-2-inpainting"
-
-try:
-    pipe = AutoPipelineForInpainting.from_pretrained(
-        model_id,
-        torch_dtype=torch.float32, # Use float32 for CPU compatibility
-        safety_checker=None        # Proactively disable the safety checker to save memory
-    )
-    
-    # Enable CPU offloading to prevent memory crashes. This is essential.
-    pipe.enable_model_cpu_offload()
-    
-    print("Model loaded successfully. The application is ready.")
+import os
 
-except Exception as e:
-    print("="*80)
-    print("A FATAL ERROR OCCURRED DURING MODEL LOADING. The app cannot start.")
-    print(f"Error: {e}")
-    print("This is likely due to the free hardware tier not having enough resources.")
-    print("="*80)
-    raise e
+# 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)
 
+def process_image(image, x, y, effect_type):
+    if image is None:
+        return None, "Please upload an image first."
 
-# --- Default "Magic" Prompts ---
-DEFAULT_PROMPT = "photorealistic, 4k, ultra high quality, sharp focus, masterpiece, high detail, professional photo"
-DEFAULT_NEGATIVE_PROMPT = "blurry, pixelated, distorted, deformed, ugly, disfigured, cartoon, anime, low quality, watermark, text"
+    img_np = np.array(image)
+    img_np_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+    processed_img_np_bgr = img_np_bgr.copy()
 
-# --- The Inpainting Function ---
-# This function signature is correct for how Gradio's Image tool works.
-def inpaint_image(image_and_mask, user_prompt, guidance_scale, num_steps, progress=gr.Progress(track_tqdm=True)):
-    
-    if image_and_mask is None or "image" not in image_and_mask or "mask" not in image_and_mask:
-        raise gr.Error("Please upload an image and draw a mask on it first!")
+    gray = cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2GRAY)
+    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+
+    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)
+
+        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)
+        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[y1:y1+roi.shape[0], x1:x1+roi.shape[1]] = processed_roi
+    else:
+        status_message = "Please click on the image to select a region."
+
+    img_pil = Image.fromarray(cv2.cvtColor(processed_img_np_bgr, cv2.COLOR_BGR2RGB))
+    return img_pil, status_message
+
+def detect_faces_only(image):
+    if image is None:
+        return None, "Please upload an image first."
     
-    # The input is a dictionary with 'image' and 'mask' keys
-    image = image_and_mask["image"].convert("RGB")
-    mask = image_and_mask["mask"].convert("RGB")
+    img_np = np.array(image)
+    img_np_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
     
-    if user_prompt and user_prompt.strip():
-        prompt = user_prompt
-        negative_prompt = DEFAULT_NEGATIVE_PROMPT 
-        print(f"Using custom prompt: '{prompt}'")
-    else:
-        prompt = DEFAULT_PROMPT
-        negative_prompt = DEFAULT_NEGATIVE_PROMPT
-        print(f"User prompt is empty. Using default 'General Fix' prompt.")
+    gray = cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2GRAY)
+    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
     
-    print(f"Starting inpainting on CPU (with offloading)... This will be very slow.")
-    start_time = time.time()
+    # Draw rectangles around detected faces
+    for (x, y, w, h) in faces:
+        cv2.rectangle(img_np_bgr, (x, y), (x+w, y+h), (255, 0, 0), 2)
     
-    result_image = pipe(
-        prompt=prompt,
-        image=image,
-        mask_image=mask,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=int(num_steps),
-    ).images[0]
+    img_pil = Image.fromarray(cv2.cvtColor(img_np_bgr, cv2.COLOR_BGR2RGB))
+    return img_pil, f"Detected {len(faces)} face(s)."
+
+# Custom CSS for better styling
+css = """
+.gradio-container {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+.main-header {
+    text-align: center;
+    color: #2c3e50;
+    margin-bottom: 20px;
+}
+.instruction-text {
+    background-color: #f8f9fa;
+    padding: 15px;
+    border-radius: 8px;
+    border-left: 4px solid #007bff;
+    margin-bottom: 20px;
+}
+"""
+
+# Gradio interface
+with gr.Blocks(css=css, title="AI Image Editor") as demo:
+    gr.HTML("<h1 class='main-header'>🎨 AI Image Editor (CPU-friendly)</h1>")
     
-    end_time = time.time()
-    print(f"Inpainting finished in {end_time - start_time:.2f} seconds.")
-    return result_image
-
-
-# --- Gradio User Interface ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎨 AI Image Fixer (Definitive Version)")
-    gr.Warning(
-        "‼️ **PATIENCE REQUIRED!** This app is running on a free CPU. "
-        "Generation will be **extremely slow (potentially 20-40 minutes)** due to memory-saving measures. "
-        "This is necessary to prevent crashes. The progress bar will appear after you click the button."
-    )
+    gr.HTML("""
+    <div class='instruction-text'>
+        <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>
+        </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>
+    </div>
+    """)
     
     with gr.Row():
-        with gr.Column(scale=2):
-            input_image = gr.Image(label="1. Upload & Mask Image", source="upload", tool="brush", type="pil")
-            prompt_textbox = gr.Textbox(label="2. Describe Your Fix (Optional)", placeholder="Leave empty for a general fix")
-            with gr.Accordion("Advanced Settings", open=False):
-                guidance_scale = gr.Slider(minimum=0, maximum=20, value=8.0, label="Guidance Scale")
-                num_steps = gr.Slider(minimum=10, maximum=50, step=1, value=20, label="Inference Steps (Fewer is faster)")
         with gr.Column(scale=1):
-            output_image = gr.Image(label="Result", type="pil")
+            input_image = gr.Image(
+                type="pil", 
+                label="📁 Upload Image", 
+                interactive=True,
+                height=400
+            )
+            
+            with gr.Row():
+                effect_dropdown = gr.Dropdown(
+                    ["None", "blur", "sharpen", "grayscale", "pixelate"], 
+                    label="🎭 Select Effect", 
+                    value="blur"
+                )
+            
+            with gr.Row():
+                process_button = gr.Button("✨ Apply Effect", variant="primary", size="lg")
+                detect_button = gr.Button("👤 Detect Faces", variant="secondary", size="lg")
+            
+            status_text = gr.Textbox(
+                label="📊 Status", 
+                interactive=False,
+                placeholder="Ready to process..."
+            )
+        
+        with gr.Column(scale=1):
+            output_image = gr.Image(
+                type="pil", 
+                label="🖼️ Processed Image",
+                height=400
+            )
 
-    submit_button = gr.Button("Fix It!", variant="primary")
+    # 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],
+        outputs=[output_image, status_text]
+    )
     
-    submit_button.click(
-        fn=inpaint_image,
-        inputs=[input_image, prompt_textbox, guidance_scale, num_steps],
-        outputs=output_image
+    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;'>
+        <p>Built with ❤️ for CPU-friendly image processing | Powered by OpenCV & Gradio</p>
+    </div>
+    """)
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()
+