Remove frame skipping and debug video output to save storage

MAJOR CHANGES - Process full video quality:
- Remove adaptive frame sampling from all 3 services
- Process ALL frames (no frame skip) for accurate analysis
- Remove annotated video output to save server storage
- Remove debug_videos section from API response

Changes by service:
1. facial_expression.py: Process all frames, no video output
2. eye_tracking.py: Process all frames, remove _annotate_frame usage
3. gesture_detection.py: Process all frames
4. video_processor.py: Remove debug_videos collection

Benefits:
- More accurate analysis (100% frames processed)
- Save storage space (no debug videos saved)
- Cleaner API response (no debug_videos field)

Trade-off: Longer processing time but better accuracy

app/services/eye_tracking.py

@@ -700,9 +700,7 @@ class EyeTrackingService:
     def analyze_video(
         self, 
         video_path: str,
-        progress_callback: Optional[callable] = None,
-        save_annotated_video: bool = True,  # Enable by default for debugging
-        output_path: Optional[str] = None
+        progress_callback: Optional[callable] = None
     ) -> Dict[str, Any]:
         """
         Analyze video for eye contact
@@ -710,15 +708,12 @@ class EyeTrackingService:
         Args:
             video_path: Path to video file
             progress_callback: Optional callback for progress updates
-            save_annotated_video: Whether to save annotated video (default: True)
-            output_path: Path for output video (default: auto-generated in temp/debug/)
         
         Returns:
-            Dict containing eye tracking analysis results with annotated_video_path
+            Dict containing eye tracking analysis results
         """
         try:
             logger.info(f"Analyzing video with Eye Tracking Service: {video_path}")
-            logger.info(f"Save annotated video: {save_annotated_video}")
             
             cap = cv.VideoCapture(video_path)
             if not cap.isOpened():
@@ -731,22 +726,6 @@ class EyeTrackingService:
             total_frames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
             
             logger.info(f"Video properties: {width}x{height} @ {fps}FPS, {total_frames} frames")
-            logger.info(f"Video properties: {width}x{height} @ {fps}FPS, {total_frames} frames")
-            
-            # Setup video writer if needed
-            out = None
-            if save_annotated_video:
-                if output_path is None:
-                    import os
-                    # Generate unique filename based on input video
-                    video_basename = os.path.basename(video_path)
-                    video_name = os.path.splitext(video_basename)[0]
-                    os.makedirs('temp/debug', exist_ok=True)
-                    output_path = f'temp/debug/{video_name}_eye_tracking.mp4'
-                
-                fourcc = cv.VideoWriter_fourcc(*'mp4v')
-                out = cv.VideoWriter(output_path, fourcc, fps, (width, height))
-                logger.info(f"📹 Annotated video will be saved to: {output_path}")
             
             # Initialize counters
             frame_count = 0
@@ -812,11 +791,6 @@ class EyeTrackingService:
                 if gaze_pos != 'CENTER' and gaze_pos != 'UNKNOWN':
                     gaze_away_frames += 1
                 
-                # Annotate frame if video output enabled
-                if save_annotated_video and out is not None:
-                    annotated_frame = self._annotate_frame(frame, result, frame_count, blink_count, gaze_pos)
-                    out.write(annotated_frame)
-                
                 # Log every 100 frames
                 if frame_count % 100 == 0:
                     logger.info(f"Processed {frame_count}/{total_frames} frames | "
@@ -826,9 +800,6 @@ class EyeTrackingService:
                                f"Blinks: {blink_count}")
             
             cap.release()
-            if out is not None:
-                out.release()
-                logger.info(f"✓ Annotated video saved: {output_path}")
             
             # Calculate metrics
             duration = frame_count / fps
@@ -886,11 +857,6 @@ class EyeTrackingService:
                 'debug_stats': debug_stats
             }
             
-            # Always include annotated video path if saved
-            if save_annotated_video and output_path:
-                result['annotated_video_path'] = output_path
-                logger.info(f"✓ Annotated video saved: {output_path}")
-            
             logger.info(f"✓ Eye Tracking analysis completed: Score {score}/5 - {rating}")
             return result
         

app/services/facial_expression.py

@@ -60,27 +60,12 @@ class FacialExpressionService:
             # Get video properties
             fps = int(cap.get(cv2.CAP_PROP_FPS))
             total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            duration_seconds = total_frames / fps if fps > 0 else 0
             
-            # ADAPTIVE FRAME SAMPLING based on video length
-            # Short video (<30s): process every 2 frames (15-25 FPS)
-            # Medium video (30-60s): process every 3 frames (10-17 FPS)
-            # Long video (>60s): process every 4 frames (7-12 FPS)
-            if duration_seconds > 60:
-                frame_skip = 4
-            elif duration_seconds > 30:
-                frame_skip = 3
-            elif fps > 30:
-                frame_skip = 2
-            else:
-                frame_skip = 1
-            
-            logger.info(f"Video duration: {duration_seconds:.1f}s, Processing every {frame_skip} frame(s) from {total_frames} total frames")
+            logger.info(f"Processing {total_frames} frames at {fps} FPS")
             
             # Data storage
             frame_data = []
             frame_number = 0
-            processed_count = 0
             
             # Process each frame
             while True:
@@ -89,12 +74,6 @@ class FacialExpressionService:
                     break
                 
                 frame_number += 1
-                
-                # Skip frames if needed
-                if frame_number % frame_skip != 0:
-                    continue
-                
-                processed_count += 1
                 timestamp_start = (frame_number - 1) / fps
                 timestamp_end = frame_number / fps
                 
@@ -152,7 +131,7 @@ class FacialExpressionService:
             
             cap.release()
             
-            logger.info(f"✓ Processed {processed_count}/{frame_number} frames (skipped every {frame_skip} frame)")
+            logger.info(f"✓ Processed {frame_number} frames")
             
             # Analyze expressions
             df_faces = [f for f in frame_data if f['expression'] not in ['no_face', 'background']]

app/services/gesture_detection.py

@@ -107,29 +107,12 @@ class GestureDetectionService:
             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))
-            duration_seconds = total_frames / fps if fps > 0 else 0
             
-            logger.info(f"Video Info: {width}x{height} @ {fps}FPS, Total frames: {total_frames}, Duration: {duration_seconds:.1f}s")
-            
-            # ADAPTIVE FRAME SAMPLING based on video length
-            # Short video (<30s): process every 2 frames
-            # Medium video (30-60s): process every 3 frames
-            # Long video (>60s): process every 4 frames
-            if duration_seconds > 60:
-                frame_skip = 4
-            elif duration_seconds > 30:
-                frame_skip = 3
-            elif fps > 30:
-                frame_skip = 2
-            else:
-                frame_skip = 1
-            
-            logger.info(f"Processing every {frame_skip} frame(s) for gesture analysis")
+            logger.info(f"Video Info: {width}x{height} @ {fps}FPS, Total frames: {total_frames}")
             
             # Data storage
             frame_data = []
             frame_count = 0
-            processed_count = 0
             prev_landmarks = None
             
             while True:
@@ -139,14 +122,8 @@ class GestureDetectionService:
                 
                 frame_count += 1
                 
-                # Skip frames if needed
-                if frame_count % frame_skip != 0:
-                    continue
-                
-                processed_count += 1
-                
                 # Progress callback
-                if progress_callback and processed_count % 30 == 0:
+                if progress_callback and frame_count % 30 == 0:
                     progress = int((frame_count / total_frames) * 100)
                     progress_callback(frame_count, total_frames, f"Processing gestures: {progress}%")
                 
@@ -240,7 +217,7 @@ class GestureDetectionService:
             
             cap.release()
             
-            logger.info(f"✓ Processed {processed_count}/{frame_count} frames (skipped every {frame_skip} frame)")
+            logger.info(f"✓ Processed {frame_count} frames")
             
             if not frame_data:
                 logger.warning("No frames processed")

app/services/video_processor.py

@@ -297,7 +297,7 @@ class VideoProcessor:
             }
         
         # Build final response
-        return {
+        result = {
             "level": level,
             "video_metadata": {
                 "duration": metadata.duration,
@@ -309,6 +309,8 @@ class VideoProcessor:
             "bonus_indicators": bonus_indicators,
             "processing_time": 0  # Will be set by task handler
         }
+        
+        return result
 
 
 # Singleton instance