Update video_processor.py

video_processor.py

@@ -1,80 +1,44 @@
-"""
-Video Processing Utility for Drowsiness Detection
-This script provides a more robust video processing interface
-"""
+# video_processor.py
 
 import cv2 as cv
-import os
-import json
-from datetime import datetime
-import argparse
-
-def get_video_info(video_path):
-    """Get detailed video information"""
-    cap = cv.VideoCapture(video_path)
-    
-    if not cap.isOpened():
-        return None
-    
-    info = {
-        'fps': cap.get(cv.CAP_PROP_FPS),
-        'width': int(cap.get(cv.CAP_PROP_FRAME_WIDTH)),
-        'height': int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)),
-        'total_frames': int(cap.get(cv.CAP_PROP_FRAME_COUNT)),
-        'duration': cap.get(cv.CAP_PROP_FRAME_COUNT) / cap.get(cv.CAP_PROP_FPS) if cap.get(cv.CAP_PROP_FPS) > 0 else 0,
-        'codec': int(cap.get(cv.CAP_PROP_FOURCC)),
-        'file_size': os.path.getsize(video_path)
-    }
-    
-    cap.release()
-    return info
-
-def create_processing_report(input_path, output_path, stats):
-    """Create a JSON report of the processing results"""
-    report = {
-        'timestamp': datetime.now().isoformat(),
-        'input_file': input_path,
-        'output_file': output_path,
-        'video_info': get_video_info(input_path),
-        'detection_stats': stats,
-        'processing_info': {
-            'software': 'Drowsiness Detection System',
-            'version': '1.0'
-        }
-    }
-    
-    report_path = output_path.replace('.mp4', '_report.json')
-    with open(report_path, 'w') as f:
-        json.dump(report, f, indent=2)
-    
-    return report_path
+# We import the necessary functions and state from drowsiness_detection
+from drowsiness_detection import process_frame, reset_counters, DROWSY_COUNTER, YAWN_COUNTER, HEAD_DOWN_COUNTER
 
 def process_video_with_progress(input_path, output_path, progress_callback=None):
     """
-    Process video with progress callback
-    progress_callback: function that takes (current_frame, total_frames)
+    Processes a video file to detect drowsiness, providing progress updates.
+
+    Args:
+        input_path (str): Path to the input video file.
+        output_path (str): Path to save the processed video file.
+        progress_callback (function, optional): A function to call with progress updates. 
+                                                It receives (current_frame, total_frames).
+    
+    Returns:
+        dict: A dictionary containing the final detection statistics.
     """
-    # Import the drowsiness detection functions
-    from drowsiness_detection import process_frame, reset_counters
-    from drowsiness_detection import DROWSY_COUNTER, YAWN_COUNTER, HEAD_DOWN_COUNTER
-    
-    reset_counters()
+    reset_counters()  # Ensure all counters are zeroed before starting
     
-    # Open video file
     video_stream = cv.VideoCapture(input_path)
-    
     if not video_stream.isOpened():
         raise ValueError(f"Could not open video file {input_path}")
     
-    # Get video properties
-    fps = int(video_stream.get(cv.CAP_PROP_FPS))
-    width = int(video_stream.get(cv.CAP_PROP_FRAME_WIDTH))
-    height = int(video_stream.get(cv.CAP_PROP_FRAME_HEIGHT))
+    # Get video properties for the writer
+    fps = video_stream.get(cv.CAP_PROP_FPS)
+    original_width = int(video_stream.get(cv.CAP_PROP_FRAME_WIDTH))
+    original_height = int(video_stream.get(cv.CAP_PROP_FRAME_HEIGHT))
     total_frames = int(video_stream.get(cv.CAP_PROP_FRAME_COUNT))
     
+    # --- FIX: Calculate correct output dimensions to prevent distortion ---
+    # The process_frame function resizes frames to a fixed width of 640.
+    output_width = 640
+    aspect_ratio = original_height / original_width
+    output_height = int(output_width * aspect_ratio)
+    output_dims = (output_width, output_height)
+    
     # Setup video writer
     fourcc = cv.VideoWriter_fourcc(*'mp4v')
-    video_writer = cv.VideoWriter(output_path, fourcc, fps, (640, 480))
+    video_writer = cv.VideoWriter(output_path, fourcc, fps, output_dims)
     
     frame_count = 0
     
@@ -85,58 +49,28 @@ def process_video_with_progress(input_path, output_path, progress_callback=None)
                 break
             
             frame_count += 1
-            
-            # Process frame
             processed_frame = process_frame(frame)
             
-            # Write frame to output video
+            # The processed frame is already resized to 640px width.
+            # We must ensure it fits the calculated output_dims.
+            # If aspect ratios differ slightly, resizing is a safe fallback.
+            if processed_frame.shape[1] != output_dims[0] or processed_frame.shape[0] != output_dims[1]:
+                processed_frame = cv.resize(processed_frame, output_dims)
+                
             video_writer.write(processed_frame)
             
-            # Call progress callback if provided
             if progress_callback:
                 progress_callback(frame_count, total_frames)
-        
-        # Get final stats
+                
         stats = {
-            'total_frames': frame_count,
+            'total_frames_processed': frame_count,
             'drowsy_events': DROWSY_COUNTER,
             'yawn_events': YAWN_COUNTER,
             'head_down_events': HEAD_DOWN_COUNTER
         }
-        
         return stats
         
     finally:
         video_stream.release()
-        video_writer.release()
-
-def main():
-    parser = argparse.ArgumentParser(description='Video Processing Utility for Drowsiness Detection')
-    parser.add_argument('--input', '-i', required=True, help='Input video file path')
-    parser.add_argument('--output', '-o', help='Output video file path (optional)')
-    parser.add_argument('--report', '-r', action='store_true', help='Generate processing report')
-    parser.add_argument('--info', action='store_true', help='Show video information only')
-    
-    args = parser.parse_args()
-    
-    if not os.path.exists(args.input):
-        print(f"Error: Input file {args.input} does not exist")
-        return
-    
-    # Show video info
-    if args.info:
-        info = get_video_info(args.input)
-        if info:
-            print(f"Video Information for: {args.input}")
-            print(f"Resolution: {info['width']}x{info['height']}")
-            print(f"FPS: {info['fps']:.2f}")
-            print(f"Duration: {info['duration']:.2f} seconds")
-            print(f"Total Frames: {info['total_frames']}")
-            print(f"File Size: {info['file_size'] / (1024*1024):.2f} MB")
-        else:
-            print("Error: Could not read video file")
-        return
-    
-    # Generate output path if not provided
-    if not args.output:
-        base_name
+        if video_writer:
+            video_writer.release()