Remove YOLOv7, ensure LFS for models, update Dockerfile

Dockerfile

@@ -15,11 +15,11 @@ 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 .
-RUN ls -la # Debug: List files in the build context root
+RUN echo "Listing files:" && ls -la # Debug: List files in the build context root
 COPY bodybuilding_pose_analyzer bodybuilding_pose_analyzer
 COPY external external
-COPY yolov7 yolov7 
-COPY yolov7-w6-pose.pt . 
+# COPY yolov7 yolov7 
+# COPY yolov7-w6-pose.pt . 
 COPY static static
 
 # Ensure the uploads directory within static exists and is writable

app.py

@@ -17,12 +17,12 @@ 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')
+# 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
+# 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."""
@@ -68,23 +68,23 @@ app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
 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()
+# 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)
+# kpt_shape = (17, 3)
 
 # Load CNN model for bodybuilding pose classification
 cnn_model_path = 'external/BodybuildingPoseClassifier/bodybuilding_pose_classifier.h5'
@@ -115,87 +115,87 @@ def after_request(response):
     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_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:

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! 

bodybuilding_pose_analyzer/bodybuilding_pose_classifier.h5

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

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 

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() 

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' 

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() 

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 

bodybuilding_pose_analyzer/src/sample_video.mp4

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

bodybuilding_pose_classifier_savedmodel.keras

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

static/uploads/output.mp4

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

static/uploads/output_mediapipe.mp4

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

static/uploads/output_movenet_lightning.mp4

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

static/uploads/output_movenet_thunder.mp4

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

static/uploads/policeb.mp4

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

templates/index.html

@@ -0,0 +1,176 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Bodybuilding Pose Analyzer</title>
+    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css" rel="stylesheet">
+</head>
+<body class="bg-gray-100 min-h-screen">
+    <div class="container mx-auto px-4 py-8">
+        <h1 class="text-4xl font-bold text-center mb-8">Bodybuilding Pose Analyzer</h1>
+        
+        <div class="max-w-2xl mx-auto bg-white rounded-lg shadow-lg p-6">
+            <div class="mb-6">
+                <h2 class="text-2xl font-semibold mb-4">Upload Video</h2>
+                <form id="uploadForm" class="space-y-4">
+                    <div class="border-2 border-dashed border-gray-300 rounded-lg p-6 text-center">
+                        <input type="file" id="videoInput" accept="video/*" class="hidden">
+                        <label for="videoInput" class="cursor-pointer">
+                            <div class="text-gray-600">
+                                <svg class="mx-auto h-12 w-12" stroke="currentColor" fill="none" viewBox="0 0 48 48">
+                                    <path d="M28 8H12a4 4 0 00-4 4v20m32-12v8m0 0v8a4 4 0 01-4 4H12a4 4 0 01-4-4v-4m32-4l-3.172-3.172a4 4 0 00-5.656 0L28 28M8 32l9.172-9.172a4 4 0 015.656 0L28 28m0 0l4 4m4-24h8m-4-4v8m-12 4h.02" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+                                </svg>
+                                <p class="mt-1">Click to upload a video</p>
+                                <p id="fileName" class="text-sm text-gray-500 mt-1"></p>
+                            </div>
+                        </label>
+                    </div>
+
+                    <div>
+                        <label class="block text-sm font-medium text-gray-700">Choose Model:</label>
+                        <div class="mt-1 flex rounded-md shadow-sm">
+                            <div class="relative flex items-stretch flex-grow focus-within:z-10">
+                                <label class="inline-flex items-center">
+                                    <input type="radio" class="form-radio" name="model_choice" value="movenet" checked>
+                                    <span class="ml-2">Gladiator BB</span>
+                                </label>
+                                <label class="inline-flex items-center ml-6">
+                                    <input type="radio" class="form-radio" name="model_choice" value="Gladiator SupaDot">
+                                    <span class="ml-2">Gladiator SupaDot</span>
+                                </label>
+                            </div>
+                        </div>
+                    </div>
+                    <div id="gladiatorBBOptions" class="space-y-4">
+                        <div>
+                            <label class="block text-sm font-medium text-gray-700">Gladiator BB Variant:</label>
+                            <div class="mt-1 flex rounded-md shadow-sm">
+                                <div class="relative flex items-stretch flex-grow focus-within:z-10">
+                                    <label class="inline-flex items-center">
+                                        <input type="radio" class="form-radio" name="movenet_variant" value="lightning" checked>
+                                        <span class="ml-2">Lightning (Faster, Less Accurate)</span>
+                                    </label>
+                                    <label class="inline-flex items-center ml-6">
+                                        <input type="radio" class="form-radio" name="movenet_variant" value="thunder">
+                                        <span class="ml-2">Thunder (Slower, More Accurate)</span>
+                                    </label>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <button type="submit" class="w-full bg-blue-500 text-white py-2 px-4 rounded-lg hover:bg-blue-600 transition duration-200">
+                        Process Video
+                    </button>
+                </form>
+            </div>
+            
+            <div id="result" class="hidden">
+                <h2 class="text-2xl font-semibold mb-4">Results</h2>
+                <div class="aspect-w-16 aspect-h-9">
+                    <video id="outputVideo" controls class="w-full rounded-lg"></video>
+                </div>
+            </div>
+            
+            <div id="loading" class="hidden">
+                <div class="flex items-center justify-center">
+                    <div class="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-500"></div>
+                </div>
+                <p class="text-center mt-4">Processing video...</p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        document.getElementById('videoInput').addEventListener('change', function() {
+            const fileName = this.files[0] ? this.files[0].name : 'No file selected';
+            document.getElementById('fileName').textContent = fileName;
+        });
+
+        document.querySelectorAll('input[name="model_choice"]').forEach(radio => {
+            radio.addEventListener('change', function() {
+                const gladiatorBBOptions = document.getElementById('gladiatorBBOptions');
+                if (this.value === 'movenet') {
+                    gladiatorBBOptions.classList.remove('hidden');
+                } else {
+                    gladiatorBBOptions.classList.add('hidden');
+                }
+            });
+        });
+
+        // Trigger change event on page load for the initially checked model_choice
+        document.querySelector('input[name="model_choice"]:checked').dispatchEvent(new Event('change'));
+
+        document.getElementById('uploadForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            const fileInput = document.getElementById('videoInput');
+            const file = fileInput.files[0];
+            
+            if (!file) {
+                alert('Please select a video file');
+                return;
+            }
+            
+            const formData = new FormData();
+            formData.append('video', file);
+            const modelChoice = document.querySelector('input[name="model_choice"]:checked').value;
+            formData.append('model_choice', modelChoice);
+            if (modelChoice === 'movenet') {
+                const movenetVariant = document.querySelector('input[name="movenet_variant"]:checked').value;
+                formData.append('movenet_variant', movenetVariant);
+            }
+
+            // Show loading
+            document.getElementById('loading').classList.remove('hidden');
+            document.getElementById('result').classList.add('hidden');
+            
+            try {
+                const response = await fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                console.log('[CLIENT] Full response object from /upload:', response); 
+                console.log('[CLIENT] Response status from /upload:', response.status);
+                console.log('[CLIENT] Response status text from /upload:', response.statusText);
+                
+                const data = await response.json();
+                console.log('[CLIENT] Parsed JSON data from /upload:', data); 
+                
+                if (response.ok) {
+                    console.log('[CLIENT] Response from /upload is OK (status 200-299)');
+                    const videoElement = document.getElementById('outputVideo');
+                    const resultDiv = document.getElementById('result');
+                    
+                    console.log('[CLIENT] Setting video src to:', data.output_path);
+                    videoElement.src = data.output_path;
+                    
+                    resultDiv.classList.remove('hidden'); 
+                    videoElement.load(); 
+                    console.log('[CLIENT] Called video.load()');
+                    
+                    videoElement.onloadeddata = () => {
+                        console.log('[CLIENT] Video data loaded successfully.');
+                    };
+                    videoElement.onerror = (e) => {
+                        console.error('[CLIENT] Video player error:', e);
+                        console.error('[CLIENT] Video src that failed:', videoElement.src);
+                        alert('Error loading video. Check browser console for details.');
+                    };
+
+                } else {
+                    console.error('[CLIENT] Response from /upload not OK. Status:', response.status);
+                    alert(data.error || `Server error: ${response.status} ${response.statusText}. Check browser console.`);
+                }
+            } catch (error) {
+                console.error('[CLIENT] Fetch Error during /upload:', error);
+                alert('A critical error occurred while uploading/processing the video. Check browser console.');
+            } finally {
+                document.getElementById('loading').classList.add('hidden');
+            }
+        });
+    </script>
+</body>
+</html>