app.py create

app.py

@@ -0,0 +1,209 @@
+import gradio as gr
+from PIL import Image
+import requests
+import io
+import os
+
+# --- Configuration ---
+# If using Hugging Face Inference API for face detection
+HF_API_TOKEN = os.environ.get("HF_API_TOKEN") # Set this in your Space secrets
+DETECTION_MODEL_URL = "https://api-inference.huggingface.co/models/facebook/detr-resnet-50" # Example
+
+# --- Placeholder for Face Shape Classification ---
+# This is the most challenging part to do with a generic free model.
+# Option 1: Find a face shape classification model on HF Hub (ideal but rare)
+# Option 2: Implement landmark detection + rule-based shape classification (complex)
+# Option 3: Use a very simple heuristic (e.g., aspect ratio of bounding box - very unreliable)
+# Option 4 (Simplest for demo): Let user *select* their face shape or a mock function
+
+def detect_face_api(image_pil):
+    if not HF_API_TOKEN:
+        raise gr.Error("Hugging Face API Token not set in Space secrets!")
+    
+    # Convert PIL Image to bytes
+    img_byte_arr = io.BytesIO()
+    image_pil.save(img_byte_arr, format='PNG')
+    img_byte_arr = img_byte_arr.getvalue()
+
+    headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+    try:
+        response = requests.post(DETECTION_MODEL_URL, headers=headers, data=img_byte_arr)
+        response.raise_for_status()
+        outputs = response.json()
+    except requests.exceptions.RequestException as e:
+        print(f"API Error: {e}")
+        print(f"Response content: {response.content if 'response' in locals() else 'No response'}")
+        return None, "Error calling detection API."
+    except Exception as e:
+        print(f"Other Error during detection: {e}")
+        return None, f"Error processing image: {str(e)}"
+
+
+    # Process outputs to find 'person' or 'face' bounding box
+    # This depends heavily on the model used.
+    # For detr-resnet-50, it returns a list of objects with 'label', 'score', 'box'
+    best_face_box = None
+    max_score = 0
+    
+    # Try to find "face", then "person"
+    for obj_type in ["face", "person"]: # Some models might label "face" directly
+        for obj in outputs:
+            if obj['label'].lower() == obj_type and obj['score'] > max_score:
+                max_score = obj['score']
+                best_face_box = obj['box']
+    
+    if best_face_box:
+        # Crop the image to the detected face
+        # box is {xmin, ymin, xmax, ymax}
+        cropped_image = image_pil.crop((best_face_box['xmin'], best_face_box['ymin'], best_face_box['xmax'], best_face_box['ymax']))
+        return cropped_image, None
+    else:
+        return None, "No face detected with sufficient confidence."
+
+def estimate_face_shape_mock(face_image_pil):
+    """
+    MOCK FUNCTION: In a real app, this would use a model or complex heuristics.
+    For now, let's pretend it analyzes and returns a shape.
+    You could also add a dropdown for the user to select their perceived face shape
+    if AI classification is too hard to implement initially.
+    """
+    # Super simple heuristic (aspect ratio) - VERY UNRELIABLE, just for demo
+    width, height = face_image_pil.size
+    aspect_ratio = height / width
+    if aspect_ratio > 1.25: return "Long"
+    elif 0.9 < aspect_ratio < 1.1: return "Round/Square" # Needs more to differentiate
+    else: return "Oval"
+    # In reality, this needs a dedicated model or landmark-based analysis.
+    # return "Oval" # Or just return a default for now
+
+def get_hairstyle_suggestions(face_shape, gender="neutral"): # Gender could be another input
+    suggestions = {
+        "Oval": {
+            "hair": [
+                "Most hairstyles work well. Lucky you!",
+                "Consider layers for volume or a sleek bob.",
+                "Side-swept bangs can be flattering."
+            ],
+            "beard": [
+                "Most beard styles are suitable.",
+                "A classic full beard, well-groomed, is excellent.",
+                "Consider a short boxed beard or a Van Dyke."
+            ]
+        },
+        "Round/Square": { # Simplified for demo, ideally separate
+            "hair": [
+                "Add height on top: pompadour, quiff, faux hawk.",
+                "Avoid blunt bobs ending at the chin or very short, round cuts.",
+                "Layers, textured cuts, and off-center parts can soften features.",
+                "For square faces: Softer styles, waves, or curls can balance a strong jaw."
+            ],
+            "beard": [
+                "For round faces: Beards that add length to the chin: goatee, soul patch, or a beard that's shorter on the sides and longer at the chin.",
+                "For square faces: Styles that soften the jawline. A circle beard or a well-trimmed full beard that rounds the chin."
+            ]
+        },
+        "Long": {
+            "hair": [
+                "Add width: Curls, waves, or layered styles with volume at the sides.",
+                "Avoid excessive height on top.",
+                "Bangs (blunt or side-swept) can shorten the face."
+            ],
+            "beard": [
+                "Styles that add width to the face: fuller on the cheeks, like a full beard or mutton chops.",
+                "Avoid long, pointy beards that further elongate the face."
+            ]
+        },
+        "Heart": {
+             "hair": [
+                "Add volume at the jawline: chin-length bobs, layered shoulder-length cuts.",
+                "Side-swept bangs or a textured fringe can balance a wider forehead.",
+                "Avoid too much height on top."
+            ],
+            "beard": [
+                "Fuller beards that add width to the jawline, like a full beard or a Garibaldi.",
+                "Avoid styles that are too narrow at the chin."
+            ]
+        },
+        # Add Diamond, etc.
+    }
+    if face_shape in suggestions:
+        hair_sug = "\n".join([f"- {s}" for s in suggestions[face_shape]["hair"]])
+        beard_sug = "\n".join([f"- {s}" for s in suggestions[face_shape]["beard"]])
+        return f"**Haircut Suggestions for {face_shape} Face:**\n{hair_sug}\n\n**Beard Style Suggestions for {face_shape} Face:**\n{beard_sug}"
+    return "Could not determine suggestions for the estimated face shape."
+
+def analyze_face_and_suggest(front_image, side_image_optional):
+    if front_image is None:
+        return None, "Please upload a front-facing photo.", ""
+
+    # Convert Gradio Image (numpy array) to PIL Image
+    img_pil = Image.fromarray(front_image)
+
+    # 1. Detect Face (using API or local model)
+    cropped_face_pil, error_msg = detect_face_api(img_pil) # Using API
+    if error_msg:
+        return None, error_msg, ""
+    if cropped_face_pil is None: # Should be caught by error_msg but as a fallback
+        return None, "Could not detect a face.", ""
+
+    # --- Placeholder for processing side_image_optional ---
+    # If side_image_optional is provided, you could:
+    # - Run face detection on it too.
+    # - If using landmarks, try to get landmarks from both.
+    # - Use it to refine the face shape estimation (e.g., confirm jawline).
+    # For now, we'll just acknowledge it.
+    side_info = "Side profile not uploaded."
+    if side_image_optional is not None:
+        side_img_pil = Image.fromarray(side_image_optional)
+        # You could try to detect face/landmarks on side_img_pil here
+        side_info = "Side profile uploaded (analysis can be enhanced in future versions)."
+        # For a more advanced system, you'd combine info from front and side.
+
+    # 2. Estimate Face Shape (the hard part)
+    # For demo, using a mock function. Replace with actual logic.
+    estimated_shape = estimate_face_shape_mock(cropped_face_pil)
+    
+    # 3. Get Suggestions
+    suggestions_text = get_hairstyle_suggestions(estimated_shape)
+
+    return cropped_face_pil, f"Estimated Face Shape: **{estimated_shape}**\n{side_info}", suggestions_text
+
+# --- Gradio Interface ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# ✂️ AI Hairstyle & Beard Suggester 🧔")
+    gr.Markdown(
+        "Upload a clear, front-facing photo of a person. "
+        "Optionally, upload a side profile for potentially better results (future enhancement)."
+        "\n*Disclaimer: This is a demo using simplified logic for face shape estimation. Suggestions are general.*"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            front_image_input = gr.Image(type="numpy", label="Front Face Photo (Required)")
+            side_image_input = gr.Image(type="numpy", label="Side Profile Photo (Optional)")
+            submit_btn = gr.Button("Get Suggestions", variant="primary")
+        with gr.Column(scale=2):
+            output_image = gr.Image(label="Detected Face")
+            output_shape_info = gr.Markdown(label="Face Analysis")
+            output_suggestions = gr.Markdown(label="Suggestions")
+
+    submit_btn.click(
+        analyze_face_and_suggest,
+        inputs=[front_image_input, side_image_input],
+        outputs=[output_image, output_shape_info, output_suggestions]
+    )
+
+    gr.Examples(
+        examples=[
+            # Add paths to example images if you have them in your Space
+            # ["path/to/example_front.jpg", "path/to/example_side.jpg"],
+            # ["another_front.png", None],
+        ],
+        inputs=[front_image_input, side_image_input],
+        outputs=[output_image, output_shape_info, output_suggestions],
+        fn=analyze_face_and_suggest,
+        cache_examples=False # or True if your function is deterministic and inputs are fixed
+    )
+
+if __name__ == "__main__":
+    demo.launch()