app.py

import gradio as gr
import numpy as np
from PIL import Image
import cv2
import json
from typing import Tuple, List, Dict, Any
import time

from utils import draw_detections, process_image, load_detection_models
from models import detect_faces, detect_objects

# Load models at startup
face_cascade, object_net, object_classes = load_detection_models()

def recognize_face_and_objects(
    image: np.ndarray,
    enable_face_detection: bool,
    enable_object_detection: bool,
    face_confidence: float,
    object_confidence: float,
    draw_boxes: bool,
    show_labels: bool,
    box_color: str
) -> Tuple[np.ndarray, str, str]:
    """
    Perform face and object detection on the input image.
    
    Args:
        image: Input image as numpy array
        enable_face_detection: Whether to detect faces
        enable_object_detection: Whether to detect objects
        face_confidence: Confidence threshold for face detection
        object_confidence: Confidence threshold for object detection
        draw_boxes: Whether to draw bounding boxes
        show_labels: Whether to show labels on detections
        box_color: Color for bounding boxes
        
    Returns:
        Tuple of (processed_image, face_results_json, object_results_json)
    """
    if image is None:
        return None, "No image provided", "No image provided"
    
    # Convert PIL to numpy if needed
    if isinstance(image, Image.Image):
        image = np.array(image)
    
    # Process image
    processed_image, face_results, object_results = process_image(
        image,
        face_cascade,
        object_net,
        object_classes,
        enable_face_detection,
        enable_object_detection,
        face_confidence,
        object_confidence
    )
    
    # Draw detections if requested
    if draw_boxes:
        processed_image = draw_detections(
            processed_image.copy(),
            face_results,
            object_results,
            show_labels,
            box_color
        )
    
    # Convert results to JSON
    face_json = json.dumps(face_results, indent=2) if face_results else "No faces detected"
    object_json = json.dumps(object_results, indent=2) if object_results else "No objects detected"
    
    return processed_image, face_json, object_json

def webcam_recognition(
    image: np.ndarray,
    enable_face_detection: bool,
    enable_object_detection: bool,
    face_confidence: float,
    object_confidence: float,
    draw_boxes: bool,
    show_labels: bool,
    box_color: str
) -> np.ndarray:
    """Real-time webcam recognition."""
    if image is None:
        return None
    
    processed_image, _, _ = recognize_face_and_objects(
        image,
        enable_face_detection,
        enable_object_detection,
        face_confidence,
        object_confidence,
        draw_boxes,
        show_labels,
        box_color
    )
    
    return processed_image

def get_detection_statistics() -> str:
    """Get information about available detection models."""
    stats = {
        "face_detection": {
            "model": "Haar Cascade",
            "features": ["Face detection", "Eye detection", "Smile detection"],
            "speed": "Fast",
            "accuracy": "Medium"
        },
        "object_detection": {
            "model": "OpenCV DNN with MobileNet-SSD",
            "classes": len(object_classes) if object_classes else 0,
            "input_size": "300x300",
            "speed": "Real-time capable",
            "accuracy": "High"
        }
    }
    return json.dumps(stats, indent=2)

# Create custom CSS for better styling
custom_css = """
.main-container {
    max-width: 1400px;
    margin: 0 auto;
}
.settings-panel {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    border-radius: 10px;
    padding: 20px;
}
.result-panel {
    border: 2px solid #e0e0e0;
    border-radius: 10px;
    padding: 15px;
}
.image-container {
    border: 1px solid #ddd;
    border-radius: 8px;
    overflow: hidden;
}
"""

with gr.Blocks(css=custom_css, title="Face & Object Recognition Platform") as demo:
    gr.Markdown("""
    # 🔍 Face & Object Recognition Platform
    Built with [anycoder](https://huggingface.co/spaces/akhaliq/anycoder)
    
    Advanced computer vision platform for real-time face and object detection with customizable settings.
    """)
    
    with gr.Row():
        with gr.Column(scale=2):
            gr.Markdown("### 📤 Input Source")
            with gr.Tabs():
                with gr.TabItem("Upload Image"):
                    input_image = gr.Image(
                        label="Upload an image for analysis",
                        type="numpy",
                        height=400
                    )
                    analyze_btn = gr.Button("🔍 Analyze Image", variant="primary", size="lg")
                
                with gr.TabItem("Webcam"):
                    webcam_image = gr.Image(
                        label="Webcam Feed",
                        sources="webcam",
                        type="numpy",
                        streaming=True,
                        height=400
                    )
                    gr.Markdown("*Webcam provides real-time detection (may have slight delay)*")
        
        with gr.Column(scale=1):
            gr.Markdown("### ⚙️ Detection Settings")
            with gr.Group(elem_classes=["settings-panel"]):
                gr.Markdown("#### Detection Modes")
                enable_face = gr.Checkbox(label="👤 Enable Face Detection", value=True)
                enable_objects = gr.Checkbox(label="📦 Enable Object Detection", value=True)
                
                gr.Markdown("#### Confidence Thresholds")
                face_conf = gr.Slider(
                    label="Face Detection Confidence",
                    minimum=0.1,
                    maximum=1.0,
                    value=0.7,
                    step=0.1,
                    info="Lower values detect more faces"
                )
                
                object_conf = gr.Slider(
                    label="Object Detection Confidence", 
                    minimum=0.1,
                    maximum=1.0,
                    value=0.5,
                    step=0.1,
                    info="Lower values detect more objects"
                )
                
                gr.Markdown("#### Display Options")
                draw_boxes = gr.Checkbox(label="📐 Draw Bounding Boxes", value=True)
                show_labels = gr.Checkbox(label="🏷️ Show Labels", value=True)
                box_color = gr.Dropdown(
                    label="Box Color",
                    choices=["red", "green", "blue", "yellow", "purple", "orange"],
                    value="red"
                )
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 🖼️ Detection Results")
            output_image = gr.Image(
                label="Processed Image with Detections",
                type="numpy",
                height=400,
                elem_classes=["image-container"]
            )
        
        with gr.Column():
            with gr.Tabs():
                with gr.TabItem("👤 Face Results"):
                    face_results = gr.JSON(
                        label="Face Detection Data",
                        elem_classes=["result-panel"]
                    )
                
                with gr.TabItem("📦 Object Results"):
                    object_results = gr.JSON(
                        label="Object Detection Data", 
                        elem_classes=["result-panel"]
                    )
                
                with gr.TabItem("ℹ️ Model Info"):
                    model_info = gr.JSON(
                        label="Detection Models Information",
                        value=json.loads(get_detection_statistics()),
                        elem_classes=["result-panel"]
                    )
    
    # Event handlers
    analyze_btn.click(
        fn=recognize_face_and_objects,
        inputs=[
            input_image,
            enable_face,
            enable_objects,
            face_conf,
            object_conf,
            draw_boxes,
            show_labels,
            box_color
        ],
        outputs=[output_image, face_results, object_results]
    )
    
    # Real-time webcam processing
    webcam_image.stream(
        fn=webcam_recognition,
        inputs=[
            webcam_image,
            enable_face,
            enable_objects,
            face_conf,
            object_conf,
            draw_boxes,
            show_labels,
            box_color
        ],
        outputs=[output_image],
        time_limit=30,
        stream_every=0.5
    )
    
    # Examples
    gr.Examples(
        examples=[
            # These would need actual image files, for now using placeholder
            ["example1.jpg", True, True, 0.7, 0.5, True, True, "red"],
            ["example2.jpg", False, True, 0.8, 0.6, True, True, "blue"],
            ["example3.jpg", True, False, 0.6, 0.4, True, False, "green"],
        ],
        inputs=[
            input_image,
            enable_face,
            enable_objects,
            face_conf,
            object_conf,
            draw_boxes,
            show_labels,
            box_color
        ],
        outputs=[output_image, face_results, object_results],
        cache_examples=False
    )
    
    gr.Markdown("""
    ---
    ### 📚 Usage Instructions
    1. **Upload Image**: Select an image from your device for analysis
    2. **Webcam**: Use your webcam for real-time detection
    3. **Adjust Settings**: Customize confidence thresholds and display options
    4. **View Results**: See detections overlayed on the image with detailed JSON data
    
    ### 🎯 Features
    - **Face Detection**: Identifies faces in images using Haar Cascade classifiers
    - **Object Detection**: Recognizes 80+ object classes using MobileNet-SSD
    - **Real-time Processing**: Webcam support with live detection
    - **Customizable**: Adjustable confidence thresholds and visual settings
    - **Detailed Output**: JSON formatted results with coordinates and confidence scores
    """)

if __name__ == "__main__":
    demo.launch(share=True, debug=True)