Deploy gaze emotion detection API

.gitignore

@@ -0,0 +1,41 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Test files
+test_image.jpg
+*.jpg
+*.png
+*.jpeg

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,44 @@
+---
+title: Gaze and Emotion Detection API
+emoji: 👁️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# Gaze and Emotion Detection API
+
+This API provides real-time gaze tracking and emotion detection from images using MediaPipe and DeepFace.
+
+## Features
+- Face detection and tracking
+- Gaze direction estimation (LEFT, RIGHT, UP, DOWN, CENTER)
+- Emotion recognition (happy, sad, angry, fear, surprise, disgust, neutral)
+- Concentration score calculation
+- Blink detection
+
+## API Endpoints
+- `GET /` - Health check
+- `POST /analyze` - Upload image for analysis
+
+## Usage
+Send a POST request to `/analyze` with an image file to get gaze and emotion data in JSON format.
+
+### Example Response:
+```json
+{
+  "emotion": "happy",
+  "face_detected": true,
+  "gaze_direction": "CENTER",
+  "concentration_score": 85.5,
+  "blinking": false,
+  "gaze_positions": {
+    "left_eye": {"horizontal": 0.45, "vertical": 0.52},
+    "right_eye": {"horizontal": 0.48, "vertical": 0.50}
+  }
+}
+```
+
+## Testing
+You can test the API using the interactive documentation at `/docs` endpoint.

app.py

@@ -0,0 +1,233 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import cv2
+import mediapipe as mp
+import numpy as np
+from deepface import DeepFace
+import base64
+from io import BytesIO
+from PIL import Image
+import json
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize MediaPipe
+mp_face_mesh = mp.solutions.face_mesh
+face_mesh = mp_face_mesh.FaceMesh(
+    refine_landmarks=True,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+mp_face_detection = mp.solutions.face_detection
+face_detection = mp_face_detection.FaceDetection(min_detection_confidence=0.5)
+
+# Eye and iris landmark indices
+LEFT_EYE = [33, 160, 158, 133, 153, 144]
+RIGHT_EYE = [362, 385, 387, 263, 373, 380]
+LEFT_IRIS = [468, 469, 470, 471, 472]
+RIGHT_IRIS = [473, 474, 475, 476, 477]
+
+def eye_aspect_ratio(landmarks, eye_points, image_w, image_h):
+    p = []
+    for idx in eye_points:
+        lm = landmarks[idx]
+        x, y = int(lm.x * image_w), int(lm.y * image_h)
+        p.append((x, y))
+    
+    A = np.linalg.norm(np.array(p[1]) - np.array(p[5]))
+    B = np.linalg.norm(np.array(p[2]) - np.array(p[4]))
+    C = np.linalg.norm(np.array(p[0]) - np.array(p[3]))
+    ear = (A + B) / (2.0 * C)
+    return ear
+
+def get_iris_position_2d(landmarks, iris_points, eye_points, image_w, image_h):
+    try:
+        iris_center = landmarks[iris_points[0]]
+        iris_x = iris_center.x * image_w
+        iris_y = iris_center.y * image_h
+        
+        left_corner = landmarks[eye_points[0]]
+        right_corner = landmarks[eye_points[3]]
+        top_point = landmarks[eye_points[1]]
+        bottom_point = landmarks[eye_points[4]]
+        
+        eye_left = left_corner.x * image_w
+        eye_right = right_corner.x * image_w
+        eye_top = top_point.y * image_h
+        eye_bottom = bottom_point.y * image_h
+        
+        eye_width = eye_right - eye_left
+        eye_height = eye_bottom - eye_top
+        
+        if eye_width > 0:
+            horizontal_pos = (iris_x - eye_left) / eye_width
+            horizontal_pos = max(0, min(1, horizontal_pos))
+        else:
+            horizontal_pos = 0.5
+            
+        if eye_height > 0:
+            vertical_pos = (iris_y - eye_top) / eye_height
+            vertical_pos = max(0, min(1, vertical_pos))
+        else:
+            vertical_pos = 0.5
+            
+        return horizontal_pos, vertical_pos
+    except:
+        return 0.5, 0.5
+
+def get_gaze_direction(h_pos, v_pos):
+    directions = []
+    
+    if h_pos < 0.35:
+        directions.append("LEFT")
+    elif h_pos > 0.65:
+        directions.append("RIGHT")
+    
+    if v_pos < 0.35:
+        directions.append("UP")
+    elif v_pos > 0.65:
+        directions.append("DOWN")
+    
+    if not directions:
+        directions.append("CENTER")
+    
+    return " + ".join(directions)
+
+def get_gaze_score(left_h_pos, left_v_pos, right_h_pos, right_v_pos):
+    avg_h_pos = (left_h_pos + right_h_pos) / 2.0
+    avg_v_pos = (left_v_pos + right_v_pos) / 2.0
+    
+    h_score = 1.0 if 0.35 <= avg_h_pos <= 0.65 else 0.5
+    v_score = 1.0 if 0.35 <= avg_v_pos <= 0.65 else 0.5
+    
+    return (h_score + v_score) / 2.0
+
+def get_head_pose_score(landmarks, image_w, image_h):
+    nose = landmarks[1]
+    x = nose.x * image_w
+    y = nose.y * image_h
+    d = np.linalg.norm(np.array([x - image_w / 2, y - image_h / 2]))
+    return 1.0 if d < 0.3 * image_w else 0.0
+
+def compute_concentration_score(gaze, head_pose, blink):
+    score = 0.5 * gaze + 0.3 * head_pose + 0.2 * (0 if blink else 1)
+    return round(score * 100, 2)
+
+def analyze_emotion(frame):
+    try:
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = face_detection.process(frame_rgb)
+        
+        if results.detections:
+            for detection in results.detections:
+                bboxC = detection.location_data.relative_bounding_box
+                ih, iw, _ = frame.shape
+                x, y, w, h = int(bboxC.xmin * iw), int(bboxC.ymin * ih), \
+                             int(bboxC.width * iw), int(bboxC.height * ih)
+                
+                x, y = max(0, x), max(0, y)
+                w = min(w, iw - x)
+                h = min(h, ih - y)
+                
+                if w > 50 and h > 50:
+                    face_img = frame[y:y+h, x:x+w]
+                    emotion_result = DeepFace.analyze(face_img, 
+                                                     actions=['emotion'], 
+                                                     enforce_detection=False)
+                    
+                    if isinstance(emotion_result, list):
+                        return emotion_result[0]['dominant_emotion']
+                    else:
+                        return emotion_result['dominant_emotion']
+    except Exception as e:
+        print(f"Error analyzing emotion: {e}")
+    
+    return "neutral"
+
+@app.post("/analyze")
+async def analyze_image(file: UploadFile = File(...)):
+    try:
+        # Read image
+        contents = await file.read()
+        nparr = np.frombuffer(contents, np.uint8)
+        frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        
+        if frame is None:
+            raise HTTPException(status_code=400, detail="Invalid image format")
+        
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        image_h, image_w, _ = frame.shape
+        
+        # Process face mesh
+        results = face_mesh.process(frame_rgb)
+        
+        # Analyze emotion
+        emotion = analyze_emotion(frame)
+        
+        response_data = {
+            "emotion": emotion,
+            "face_detected": False,
+            "gaze_direction": "UNKNOWN",
+            "concentration_score": 0.0,
+            "blinking": False,
+            "gaze_positions": {
+                "left_eye": {"horizontal": 0.5, "vertical": 0.5},
+                "right_eye": {"horizontal": 0.5, "vertical": 0.5}
+            }
+        }
+        
+        if results.multi_face_landmarks:
+            for face_landmarks in results.multi_face_landmarks:
+                landmarks = face_landmarks.landmark
+                response_data["face_detected"] = True
+                
+                # Calculate eye aspect ratios
+                left_ear = eye_aspect_ratio(landmarks, LEFT_EYE, image_w, image_h)
+                right_ear = eye_aspect_ratio(landmarks, RIGHT_EYE, image_w, image_h)
+                avg_ear = (left_ear + right_ear) / 2
+                
+                # Get iris positions
+                left_h_pos, left_v_pos = get_iris_position_2d(landmarks, LEFT_IRIS, LEFT_EYE, image_w, image_h)
+                right_h_pos, right_v_pos = get_iris_position_2d(landmarks, RIGHT_IRIS, RIGHT_EYE, image_w, image_h)
+                
+                # Calculate gaze direction
+                avg_direction = get_gaze_direction((left_h_pos + right_h_pos) / 2, (left_v_pos + right_v_pos) / 2)
+                
+                # Calculate scores
+                blink = avg_ear < 0.25
+                gaze_score = get_gaze_score(left_h_pos, left_v_pos, right_h_pos, right_v_pos)
+                head_score = get_head_pose_score(landmarks, image_w, image_h)
+                concentration = compute_concentration_score(gaze_score, head_score, blink)
+                
+                response_data.update({
+                    "gaze_direction": avg_direction,
+                    "concentration_score": float(concentration),
+                    "blinking": bool(blink),
+                    "gaze_positions": {
+                        "left_eye": {"horizontal": float(left_h_pos), "vertical": float(left_v_pos)},
+                        "right_eye": {"horizontal": float(right_h_pos), "vertical": float(right_v_pos)}
+                    }
+                })
+                break
+        
+        return response_data
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
+
+@app.get("/")
+async def root():
+    return {"message": "Gaze and Emotion Detection API"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

deploy.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+echo "🚀 Deploying to Hugging Face Spaces..."
+
+# Check if git is initialized
+if [ ! -d ".git" ]; then
+    echo "Initializing git repository..."
+    git init
+fi
+
+# Add all files
+echo "Adding files to git..."
+git add .
+
+# Commit changes
+echo "Committing changes..."
+git commit -m "Deploy gaze emotion detection API"
+
+echo "✅ Ready for deployment!"
+echo ""
+echo "To deploy to Hugging Face Spaces:"
+echo "1. Go to https://huggingface.co/spaces"
+echo "2. Click 'Create new Space'"
+echo "3. Choose:"
+echo "   - Space name: gaze-emotion-api"
+echo "   - SDK: Docker"
+echo "   - Hardware: CPU basic (free)"
+echo "4. After creating, run:"
+echo "   git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME"
+echo "   git push origin main"
+echo ""
+echo "Or upload these files manually:"
+echo "   - app.py"
+echo "   - requirements.txt"
+echo "   - Dockerfile" 
+echo "   - README.md"

gaze_emotion.py

@@ -0,0 +1,403 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+import time
+from collections import deque
+from deepface import DeepFace
+
+# Initialize MediaPipe Face Mesh with iris landmarks
+mp_face_mesh = mp.solutions.face_mesh
+face_mesh = mp_face_mesh.FaceMesh(
+    refine_landmarks=True,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+# Initialize MediaPipe Face Detection for emotion analysis
+mp_face_detection = mp.solutions.face_detection
+face_detection = mp_face_detection.FaceDetection(min_detection_confidence=0.5)
+mp_drawing = mp.solutions.drawing_utils
+
+# Eye landmark indices
+LEFT_EYE = [33, 160, 158, 133, 153, 144]
+RIGHT_EYE = [362, 385, 387, 263, 373, 380]
+
+# Iris landmark indices
+LEFT_IRIS = [468, 469, 470, 471, 472]
+RIGHT_IRIS = [473, 474, 475, 476, 477]
+
+# Global variables
+score_history = deque(maxlen=10)
+distraction = 0
+last_emotion_time = 0
+current_emotion = "neutral"
+
+# Define emotion colors (BGR format)
+emotion_colors = {
+    'angry': (0, 0, 255),     # Red
+    'disgust': (0, 140, 255), # Orange
+    'fear': (0, 0, 0),        # Black
+    'happy': (0, 255, 255),   # Yellow
+    'sad': (255, 0, 0),       # Blue
+    'surprise': (255, 0, 255),# Purple
+    'neutral': (255, 255, 255)# White
+}
+
+def eye_aspect_ratio(landmarks, eye_points, image_w, image_h, frame):
+    p = []
+    for idx in eye_points:
+        lm = landmarks[idx]
+        x, y = int(lm.x * image_w), int(lm.y * image_h)
+        cv2.circle(frame, (x, y), 2, (0, 255, 0), -1)
+        p.append((x, y))
+    
+    A = np.linalg.norm(np.array(p[1]) - np.array(p[5]))
+    B = np.linalg.norm(np.array(p[2]) - np.array(p[4]))
+    C = np.linalg.norm(np.array(p[0]) - np.array(p[3]))
+    ear = (A + B) / (2.0 * C)
+    return ear
+
+def draw_iris(landmarks, iris_points, image_w, image_h, frame, color=(0, 255, 255)):
+    """Draw iris/pupil tracking"""
+    iris_coords = []
+    for idx in iris_points:
+        lm = landmarks[idx]
+        x, y = int(lm.x * image_w), int(lm.y * image_h)
+        iris_coords.append((x, y))
+    
+    if len(iris_coords) >= 5:
+        # Draw iris center (first point is center)
+        center = iris_coords[0]
+        cv2.circle(frame, center, 4, color, -1)
+        
+        # Draw iris boundary
+        for i in range(1, len(iris_coords)):
+            cv2.circle(frame, iris_coords[i], 2, color, -1)
+        
+        # Draw iris circle
+        if len(iris_coords) >= 3:
+            radius = int(np.linalg.norm(np.array(iris_coords[0]) - np.array(iris_coords[1])))
+            cv2.circle(frame, center, radius, color, 2)
+    
+    return iris_coords
+
+def get_iris_position_2d(landmarks, iris_points, eye_points, image_w, image_h):
+    """Get iris position relative to eye in both X and Y directions"""
+    try:
+        # Get iris center
+        iris_center = landmarks[iris_points[0]]
+        iris_x = iris_center.x * image_w
+        iris_y = iris_center.y * image_h
+        
+        # Get eye corners for horizontal position
+        left_corner = landmarks[eye_points[0]]
+        right_corner = landmarks[eye_points[3]]
+        
+        # Get eye top and bottom for vertical position
+        top_point = landmarks[eye_points[1]]
+        bottom_point = landmarks[eye_points[4]]
+        
+        # Calculate eye dimensions
+        eye_left = left_corner.x * image_w
+        eye_right = right_corner.x * image_w
+        eye_top = top_point.y * image_h
+        eye_bottom = bottom_point.y * image_h
+        
+        eye_width = eye_right - eye_left
+        eye_height = eye_bottom - eye_top
+        
+        # Calculate relative positions (0 to 1)
+        if eye_width > 0:
+            horizontal_pos = (iris_x - eye_left) / eye_width
+            horizontal_pos = max(0, min(1, horizontal_pos))
+        else:
+            horizontal_pos = 0.5
+            
+        if eye_height > 0:
+            vertical_pos = (iris_y - eye_top) / eye_height
+            vertical_pos = max(0, min(1, vertical_pos))
+        else:
+            vertical_pos = 0.5
+            
+        return horizontal_pos, vertical_pos
+    except:
+        return 0.5, 0.5
+
+def get_gaze_direction(h_pos, v_pos):
+    """Determine gaze direction based on iris position"""
+    directions = []
+    
+    # Horizontal direction
+    if h_pos < 0.35:
+        directions.append("LEFT")
+    elif h_pos > 0.65:
+        directions.append("RIGHT")
+    
+    # Vertical direction
+    if v_pos < 0.35:
+        directions.append("UP")
+    elif v_pos > 0.65:
+        directions.append("DOWN")
+    
+    if not directions:
+        directions.append("CENTER")
+    
+    return " + ".join(directions)
+
+def is_blinking(ear, threshold=0.25):
+    return ear < threshold
+
+def get_head_pose_score(landmarks, image_w, image_h):
+    nose = landmarks[1]
+    x = nose.x * image_w
+    y = nose.y * image_h
+    d = np.linalg.norm(np.array([x - image_w / 2, y - image_h / 2]))
+    return 1.0 if d < 0.3 * image_w else 0.0
+
+def get_gaze_score(left_h_pos, left_v_pos, right_h_pos, right_v_pos):
+    """Calculate gaze score based on iris positions"""
+    avg_h_pos = (left_h_pos + right_h_pos) / 2.0
+    avg_v_pos = (left_v_pos + right_v_pos) / 2.0
+    
+    # Score higher when looking at center
+    h_score = 1.0 if 0.35 <= avg_h_pos <= 0.65 else 0.5
+    v_score = 1.0 if 0.35 <= avg_v_pos <= 0.65 else 0.5
+    
+    return (h_score + v_score) / 2.0
+
+def compute_concentration_score(gaze, head_pose, blink):
+    score = 0.5 * gaze + 0.3 * head_pose + 0.2 * (0 if blink else 1)
+    return round(score * 100, 2)
+
+def draw_concentration_bar(score, frame):
+    bar_width = 200
+    bar_height = 30
+    bar_x = 30
+    bar_y = 100
+    
+    # Background
+    cv2.rectangle(frame, (bar_x, bar_y), (bar_x + bar_width, bar_y + bar_height), (50, 50, 50), -1)
+    
+    # Fill
+    fill_width = int(score * bar_width / 100)
+    color = (0, 255, 0) if score > 60 else (0, 150, 255) if score > 40 else (0, 100, 255)
+    cv2.rectangle(frame, (bar_x, bar_y), (bar_x + fill_width, bar_y + bar_height), color, -1)
+    
+    # Border
+    cv2.rectangle(frame, (bar_x, bar_y), (bar_x + bar_width, bar_y + bar_height), (200, 200, 200), 2)
+    
+    # Text
+    cv2.putText(frame, f"{score}%", (bar_x + bar_width + 10, bar_y + bar_height // 2 + 5),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (200, 200, 200), 2)
+
+def draw_gaze_tracker(left_h_pos, left_v_pos, right_h_pos, right_v_pos, frame):
+    """Draw comprehensive gaze tracking display"""
+    # Calculate average gaze
+    avg_h = (left_h_pos + right_h_pos) / 2.0
+    avg_v = (left_v_pos + right_v_pos) / 2.0
+    
+    # Draw gaze grid
+    grid_x = 350
+    grid_y = 50
+    grid_size = 120
+    
+    # Grid background
+    cv2.rectangle(frame, (grid_x, grid_y), (grid_x + grid_size, grid_y + grid_size), (50, 50, 50), -1)
+    cv2.rectangle(frame, (grid_x, grid_y), (grid_x + grid_size, grid_y + grid_size), (200, 200, 200), 2)
+    
+    # Grid lines
+    for i in range(1, 3):
+        # Vertical lines
+        x_line = grid_x + i * grid_size // 3
+        cv2.line(frame, (x_line, grid_y), (x_line, grid_y + grid_size), (100, 100, 100), 1)
+        # Horizontal lines
+        y_line = grid_y + i * grid_size // 3
+        cv2.line(frame, (grid_x, y_line), (grid_x + grid_size, y_line), (100, 100, 100), 1)
+    
+    # Gaze position indicator
+    gaze_x = int(grid_x + avg_h * grid_size)
+    gaze_y = int(grid_y + avg_v * grid_size)
+    cv2.circle(frame, (gaze_x, gaze_y), 8, (0, 255, 255), -1)
+    cv2.circle(frame, (gaze_x, gaze_y), 12, (0, 255, 255), 2)
+    
+    # Center target
+    center_x = grid_x + grid_size // 2
+    center_y = grid_y + grid_size // 2
+    cv2.circle(frame, (center_x, center_y), 15, (0, 255, 0), 2)
+    
+    # Labels
+    cv2.putText(frame, "Gaze Tracker", (grid_x, grid_y - 10),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (200, 200, 200), 2)
+
+def draw_emotion_info(emotion, frame):
+    """Draw emotion information"""
+    emotion_x = 500
+    emotion_y = 50
+    emotion_width = 150
+    emotion_height = 120
+    
+    # Background
+    cv2.rectangle(frame, (emotion_x, emotion_y), (emotion_x + emotion_width, emotion_y + emotion_height), (40, 40, 40), -1)
+    cv2.rectangle(frame, (emotion_x, emotion_y), (emotion_x + emotion_width, emotion_y + emotion_height), (200, 200, 200), 2)
+    
+    # Title
+    cv2.putText(frame, "Emotion", (emotion_x + 10, emotion_y + 25),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (200, 200, 200), 2)
+    
+    # Current emotion
+    emotion_color = emotion_colors.get(emotion, (255, 255, 255))
+    cv2.putText(frame, emotion.upper(), (emotion_x + 10, emotion_y + 55),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.7, emotion_color, 2)
+    
+    # Emotion indicator circle
+    cv2.circle(frame, (emotion_x + 75, emotion_y + 85), 20, emotion_color, -1)
+    cv2.circle(frame, (emotion_x + 75, emotion_y + 85), 20, (200, 200, 200), 2)
+
+def analyze_emotion(frame, face_detection):
+    """Analyze emotion from frame"""
+    global last_emotion_time, current_emotion
+    
+    current_time = time.time()
+    
+    # Only analyze emotion every 1 second to reduce computational load
+    if current_time - last_emotion_time > 1.0:
+        try:
+            # Convert frame to RGB for face detection
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = face_detection.process(frame_rgb)
+            
+            if results.detections:
+                for detection in results.detections:
+                    # Get bounding box coordinates
+                    bboxC = detection.location_data.relative_bounding_box
+                    ih, iw, _ = frame.shape
+                    x, y, w, h = int(bboxC.xmin * iw), int(bboxC.ymin * ih), \
+                                 int(bboxC.width * iw), int(bboxC.height * ih)
+                    
+                    # Ensure coordinates are within image boundaries
+                    x, y = max(0, x), max(0, y)
+                    w = min(w, iw - x)
+                    h = min(h, ih - y)
+                    
+                    if w > 50 and h > 50:  # Ensure face is large enough
+                        # Extract face for emotion analysis
+                        face_img = frame[y:y+h, x:x+w]
+                        
+                        # Analyze emotion using DeepFace
+                        emotion_result = DeepFace.analyze(face_img, 
+                                                         actions=['emotion'], 
+                                                         enforce_detection=False)
+                        
+                        # Extract dominant emotion
+                        if isinstance(emotion_result, list):
+                            current_emotion = emotion_result[0]['dominant_emotion']
+                        else:
+                            current_emotion = emotion_result['dominant_emotion']
+                        
+                        last_emotion_time = current_time
+                        break
+        except Exception as e:
+            print(f"Error analyzing emotion: {e}")
+    
+    return current_emotion
+
+# Main loop
+cap = cv2.VideoCapture(0)
+blink_counter = 0
+prev_frame_time = 0
+
+while True:
+    ret, frame = cap.read()
+    if not ret:
+        break
+
+    # Calculate FPS
+    new_frame_time = time.time()
+    fps = 1/(new_frame_time-prev_frame_time) if prev_frame_time != 0 else 0
+    prev_frame_time = new_frame_time
+
+    # Create UI background
+    ui_bg = frame.copy()
+    cv2.rectangle(ui_bg, (0, 0), (frame.shape[1], 220), (30, 30, 30), -1)
+    cv2.addWeighted(ui_bg, 0.7, frame, 0.3, 0, frame)
+
+    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    image_h, image_w, _ = frame.shape
+    
+    # Process face mesh for eye tracking
+    results = face_mesh.process(frame_rgb)
+    
+    # Analyze emotion
+    emotion = analyze_emotion(frame, face_detection)
+
+    if results.multi_face_landmarks:
+        for face_landmarks in results.multi_face_landmarks:
+            landmarks = face_landmarks.landmark
+
+            # Calculate eye aspect ratios
+            left_ear = eye_aspect_ratio(landmarks, LEFT_EYE, image_w, image_h, frame)
+            right_ear = eye_aspect_ratio(landmarks, RIGHT_EYE, image_w, image_h, frame)
+            avg_ear = (left_ear + right_ear) / 2
+
+            # Draw iris tracking
+            left_iris_coords = draw_iris(landmarks, LEFT_IRIS, image_w, image_h, frame, (255, 100, 0))
+            right_iris_coords = draw_iris(landmarks, RIGHT_IRIS, image_w, image_h, frame, (0, 100, 255))
+
+            # Get 2D iris positions
+            left_h_pos, left_v_pos = get_iris_position_2d(landmarks, LEFT_IRIS, LEFT_EYE, image_w, image_h)
+            right_h_pos, right_v_pos = get_iris_position_2d(landmarks, RIGHT_IRIS, RIGHT_EYE, image_w, image_h)
+
+            # Get gaze directions
+            left_direction = get_gaze_direction(left_h_pos, left_v_pos)
+            right_direction = get_gaze_direction(right_h_pos, right_v_pos)
+            avg_direction = get_gaze_direction((left_h_pos + right_h_pos) / 2, (left_v_pos + right_v_pos) / 2)
+
+            # Calculate scores
+            blink = is_blinking(avg_ear)
+            gaze_score = get_gaze_score(left_h_pos, left_v_pos, right_h_pos, right_v_pos)
+            head_score = get_head_pose_score(landmarks, image_w, image_h)
+            concentration = compute_concentration_score(gaze_score, head_score, blink)
+
+            # Update history and smooth score
+            score_history.append(concentration)
+            smooth_score = int(np.mean(score_history))
+            
+            # Draw UI elements
+            draw_concentration_bar(smooth_score, frame)
+            draw_gaze_tracker(left_h_pos, left_v_pos, right_h_pos, right_v_pos, frame)
+            draw_emotion_info(emotion, frame)
+
+            # Text information
+            cv2.putText(frame, f"Concentration: {smooth_score}%", (30, 30),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
+            
+            cv2.putText(frame, f"Gaze: {avg_direction}", (30, 55),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
+            
+            cv2.putText(frame, f"Emotion: {emotion}", (30, 75),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, emotion_colors.get(emotion, (255, 255, 255)), 2)
+
+            if blink:
+                cv2.putText(frame, "BLINKING", (30, 200),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 150, 255), 2)
+
+            # Distraction tracking
+            if smooth_score < 40:
+                distraction += 1
+                if distraction > 1000:
+                    distraction = 0
+                    print(f'Focus alert! Looking {avg_direction}, Emotion: {emotion}')
+
+    # FPS and status
+    cv2.putText(frame, f"FPS: {fps:.1f}", (image_w - 120, 30),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (200, 200, 0), 2)
+
+    status_color = (0, 255, 0) if distraction < 50 else (0, 100, 255)
+    cv2.circle(frame, (image_w - 30, 50), 10, status_color, -1)
+
+    cv2.imshow("Eye Tracking + Emotion Detection", frame)
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+cap.release()
+cv2.destroyAllWindows()

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+opencv-python-headless
+mediapipe
+numpy
+deepface
+Pillow
+python-multipart
+# tensorflow
+tf-keras

test_api.py

@@ -0,0 +1,21 @@
+import requests
+import json
+
+# Test the API
+def test_api():
+    # Use existing image.png file
+    url = "http://localhost:7860/analyze"
+    
+    with open("image.png", "rb") as f:
+        files = {"file": ("image.png", f, "image/jpeg")}
+        response = requests.post(url, files=files)
+    
+    if response.status_code == 200:
+        result = response.json()
+        print(json.dumps(result, indent=2))
+    else:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+
+if __name__ == "__main__":
+    test_api()