Fix video processing and client-side issues

HFup/app.py

@@ -1,3 +1,8 @@
+# Patch for Hugging Face Spaces: set MPLCONFIGDIR to avoid permission errors with matplotlib
+import os
+os.environ["MPLCONFIGDIR"] = "/tmp/matplotlib"
+os.makedirs("/tmp/matplotlib", exist_ok=True)
+
 from flask import Flask, render_template, request, jsonify, send_from_directory, url_for
 from flask_cors import CORS
 import cv2
@@ -7,100 +12,156 @@ import os
 from werkzeug.utils import secure_filename
 import sys
 import traceback
+import tensorflow as tf
 from tensorflow.keras.models import load_model
 from tensorflow.keras.preprocessing import image
 import time
+import tensorflow_hub as hub
+import gc
+import psutil
+import logging
+
+# Check GPU availability
+print("[GPU] Checking GPU availability...")
+gpus = tf.config.list_physical_devices('GPU')
+if gpus:
+    print(f"[GPU] Found {len(gpus)} GPU(s):")
+    for gpu in gpus:
+        print(f"[GPU] {gpu}")
+    # Enable memory growth to avoid allocating all GPU memory at once
+    for gpu in gpus:
+        tf.config.experimental.set_memory_growth(gpu, True)
+    print("[GPU] Memory growth enabled for all GPUs")
+else:
+    print("[GPU] No GPU found, will use CPU")
 
 # 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)
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
-        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
+def log_memory_usage():
+    """Log current memory usage."""
+    try:
+        process = psutil.Process()
+        memory_info = process.memory_info()
+        logger.info(f"Memory usage: {memory_info.rss / 1024 / 1024:.2f} MB")
+    except Exception as e:
+        logger.error(f"Error logging memory usage: {e}")
 
-app = Flask(__name__, static_url_path='/static', static_folder='static')
+def cleanup_memory():
+    """Force garbage collection and log memory usage."""
+    try:
+        gc.collect()
+        log_memory_usage()
+    except Exception as e:
+        logger.error(f"Error in cleanup_memory: {e}")
+
+# Add file handler for persistent logging
+log_dir = 'logs'
+os.makedirs(log_dir, exist_ok=True)
+file_handler = logging.FileHandler(os.path.join(log_dir, 'app.log'))
+file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+logger.addHandler(file_handler)
+
+# Define base paths
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+STATIC_DIR = os.path.join(BASE_DIR, 'static')
+UPLOAD_DIR = os.path.join(STATIC_DIR, 'uploads')
+MODEL_DIR = os.path.join(BASE_DIR, 'external', 'BodybuildingPoseClassifier')
+
+# Ensure all required directories exist
+for directory in [STATIC_DIR, UPLOAD_DIR, MODEL_DIR, log_dir]:
+    os.makedirs(directory, exist_ok=True)
+    logger.info(f"Ensured directory exists: {directory}")
+
+app = Flask(__name__, static_url_path='/static', static_folder=STATIC_DIR)
 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
+app.config['UPLOAD_FOLDER'] = UPLOAD_DIR
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB max file size
 
+# Load CNN model for bodybuilding pose classification
 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")
+    logger.info("Loading CNN model...")
+    cnn_model_path = os.path.join(MODEL_DIR, 'bodybuilding_pose_classifier.h5')
+    logger.info(f"Looking for model at: {cnn_model_path}")
+    
+    # List directory contents to debug
+    logger.info(f"Contents of MODEL_DIR: {os.listdir(MODEL_DIR)}")
+    
+    if not os.path.exists(cnn_model_path):
+        logger.error(f"Model file not found at {cnn_model_path}")
+        logger.error(f"Current working directory: {os.getcwd()}")
+        logger.error(f"Directory contents: {os.listdir('.')}")
+        raise FileNotFoundError(f"CNN model not found at {cnn_model_path}")
+    
+    # Check file permissions
+    logger.info(f"Model file permissions: {oct(os.stat(cnn_model_path).st_mode)[-3:]}")
+    
+    # Load model with custom_objects to handle any custom layers
+    logger.info("Attempting to load model...")
+    cnn_model = load_model(cnn_model_path, compile=False)
+    logger.info("CNN 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.
+    logger.error(f"Error loading CNN model: {e}")
+    logger.error(traceback.format_exc())
+    raise
 
-# YOLOv7 pose model expects 17 keypoints
-kpt_shape = (17, 3)
+# Initialize TensorFlow session with memory growth
+try:
+    gpus = tf.config.list_physical_devices('GPU')
+    if gpus:
+        for gpu in gpus:
+            tf.config.experimental.set_memory_growth(gpu, True)
+        logger.info("GPU memory growth enabled")
+    else:
+        logger.info("No GPU found, using CPU")
+except Exception as e:
+    logger.error(f"Error configuring GPU: {e}")
+    logger.error(traceback.format_exc())
 
-# 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>')
+    try:
+        cleanup_memory()
+        if gpus:
+            logger.info("[CNN_DEBUG] Using GPU for CNN prediction")
+            with tf.device('/GPU:0'):
+                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, verbose=0)
+                predicted_class = np.argmax(predictions, axis=1)
+                confidence = float(np.max(predictions))
+        else:
+            logger.info("[CNN_DEBUG] No GPU found, using CPU for CNN prediction")
+            with tf.device('/CPU:0'):
+                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, verbose=0)
+                predicted_class = np.argmax(predictions, axis=1)
+                confidence = float(np.max(predictions))
+        
+        logger.info(f"[CNN_DEBUG] Prediction successful: {cnn_class_labels[predicted_class[0]]}")
+        return cnn_class_labels[predicted_class[0]], confidence
+    except Exception as e:
+        logger.error(f"[CNN_ERROR] Exception during CNN prediction: {e}")
+        logger.error(traceback.format_exc())
+        raise
+    finally:
+        cleanup_memory()
+
+@app.route('/static/uploads/<path:filename>', endpoint='serve_video')
 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
@@ -115,256 +176,157 @@ 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.")
+def process_video_movenet(video_path):
     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")
+        print("[DEBUG] Starting MoveNet video processing")
+        print(f"[DEBUG] Python version: {sys.version}")
+        print(f"[DEBUG] OpenCV version: {cv2.__version__}")
+        print(f"[DEBUG] TensorFlow version: {tf.__version__}")
+        print(f"[DEBUG] Upload dir contents: {os.listdir(os.path.dirname(video_path))}")
+        print(f"[DEBUG] Current working dir: {os.getcwd()}")
         
-        # 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))
+        # Ensure upload directory exists and has proper permissions
+        upload_dir = os.path.dirname(video_path)
+        os.makedirs(upload_dir, exist_ok=True)
+        os.chmod(upload_dir, 0o777)
         
-        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}")
+            print(f"[ERROR] Could not open video file: {video_path}")
+            raise ValueError("Could not open video file")
+        
+        # Get video properties
         fps = int(cap.get(cv2.CAP_PROP_FPS))
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        print(f"[DEBUG] Video properties - FPS: {fps}, Width: {width}, Height: {height}, Total Frames: {total_frames}")
         
-        # Add panel width to total width
-        panel_width = 300
-        total_width = width + panel_width
+        # Force MoveNet to CPU to avoid GPU JIT error
+        print("[DEBUG] Forcing CPU for MoveNet (due to GPU JIT error)")
+        try:
+            with tf.device('/CPU:0'):
+                print("[DEBUG] Loading MoveNet model...")
+                movenet_model = hub.load("https://tfhub.dev/google/movenet/singlepose/lightning/4")
+                movenet = movenet_model.signatures['serving_default']
+                print("[DEBUG] MoveNet model loaded.")
+        except Exception as e:
+            print(f"[ERROR] Exception during MoveNet model load: {e}")
+            import traceback; traceback.print_exc()
+            raise
         
-        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'
+        # Create output video writer with H.264 codec
+        output_filename = f'output_movenet_lightning.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():
+        # Try different codecs in order of preference
+        codecs = ['mp4v', 'avc1', 'XVID']
+        out = None
+        for codec in codecs:
+            try:
+                fourcc = cv2.VideoWriter_fourcc(*codec)
+                out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+                if out.isOpened():
+                    print(f"[DEBUG] Successfully created video writer with codec: {codec}")
+                    break
+            except Exception as e:
+                print(f"[DEBUG] Failed to create video writer with codec {codec}: {e}")
+                continue
+        
+        if not out or not out.isOpened():
+            print(f"[ERROR] Failed to create output video writer at {output_path}")
             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
+        processed_frames = 0
+        first_frame_shape = None
+        print("[DEBUG] Entering frame loop...")
         
         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:
+                ret, frame = cap.read()
+                if not ret or frame is None:
+                    print(f"[DEBUG] Stopping at frame {frame_count+1}: ret={ret}, frame is None: {frame is None}")
+                    break
+                    
+                if first_frame_shape is None:
+                    first_frame_shape = frame.shape
+                    print(f"[DEBUG] First frame shape: {first_frame_shape}")
+                    
+                frame_count += 1
+                
+                # Ensure frame size matches VideoWriter
+                if frame.shape[1] != width or frame.shape[0] != height:
+                    print(f"[WARNING] Frame size {frame.shape[1]}x{frame.shape[0]} does not match VideoWriter size {width}x{height}. Resizing.")
+                    frame = cv2.resize(frame, (width, height))
+                
+                # Resize and pad the image to keep aspect ratio
+                img = frame.copy()
+                img = tf.image.resize_with_pad(tf.expand_dims(img, axis=0), 192, 192)
+                img = tf.cast(img, dtype=tf.int32)
+                
+                # Always run inference on CPU
                 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
+                    with tf.device('/CPU:0'):
+                        results = movenet(img)
+                        keypoints = results['output_0'].numpy()
                 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
+                    print(f"[ERROR] Exception during MoveNet inference on frame {frame_count}: {e}")
+                    import traceback; traceback.print_exc()
+                    continue
                 
-                # 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
+                # Process keypoints and draw on frame
+                y, x, c = frame.shape
+                shaped = np.squeeze(keypoints)
+                for kp in range(17):
+                    ky, kx, kp_conf = shaped[kp]
+                    if kp_conf > 0.3:
+                        cx, cy = int(kx * x), int(ky * y)
+                        cv2.circle(frame, (cx, cy), 6, (0, 255, 0), -1)
+                
+                out.write(frame)
+                processed_frames += 1
+                print(f"[DEBUG] Wrote frame {frame_count} to output video.")
+                
+            except Exception as e:
+                print(f"[ERROR] Exception in frame loop at frame {frame_count+1}: {e}")
+                import traceback; traceback.print_exc()
+                continue
                 
-                # 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"[DEBUG] Processed {processed_frames} frames out of {total_frames} total frames")
+        
+        # Check output file size
+        if not os.path.exists(output_path):
+            print(f"[ERROR] Output video file was not created: {output_path}")
+            raise ValueError(f"Output video file was not created: {output_path}")
             
-        print(f"MoveNet video processing completed. Processed {frame_count} frames. Output: {output_path}")
-        print(f"Output file size: {os.path.getsize(output_path)} bytes")
+        file_size = os.path.getsize(output_path)
+        print(f"[DEBUG] Output video file size: {file_size} bytes")
+        
+        if processed_frames == 0 or file_size < 1000:
+            print(f"[ERROR] Output video file is empty or too small: {output_path}")
+            raise ValueError(f"Output video file is empty or too small: {output_path}")
+            
+        # Ensure output file has proper permissions
+        os.chmod(output_path, 0o666)
+        
+        video_url = url_for('serve_video', filename=output_filename, _external=False)
+        print(f"[DEBUG] Returning video URL: {video_url}")
+        return video_url
         
-        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()
+        print(f"[FATAL ERROR] Uncaught exception in process_video_movenet: {e}")
+        import traceback; traceback.print_exc()
         raise
 
 def process_video_mediapipe(video_path):
     try:
-        print(f"[PROCESS_VIDEO_MEDIAPIPE] Called with video_path: {video_path}")
+        cleanup_memory()  # Clean up before processing
+        logger.info(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}")
 
@@ -383,7 +345,7 @@ def process_video_mediapipe(video_path):
         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')
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         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}")
@@ -401,7 +363,8 @@ def process_video_mediapipe(video_path):
                 break
             frame_count += 1
             if frame_count % 30 == 0:
-                print(f"Processing frame {frame_count}")
+                logger.info(f"Processing frame {frame_count}")
+                cleanup_memory()  # Clean up periodically
 
             # Process frame with MediaPipe
             processed_frame, current_analysis_results, landmarks = analyzer.process_frame(frame, last_valid_landmarks=last_valid_landmarks)
@@ -415,11 +378,11 @@ def process_video_mediapipe(video_path):
                 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}")
+                    logger.info(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}")
+                    logger.error(f"[CNN] Error predicting pose on frame {frame_count}: {e}")
                 finally:
                     if os.path.exists(temp_img_path):
                         os.remove(temp_img_path)
@@ -431,33 +394,29 @@ def process_video_mediapipe(video_path):
             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
+            reference_height_for_font_scale = 640.0
             
             # 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
+            # Calculate dynamic line_height
             (_, 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_spacing_factor = 1.8
             line_height = int(text_actual_height * line_spacing_factor)
-            line_height = max(line_height, 15) # Ensure a minimum line height
+            line_height = max(line_height, 15)
 
-            # 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 ---
+            # Initial y_offset
+            y_offset_panel = max(line_height, 20)
 
             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}")
+            if frame_count % 30 == 0:
+                logger.info(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)
 
@@ -477,10 +436,9 @@ def process_video_mediapipe(video_path):
                         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
+                    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 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)
@@ -490,76 +448,95 @@ def process_video_mediapipe(video_path):
                 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
+            combined_frame = np.hstack((processed_frame, panel))
             out.write(combined_frame)
 
         cap.release()
         out.release()
+        cleanup_memory()  # Clean up after processing
         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)
+        logger.info(f"MediaPipe video processing completed. Processed {frame_count} frames. Output: {output_path}")
+        video_url = url_for('serve_video', filename=output_filename, _external=False)
+        print(f"[DEBUG] Returning video URL: {video_url}")
+        return video_url
     except Exception as e:
-        print(f'Error in process_video_mediapipe: {e}')
+        logger.error(f'Error in process_video_mediapipe: {e}')
         traceback.print_exc()
         raise
+    finally:
+        cleanup_memory()  # Clean up in case of error
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
+# Add error handling for video processing
+def safe_video_processing(video_path, model_choice):
+    """Wrapper function to handle video processing with proper cleanup."""
+    try:
+        if model_choice == 'movenet':
+            return process_video_movenet(video_path)
+        else:
+            return process_video_mediapipe(video_path)
+    except Exception as e:
+        logger.error(f"Error in video processing: {e}")
+        logger.error(traceback.format_exc())
+        raise
+    finally:
+        cleanup_memory()
+
 @app.route('/upload', methods=['POST'])
 def upload_file():
     try:
+        cleanup_memory()
         if 'video' not in request.files:
-            print("[UPLOAD] No video file in request")
+            logger.error("[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")
+            logger.error("[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}")
+                logger.error(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}")
+            logger.info(f"[UPLOAD] Original filename: {file.filename}")
+            logger.info(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}")
+            # Ensure upload directory exists
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            
+            logger.info(f"[UPLOAD] Saving file to: {filepath}")
             file.save(filepath)
             
             if not os.path.exists(filepath):
-                print(f"[UPLOAD] File not found after save: {filepath}")
+                logger.error(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")
+            logger.info(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}")
+                logger.info(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}")
+                output_path_url = safe_video_processing(filepath, model_choice)
+                logger.info(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}")
+                output_path = os.path.join(app.config['UPLOAD_FOLDER'], os.path.basename(output_path_url))
+                if not os.path.exists(output_path):
+                    logger.error(f"[UPLOAD] Output file not found: {output_path}")
                     return jsonify({'error': 'Output video file not found'}), 500
                     
                 return jsonify({
@@ -568,22 +545,40 @@ def upload_file():
                 })
                 
             except Exception as e:
-                print(f"[UPLOAD] Error processing video: {str(e)}")
-                traceback.print_exc()
+                logger.error(f"[UPLOAD] Error processing video: {str(e)}")
+                logger.error(traceback.format_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}")
+                        logger.info(f"[UPLOAD] Cleaned up input file: {filepath}")
                 except Exception as e:
-                    print(f"[UPLOAD] Error cleaning up file: {str(e)}")
+                    logger.error(f"[UPLOAD] Error cleaning up file: {str(e)}")
                     
     except Exception as e:
-        print(f"[UPLOAD] Unexpected error: {str(e)}")
-        traceback.print_exc()
+        logger.error(f"[UPLOAD] Unexpected error: {str(e)}")
+        logger.error(traceback.format_exc())
         return jsonify({'error': 'Internal server error'}), 500
+    finally:
+        cleanup_memory()
+
+# Add more specific error handlers
+@app.errorhandler(413)
+def request_entity_too_large(error):
+    logger.error(f"File too large: {error}")
+    return jsonify({'error': 'File too large. Maximum size is 100MB'}), 413
+
+@app.errorhandler(500)
+def internal_server_error(error):
+    logger.error(f"Internal server error: {error}")
+    return jsonify({'error': 'Internal server error. Please try again later.'}), 500
+
+@app.errorhandler(404)
+def not_found_error(error):
+    logger.error(f"Resource not found: {error}")
+    return jsonify({'error': 'Resource not found'}), 404
 
 if __name__ == '__main__':
     # Ensure the port is 7860 and debug is False for HF Spaces deployment

HFup/templates/index.html

@@ -0,0 +1,179 @@
+<!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) {
+                    throw new Error(data.error || 'Failed to process video');
+                }
+                
+                // Create video element if it doesn't exist
+                let videoElement = document.getElementById('outputVideo');
+                if (!videoElement) {
+                    videoElement = document.createElement('video');
+                    videoElement.id = 'outputVideo';
+                    videoElement.controls = true;
+                    videoElement.style.width = '100%';
+                    videoElement.style.maxWidth = '800px';
+                    document.getElementById('result').appendChild(videoElement);
+                }
+                
+                // Set up video source
+                videoElement.src = data.output_path;
+                
+                // Wait for video to be loaded
+                await new Promise((resolve, reject) => {
+                    videoElement.onloadeddata = resolve;
+                    videoElement.onerror = reject;
+                    videoElement.load();
+                });
+                
+                // Show result
+                document.getElementById('loading').classList.add('hidden');
+                document.getElementById('result').classList.remove('hidden');
+                
+            } catch (error) {
+                console.error('[CLIENT] Error:', error);
+                document.getElementById('loading').classList.add('hidden');
+                alert('Error processing video: ' + error.message);
+            }
+        });
+    </script>
+</body>
+</html>