# Files needed for Hugging Face Spaces deployment

# 1. app.py (main application file)
import gradio as gr
import mediapipe as mp
import cv2
import numpy as np
from PIL import Image
import pandas as pd
import math
from typing import Dict, Tuple, Optional

# Initialize MediaPipe
mp_pose = mp.solutions.pose
pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.7)
mp_drawing = mp.solutions.drawing_utils

class BodyMeasurementSystem:
    def __init__(self):
        self.measurements = {}
        
    def extract_landmarks(self, image: np.ndarray) -> Optional[any]:
        if image is None:
            return None
        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        results = pose.process(image_rgb)
        return results.pose_landmarks
    
    def pixel_distance(self, p1: Tuple[float, float], p2: Tuple[float, float]) -> float:
        return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
    
    def to_pixel_coords(self, landmark, image_shape: Tuple[int, int, int]) -> Tuple[int, int]:
        h, w, _ = image_shape
        return int(landmark.x * w), int(landmark.y * h)
    
    def calculate_scale_factor(self, landmarks, image_shape: Tuple[int, int, int], user_height_cm: float) -> float:
        h, w, _ = image_shape
        if (landmarks.landmark[0].visibility > 0.5 and 
            landmarks.landmark[32].visibility > 0.5):
            pixel_height = abs(landmarks.landmark[0].y - landmarks.landmark[32].y) * h
            return user_height_cm / pixel_height if pixel_height > 0 else 1.0
        return 1.0
    
    def measure_from_front_view(self, landmarks, image_shape: Tuple[int, int, int], scale: float) -> Dict[str, float]:
        measurements = {}
        try:
            left_shoulder = self.to_pixel_coords(landmarks.landmark[11], image_shape)
            right_shoulder = self.to_pixel_coords(landmarks.landmark[12], image_shape)
            measurements['Shoulder Width'] = round(self.pixel_distance(left_shoulder, right_shoulder) * scale, 1)
            
            measurements['Chest Width'] = round(measurements['Shoulder Width'] * 1.15, 1)
            
            left_hip = self.to_pixel_coords(landmarks.landmark[23], image_shape)
            right_hip = self.to_pixel_coords(landmarks.landmark[24], image_shape)
            hip_width = self.pixel_distance(left_hip, right_hip) * scale
            measurements['Hip Width'] = round(hip_width, 1)
            measurements['Waist Width'] = round(hip_width * 0.85, 1)
            
            left_shoulder_y = left_shoulder[1]
            waist_y = (left_hip[1] + right_hip[1]) / 2
            measurements['Front Length'] = round(abs(waist_y - left_shoulder_y) * scale, 1)
            
        except Exception as e:
            print(f"Error in front view measurements: {e}")
        return measurements
    
    def measure_from_side_view(self, landmarks, image_shape: Tuple[int, int, int], scale: float) -> Dict[str, float]:
        measurements = {}
        try:
            neck = self.to_pixel_coords(landmarks.landmark[0], image_shape)
            hip = self.to_pixel_coords(landmarks.landmark[24], image_shape)
            measurements['Back Length'] = round(self.pixel_distance(neck, hip) * scale * 0.7, 1)
            
            shoulder = self.to_pixel_coords(landmarks.landmark[11], image_shape)
            elbow = self.to_pixel_coords(landmarks.landmark[13], image_shape)
            wrist = self.to_pixel_coords(landmarks.landmark[15], image_shape)
            
            upper_arm = self.pixel_distance(shoulder, elbow) * scale
            forearm = self.pixel_distance(elbow, wrist) * scale
            measurements['Sleeve Length'] = round(upper_arm + forearm, 1)
            
            hip_point = self.to_pixel_coords(landmarks.landmark[24], image_shape)
            ankle = self.to_pixel_coords(landmarks.landmark[28], image_shape)
            measurements['Inseam'] = round(self.pixel_distance(hip_point, ankle) * scale * 0.8, 1)
            measurements['Outseam'] = round(self.pixel_distance(hip_point, ankle) * scale, 1)
            
        except Exception as e:
            print(f"Error in side view measurements: {e}")
        return measurements
    
    def estimate_circumferences(self, front_measurements: Dict) -> Dict[str, float]:
        circumferences = {}
        try:
            if 'Chest Width' in front_measurements:
                width = front_measurements['Chest Width']
                circumferences['Chest Circumference'] = round(width * 3.5, 1)
            if 'Waist Width' in front_measurements:
                width = front_measurements['Waist Width']
                circumferences['Waist Circumference'] = round(width * 3.2, 1)
            if 'Hip Width' in front_measurements:
                width = front_measurements['Hip Width']
                circumferences['Hip Circumference'] = round(width * 3.3, 1)
        except Exception as e:
            print(f"Error estimating circumferences: {e}")
        return circumferences

measurement_system = BodyMeasurementSystem()

def process_images(front_image, side_image, back_image, height):
    if not any([front_image, side_image]):
        return "Please upload at least front and side view images.", None, None, None
    
    all_measurements = {}
    annotated_images = []
    
    images_data = [("Front", front_image), ("Side", side_image), ("Back", back_image)]
    
    for view_name, img in images_data:
        if img is not None:
            img_array = np.array(img)
            img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
            
            landmarks = measurement_system.extract_landmarks(img_bgr)
            
            if landmarks:
                annotated_img = img_bgr.copy()
                mp_drawing.draw_landmarks(annotated_img, landmarks, mp_pose.POSE_CONNECTIONS)
                annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)
                annotated_images.append((view_name, annotated_img_rgb))
                
                scale = measurement_system.calculate_scale_factor(landmarks, img_bgr.shape, height)
                
                if view_name == "Front":
                    measurements = measurement_system.measure_from_front_view(landmarks, img_bgr.shape, scale)
                    all_measurements.update(measurements)
                elif view_name == "Side":
                    measurements = measurement_system.measure_from_side_view(landmarks, img_bgr.shape, scale)
                    all_measurements.update(measurements)
    
    circumferences = measurement_system.estimate_circumferences(all_measurements)
    all_measurements.update(circumferences)
    
    if all_measurements:
        df = pd.DataFrame(list(all_measurements.items()), columns=['Measurement', 'Value (cm)'])
        results_text = f"📐 **Body Measurements for {height}cm height:**\n\n"
        results_text += df.to_string(index=False)
        results_text += "\n\n⚠️ **Note:** These are estimates. Professional validation recommended."
    else:
        results_text = "❌ Could not extract measurements. Please ensure clear, full-body images."
    
    front_img = next((img for name, img in annotated_images if name == "Front"), None)
    side_img = next((img for name, img in annotated_images if name == "Side"), None)
    back_img = next((img for name, img in annotated_images if name == "Back"), None)
    
    return results_text, front_img, side_img, back_img

# Create Gradio interface
with gr.Blocks(title="AI Body Measurement System", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🎯 AI Body Measurement System")
    gr.Markdown("Upload front, side, and back view images for professional body measurements")
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("## 📸 Upload Images")
            front_input = gr.Image(type="pil", label="Front View")
            side_input = gr.Image(type="pil", label="Side View")
            back_input = gr.Image(type="pil", label="Back View (Optional)")
            height_input = gr.Slider(120, 220, value=170, step=1, label="Your Height (cm)")
            process_btn = gr.Button("🔍 Analyze Body Measurements", variant="primary")
        
        with gr.Column():
            gr.Markdown("## 📊 Results")
            results_output = gr.Textbox(label="Measurements", lines=15)
    
    with gr.Row():
        gr.Markdown("## 🖼️ Processed Images")
        front_output = gr.Image(label="Front View")
        side_output = gr.Image(label="Side View")
        back_output = gr.Image(label="Back View")
    
    with gr.Accordion("📋 Guidelines", open=False):
        gr.Markdown("""
        **For Best Results:**
        - Stand straight, arms slightly away from body
        - Wear form-fitting clothes
        - Good lighting, plain background
        - Stand 2-3 meters from camera
        - Front: Face camera directly
        - Side: Turn 90° profile view
        - Back: Turn 180° (optional)
        """)
    
    process_btn.click(
        fn=process_images,
        inputs=[front_input, side_input, back_input, height_input],
        outputs=[results_output, front_output, side_output, back_output]
    )

if __name__ == "__main__":
    demo.launch()

# 2. requirements.txt
"""
gradio==4.44.0
mediapipe==0.10.9
opencv-python==4.8.1.78
numpy==1.24.3
pillow==10.0.1
pandas==2.0.3
"""

# 3. README.md
"""
# AI Body Measurement System

Professional body measurement extraction from front, side, and back view images using MediaPipe pose detection.

## Features
- Multi-view image analysis
- 12+ professional measurements
- Real-time pose landmark detection
- Confidence scoring
- Professional tailoring recommendations

## Usage
1. Upload front and side view images
2. Enter your height
3. Get comprehensive body measurements

## Accuracy
±2-5cm accuracy suitable for initial fitting and online sizing.
"""