Track image and asset files with LFS

HFup/.gitattributes

@@ -1 +1,14 @@
 *.keras filter=lfs diff=lfs merge=lfs -text
+*.JPEG filter=lfs diff=lfs merge=lfs -text
+*.GIF filter=lfs diff=lfs merge=lfs -text
+*.BMP filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+*.PNG filter=lfs diff=lfs merge=lfs -text
+*.JPG filter=lfs diff=lfs merge=lfs -text
+*.TIFF filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.bmp filter=lfs diff=lfs merge=lfs -text

HFup/Dockerfile

@@ -0,0 +1,30 @@
+# Use a Python version that matches your (keras2env) as closely as possible
+FROM python:3.9-slim 
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all necessary application files and folders from HFup/ to /app in the container
+# These paths are relative to the Dockerfile's location (i.e., inside HFup/)
+COPY app.py .
+COPY bodybuilding_pose_analyzer bodybuilding_pose_analyzer
+COPY external external
+COPY yolov7 yolov7 
+COPY yolov7-w6-pose.pt . 
+COPY static static
+
+# Ensure the uploads directory within static exists and is writable
+RUN mkdir -p static/uploads && chmod -R 777 static/uploads
+
+EXPOSE 7860
+
+# Command to run app with Gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "2", "--timeout", "300", "app:app"] 

HFup/README.md

@@ -0,0 +1,76 @@
+---
+title: Gladiator Pose Analyzer
+emoji: 💪🏋️‍♂️
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+app_port: 7860
+# Add license if you have one, e.g., license: apache-2.0
+---
+
+# Gladiator Pose Analyzer 💪🏋️‍♂️
+
+**Live Demo:** [Link to your Gladiator Pose Analyzer Hugging Face Space] (<- REPLACE THIS with your actual Space URL after deployment)
+
+## Overview
+
+The Gladiator Pose Analyzer is a web application designed for bodybuilding pose analysis and feedback. Users can upload videos of their poses, and the application utilizes computer vision models to provide insights into angles, form corrections, and pose classification.
+
+This Space uses a Flask backend with various machine learning models for pose estimation and classification.
+
+## Features
+
+*   **Video Upload:** Upload your bodybuilding pose videos (MP4, AVI, MOV, MKV).
+*   **Multiple Pose Estimation Models:**
+    *   **Gladiator SupaDot (MediaPipe):** General pose estimation using MediaPipe Pose.
+    *   **Gladiator BB - Lightning (MoveNet):** Fast and efficient pose estimation with MoveNet Lightning.
+    *   **Gladiator BB - Thunder (MoveNet):** Higher accuracy pose estimation with MoveNet Thunder.
+    *   **(Experimental) YOLOv7-w6 Pose:** Object detection based pose estimation (can be selected if enabled in UI).
+*   **Automated Pose Classification:** A custom-trained CNN classifies common bodybuilding poses (e.g., Side Chest, Front Double Biceps).
+*   **Real-time Feedback Panel:** Displays:
+    *   Selected model.
+    *   Current classified pose (via CNN, updated periodically).
+    *   Calculated body angles (e.g., shoulder, elbow, knee).
+    *   Specific form corrections based on ideal angle ranges for classified poses.
+    *   General notes for poses where specific angle checks aren't defined.
+*   **Processed Video Output:** View the input video overlaid with detected keypoints and the feedback panel.
+
+## How to Use
+
+1.  **Navigate to the Live Demo link** provided above.
+2.  **Choose a Pose Estimation Model** from the dropdown menu:
+    *   `Gladiator SupaDot` (MediaPipe based)
+    *   `Gladiator BB - Lightning` (MoveNet Lightning)
+    *   `Gladiator BB - Thunder` (MoveNet Thunder)
+3.  **Select a Video File:** Click the "Choose File" button and select a video of your pose.
+4.  **Upload:** Click the "Upload Video" button.
+5.  **Processing:** Wait for the video to be processed. The server will analyze the video frame by frame.
+6.  **View Results:** The processed video with keypoint overlays and the dynamic feedback panel will be displayed.
+
+## Models Used
+
+*   **Pose Estimation:**
+    *   **MediaPipe Pose:** For the "Gladiator SupaDot" option.
+    *   **Google MoveNet (Lightning & Thunder):** TensorFlow Hub models for "Gladiator BB" options.
+    *   **YOLOv7-w6 Pose:** `yolov7-w6-pose.pt` (if enabled/selected).
+*   **Pose Classification:**
+    *   A custom Convolutional Neural Network (CNN) trained on bodybuilding poses, loaded from `external/BodybuildingPoseClassifier/bodybuilding_pose_classifier.h5`.
+    *   Classes: Side Chest, Front Double Biceps, Back Double Biceps, Front Lat Spread, Back Lat Spread.
+
+## Technical Stack
+
+*   **Backend:** Flask (Python)
+*   **Frontend:** HTML, CSS, JavaScript (served by Flask)
+*   **CV & ML Libraries:** OpenCV, TensorFlow/Keras, PyTorch, MediaPipe
+*   **Deployment:** Docker on Hugging Face Spaces
+
+## Known Issues & Limitations
+
+*   Accuracy of pose estimation and classification can vary depending on video quality, lighting, angle, and occlusion.
+*   The feedback provided is based on predefined angle ranges and may not cover all nuances of perfect form.
+*   Processing time can be significant for longer videos or when using more computationally intensive models.
+
+---
+
+*Remember to replace placeholder links and add any other specific information relevant to your project!* 

HFup/app.py

@@ -0,0 +1,590 @@
+from flask import Flask, render_template, request, jsonify, send_from_directory, url_for
+from flask_cors import CORS
+import cv2
+import torch
+import numpy as np
+import os
+from werkzeug.utils import secure_filename
+import sys
+import traceback
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+import time
+
+# Add bodybuilding_pose_analyzer to path
+sys.path.append('.') # Assuming app.py is at the root of cv.github.io
+from bodybuilding_pose_analyzer.src.movenet_analyzer import MoveNetAnalyzer
+from bodybuilding_pose_analyzer.src.pose_analyzer import PoseAnalyzer
+
+# Add YOLOv7 to path
+sys.path.append('yolov7')
+
+from yolov7.models.experimental import attempt_load
+from yolov7.utils.general import check_img_size, non_max_suppression_kpt, scale_coords
+from yolov7.utils.torch_utils import select_device
+from yolov7.utils.plots import plot_skeleton_kpts
+
+def wrap_text(text: str, font_face: int, font_scale: float, thickness: int, max_width: int) -> list[str]:
+    """Wrap text to fit within max_width."""
+    if not text:
+        return []
+
+    lines = []
+    words = text.split(' ')
+    current_line = ''
+
+    for word in words:
+        # Check width if current_line + word fits
+        test_line = current_line + word + ' '
+        (text_width, _), _ = cv2.getTextSize(test_line.strip(), font_face, font_scale, thickness)
+
+        if text_width <= max_width:
+            current_line = test_line
+        else:
+            # Word doesn't fit, so current_line (without the new word) is a complete line
+            lines.append(current_line.strip())
+            # Start new line with the current word
+            current_line = word + ' '
+            # If a single word is too long, it will still overflow. Handle by breaking word if necessary (future enhancement)
+            (single_word_width, _), _ = cv2.getTextSize(word.strip(), font_face, font_scale, thickness)
+            if single_word_width > max_width:
+                # For now, just add the long word and let it overflow, or truncate it.
+                # A more complex solution would break the word.
+                lines.append(word.strip()) # Add the long word as its own line
+                current_line = '' # Reset current_line as the long word is handled
+
+    if current_line.strip(): # Add the last line
+        lines.append(current_line.strip())
+    
+    return lines if lines else [text] # Ensure at least the original text is returned if no wrapping happens
+
+app = Flask(__name__, static_url_path='/static', static_folder='static')
+CORS(app, resources={r"/*": {"origins": "*"}})
+
+app.config['UPLOAD_FOLDER'] = 'static/uploads'
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
+
+# Ensure upload directory exists
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Initialize YOLOv7 model
+device = select_device('')
+yolo_model = None # Initialize as None
+stride = None
+imgsz = None
+
+try:
+    yolo_model = attempt_load('yolov7-w6-pose.pt', map_location=device)
+    stride = int(yolo_model.stride.max())
+    imgsz = check_img_size(640, s=stride)
+    print("YOLOv7 Model loaded successfully")
+except Exception as e:
+    print(f"Error loading YOLOv7 model: {e}")
+    traceback.print_exc()
+    # Not raising here to allow app to run if only MoveNet is used. Error will be caught if YOLOv7 is selected.
+
+# YOLOv7 pose model expects 17 keypoints
+kpt_shape = (17, 3)
+
+# Load CNN model for bodybuilding pose classification
+cnn_model_path = 'external/BodybuildingPoseClassifier/bodybuilding_pose_classifier.h5'
+cnn_model = load_model(cnn_model_path)
+cnn_class_labels = ['side_chest', 'front_double_biceps', 'back_double_biceps', 'front_lat_spread', 'back_lat_spread']
+
+def predict_pose_cnn(img_path):
+    img = image.load_img(img_path, target_size=(150, 150))
+    img_array = image.img_to_array(img)
+    img_array = np.expand_dims(img_array, axis=0) / 255.0
+    predictions = cnn_model.predict(img_array)
+    predicted_class = np.argmax(predictions, axis=1)
+    confidence = float(np.max(predictions))
+    return cnn_class_labels[predicted_class[0]], confidence
+
+@app.route('/static/uploads/<path:filename>')
+def serve_video(filename):
+    response = send_from_directory(app.config['UPLOAD_FOLDER'], filename, as_attachment=False)
+    # Ensure correct content type, especially for Safari/iOS if issues arise
+    if filename.lower().endswith('.mp4'):
+        response.headers['Content-Type'] = 'video/mp4'
+    return response
+
+@app.after_request
+def after_request(response):
+    response.headers.add('Access-Control-Allow-Origin', '*')
+    response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-Requested-With,Accept')
+    response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS')
+    return response
+
+def process_video_yolov7(video_path): # Renamed from process_video
+    global yolo_model, imgsz, stride # Ensure global model is used
+    if yolo_model is None:
+        raise RuntimeError("YOLOv7 model failed to load. Cannot process video.")
+    try:
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+            
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise ValueError(f"Failed to open video file: {video_path}")
+            
+        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))
+        
+        print(f"Processing video: {width}x{height} @ {fps}fps")
+        
+        # Create output video writer
+        output_path = os.path.join(app.config['UPLOAD_FOLDER'], 'output.mp4')
+        fourcc = cv2.VideoWriter_fourcc(*'avc1')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        
+        frame_count = 0
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            frame_count += 1
+            print(f"Processing frame {frame_count}")
+            
+            # Prepare image
+            img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            img = cv2.resize(img, (imgsz, imgsz))
+            img = img.transpose((2, 0, 1))  # HWC to CHW
+            img = np.ascontiguousarray(img)
+            img = torch.from_numpy(img).to(device)
+            img = img.float() / 255.0
+            if img.ndimension() == 3:
+                img = img.unsqueeze(0)
+            
+            # Inference
+            with torch.no_grad():
+                pred = yolo_model(img)[0] # Use yolo_model
+                pred = non_max_suppression_kpt(pred, conf_thres=0.25, iou_thres=0.45, nc=yolo_model.yaml['nc'], kpt_label=True)
+            
+            # Draw results
+            output_frame = frame.copy()
+            poses_detected = False
+            for det in pred:
+                if len(det):
+                    poses_detected = True
+                    det[:, :4] = scale_coords(img.shape[2:], det[:, :4], frame.shape).round()
+                    for row in det:
+                        xyxy = row[:4]
+                        conf = row[4]
+                        cls = row[5]
+                        kpts = row[6:]
+                        kpts = torch.tensor(kpts).view(kpt_shape)
+                        output_frame = plot_skeleton_kpts(output_frame, kpts, steps=3, orig_shape=output_frame.shape[:2])
+            
+            if not poses_detected:
+                print(f"No poses detected in frame {frame_count}")
+            
+            out.write(output_frame)
+        
+        cap.release()
+        out.release()
+        
+        if frame_count == 0:
+            raise ValueError("No frames were processed from the video")
+            
+        print(f"Video processing completed. Processed {frame_count} frames")
+        # Return URL for the client, using the 'serve_video' endpoint
+        output_filename = 'output.mp4'
+        return url_for('serve_video', filename=output_filename, _external=False)
+    except Exception as e:
+        print('Error in process_video:', e)
+        traceback.print_exc()
+        raise
+
+def process_video_movenet(video_path, model_variant='lightning', pose_type='front_double_biceps'):
+    try:
+        print(f"[PROCESS_VIDEO_MOVENET] Called with video_path: {video_path}, model_variant: {model_variant}, pose_type: {pose_type}")
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+
+        analyzer = MoveNetAnalyzer(model_name=model_variant)
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise ValueError(f"Failed to open video file: {video_path}")
+        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))
+        
+        # Add panel width to total width
+        panel_width = 300
+        total_width = width + panel_width
+        
+        print(f"Processing video with MoveNet ({model_variant}): {width}x{height} @ {fps}fps")
+        print(f"Output dimensions will be: {total_width}x{height}")
+        output_filename = f'output_movenet_{model_variant}.mp4'
+        output_path = os.path.join(app.config['UPLOAD_FOLDER'], output_filename)
+        print(f"Output path: {output_path}")
+        
+        fourcc = cv2.VideoWriter_fourcc(*'avc1')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (total_width, height))
+        if not out.isOpened():
+            raise ValueError(f"Failed to create output video writer at {output_path}")
+            
+        frame_count = 0
+        current_pose = pose_type
+        segment_length = 4 * fps if fps > 0 else 120
+        cnn_pose = None
+        last_valid_landmarks = None
+        landmarks_analysis = {'error': 'Processing not started'} # Initialize landmarks_analysis
+        
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frame_count += 1
+            if frame_count % 30 == 0:
+                print(f"Processing frame {frame_count}")
+            
+            # Process frame
+            processed_frame, current_landmarks_analysis, landmarks = analyzer.process_frame(frame, current_pose, last_valid_landmarks=last_valid_landmarks)
+            landmarks_analysis = current_landmarks_analysis # Update with the latest analysis
+            if frame_count % 30 == 0: # Log every 30 frames
+                print(f"[MOVENET_DEBUG] Frame {frame_count} - landmarks_analysis: {landmarks_analysis}")
+            if landmarks:
+                last_valid_landmarks = landmarks
+            
+            # CNN prediction (every 4 seconds)
+            if (frame_count - 1) % segment_length == 0:
+                temp_img_path = f'temp_frame_for_cnn_{frame_count}.jpg' # Unique temp name
+                cv2.imwrite(temp_img_path, frame)
+                try:
+                    cnn_pose_pred, cnn_conf = predict_pose_cnn(temp_img_path)
+                    print(f"[CNN] Frame {frame_count}: Pose: {cnn_pose_pred}, Conf: {cnn_conf:.2f}")
+                    if cnn_conf >= 0.3:
+                        current_pose = cnn_pose_pred # Update current_pose for the analyzer
+                except Exception as e:
+                    print(f"[CNN] Error predicting pose on frame {frame_count}: {e}")
+                finally:
+                    if os.path.exists(temp_img_path):
+                        os.remove(temp_img_path)
+            
+            # Create side panel
+            panel = np.zeros((height, panel_width, 3), dtype=np.uint8)
+            
+            # --- Dynamic Text Parameter Calculations ---
+            current_font = cv2.FONT_HERSHEY_DUPLEX
+            
+            # Base font scale and reference video height for scaling
+            # Adjust base_font_scale_at_ref_height if text is generally too large or too small
+            base_font_scale_at_ref_height = 0.6 
+            reference_height_for_font_scale = 640.0 # e.g., a common video height like 480p, 720p
+            
+            # Calculate dynamic font_scale
+            font_scale = (height / reference_height_for_font_scale) * base_font_scale_at_ref_height
+            # Clamp font_scale to a min/max range to avoid extremes
+            font_scale = max(0.4, min(font_scale, 1.2)) 
+
+            # Calculate dynamic thickness
+            thickness = 1 if font_scale < 0.7 else 2
+
+            # Calculate dynamic line_height based on actual text height
+            # Using a sample string like "Ag" which has ascenders and descenders
+            (_, text_actual_height), _ = cv2.getTextSize("Ag", current_font, font_scale, thickness)
+            line_spacing_factor = 1.8 # Adjust for more or less space between lines
+            line_height = int(text_actual_height * line_spacing_factor)
+            line_height = max(line_height, 15) # Ensure a minimum line height
+
+            # Initial y_offset for the first line of text
+            y_offset_panel = max(line_height, 20) # Start considering top margin and text height
+            # --- End of Dynamic Text Parameter Calculations ---
+
+            display_model_name = f"Gladiator {model_variant.capitalize()}"
+            cv2.putText(panel, f"Model: {display_model_name}", (10, y_offset_panel), current_font, font_scale, (0, 255, 255), thickness, lineType=cv2.LINE_AA)
+            y_offset_panel += line_height
+
+            if 'error' not in landmarks_analysis:
+                cv2.putText(panel, "Angles:", (10, y_offset_panel), current_font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)
+                y_offset_panel += line_height
+                for joint, angle in landmarks_analysis.get('angles', {}).items():
+                    text_to_display = f"{joint.capitalize()}: {angle:.1f} deg"
+                    cv2.putText(panel, text_to_display, (20, y_offset_panel), current_font, font_scale, (0, 255, 0), thickness, lineType=cv2.LINE_AA)
+                    y_offset_panel += line_height
+                
+                # Define available width for text within the panel, considering padding
+                text_area_x_start = 20
+                panel_padding = 10 # Padding from the right edge of the panel
+                text_area_width = panel_width - text_area_x_start - panel_padding
+
+                if landmarks_analysis.get('corrections'):
+                    y_offset_panel += int(line_height * 0.5) # Smaller gap before section title
+                    cv2.putText(panel, "Corrections:", (10, y_offset_panel), current_font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)
+                    y_offset_panel += line_height
+                    for correction_text in landmarks_analysis.get('corrections', []):
+                        wrapped_lines = wrap_text(correction_text, current_font, font_scale, thickness, text_area_width)
+                        for line in wrapped_lines:
+                            cv2.putText(panel, line, (text_area_x_start, y_offset_panel), current_font, font_scale, (0, 0, 255), thickness, lineType=cv2.LINE_AA)
+                            y_offset_panel += line_height
+                
+                # Display notes if any
+                if landmarks_analysis.get('notes'):
+                    y_offset_panel += int(line_height * 0.5) # Smaller gap before section title
+                    cv2.putText(panel, "Notes:", (10, y_offset_panel), current_font, font_scale, (200, 200, 200), thickness, lineType=cv2.LINE_AA)
+                    y_offset_panel += line_height
+                    for note_text in landmarks_analysis.get('notes', []):
+                        wrapped_lines = wrap_text(note_text, current_font, font_scale, thickness, text_area_width)
+                        for line in wrapped_lines:
+                            cv2.putText(panel, line, (text_area_x_start, y_offset_panel), current_font, font_scale, (200, 200, 200), thickness, lineType=cv2.LINE_AA)
+                            y_offset_panel += line_height
+            else:
+                cv2.putText(panel, "Error:", (10, y_offset_panel), current_font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)
+                y_offset_panel += line_height
+                # Also wrap error message if it can be long
+                error_text = landmarks_analysis.get('error', 'Unknown error')
+                text_area_x_start = 20 # Assuming error message also starts at x=20
+                panel_padding = 10
+                text_area_width = panel_width - text_area_x_start - panel_padding
+                wrapped_error_lines = wrap_text(error_text, current_font, font_scale, thickness, text_area_width)
+                for line in wrapped_error_lines:
+                    cv2.putText(panel, line, (text_area_x_start, y_offset_panel), current_font, font_scale, (0, 0, 255), thickness, lineType=cv2.LINE_AA)
+                    y_offset_panel += line_height
+            
+            combined_frame = np.hstack((processed_frame, panel))
+            out.write(combined_frame)
+            
+        cap.release()
+        out.release()
+        
+        if frame_count == 0:
+            raise ValueError("No frames were processed from the video by MoveNet")
+            
+        print(f"MoveNet video processing completed. Processed {frame_count} frames. Output: {output_path}")
+        print(f"Output file size: {os.path.getsize(output_path)} bytes")
+        
+        return url_for('serve_video', filename=output_filename, _external=False)
+    except Exception as e:
+        print(f'Error in process_video_movenet: {e}')
+        traceback.print_exc()
+        raise
+
+def process_video_mediapipe(video_path):
+    try:
+        print(f"[PROCESS_VIDEO_MEDIAPIPE] Called with video_path: {video_path}")
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+
+        analyzer = PoseAnalyzer()
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise ValueError(f"Failed to open video file: {video_path}")
+        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))
+        
+        # Add panel width to total width
+        panel_width = 300
+        total_width = width + panel_width
+        
+        print(f"Processing video with MediaPipe: {width}x{height} @ {fps}fps")
+        output_filename = f'output_mediapipe.mp4'
+        output_path = os.path.join(app.config['UPLOAD_FOLDER'], output_filename)
+        fourcc = cv2.VideoWriter_fourcc(*'avc1')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (total_width, height))
+        if not out.isOpened():
+            raise ValueError(f"Failed to create output video writer at {output_path}")
+
+        frame_count = 0
+        current_pose = 'Uncertain' # Initial pose for MediaPipe
+        segment_length = 4 * fps if fps > 0 else 120
+        cnn_pose = None
+        last_valid_landmarks = None
+        analysis_results = {'error': 'Processing not started'} # Initialize analysis_results
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frame_count += 1
+            if frame_count % 30 == 0:
+                print(f"Processing frame {frame_count}")
+
+            # Process frame with MediaPipe
+            processed_frame, current_analysis_results, landmarks = analyzer.process_frame(frame, last_valid_landmarks=last_valid_landmarks)
+            analysis_results = current_analysis_results # Update with the latest analysis
+            if landmarks:
+                last_valid_landmarks = landmarks
+
+            # CNN prediction (every 4 seconds)
+            if (frame_count - 1) % segment_length == 0:
+                temp_img_path = f'temp_frame_for_cnn_{frame_count}.jpg' # Unique temp name
+                cv2.imwrite(temp_img_path, frame)
+                try:
+                    cnn_pose_pred, cnn_conf = predict_pose_cnn(temp_img_path)
+                    print(f"[CNN] Frame {frame_count}: Pose: {cnn_pose_pred}, Conf: {cnn_conf:.2f}")
+                    if cnn_conf >= 0.3:
+                        current_pose = cnn_pose_pred # Update current_pose to be displayed
+                except Exception as e:
+                    print(f"[CNN] Error predicting pose on frame {frame_count}: {e}")
+                finally:
+                    if os.path.exists(temp_img_path):
+                        os.remove(temp_img_path)
+
+            # Create side panel
+            panel = np.zeros((height, panel_width, 3), dtype=np.uint8)
+            
+            # --- Dynamic Text Parameter Calculations ---
+            current_font = cv2.FONT_HERSHEY_DUPLEX
+            
+            # Base font scale and reference video height for scaling
+            # Adjust base_font_scale_at_ref_height if text is generally too large or too small
+            base_font_scale_at_ref_height = 0.6 
+            reference_height_for_font_scale = 640.0 # e.g., a common video height like 480p, 720p
+            
+            # Calculate dynamic font_scale
+            font_scale = (height / reference_height_for_font_scale) * base_font_scale_at_ref_height
+            # Clamp font_scale to a min/max range to avoid extremes
+            font_scale = max(0.4, min(font_scale, 1.2)) 
+
+            # Calculate dynamic thickness
+            thickness = 1 if font_scale < 0.7 else 2
+
+            # Calculate dynamic line_height based on actual text height
+            # Using a sample string like "Ag" which has ascenders and descenders
+            (_, text_actual_height), _ = cv2.getTextSize("Ag", current_font, font_scale, thickness)
+            line_spacing_factor = 1.8 # Adjust for more or less space between lines
+            line_height = int(text_actual_height * line_spacing_factor)
+            line_height = max(line_height, 15) # Ensure a minimum line height
+
+            # Initial y_offset for the first line of text
+            y_offset_panel = max(line_height, 20) # Start considering top margin and text height
+            # --- End of Dynamic Text Parameter Calculations ---
+
+            cv2.putText(panel, "Model: Gladiator SupaDot", (10, y_offset_panel), current_font, font_scale, (0, 255, 255), thickness, lineType=cv2.LINE_AA)
+            y_offset_panel += line_height
+            if frame_count % 30 == 0: # Print every 30 frames to avoid flooding console
+                print(f"[MEDIAPIPE_PANEL] Frame {frame_count} - Current Pose for Panel: {current_pose}")
+            cv2.putText(panel, f"Pose: {current_pose}", (10, y_offset_panel), current_font, font_scale, (255, 0, 0), thickness, lineType=cv2.LINE_AA)
+            y_offset_panel += int(line_height * 1.5)
+
+            if 'error' not in analysis_results:
+                cv2.putText(panel, "Angles:", (10, y_offset_panel), current_font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)
+                y_offset_panel += line_height
+                for joint, angle in analysis_results.get('angles', {}).items():
+                    text_to_display = f"{joint.capitalize()}: {angle:.1f} deg"
+                    cv2.putText(panel, text_to_display, (20, y_offset_panel), current_font, font_scale, (0, 255, 0), thickness, lineType=cv2.LINE_AA)
+                    y_offset_panel += line_height
+                
+                if analysis_results.get('corrections'):
+                    y_offset_panel += line_height
+                    cv2.putText(panel, "Corrections:", (10, y_offset_panel), current_font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)
+                    y_offset_panel += line_height
+                    for correction in analysis_results.get('corrections', []):
+                        cv2.putText(panel, f"• {correction}", (20, y_offset_panel), current_font, font_scale, (0, 0, 255), thickness, lineType=cv2.LINE_AA)
+                        y_offset_panel += line_height
+                
+                # Display notes if any
+                if analysis_results.get('notes'):
+                    y_offset_panel += line_height
+                    cv2.putText(panel, "Notes:", (10, y_offset_panel), current_font, font_scale, (200, 200, 200), thickness, lineType=cv2.LINE_AA) # Grey color for notes
+                    y_offset_panel += line_height
+                    for note in analysis_results.get('notes', []):
+                        cv2.putText(panel, f"• {note}", (20, y_offset_panel), current_font, font_scale, (200, 200, 200), thickness, lineType=cv2.LINE_AA)
+                        y_offset_panel += line_height
+            else:
+                cv2.putText(panel, "Error:", (10, y_offset_panel), current_font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)
+                y_offset_panel += line_height
+                cv2.putText(panel, analysis_results.get('error', 'Unknown error'), (20, y_offset_panel), current_font, font_scale, (0, 0, 255), thickness, lineType=cv2.LINE_AA)
+            
+            combined_frame = np.hstack((processed_frame, panel)) # Use processed_frame from analyzer
+            out.write(combined_frame)
+
+        cap.release()
+        out.release()
+        if frame_count == 0:
+            raise ValueError("No frames were processed from the video by MediaPipe")
+        print(f"MediaPipe video processing completed. Processed {frame_count} frames. Output: {output_path}")
+        return url_for('serve_video', filename=output_filename, _external=False)
+    except Exception as e:
+        print(f'Error in process_video_mediapipe: {e}')
+        traceback.print_exc()
+        raise
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    try:
+        if 'video' not in request.files:
+            print("[UPLOAD] No video file in request")
+            return jsonify({'error': 'No video file provided'}), 400
+            
+        file = request.files['video']
+        if file.filename == '':
+            print("[UPLOAD] Empty filename")
+            return jsonify({'error': 'No selected file'}), 400
+            
+        if file:
+            allowed_extensions = {'mp4', 'avi', 'mov', 'mkv'}
+            if '.' not in file.filename or file.filename.rsplit('.', 1)[1].lower() not in allowed_extensions:
+                print(f"[UPLOAD] Invalid file format: {file.filename}")
+                return jsonify({'error': 'Invalid file format. Allowed formats: mp4, avi, mov, mkv'}), 400
+                
+            # Ensure the filename is properly sanitized
+            filename = secure_filename(file.filename)
+            print(f"[UPLOAD] Original filename: {file.filename}")
+            print(f"[UPLOAD] Sanitized filename: {filename}")
+            
+            # Create a unique filename to prevent conflicts
+            base, ext = os.path.splitext(filename)
+            unique_filename = f"{base}_{int(time.time())}{ext}"
+            filepath = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
+            
+            print(f"[UPLOAD] Saving file to: {filepath}")
+            file.save(filepath)
+            
+            if not os.path.exists(filepath):
+                print(f"[UPLOAD] File not found after save: {filepath}")
+                return jsonify({'error': 'Failed to save uploaded file'}), 500
+                
+            print(f"[UPLOAD] File saved successfully. Size: {os.path.getsize(filepath)} bytes")
+            
+            try:
+                model_choice = request.form.get('model_choice', 'Gladiator SupaDot')
+                print(f"[UPLOAD] Processing with model: {model_choice}")
+                
+                if model_choice == 'movenet':
+                    movenet_variant = request.form.get('movenet_variant', 'lightning')
+                    print(f"[UPLOAD] Using MoveNet variant: {movenet_variant}")
+                    output_path_url = process_video_movenet(filepath, model_variant=movenet_variant)
+                else:
+                    output_path_url = process_video_mediapipe(filepath)
+                    
+                print(f"[UPLOAD] Processing complete. Output URL: {output_path_url}")
+                
+                if not os.path.exists(os.path.join(app.config['UPLOAD_FOLDER'], os.path.basename(output_path_url))):
+                    print(f"[UPLOAD] Output file not found: {output_path_url}")
+                    return jsonify({'error': 'Output video file not found'}), 500
+                    
+                return jsonify({
+                    'message': f'Video processed successfully with {model_choice}',
+                    'output_path': output_path_url
+                })
+                
+            except Exception as e:
+                print(f"[UPLOAD] Error processing video: {str(e)}")
+                traceback.print_exc()
+                return jsonify({'error': f'Error processing video: {str(e)}'}), 500
+                
+            finally:
+                try:
+                    if os.path.exists(filepath):
+                        os.remove(filepath)
+                        print(f"[UPLOAD] Cleaned up input file: {filepath}")
+                except Exception as e:
+                    print(f"[UPLOAD] Error cleaning up file: {str(e)}")
+                    
+    except Exception as e:
+        print(f"[UPLOAD] Unexpected error: {str(e)}")
+        traceback.print_exc()
+        return jsonify({'error': 'Internal server error'}), 500
+
+if __name__ == '__main__':
+    # Ensure the port is 7860 and debug is False for HF Spaces deployment
+    app.run(host='0.0.0.0', port=7860, debug=False) 

HFup/bodybuilding_pose_analyzer/README.md

@@ -0,0 +1,63 @@
+# Bodybuilding Pose Analyzer
+
+A real-time pose analysis tool for bodybuilders that helps analyze and provide feedback on common bodybuilding poses.
+
+## Features
+
+- Real-time pose detection using MediaPipe
+- Analysis of common bodybuilding poses:
+  - Front Double Biceps
+  - Side Chest
+  - Back Double Biceps
+- Angle measurements for key body parts
+- Real-time feedback and corrections
+- FPS display
+
+## Requirements
+
+- Python 3.8+
+- Webcam
+- Required Python packages (listed in requirements.txt)
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd bodybuilding_pose_analyzer
+```
+
+2. Create a virtual environment (recommended):
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+3. Install required packages:
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+1. Run the demo script:
+```bash
+python src/demo.py
+```
+
+2. Position yourself in front of the webcam
+3. The system will automatically detect your pose and provide feedback
+4. Press 'q' to quit the application
+
+## Supported Poses
+
+Currently, the system supports the following poses:
+- Front Double Biceps
+- Side Chest
+- Back Double Biceps
+
+More poses will be added in future updates.
+
+## Contributing
+
+Feel free to submit issues and enhancement requests! 

HFup/bodybuilding_pose_analyzer/bodybuilding_pose_classifier.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56cdfbdadbef2675622e699fcf444d5bcb0aab6c695bb32165ae60e984278346
+size 228483160

HFup/bodybuilding_pose_analyzer/requirements.txt

@@ -0,0 +1,8 @@
+opencv-python>=4.8.0
+mediapipe>=0.10.0
+numpy>=1.24.0
+torch>=2.0.0
+torchvision>=0.15.0
+scikit-learn>=1.3.0
+matplotlib>=3.7.0
+tqdm>=4.65.0 

HFup/bodybuilding_pose_analyzer/src/demo.py

@@ -0,0 +1,80 @@
+import cv2
+import time
+import argparse
+from pose_analyzer import PoseAnalyzer
+
+def process_video(video_source, analyzer):
+    # Initialize video capture
+    cap = cv2.VideoCapture(video_source)
+    
+    # Set window properties
+    cv2.namedWindow('Bodybuilding Pose Analyzer', cv2.WINDOW_NORMAL)
+    cv2.resizeWindow('Bodybuilding Pose Analyzer', 1280, 720)
+    
+    # FPS calculation variables
+    prev_time = 0
+    curr_time = 0
+    
+    while cap.isOpened():
+        # Read frame
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        # Calculate FPS
+        curr_time = time.time()
+        fps = 1 / (curr_time - prev_time) if prev_time > 0 else 0
+        prev_time = curr_time
+        
+        # Process frame
+        frame_with_pose, analysis = analyzer.process_frame(frame)
+        
+        # Add FPS and analysis text to frame
+        cv2.putText(frame_with_pose, f'FPS: {fps:.1f}', (10, 30),
+                    cv2.FONT_HERSHEY_PLAIN, 0.5, (0, 255, 0), 1, lineType=cv2.LINE_AA)
+        
+        # Display feedback
+        if 'error' not in analysis:
+            y_offset = 70
+            cv2.putText(frame_with_pose, f'Pose: {analysis["pose_type"]}', (10, y_offset),
+                        cv2.FONT_HERSHEY_PLAIN, 0.5, (0, 255, 0), 1, lineType=cv2.LINE_AA)
+            
+            for angle_name, angle_value in analysis['angles'].items():
+                y_offset += 40
+                cv2.putText(frame_with_pose, f'{angle_name}: {angle_value:.1f}°', (10, y_offset),
+                            cv2.FONT_HERSHEY_PLAIN, 0.5, (0, 255, 0), 1, lineType=cv2.LINE_AA)
+            
+            for correction in analysis['corrections']:
+                y_offset += 40
+                cv2.putText(frame_with_pose, correction, (10, y_offset),
+                            cv2.FONT_HERSHEY_PLAIN, 0.5, (0, 0, 255), 1, lineType=cv2.LINE_AA)
+        else:
+            cv2.putText(frame_with_pose, analysis['error'], (10, 70),
+                        cv2.FONT_HERSHEY_PLAIN, 0.5, (0, 0, 255), 1, lineType=cv2.LINE_AA)
+        
+        # Display the frame
+        cv2.imshow('Bodybuilding Pose Analyzer', frame_with_pose)
+        
+        # Break the loop if 'q' is pressed
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    
+    # Release resources
+    cap.release()
+    cv2.destroyAllWindows()
+
+def main():
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Bodybuilding Pose Analyzer Demo')
+    parser.add_argument('--video', type=str, help='Path to video file (optional)')
+    args = parser.parse_args()
+    
+    # Initialize the pose analyzer
+    analyzer = PoseAnalyzer()
+    
+    # Process video (either webcam or file)
+    video_source = args.video if args.video else 0
+    process_video(video_source, analyzer)
+
+if __name__ == '__main__':
+    main() 

HFup/bodybuilding_pose_analyzer/src/movenet_analyzer.py

@@ -0,0 +1,321 @@
+import cv2
+import numpy as np
+import tensorflow as tf
+import tensorflow_hub as hub
+from typing import List, Dict, Tuple
+
+class MoveNetAnalyzer:
+    KEYPOINT_DICT = {
+        'nose': 0,
+        'left_eye': 1,
+        'right_eye': 2,
+        'left_ear': 3,
+        'right_ear': 4,
+        'left_shoulder': 5,
+        'right_shoulder': 6,
+        'left_elbow': 7,
+        'right_elbow': 8,
+        'left_wrist': 9,
+        'right_wrist': 10,
+        'left_hip': 11,
+        'right_hip': 12,
+        'left_knee': 13,
+        'right_knee': 14,
+        'left_ankle': 15,
+        'right_ankle': 16
+    }
+
+    def __init__(self, model_name="lightning"):
+        # Initialize MoveNet model
+        if model_name == "lightning":
+            self.model = hub.load("https://tfhub.dev/google/movenet/singlepose/lightning/4")
+            self.input_size = 192
+        else:  # thunder
+            self.model = hub.load("https://tfhub.dev/google/movenet/singlepose/thunder/4")
+            self.input_size = 256
+        
+        self.movenet = self.model.signatures['serving_default']
+        
+        # Define key angles for bodybuilding poses
+        self.key_angles = {
+            'front_double_biceps': {
+                'shoulder_angle': (90, 120),  # Expected angle range
+                'elbow_angle': (80, 100),
+                'wrist_angle': (0, 20)
+            },
+            'side_chest': {
+                'shoulder_angle': (45, 75),
+                'elbow_angle': (90, 110),
+                'wrist_angle': (0, 20)
+            },
+            'back_double_biceps': {
+                'shoulder_angle': (90, 120),
+                'elbow_angle': (80, 100),
+                'wrist_angle': (0, 20)
+            }
+        }
+
+    def detect_pose(self, frame: np.ndarray, last_valid_landmarks=None) -> Tuple[np.ndarray, List[Dict]]:
+        """
+        Detect pose in the given frame and return the frame with pose landmarks drawn
+        and the list of detected landmarks.
+        If detection fails, reuse last valid landmarks if provided.
+        """
+        # Resize and pad the image to keep aspect ratio
+        img = frame.copy()
+        img = tf.image.resize_with_pad(tf.expand_dims(img, axis=0), self.input_size, self.input_size)
+        img = tf.cast(img, dtype=tf.int32)
+        
+        # Detection
+        results = self.movenet(img)
+        keypoints = results['output_0'].numpy() # Shape [1, 1, 17, 3]
+        
+        # Draw the pose landmarks on the frame
+        if keypoints[0, 0, 0, 2] > 0.1:  # Lowered confidence threshold for the nose
+            # Convert keypoints to image coordinates
+            y, x, c = frame.shape
+            shaped = np.squeeze(keypoints) # Shape [17, 3]
+            
+            # Draw keypoints
+            for kp in shaped:
+                ky, kx, kp_conf = kp
+                if kp_conf > 0.1:
+                    # Convert to image coordinates
+                    x_coord = int(kx * x)
+                    y_coord = int(ky * y)
+                    cv2.circle(frame, (x_coord, y_coord), 6, (0, 255, 0), -1)
+            
+            # Convert landmarks to a list of dictionaries
+            landmarks = []
+            for kp in shaped:
+                landmarks.append({
+                    'x': float(kp[1]),
+                    'y': float(kp[0]),
+                    'visibility': float(kp[2])
+                })
+            
+            return frame, landmarks
+        
+        # If detection fails, reuse last valid landmarks if provided
+        if last_valid_landmarks is not None:
+            return frame, last_valid_landmarks
+        return frame, []
+
+    def calculate_angle(self, landmarks: List[Dict], joint1: int, joint2: int, joint3: int) -> float:
+        """
+        Calculate the angle between three joints.
+        """
+        if len(landmarks) < max(joint1, joint2, joint3):
+            return None
+            
+        # Get the coordinates of the three joints
+        p1 = np.array([landmarks[joint1]['x'], landmarks[joint1]['y']])
+        p2 = np.array([landmarks[joint2]['x'], landmarks[joint2]['y']])
+        p3 = np.array([landmarks[joint3]['x'], landmarks[joint3]['y']])
+        
+        # Calculate the angle
+        v1 = p1 - p2
+        v2 = p3 - p2
+        
+        angle = np.degrees(np.arccos(
+            np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
+        ))
+        
+        return angle
+
+    def analyze_pose(self, landmarks: List[Dict], pose_type: str) -> Dict:
+        """
+        Analyze the pose and provide feedback based on the pose_type.
+        Handles pose_types not in self.key_angles by providing a note.
+        """
+        feedback = {
+            'pose_type': pose_type,
+            'angles': {},
+            'corrections': [],
+            'notes': []  # Initialize notes field
+        }
+
+        if not landmarks:
+            # If no landmarks, it's a more fundamental issue than just pose_type.
+            # The process_frame method already handles this by passing {'error': 'No pose detected'}
+            # from self.analyze_pose if landmarks is empty.
+            # However, to be safe, if this method is called directly with no landmarks:
+            feedback['error'] = 'No landmarks provided for analysis'
+            return feedback
+
+        if pose_type not in self.key_angles:
+            feedback['notes'].append(f"No specific angle checks defined for pose: {pose_type}")
+            # Still return the feedback structure, but angles and corrections will be empty.
+            # The 'error' field will not be set here, allowing app.py to distinguish this case.
+            return feedback
+        
+        pose_rules = self.key_angles[pose_type]
+        
+        if pose_type == 'front_double_biceps':
+            # Example: Left Shoulder - Elbow - Wrist for elbow angle
+            # Example: Left Hip - Shoulder - Elbow for shoulder angle (arm abduction)
+            # Note: These are examples, actual biomechanical definitions can be complex.
+            # We'll stick to the previous definition for front_double_biceps shoulder angle for now.
+            # Shoulder angle: right_hip - right_shoulder - right_elbow (can also use left)
+            # Elbow angle: right_shoulder - right_elbow - right_wrist (can also use left)
+            # Wrist angle (simplistic): right_elbow - right_wrist - a point slightly above wrist (not easily done without more points)
+
+            # Using right side for front_double_biceps as an example, consistent with a typical bodybuilding pose display
+            # Shoulder Angle (approximating arm abduction/flexion relative to torso)
+            # Using Right Hip, Right Shoulder, Right Elbow
+            rs = self.KEYPOINT_DICT['right_shoulder']
+            re = self.KEYPOINT_DICT['right_elbow']
+            rh = self.KEYPOINT_DICT['right_hip']
+            rw = self.KEYPOINT_DICT['right_wrist']
+
+            shoulder_angle = self.calculate_angle(landmarks, rh, rs, re)
+            if shoulder_angle is not None:
+                feedback['angles']['R Shoulder'] = shoulder_angle
+                if not (pose_rules['shoulder_angle'][0] <= shoulder_angle <= pose_rules['shoulder_angle'][1]):
+                    # Debug print before forming correction string
+                    print(f"[MOVENET_DEBUG_CORRECTION] pose_type: {pose_type}, rule_key: 'shoulder_angle', rules_for_angle: {pose_rules.get('shoulder_angle')}")
+                    feedback['corrections'].append(
+                        f"Adjust R Shoulder to {pose_rules['shoulder_angle'][0]}-{pose_rules['shoulder_angle'][1]} deg"
+                    )
+            
+            elbow_angle = self.calculate_angle(landmarks, rs, re, rw)
+            if elbow_angle is not None:
+                feedback['angles']['R Elbow'] = elbow_angle
+                if not (pose_rules['elbow_angle'][0] <= elbow_angle <= pose_rules['elbow_angle'][1]):
+                    feedback['corrections'].append(
+                        f"Adjust R Elbow to {pose_rules['elbow_angle'][0]}-{pose_rules['elbow_angle'][1]} deg"
+                    )
+            # Wrist angle is hard to define meaningfully with current keypoints for this pose, skipping for now.
+
+        elif pose_type == 'side_chest':
+            # Assuming side chest often displays left side to judges
+            ls = self.KEYPOINT_DICT['left_shoulder']
+            le = self.KEYPOINT_DICT['left_elbow']
+            lw = self.KEYPOINT_DICT['left_wrist']
+            lh = self.KEYPOINT_DICT['left_hip'] # For shoulder angle relative to torso
+
+            # Shoulder angle (e.g. arm flexion/extension in sagittal plane for the front arm)
+            # For side chest, the front arm's shoulder angle relative to the torso (hip-shoulder-elbow)
+            shoulder_angle = self.calculate_angle(landmarks, lh, ls, le) 
+            if shoulder_angle is not None:
+                feedback['angles']['L Shoulder'] = shoulder_angle
+                if not (pose_rules['shoulder_angle'][0] <= shoulder_angle <= pose_rules['shoulder_angle'][1]):
+                    feedback['corrections'].append(
+                        f"Adjust L Shoulder to {pose_rules['shoulder_angle'][0]}-{pose_rules['shoulder_angle'][1]} deg"
+                    )
+
+            elbow_angle = self.calculate_angle(landmarks, ls, le, lw)
+            if elbow_angle is not None:
+                feedback['angles']['L Elbow'] = elbow_angle
+                if not (pose_rules['elbow_angle'][0] <= elbow_angle <= pose_rules['elbow_angle'][1]):
+                    feedback['corrections'].append(
+                        f"Adjust L Elbow to {pose_rules['elbow_angle'][0]}-{pose_rules['elbow_angle'][1]} deg"
+                    )
+            # Wrist angle for side chest is also nuanced, skipping detailed check for now.
+
+        elif pose_type == 'back_double_biceps':
+            # Similar to front, but from back. We can calculate for both arms or pick one.
+            # Let's do right side for consistency with front_double_biceps example.
+            rs = self.KEYPOINT_DICT['right_shoulder']
+            re = self.KEYPOINT_DICT['right_elbow']
+            rh = self.KEYPOINT_DICT['right_hip']
+            rw = self.KEYPOINT_DICT['right_wrist']
+
+            shoulder_angle = self.calculate_angle(landmarks, rh, rs, re)
+            if shoulder_angle is not None:
+                feedback['angles']['R Shoulder'] = shoulder_angle
+                if not (pose_rules['shoulder_angle'][0] <= shoulder_angle <= pose_rules['shoulder_angle'][1]):
+                    feedback['corrections'].append(
+                        f"Adjust R Shoulder to {pose_rules['shoulder_angle'][0]}-{pose_rules['shoulder_angle'][1]} deg"
+                    )
+            
+            elbow_angle = self.calculate_angle(landmarks, rs, re, rw)
+            if elbow_angle is not None:
+                feedback['angles']['R Elbow'] = elbow_angle
+                if not (pose_rules['elbow_angle'][0] <= elbow_angle <= pose_rules['elbow_angle'][1]):
+                    feedback['corrections'].append(
+                        f"Adjust R Elbow to {pose_rules['elbow_angle'][0]}-{pose_rules['elbow_angle'][1]} deg"
+                    )
+        
+        # Clear notes if pose_type was valid and processed, unless specific notes were added by pose logic
+        if not feedback['notes']: # Only clear if no specific notes were added during pose rule processing
+            feedback.pop('notes', None)
+            
+        return feedback
+
+    def process_frame(self, frame: np.ndarray, pose_type: str = 'front_double_biceps', last_valid_landmarks=None) -> Tuple[np.ndarray, Dict, List[Dict]]:
+        """
+        Process a single frame, detect pose, and analyze it. Returns frame, analysis, and used landmarks.
+        """
+        # Detect pose
+        frame_with_pose, landmarks = self.detect_pose(frame, last_valid_landmarks=last_valid_landmarks)
+        
+        # Analyze pose if landmarks are detected
+        analysis = self.analyze_pose(landmarks, pose_type) if landmarks else {'error': 'No pose detected'}
+        
+        return frame_with_pose, analysis, landmarks
+
+    def classify_pose(self, landmarks: List[Dict]) -> str:
+        """
+        Classify the pose based on keypoint positions and angles.
+        Returns one of: 'front_double_biceps', 'side_chest', 'back_double_biceps'.
+        """
+        if not landmarks or len(landmarks) < 17:
+            return 'front_double_biceps'  # Default/fallback
+
+        # Calculate angles for both arms
+        # Right side
+        rs = self.KEYPOINT_DICT['right_shoulder']
+        re = self.KEYPOINT_DICT['right_elbow']
+        rh = self.KEYPOINT_DICT['right_hip']
+        rw = self.KEYPOINT_DICT['right_wrist']
+        # Left side
+        ls = self.KEYPOINT_DICT['left_shoulder']
+        le = self.KEYPOINT_DICT['left_elbow']
+        lh = self.KEYPOINT_DICT['left_hip']
+        lw = self.KEYPOINT_DICT['left_wrist']
+
+        # Shoulder angles
+        r_shoulder_angle = self.calculate_angle(landmarks, rh, rs, re)
+        l_shoulder_angle = self.calculate_angle(landmarks, lh, ls, le)
+        # Elbow angles
+        r_elbow_angle = self.calculate_angle(landmarks, rs, re, rw)
+        l_elbow_angle = self.calculate_angle(landmarks, ls, le, lw)
+
+        # Heuristic rules:
+        # - Front double biceps: both arms raised, elbows bent, both shoulders abducted
+        # - Side chest: one arm across chest (elbow in front of body), other arm flexed
+        # - Back double biceps: both arms raised, elbows bent, but person is facing away (shoulders/hips x order reversed)
+
+        # Use x-coordinates to estimate facing direction
+        # If right shoulder x < left shoulder x, assume facing front; else, facing back
+        facing_front = landmarks[rs]['x'] < landmarks[ls]['x']
+
+        # Count how many arms are "up" (shoulder angle in expected range)
+        arms_up = 0
+        if r_shoulder_angle and 80 < r_shoulder_angle < 150:
+            arms_up += 1
+        if l_shoulder_angle and 80 < l_shoulder_angle < 150:
+            arms_up += 1
+        elbows_bent = 0
+        if r_elbow_angle and 60 < r_elbow_angle < 130:
+            elbows_bent += 1
+        if l_elbow_angle and 60 < l_elbow_angle < 130:
+            elbows_bent += 1
+
+        # Side chest: one arm's elbow is much closer to the body's midline (x of elbow near x of nose)
+        nose_x = landmarks[self.KEYPOINT_DICT['nose']]['x']
+        le_x = landmarks[le]['x']
+        re_x = landmarks[re]['x']
+        side_chest_like = (abs(le_x - nose_x) < 0.08 or abs(re_x - nose_x) < 0.08)
+
+        if arms_up == 2 and elbows_bent == 2:
+            if facing_front:
+                return 'front_double_biceps'
+            else:
+                return 'back_double_biceps'
+        elif side_chest_like:
+            return 'side_chest'
+        else:
+            # Default/fallback
+            return 'front_double_biceps' 

HFup/bodybuilding_pose_analyzer/src/movenet_demo.py

@@ -0,0 +1,66 @@
+import cv2
+import argparse
+from movenet_analyzer import MoveNetAnalyzer
+
+def main():
+    parser = argparse.ArgumentParser(description='MoveNet Pose Analysis Demo')
+    parser.add_argument('--video', type=str, help='Path to video file (optional)')
+    parser.add_argument('--model', type=str, default='lightning', choices=['lightning', 'thunder'],
+                      help='MoveNet model variant (lightning or thunder)')
+    args = parser.parse_args()
+
+    # Initialize the MoveNet analyzer
+    analyzer = MoveNetAnalyzer(model_name=args.model)
+
+    # Initialize video capture
+    if args.video:
+        cap = cv2.VideoCapture(args.video)
+    else:
+        cap = cv2.VideoCapture(0)  # Use webcam if no video file provided
+
+    if not cap.isOpened():
+        print("Error: Could not open video source")
+        return
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Process frame
+        frame_with_pose, analysis = analyzer.process_frame(frame)
+
+        # Display analysis results
+        if 'error' not in analysis:
+            # Display pose type
+            cv2.putText(frame_with_pose, f"Pose: {analysis['pose_type']}", 
+                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+
+            # Display angles
+            y_offset = 60
+            for joint, angle in analysis['angles'].items():
+                cv2.putText(frame_with_pose, f"{joint}: {angle:.1f}°", 
+                           (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+                y_offset += 30
+
+            # Display corrections
+            for correction in analysis['corrections']:
+                cv2.putText(frame_with_pose, correction, 
+                           (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                y_offset += 30
+        else:
+            cv2.putText(frame_with_pose, analysis['error'], 
+                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+
+        # Display the frame
+        cv2.imshow('MoveNet Pose Analysis', frame_with_pose)
+
+        # Break the loop if 'q' is pressed
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    main() 

HFup/bodybuilding_pose_analyzer/src/pose_analyzer.py

@@ -0,0 +1,200 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+from typing import List, Dict, Tuple
+
+class PoseAnalyzer:
+    # Add MediaPipe skeleton connections as a class variable
+    MP_CONNECTIONS = [
+        (11, 13), (13, 15), # Left arm
+        (12, 14), (14, 16), # Right arm
+        (11, 12),           # Shoulders
+        (11, 23), (12, 24), # Torso sides
+        (23, 24),           # Hips
+        (23, 25), (25, 27), # Left leg
+        (24, 26), (26, 28), # Right leg
+        (27, 31), (28, 32), # Ankles to feet
+        (15, 17), (16, 18), # Wrists to hands
+        (15, 19), (16, 20), # Wrists to pinky
+        (15, 21), (16, 22), # Wrists to index
+        (15, 17), (17, 19), (19, 21), # Left hand
+        (16, 18), (18, 20), (20, 22)  # Right hand
+    ]
+    def __init__(self):
+        # Initialize MediaPipe Pose
+        self.mp_pose = mp.solutions.pose
+        self.pose = self.mp_pose.Pose(
+            static_image_mode=False,
+            model_complexity=2,  # Using the most accurate model
+            min_detection_confidence=0.1,
+            min_tracking_confidence=0.1
+        )
+        self.mp_drawing = mp.solutions.drawing_utils
+        
+        # Define key angles for bodybuilding poses
+        self.key_angles = {
+            'front_double_biceps': {
+                'shoulder_angle': (90, 120),  # Expected angle range
+                'elbow_angle': (80, 100),
+                'wrist_angle': (0, 20)
+            },
+            'side_chest': {
+                'shoulder_angle': (45, 75),
+                'elbow_angle': (90, 110),
+                'wrist_angle': (0, 20)
+            },
+            'back_double_biceps': {
+                'shoulder_angle': (90, 120),
+                'elbow_angle': (80, 100),
+                'wrist_angle': (0, 20)
+            }
+        }
+
+    def detect_pose(self, frame: np.ndarray, last_valid_landmarks=None) -> Tuple[np.ndarray, List[Dict]]:
+        """
+        Detect pose in the given frame and return the frame with pose landmarks drawn
+        and the list of detected landmarks. If detection fails, reuse last valid landmarks if provided.
+        """
+        # Convert the BGR image to RGB
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        
+        # Process the frame and detect pose
+        results = self.pose.process(rgb_frame)
+        
+        # Draw the pose landmarks on the frame
+        if results.pose_landmarks:
+            # Draw all 33 keypoints as bright red, smaller circles, and show index
+            for idx, landmark in enumerate(results.pose_landmarks.landmark):
+                x = int(landmark.x * frame.shape[1])
+                y = int(landmark.y * frame.shape[0])
+                if landmark.visibility > 0.1:  # Lowered threshold from 0.3 to 0.1
+                    cv2.circle(frame, (x, y), 3, (0, 0, 255), -1)
+                    cv2.putText(frame, str(idx), (x+8, y-8), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)
+            # Draw skeleton lines
+            # Convert landmarks to pixel coordinates for easier access
+            landmark_points = []
+            for landmark in results.pose_landmarks.landmark:
+                landmark_points.append((int(landmark.x * frame.shape[1]), int(landmark.y * frame.shape[0]), landmark.visibility))
+            for pt1, pt2 in self.MP_CONNECTIONS:
+                if pt1 < len(landmark_points) and pt2 < len(landmark_points):
+                    x1, y1, v1 = landmark_points[pt1]
+                    x2, y2, v2 = landmark_points[pt2]
+                    if v1 > 0.1 and v2 > 0.1:
+                        cv2.line(frame, (x1, y1), (x2, y2), (0, 255, 255), 2)
+            # Convert landmarks to a list of dictionaries
+            landmarks = []
+            for idx, landmark in enumerate(results.pose_landmarks.landmark):
+                landmarks.append({
+                    'x': landmark.x,
+                    'y': landmark.y,
+                    'z': landmark.z,
+                    'visibility': landmark.visibility
+                })
+            return frame, landmarks
+        # If detection fails, reuse last valid landmarks if provided
+        if last_valid_landmarks is not None:
+            return frame, last_valid_landmarks
+        return frame, []
+
+    def calculate_angle(self, landmarks: List[Dict], joint1: int, joint2: int, joint3: int) -> float:
+        """
+        Calculate the angle between three joints.
+        """
+        if len(landmarks) < max(joint1, joint2, joint3):
+            return None
+            
+        # Get the coordinates of the three joints
+        p1 = np.array([landmarks[joint1]['x'], landmarks[joint1]['y']])
+        p2 = np.array([landmarks[joint2]['x'], landmarks[joint2]['y']])
+        p3 = np.array([landmarks[joint3]['x'], landmarks[joint3]['y']])
+        
+        # Calculate the angle
+        v1 = p1 - p2
+        v2 = p3 - p2
+        
+        angle = np.degrees(np.arccos(
+            np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
+        ))
+        
+        return angle
+
+    def analyze_pose(self, landmarks: List[Dict], pose_type: str) -> Dict:
+        """
+        Analyze the pose and provide feedback based on the pose type.
+        Enhanced: Calculates angles for both left and right arms (shoulder, elbow, wrist) for all pose types.
+        """
+        if not landmarks or pose_type not in self.key_angles:
+            return {'error': 'Invalid pose type or no landmarks detected'}
+        
+        feedback = {
+            'pose_type': pose_type,
+            'angles': {},
+            'corrections': []
+        }
+        # Indices for MediaPipe 33 keypoints
+        LEFT_SHOULDER = 11
+        RIGHT_SHOULDER = 12
+        LEFT_ELBOW = 13
+        RIGHT_ELBOW = 14
+        LEFT_WRIST = 15
+        RIGHT_WRIST = 16
+        LEFT_HIP = 23
+        RIGHT_HIP = 24
+        LEFT_KNEE = 25
+        RIGHT_KNEE = 26
+        LEFT_ANKLE = 27
+        RIGHT_ANKLE = 28
+        # Calculate angles for both arms
+        # Shoulder angles (hip-shoulder-elbow)
+        l_shoulder_angle = self.calculate_angle(landmarks, LEFT_HIP, LEFT_SHOULDER, LEFT_ELBOW)
+        r_shoulder_angle = self.calculate_angle(landmarks, RIGHT_HIP, RIGHT_SHOULDER, RIGHT_ELBOW)
+        # Elbow angles (shoulder-elbow-wrist)
+        l_elbow_angle = self.calculate_angle(landmarks, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST)
+        r_elbow_angle = self.calculate_angle(landmarks, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST)
+        # Wrist angles (elbow-wrist-hand index, if available)
+        # MediaPipe does not have hand index, so we can use a pseudo point (e.g., extend wrist direction)
+        # For now, skip wrist angle or set to None
+        # Leg angles (optional)
+        l_knee_angle = self.calculate_angle(landmarks, LEFT_HIP, LEFT_KNEE, LEFT_ANKLE)
+        r_knee_angle = self.calculate_angle(landmarks, RIGHT_HIP, RIGHT_KNEE, RIGHT_ANKLE)
+        # Add angles to feedback
+        if l_shoulder_angle:
+            feedback['angles']['L Shoulder'] = l_shoulder_angle
+            if not self.key_angles[pose_type]['shoulder_angle'][0] <= l_shoulder_angle <= self.key_angles[pose_type]['shoulder_angle'][1]:
+                feedback['corrections'].append(
+                    f"Adjust L Shoulder to {self.key_angles[pose_type]['shoulder_angle'][0]}-{self.key_angles[pose_type]['shoulder_angle'][1]} deg"
+                )
+        if r_shoulder_angle:
+            feedback['angles']['R Shoulder'] = r_shoulder_angle
+            if not self.key_angles[pose_type]['shoulder_angle'][0] <= r_shoulder_angle <= self.key_angles[pose_type]['shoulder_angle'][1]:
+                feedback['corrections'].append(
+                    f"Adjust R Shoulder to {self.key_angles[pose_type]['shoulder_angle'][0]}-{self.key_angles[pose_type]['shoulder_angle'][1]} deg"
+                )
+        if l_elbow_angle:
+            feedback['angles']['L Elbow'] = l_elbow_angle
+            if not self.key_angles[pose_type]['elbow_angle'][0] <= l_elbow_angle <= self.key_angles[pose_type]['elbow_angle'][1]:
+                feedback['corrections'].append(
+                    f"Adjust L Elbow to {self.key_angles[pose_type]['elbow_angle'][0]}-{self.key_angles[pose_type]['elbow_angle'][1]} deg"
+                )
+        if r_elbow_angle:
+            feedback['angles']['R Elbow'] = r_elbow_angle
+            if not self.key_angles[pose_type]['elbow_angle'][0] <= r_elbow_angle <= self.key_angles[pose_type]['elbow_angle'][1]:
+                feedback['corrections'].append(
+                    f"Adjust R Elbow to {self.key_angles[pose_type]['elbow_angle'][0]}-{self.key_angles[pose_type]['elbow_angle'][1]} deg"
+                )
+        # Optionally add knee angles
+        if l_knee_angle:
+            feedback['angles']['L Knee'] = l_knee_angle
+        if r_knee_angle:
+            feedback['angles']['R Knee'] = r_knee_angle
+        return feedback
+
+    def process_frame(self, frame: np.ndarray, pose_type: str = 'front_double_biceps', last_valid_landmarks=None) -> Tuple[np.ndarray, Dict, List[Dict]]:
+        """
+        Process a single frame, detect pose, and analyze it. Returns frame, analysis, and used landmarks.
+        """
+        # Detect pose
+        frame_with_pose, landmarks = self.detect_pose(frame, last_valid_landmarks=last_valid_landmarks)
+        # Analyze pose if landmarks are detected
+        analysis = self.analyze_pose(landmarks, pose_type) if landmarks else {'error': 'No pose detected'}
+        return frame_with_pose, analysis, landmarks 

HFup/bodybuilding_pose_analyzer/src/sample_video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16b5cfe3c836a5fba2c46ce4bcf9d241b9a9292647822fbbf767f3db9f1aa0e9
+size 1684449

HFup/external/BodybuildingPoseClassifier

@@ -0,0 +1 @@
+Subproject commit 0af89e6c36e63818059f89e82af6b13686ad25e3

HFup/requirements.txt

@@ -0,0 +1,80 @@
+absl-py==2.2.2
+astunparse==1.6.3
+attrs==25.3.0
+blinker==1.9.0
+certifi==2025.4.26
+cffi==1.17.1
+charset-normalizer==3.4.2
+click==8.1.7
+contourpy==1.2.1
+cycler==0.12.1
+ffmpeg-python==0.2.0
+filelock==3.18.0
+Flask==3.1.1
+flask-cors==5.0.1
+flatbuffers==25.2.10
+fonttools==4.58.0
+fsspec==2025.3.2
+future==1.0.0
+gast==0.6.0
+google-pasta==0.2.0
+gunicorn==22.0.0
+grpcio==1.71.0
+h5py==3.13.0
+idna==3.10
+itsdangerous==2.2.0
+jax==0.4.30
+jaxlib==0.4.30
+Jinja2==3.1.6
+keras==3.9.2
+kiwisolver==1.4.7
+libclang==18.1.1
+Markdown==3.8
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.9.4
+mdurl==0.1.2
+mediapipe==0.10.21
+ml_dtypes==0.5.1
+mpmath==1.3.0
+namex==0.0.9
+networkx==3.2.1
+ngrok==1.4.0
+numpy==1.26.4
+opencv-contrib-python==4.11.0.86
+opencv-python==4.11.0.86
+opt_einsum==3.4.0
+optree==0.15.0
+packaging==25.0
+pandas==2.2.3
+pillow==11.2.1
+protobuf==4.25.7
+pycparser==2.22
+Pygments==2.19.1
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.2
+requests==2.32.3
+rich==14.0.0
+scipy==1.13.1
+seaborn==0.13.2
+sentencepiece==0.2.0
+six==1.17.0
+sounddevice==0.5.1
+sympy==1.14.0
+tensorboard==2.19.0
+tensorboard-data-server==0.7.2
+tensorflow==2.19.0
+tensorflow-hub==0.16.1
+tensorflow-io-gcs-filesystem==0.37.1
+termcolor==3.1.0
+tf_keras==2.19.0
+torch==2.7.0
+torchvision==0.22.0
+tqdm==4.67.1
+typing_extensions==4.13.2
+tzdata==2025.2
+urllib3==2.4.0
+Werkzeug==3.1.3
+wrapt==1.17.2

HFup/static/uploads/output.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a555701da6bea5183cac40ea6f1b45d6fe182db4efc0cfca10ebab60fcdce498
+size 261

HFup/static/uploads/output_mediapipe.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dff942eb4a92e2af3f05573368ffa81cde14add1b0aeb28d7acc76b154aa56f0
+size 926873

HFup/static/uploads/output_movenet_lightning.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29e0173c04e5eb95a1f951e756a1f48fb56f5fee53afd0f2f812d1716de61bc4
+size 557403

HFup/static/uploads/output_movenet_thunder.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1aebd72c36462e0725557a154b595d70128b1723a01a33a2f9aa2854084c6a1
+size 1757104

HFup/static/uploads/policeb.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bedaa005f970439d8b6fe99e937027a3dc7c7f7d9ccec319af22344ed06df790
+size 7552156

HFup/yolov7

@@ -0,0 +1 @@
+Subproject commit a207844b1ce82d204ab36d87d496728d3d2348e7

HFup/yolov7-w6-pose.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8394a97f5a5283269028738e80006f3e9835088f00d293108bdee3320f2b0f8d
+size 161114789