Face Detection & ROI Extraction

class FaceDetector:
    """
    Unified face detector manager with ROI stabilization.
    
    Attributes:
        MODELS (dict): Available face detection models.
        detector (BaseFaceDetector): Current detector instance.
        roi_history (deque): History of recent ROI detections for stabilization.
        stabilized_roi (tuple or None): Current stabilized ROI coordinates.
    """
    
    MODELS = {
        "haar": HaarCascadeDetector,        # Haar Cascade classifier
        "mtcnn": MTCNNDetector,             # Multi-task Cascaded CNN
        "yolo": YOLODetector,               # YOLO-based detector
        "mediapipe": MediaPipeDetector      # MediaPipe Face Detection
    }

# YOLO model paths
YOLO_MODELS = {
    "yolov8n": "src/weights_models/yolov8n-face.pt",   # YOLOv8 nano
    "yolov12n": "src/weights_models/yolov12n-face.pt"  # YOLOv12 nano
}

def __init__(self, model_type="haar", **kwargs):
    # Initialize the selected detector
    self.detector = self.MODELS[model_type](**kwargs)
    
    # ROI stabilization buffers
    self.roi_history = deque(maxlen=5)  # Store last 5 detections
    self.stabilized_roi = None          # Current stabilized ROI

def stabilize_roi(self, new_roi):
    """
    Apply temporal smoothing to ROI using weighted averaging.
    
    Uses a weighted average of recent ROIs to reduce jitter in detection.
    Recent detections are given higher weight according to ROI_WEIGHTS.
    """
    if new_roi is None:
        # Return previous stabilized ROI if no new detection
        return self.stabilized_roi

    # Add new detection to history
    self.roi_history.append(new_roi)

    # Need minimum history for stabilization
    if len(self.roi_history) < 3:
        return new_roi
    
    # Calculate weighted average of historical ROIs
    weights = ROI_WEIGHTS[:len(self.roi_history)]
    weights = [w / sum(weights) for w in weights]  # Normalize weights

    # Weighted average calculation for each dimension
    x_roi = int(sum(r[0] * w for r, w in zip(self.roi_history, weights)))
    y_roi = int(sum(r[1] * w for r, w in zip(self.roi_history, weights)))
    w_roi = int(sum(r[2] * w for r, w in zip(self.roi_history, weights)))
    h_roi = int(sum(r[3] * w for r, w in zip(self.roi_history, weights)))

    # Update and return stabilized ROI
    self.stabilized_roi = (x_roi, y_roi, w_roi, h_roi)
    return self.stabilized_roi

ROI_WEIGHTS = [0.1, 0.15, 0.2, 0.25, 0.3]  # Weights for ROI smoothing

def is_significant_change(self, old_roi, new_roi):
    """
    Check if ROI change exceeds threshold to avoid unnecessary updates.
    
    Returns:
        bool: True if change is significant, False otherwise.
    """
    if old_roi is None or new_roi is None:
        return True

    # Extract coordinates
    x1, y1, w1, h1 = old_roi
    x2, y2, w2, h2 = new_roi

    # Calculate absolute differences
    dx = abs(x1 - x2)
    dy = abs(y1 - y2)
    dw = abs(w1 - w2)
    dh = abs(h1 - h2)

    # Check if any dimension change exceeds threshold
    return (dx > ROI_CHANGE_THRESHOLD or dy > ROI_CHANGE_THRESHOLD or 
            dw > ROI_CHANGE_THRESHOLD or dh > ROI_CHANGE_THRESHOLD)

ROI_CHANGE_THRESHOLD = 20  # Pixels

def detect_face(self, frame):
    """
    Detect face in frame with stabilization and bounds checking.
    
    Returns:
        tuple or None: Stabilized ROI coordinates (x, y, w, h) or None.
    """
    # Get detection from underlying detector
    roi = self.detector.detect(frame)
    if roi is None:
        return None

    # Skip stabilization if change is not significant
    if self.stabilized_roi and not self.is_significant_change(self.stabilized_roi, roi):
        return self.stabilized_roi
    
    # Apply stabilization to new detection
    stable = self.stabilize_roi(roi)
    if stable:
        sx, sy, sw, sh = stable
        
        # Ensure ROI stays within frame boundaries
        sx = max(0, sx)
        sy = max(0, sy)
        sw = min(frame.shape[1] - sx, sw)
        sh = min(frame.shape[0] - sy, sh)
        
        return (sx, sy, sw, sh)
    
    return None

# ROI sizing configuration
TARGET_ROI_SIZE = (320, 240)  # Width × Height
ROI_PADDING = 10               # Pixels added around detected face

class BaseFaceDetector(ABC):
    """
    Abstract base class for face detection implementations.
    """
    
    @abstractmethod
    def detect(self, frame):
        """
        Detect faces in the provided frame.
        
        Args:
            frame (numpy.ndarray): Input image in BGR format.
            
        Returns:
            tuple or None: Face coordinates as (x, y, w, h) or None if no face detected.
        """
        pass

    @abstractmethod
    def close(self):
        """
        Release any resources used by the detector.
        """
        pass

from src.face_detector.manager import FaceDetector
import cv2

# Initialize detector (default: Haar Cascade)
detector = FaceDetector(model_type="haar")

# Process frame
frame = cv2.imread("face.jpg")
roi = detector.detect_face(frame)

if roi:
    x, y, w, h = roi
    face_region = frame[y:y+h, x:x+w]
    print(f"Face detected at ({x}, {y}) with size {w}×{h}")
else:
    print("No face detected")

# Cleanup
detector.close()

# Compare different backends
backends = ["haar", "mtcnn", "yolo", "mediapipe"]
results = {}

for backend in backends:
    detector = FaceDetector(model_type=backend)
    roi = detector.detect_face(frame)
    results[backend] = roi
    detector.close()

print("Detection results:", results)

from src.face_detector.manager import FaceDetector
from src.evm.evm_manager import process_video_evm_vital_signs
import cv2

detector = FaceDetector(model_type="yolo")
video_frames = []

# Capture video and extract ROIs
cap = cv2.VideoCapture(0)
for _ in range(90):  # 3 seconds at 30 FPS
    ret, frame = cap.read()
    if ret:
        roi = detector.detect_face(frame)
        if roi:
            x, y, w, h = roi
            roi_frame = frame[y:y+h, x:x+w]
            roi_frame = cv2.resize(roi_frame, (320, 240))
            video_frames.append(roi_frame)

cap.release()
detector.close()

# Process with EVM
results = process_video_evm_vital_signs(video_frames, verbose=True)
print(f"Heart Rate: {results['heart_rate']} BPM")
print(f"Respiratory Rate: {results['respiratory_rate']} RPM")