Add application file

.docker-compose.yml

@@ -0,0 +1,30 @@
+version: '3.8'
+
+services:
+  squat-analyzer:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "7860:7860"
+    volumes:
+      # Mount temporary directory for video processing
+      - /tmp/squat-analyzer:/tmp/gradio
+    environment:
+      - GRADIO_SERVER_NAME=0.0.0.0
+      - GRADIO_SERVER_PORT=7860
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:7860/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    restart: unless-stopped
+    deploy:
+      resources:
+        limits:
+          memory: 2G
+          cpus: '1.0'
+        reservations:
+          memory: 1G
+          cpus: '0.5'

.dockerignore

@@ -0,0 +1,90 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+.gitattributes
+
+# Documentation
+README.md
+*.md
+docs/
+
+# Test files
+tests/
+test_*.py
+*_test.py
+
+# Jupyter notebooks
+*.ipynb
+.ipynb_checkpoints/
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+*.temp
+
+# Logs
+*.log
+logs/
+
+# Media files (examples)
+*.mp4
+*.avi
+*.mov
+*.mkv
+*.wmv
+*.flv
+*.webm
+
+# Cache
+.cache/
+*.cache

Dockerfile

@@ -0,0 +1,73 @@
+FROM python:3.9-slim
+
+# Create non-root user for security
+RUN useradd -m -u 1000 user
+
+# Install system dependencies needed for OpenCV and MediaPipe
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgstreamer1.0-0 \
+    libgstreamer-plugins-base1.0-0 \
+    libgstreamer-plugins-good1.0-0 \
+    libgstreamer-plugins-bad1.0-0 \
+    gstreamer1.0-plugins-ugly \
+    gstreamer1.0-tools \
+    ffmpeg \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    wget \
+    curl \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Create necessary directories with proper permissions
+RUN mkdir -p /tmp/matplotlib \
+    && mkdir -p /tmp/mediapipe \
+    && mkdir -p /tmp/gradio \
+    && mkdir -p /home/user/.cache/matplotlib \
+    && mkdir -p /home/user/.cache/pip \
+    && mkdir -p /home/user/.local/lib/python3.9/site-packages \
+    && chown -R user:user /app \
+    && chown -R user:user /tmp \
+    && chown -R user:user /home/user
+
+# Set environment variables for headless operation
+ENV OPENCV_IO_ENABLE_JASPER=1
+ENV OPENCV_IO_ENABLE_OPENEXR=1
+ENV MPLCONFIGDIR=/home/user/.cache/matplotlib
+ENV MEDIAPIPE_CACHE_DIR=/tmp/mediapipe
+ENV GRADIO_TEMP_DIR=/tmp/gradio
+ENV HOME=/home/user
+ENV PATH="/home/user/.local/bin:${PATH}"
+ENV PYTHONPATH="${PYTHONPATH}:/home/user/.local/lib/python3.9/site-packages"
+
+# Switch to non-root user
+USER user
+
+# Copy and install Python dependencies
+COPY --chown=user:user requirements.txt .
+RUN pip install --no-cache-dir --user --upgrade pip
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Pre-download MediaPipe models to avoid runtime downloads
+RUN python -c "import mediapipe as mp; mp.solutions.pose.Pose()"
+
+# Copy application code
+COPY --chown=user:user app.py .
+
+# Expose the port that Gradio uses
+EXPOSE 7860
+
+# Health check to ensure the service is running
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+  CMD curl -f http://localhost:7860/ || exit 1
+
+# Run the application with proper Gradio server settings for Hugging Face
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,348 @@
+import gradio as gr
+import cv2
+import numpy as np
+import mediapipe as mp
+import tempfile
+import os
+from typing import List, Tuple, Dict
+import math
+from pathlib import Path
+
+
+class SquatFormAnalyzer:
+    def __init__(self):
+        self.mp_pose = mp.solutions.pose
+        self.pose = self.mp_pose.Pose(
+            static_image_mode=False,
+            model_complexity=2,
+            enable_segmentation=False,
+            min_detection_confidence=0.5,
+            min_tracking_confidence=0.5
+        )
+        self.mp_drawing = mp.solutions.drawing_utils
+
+    def calculate_angle(self, a, b, c):
+        """Calculate angle between three points"""
+        a = np.array(a)
+        b = np.array(b)
+        c = np.array(c)
+
+        radians = np.arctan2(c[1] - b[1], c[0] - b[0]) - np.arctan2(a[1] - b[1], a[0] - b[0])
+        angle = np.abs(radians * 180.0 / np.pi)
+
+        if angle > 180.0:
+            angle = 360 - angle
+
+        return angle
+
+    def analyze_knee_alignment(self, landmarks, frame_width, frame_height):
+        """Check for knees caving inward"""
+        try:
+            # Get hip, knee, and ankle landmarks
+            left_hip = [landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].x * frame_width,
+                        landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].y * frame_height]
+            right_hip = [landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x * frame_width,
+                         landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y * frame_height]
+            left_knee = [landmarks[self.mp_pose.PoseLandmark.LEFT_KNEE.value].x * frame_width,
+                         landmarks[self.mp_pose.PoseLandmark.LEFT_KNEE.value].y * frame_height]
+            right_knee = [landmarks[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].x * frame_width,
+                          landmarks[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].y * frame_height]
+            left_ankle = [landmarks[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].x * frame_width,
+                          landmarks[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].y * frame_height]
+            right_ankle = [landmarks[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].x * frame_width,
+                           landmarks[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].y * frame_height]
+
+            # Calculate knee angles relative to hip-ankle line
+            left_knee_angle = self.calculate_angle(left_hip, left_knee, left_ankle)
+            right_knee_angle = self.calculate_angle(right_hip, right_knee, right_ankle)
+
+            # Also check knee width ratio
+            hip_width = abs(left_hip[0] - right_hip[0])
+            knee_width = abs(left_knee[0] - right_knee[0])
+            ankle_width = abs(left_ankle[0] - right_ankle[0])
+
+            # Multiple criteria for knee valgus
+            knee_ratio = knee_width / hip_width if hip_width > 0 else 1
+            ankle_ratio = knee_width / ankle_width if ankle_width > 0 else 1
+
+            # Knees cave in if they're too close relative to hips and ankles
+            knee_valgus = (knee_ratio < 0.75 or ankle_ratio < 0.9 or
+                           left_knee_angle < 160 or right_knee_angle < 160)
+
+            return knee_valgus
+
+        except (AttributeError, IndexError, ZeroDivisionError):
+            return False
+
+    def analyze_forward_lean(self, landmarks):
+        """Check for excessive forward lean"""
+        try:
+            # Get shoulder, hip, and ankle landmarks
+            left_shoulder = [landmarks[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                             landmarks[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
+            right_shoulder = [landmarks[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x,
+                              landmarks[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y]
+            left_hip = [landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].x,
+                        landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].y]
+            right_hip = [landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x,
+                         landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y]
+
+            # Calculate average positions
+            avg_shoulder = [(left_shoulder[0] + right_shoulder[0]) / 2,
+                            (left_shoulder[1] + right_shoulder[1]) / 2]
+            avg_hip = [(left_hip[0] + right_hip[0]) / 2,
+                       (left_hip[1] + right_hip[1]) / 2]
+
+            # Calculate forward lean angle
+            horizontal_distance = abs(avg_shoulder[0] - avg_hip[0])
+            vertical_distance = abs(avg_shoulder[1] - avg_hip[1])
+
+            if vertical_distance > 0:
+                lean_angle = math.degrees(math.atan(horizontal_distance / vertical_distance))
+                return lean_angle > 15  # More than 15 degrees forward lean
+
+            return False
+
+        except (AttributeError, IndexError, ZeroDivisionError):
+            return False
+
+    def analyze_depth(self, landmarks):
+        """Check if squat depth is adequate"""
+        try:
+            # Get hip, knee, and ankle landmarks
+            left_hip = [landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].x,
+                        landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].y]
+            right_hip = [landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x,
+                         landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y]
+            left_knee = [landmarks[self.mp_pose.PoseLandmark.LEFT_KNEE.value].x,
+                         landmarks[self.mp_pose.PoseLandmark.LEFT_KNEE.value].y]
+            right_knee = [landmarks[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].x,
+                          landmarks[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].y]
+
+            # Calculate average positions
+            avg_hip = [(left_hip[0] + right_hip[0]) / 2, (left_hip[1] + right_hip[1]) / 2]
+            avg_knee = [(left_knee[0] + right_knee[0]) / 2, (left_knee[1] + right_knee[1]) / 2]
+
+            # Check if hips drop below knees (good depth)
+            return avg_hip[1] > avg_knee[1]  # In image coordinates, y increases downward
+
+        except (AttributeError, IndexError):
+            return False
+
+    def process_video(self, video_path):
+        """Process video and analyze squat form"""
+        cap = cv2.VideoCapture(video_path)
+
+        # Get video properties
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+        # Create output video writer
+        output_path = tempfile.mktemp(suffix='.mp4')
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
+        frame_count = 0
+        analysis_results = {
+            'knee_inward': [],
+            'forward_lean': [],
+            'depth_issues': [],
+            'total_frames': 0
+        }
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            frame_count += 1
+
+            # Convert BGR to RGB
+            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+            # Process frame with MediaPipe
+            results = self.pose.process(rgb_frame)
+
+            # Initialize error flags
+            knee_error = False
+            lean_error = False
+            depth_ok = True
+
+            if results.pose_landmarks:
+                # Draw pose landmarks
+                annotated_frame = frame.copy()
+                self.mp_drawing.draw_landmarks(
+                    annotated_frame, results.pose_landmarks, self.mp_pose.POSE_CONNECTIONS)
+
+                # Analyze form
+                knee_error = self.analyze_knee_alignment(results.pose_landmarks.landmark, width, height)
+                lean_error = self.analyze_forward_lean(results.pose_landmarks.landmark)
+                depth_ok = self.analyze_depth(results.pose_landmarks.landmark)
+
+                # Add analysis results
+                analysis_results['knee_inward'].append(knee_error)
+                analysis_results['forward_lean'].append(lean_error)
+                analysis_results['depth_issues'].append(not depth_ok)
+
+                # Add status indicators
+                y_offset = 30
+                if knee_error:
+                    cv2.putText(annotated_frame, "KNEE VALGUS", (10, y_offset),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                    cv2.circle(annotated_frame, (width - 50, y_offset - 10), 15, (0, 0, 255), -1)
+                    y_offset += 40
+
+                if lean_error:
+                    cv2.putText(annotated_frame, "FORWARD LEAN", (10, y_offset),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                    cv2.circle(annotated_frame, (width - 50, y_offset - 10), 15, (0, 0, 255), -1)
+                    y_offset += 40
+
+                if not depth_ok:
+                    cv2.putText(annotated_frame, "SHALLOW DEPTH", (10, y_offset),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 165, 0), 2)
+                    cv2.circle(annotated_frame, (width - 50, y_offset - 10), 15, (255, 165, 0), -1)
+
+                # Green light if form is good
+                if not knee_error and not lean_error and depth_ok:
+                    cv2.putText(annotated_frame, "GOOD FORM", (10, 30),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+                    cv2.circle(annotated_frame, (width - 50, 20), 15, (0, 255, 0), -1)
+
+                out.write(annotated_frame)
+            else:
+                out.write(frame)
+
+        cap.release()
+        out.release()
+
+        analysis_results['total_frames'] = frame_count
+
+        return output_path, analysis_results
+
+    def generate_summary(self, analysis_results):
+        """Generate analysis summary"""
+        total_frames = analysis_results['total_frames']
+        if total_frames == 0:
+            return "No pose detected in video"
+
+        knee_issues = sum(analysis_results['knee_inward'])
+        lean_issues = sum(analysis_results['forward_lean'])
+        depth_issues = sum(analysis_results['depth_issues'])
+
+        knee_percentage = (knee_issues / total_frames) * 100
+        lean_percentage = (lean_issues / total_frames) * 100
+        depth_percentage = (depth_issues / total_frames) * 100
+
+        summary = f"""
+        ## Squat Form Analysis Results
+
+        **Total Frames Analyzed:** {total_frames}
+
+        ### Form Issues Detected:
+
+        🦵 **Knee Valgus (Knees Inward):** {knee_percentage:.1f}% of frames
+        {'❌ Significant issue - Focus on pushing knees out' if knee_percentage > 20 else '✅ Good knee alignment' if knee_percentage < 10 else '⚠️ Minor issue - Monitor knee tracking'}
+
+        🏃 **Forward Lean:** {lean_percentage:.1f}% of frames
+        {'❌ Excessive forward lean detected' if lean_percentage > 30 else '✅ Good posture' if lean_percentage < 15 else '⚠️ Some forward lean - Keep chest up'}
+
+        📏 **Squat Depth:** {depth_percentage:.1f}% of frames with shallow depth
+        {'❌ Insufficient depth - Go lower' if depth_percentage > 50 else '✅ Good depth' if depth_percentage < 20 else '⚠️ Inconsistent depth'}
+
+        ### Recommendations:
+        """
+
+        if knee_percentage > 20:
+            summary += "\n- Focus on pushing your knees out in line with your toes"
+            summary += "\n- Strengthen your glutes and hip external rotators"
+
+        if lean_percentage > 30:
+            summary += "\n- Work on ankle mobility and thoracic spine extension"
+            summary += "\n- Keep your chest up and maintain a neutral spine"
+
+        if depth_percentage > 50:
+            summary += "\n- Improve ankle and hip mobility"
+            summary += "\n- Practice bodyweight squats to full depth"
+
+        if knee_percentage < 10 and lean_percentage < 15 and depth_percentage < 20:
+            summary += "\n✅ **Excellent squat form! Keep up the great work!**"
+
+        return summary
+
+
+# Initialize the analyzer
+analyzer = SquatFormAnalyzer()
+
+
+def analyze_squat_video(video_file):
+    """Main function to process uploaded video"""
+    if video_file is None:
+        return None, "Please upload a video file."
+
+    # Check file size (limit to 100MB)
+    file_size = os.path.getsize(video_file) / (1024 * 1024)  # Size in MB
+    if file_size > 100:
+        return None, "File size too large. Please upload a video smaller than 100MB."
+
+    try:
+        # Process the video
+        output_video, results = analyzer.process_video(video_file)
+
+        # Generate summary
+        summary = analyzer.generate_summary(results)
+
+        return output_video, summary
+
+    except Exception as e:
+        return None, f"Error processing video: {str(e)}. Please ensure the video format is supported (MP4, AVI, MOV)."
+
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=analyze_squat_video,
+    inputs=[
+        gr.Video(
+            label="Upload Squat Video",
+            format="mp4"
+        )
+    ],
+    outputs=[
+        gr.Video(
+            label="Analyzed Video",
+            format="mp4"
+        ),
+        gr.Markdown(
+            label="Analysis Report"
+        )
+    ],
+    title="🏋️ Squat Form Analyzer",
+    description="""
+    Upload a video of yourself performing squats to get real-time form analysis.
+
+    **The app will analyze:**
+    - Knee alignment (knees caving inward)
+    - Forward lean of the torso
+    - Squat depth
+
+    **Instructions:**
+    1. Upload a clear video showing your full body
+    2. Perform squats in the side view for best results
+    3. Ensure good lighting and minimal background clutter
+    """,
+    examples=[],
+    cache_examples=False
+)
+
+if __name__ == "__main__":
+    # Launch with settings optimized for Docker and Hugging Face Spaces
+    demo.launch(
+        server_name="0.0.0.0",  # Allow external connections
+        server_port=7860,  # Standard port for Hugging Face Spaces
+        share=False,  # Don't create public URLs in production
+        show_error=True,  # Show detailed error messages
+        quiet=False,  # Enable logging
+        enable_queue=True,  # Handle multiple requests
+        max_threads=4  # Limit concurrent processing
+    )

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.44.0
+opencv-python-headless==4.8.1.78
+mediapipe==0.10.8
+numpy==1.24.3
+Pillow==10.0.1
+setuptools==68.2.2
+wheel==0.41.2