Update app.py

app.py

@@ -1,74 +1,169 @@
 import cv2
-import mediapipe as mp
 import numpy as np
+import mediapipe as mp
 import gradio as gr
+import math
+from collections import deque
+import time
 
-# Initialize Mediapipe Hands
+# Initialize MediaPipe Hand solution
 mp_hands = mp.solutions.hands
-hands = mp_hands.Hands(min_detection_confidence=0.7, min_tracking_confidence=0.7)
-
-# Generate simple circle points as target shape
-def generate_circle_points(center, radius, num_points=50):
-    return np.array([
-        [int(center[0] + radius * np.cos(2 * np.pi * i / num_points)),
-         int(center[1] + radius * np.sin(2 * np.pi * i / num_points))]
-        for i in range(num_points)
-    ])
-
-target_shape = generate_circle_points(center=(320, 240), radius=100)
-
-# Calculate shape similarity (simplified)
-def compare_shapes(drawn_points, target_points):
-    if len(drawn_points) < 10:
-        return 0  # Not enough points to compare
-    drawn_resampled = np.array(drawn_points[::max(1, len(drawn_points)//50)])
-    if drawn_resampled.shape[0] != target_points.shape[0]:
-        return 0
-    dist = np.linalg.norm(drawn_resampled - target_points, axis=1)
-    score = max(0, 100 - np.mean(dist) * 0.1)  # Scale and clamp score
-    return round(score, 2)
+mp_drawing = mp.solutions.drawing_utils
+hands = mp_hands.Hands(
+    static_image_mode=False,
+    max_num_hands=1,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
 
-# Gradio function
-def live_shape_match(video_frame):
-    global points  # Keep trail across frames
-    h, w, _ = video_frame.shape
-    rgb_frame = cv2.cvtColor(video_frame, cv2.COLOR_BGR2RGB)
-    result = hands.process(rgb_frame)
+# Initialize deque to store finger path points (with max length to avoid memory issues)
+max_path_length = 100
+finger_path = deque(maxlen=max_path_length)
 
-    if result.multi_hand_landmarks:
-        for hand_landmarks in result.multi_hand_landmarks:
-            x = int(hand_landmarks.landmark[8].x * w)
-            y = int(hand_landmarks.landmark[8].y * h)
-            points.append([x, y])
+# Flag to start/stop drawing
+is_drawing = False
 
-    # Draw the trail
-    for i in range(1, len(points)):
-        cv2.line(video_frame, tuple(points[i - 1]), tuple(points[i]), (0, 255, 0), 3)
+# Perfect shapes for comparison
+def create_perfect_circle(center, radius, num_points=100):
+    """Create points for a perfect circle"""
+    circle_points = []
+    for i in range(num_points):
+        angle = 2 * math.pi * i / num_points
+        x = int(center[0] + radius * math.cos(angle))
+        y = int(center[1] + radius * math.sin(angle))
+        circle_points.append((x, y))
+    return circle_points
 
-    # Draw the target shape
-    for i in range(1, len(target_shape)):
-        cv2.line(video_frame, tuple(target_shape[i - 1]), tuple(target_shape[i]), (255, 0, 0), 2)
+# Initial target shape - circle
+target_shape_name = "circle"
+target_shape = None  # Will be set based on frame dimensions
 
-    # Calculate score
-    score = compare_shapes(points, target_shape)
+# Calculate similarity between drawn path and target shape
+def calculate_similarity(path, target_shape):
+    """Calculate similarity between drawn path and target shape using shape metrics"""
+    if len(path) < 5:  # Not enough points to calculate
+        return 0
+    
+    # Convert path to numpy array
+    path_array = np.array(list(path))
+    
+    # Simple metrics - compare against circle properties
+    # 1. Calculate centroid of the drawn shape
+    centroid = np.mean(path_array, axis=0)
+    
+    # 2. Calculate distances from centroid to each point
+    distances = np.sqrt(np.sum((path_array - centroid)**2, axis=1))
+    
+    # 3. For a perfect circle, the standard deviation of distances should be close to 0
+    std_dev = np.std(distances)
+    mean_dist = np.mean(distances)
+    
+    # 4. Normalize the standard deviation as a percentage of the mean radius
+    if mean_dist > 0:
+        # Lower std_dev means more circular
+        similarity = max(0, 100 - (std_dev / mean_dist * 100))
+        return min(100, similarity)  # Cap at 100%
+    return 0
 
-    # Show score
-    cv2.putText(video_frame, f"Score: {score}", (10, 30),
-                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+def process_frame(frame):
+    """Process a single frame from the webcam"""
+    global finger_path, is_drawing, target_shape
+    
+    # Set target shape if not already set
+    if target_shape is None:
+        height, width = frame.shape[:2]
+        center = (width // 2, height // 2)
+        radius = min(width, height) // 4
+        target_shape = create_perfect_circle(center, radius)
+    
+    # Convert the BGR image to RGB
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    
+    # Process the frame with MediaPipe Hands
+    results = hands.process(rgb_frame)
+    
+    # Draw target shape (circle for now)
+    for point in target_shape:
+        cv2.circle(frame, point, 1, (0, 255, 0), -1)
+    
+    # If hands are detected
+    if results.multi_hand_landmarks:
+        for hand_landmarks in results.multi_hand_landmarks:
+            # Draw hand landmarks
+            mp_drawing.draw_landmarks(
+                frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)
+            
+            # Get index finger tip coordinates
+            index_finger_tip = hand_landmarks.landmark[mp_hands.HandLandmark.INDEX_FINGER_TIP]
+            h, w, c = frame.shape
+            x, y = int(index_finger_tip.x * w), int(index_finger_tip.y * h)
+            
+            # Check if index finger is raised (simplified)
+            index_finger_mcp = hand_landmarks.landmark[mp_hands.HandLandmark.INDEX_FINGER_MCP]
+            if index_finger_tip.y < index_finger_mcp.y:  # Index finger is raised
+                is_drawing = True
+                finger_path.append((x, y))
+                
+                # Draw a filled circle at the finger tip
+                cv2.circle(frame, (x, y), 10, (255, 0, 0), -1)
+            else:
+                is_drawing = False
+    
+    # Draw the finger path
+    if len(finger_path) > 1:
+        for i in range(1, len(finger_path)):
+            cv2.line(frame, finger_path[i-1], finger_path[i], (0, 0, 255), 2)
+    
+    # Calculate and display similarity score
+    similarity = calculate_similarity(finger_path, target_shape)
+    cv2.putText(
+        frame, f"Score: {similarity:.1f}%", (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2
+    )
+    
+    # Display instructions
+    cv2.putText(
+        frame, "Draw a circle with your index finger", (10, 70),
+        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2
+    )
+    
+    return frame
 
-    return video_frame
+def clear_path():
+    """Clear the current drawing path"""
+    global finger_path
+    finger_path.clear()
+    return "Path cleared!"
 
-# Reset points buffer
-points = []
+def webcam_feed(video):
+    """Process webcam feed and return processed frames"""
+    return process_frame(video)
 
-# Build Gradio app
-iface = gr.Interface(
-    fn=live_shape_match,
-    inputs=gr.Image(source="webcam", streaming=True),
-    outputs="image",
-    live=True,
-    title="Real-Time Shape Drawing Analyzer",
-    description="Draw a circle in the air with your finger! Watch your score update live."
-)
+# Create Gradio interface
+with gr.Blocks(title="Shape Drawing Game") as demo:
+    gr.Markdown("# ✏️ Shape Drawing Game")
+    gr.Markdown("Draw shapes in the air using your index finger and see how close you get to the target shape!")
+    
+    with gr.Row():
+        webcam = gr.Image(source="webcam", streaming=True, label="Webcam Feed")
+        processed = gr.Image(label="Game View")
+    
+    webcam.stream(webcam_feed, webcam, processed)
+    
+    with gr.Row():
+        clear_button = gr.Button("Clear Drawing")
+    
+    clear_button.click(fn=clear_path, outputs=gr.Textbox(label="Status"))
+    
+    gr.Markdown("""
+    ## How to Play:
+    1. Position your hand in front of the camera
+    2. Raise your index finger to start drawing
+    3. Try to trace the green circle as closely as possible
+    4. See your score update in real-time
+    5. Click 'Clear Drawing' to start over
+    """)
 
-iface.launch()
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(debug=True)