video_processor.py

# backend/core/video_processor.py
import cv2
import asyncio
from datetime import datetime
from core.face_detection import FaceDetector
from core.face_recognition import FaceRecognizer
from core.attendance_manager import AttendanceManager

class VideoProcessor:
    def __init__(self, detector, recognizer, attendance_manager):
        self.detector = detector
        self.recognizer = recognizer
        self.attendance_manager = attendance_manager
        self.frame_buffer = []
        self.processing_interval = 0.5  # Process every 0.5 seconds
        
    async def process_video(self, video_source=0):
        """Process video stream from camera or file"""
        cap = cv2.VideoCapture(video_source)
        
        if not cap.isOpened():
            raise ValueError("Could not open video source")
            
        last_process_time = datetime.now()
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
                
            # Process at intervals for efficiency
            current_time = datetime.now()
            if (current_time - last_process_time).total_seconds() >= self.processing_interval:
                # Detect faces
                faces = self.detector.detect_faces(frame)
                
                for face_data in faces:
                    # Recognize face
                    name = self.recognizer.recognize_face(face_data['face_img'])
                    if name:
                        # Mark attendance
                        employee_id = self._get_employee_id(name)
                        if employee_id:
                            self.attendance_manager.mark_attendance(employee_id)
                            # Draw bounding box with name
                            x1, y1, x2, y2 = face_data['bbox']
                            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                            cv2.putText(frame, name, (x1, y1-10), 
                                      cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0,255,0), 2)
                
                last_process_time = current_time
                
            yield frame
            
        cap.release()