Delete main.ipynb

main.ipynb

@@ -1,975 +0,0 @@
-# Complete Stress Detection System - 10 Action Units
-# Real-time Multi-AU Detection with Comprehensive Analysis
-# Research Assistant: [Your Name]
-# Guide: Prof. Anup Nandy
-# Based on Facial Action Coding System (FACS) - Ekman & Friesen
-
-import cv2
-import mediapipe as mp
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from matplotlib.gridspec import GridSpec
-from collections import deque
-import time
-from datetime import datetime
-import warnings
-warnings.filterwarnings('ignore')
-
-# ==================== CONFIGURATION ====================
-WINDOW_SIZE = 30
-RECORDING_DURATION = 15
-FPS = 30
-
-# ==================== MediaPipe Setup ====================
-mp_face_mesh = mp.solutions.face_mesh
-face_mesh = mp_face_mesh.FaceMesh(
-    min_detection_confidence=0.5,
-    min_tracking_confidence=0.5,
-    refine_landmarks=True
-)
-
-# ==================== LANDMARK INDICES (468 landmarks) ====================
-
-# AU01 - Inner Brow Raiser (Surprise, Fear, Sadness)
-AU01_LANDMARKS = {
-    'left_inner_brow': 336,
-    'right_inner_brow': 107,
-    'nose_bridge': 6,
-    'left_outer_brow': 285,
-    'right_outer_brow': 55
-}
-
-# AU04 - Brow Lowerer (Anger, Sadness, Concentration)
-AU04_LANDMARKS = {
-    'left_inner_brow': 336,
-    'right_inner_brow': 107,
-    'left_mid_brow': 285,
-    'right_mid_brow': 55,
-    'left_eyelid': 159,
-    'right_eyelid': 386,
-    'nose_bridge': 6
-}
-
-# AU06 - Cheek Raiser (Genuine Smile - Duchenne)
-AU06_LANDMARKS = {
-    'left_cheek': 205,
-    'right_cheek': 425,
-    'left_lower_eyelid': 145,
-    'right_lower_eyelid': 374,
-    'left_eye_outer': 33,
-    'right_eye_outer': 263
-}
-
-# AU07 - Lid Tightener (Concentration, Anger, Disgust)
-AU07_LANDMARKS = {
-    'left_upper_lid': 159,
-    'right_upper_lid': 386,
-    'left_lower_lid': 145,
-    'right_lower_lid': 374,
-    'left_eye_top': 159,
-    'right_eye_top': 386
-}
-
-# AU12 - Lip Corner Puller (Happiness)
-AU12_LANDMARKS = {
-    'left_corner': 61,
-    'right_corner': 291,
-    'upper_center': 13,
-    'lower_center': 14
-}
-
-# AU14 - Dimpler (Smile Intensity)
-AU14_LANDMARKS = {
-    'left_dimple': 206,
-    'right_dimple': 426,
-    'left_corner': 61,
-    'right_corner': 291
-}
-
-# AU17 - Chin Raiser (Doubt, Sadness, Pouting)
-AU17_LANDMARKS = {
-    'chin_center': 152,
-    'lower_lip': 17,
-    'chin_left': 176,
-    'chin_right': 400
-}
-
-# AU23 - Lip Tightener (Anger, Tension)
-AU23_LANDMARKS = {
-    'left_corner': 61,
-    'right_corner': 291,
-    'left_outer': 57,
-    'right_outer': 287
-}
-
-# AU24 - Lip Pressor (Stress, Tension, Anger)
-AU24_LANDMARKS = {
-    'upper_lip_top': 0,
-    'upper_lip_bottom': 13,
-    'lower_lip_top': 14,
-    'lower_lip_bottom': 17
-}
-
-# AU26 - Jaw Drop (Surprise, Shock, Mouth Opening)
-AU26_LANDMARKS = {
-    'upper_lip': 13,
-    'lower_lip': 14,
-    'chin': 152,
-    'nose': 1
-}
-
-# ==================== UTILITY FUNCTIONS ====================
-def calculate_distance(point1, point2):
-    return np.sqrt((point1[0] - point2[0])**2 + (point1[1] - point2[1])**2)
-
-def get_landmark_coords(landmarks, idx, frame_width, frame_height):
-    lm = landmarks[idx]
-    return np.array([lm.x * frame_width, lm.y * frame_height])
-
-# ==================== AU DETECTOR CLASSES ====================
-
-class AU01Detector:
-    """AU01 - Inner Brow Raiser (Surprise, Fear, Worry)"""
-    def __init__(self, window_size=30):
-        self.name = "AU01_InnerBrowRaise"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        left_inner = get_landmark_coords(landmarks, AU01_LANDMARKS['left_inner_brow'], frame_width, frame_height)
-        right_inner = get_landmark_coords(landmarks, AU01_LANDMARKS['right_inner_brow'], frame_width, frame_height)
-        left_outer = get_landmark_coords(landmarks, AU01_LANDMARKS['left_outer_brow'], frame_width, frame_height)
-        right_outer = get_landmark_coords(landmarks, AU01_LANDMARKS['right_outer_brow'], frame_width, frame_height)
-        nose = get_landmark_coords(landmarks, AU01_LANDMARKS['nose_bridge'], frame_width, frame_height)
-        
-        # Calculate inner vs outer brow height
-        inner_height = ((nose[1] - left_inner[1]) + (nose[1] - right_inner[1])) / 2
-        outer_height = ((nose[1] - left_outer[1]) + (nose[1] - right_outer[1])) / 2
-        
-        # AU01 active when inner brows raised MORE than outer (creates worried look)
-        raise_ratio = inner_height / (outer_height + 1e-6)
-        
-        is_active = raise_ratio > 1.15  # Inner brows 15% higher than outer
-        intensity = min(100, max(0, (raise_ratio - 1.0) * 500))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU04Detector:
-    """AU04 - Brow Lowerer (Anger, Concentration, Stress)"""
-    def __init__(self, window_size=30):
-        self.name = "AU04_BrowLower"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        left_inner_brow = get_landmark_coords(landmarks, AU04_LANDMARKS['left_inner_brow'], frame_width, frame_height)
-        right_inner_brow = get_landmark_coords(landmarks, AU04_LANDMARKS['right_inner_brow'], frame_width, frame_height)
-        left_eyelid = get_landmark_coords(landmarks, AU04_LANDMARKS['left_eyelid'], frame_width, frame_height)
-        right_eyelid = get_landmark_coords(landmarks, AU04_LANDMARKS['right_eyelid'], frame_width, frame_height)
-        nose_bridge = get_landmark_coords(landmarks, AU04_LANDMARKS['nose_bridge'], frame_width, frame_height)
-        
-        left_brow_eyelid_dist = left_inner_brow[1] - left_eyelid[1]
-        right_brow_eyelid_dist = right_inner_brow[1] - right_eyelid[1]
-        avg_brow_eyelid_dist = (left_brow_eyelid_dist + right_brow_eyelid_dist) / 2
-        
-        face_height = calculate_distance(left_inner_brow, nose_bridge)
-        normalized_distance = avg_brow_eyelid_dist / (face_height + 1e-6)
-        
-        inner_brow_distance = calculate_distance(left_inner_brow, right_inner_brow)
-        outer_eye_distance = calculate_distance(left_eyelid, right_eyelid)
-        brow_compression_ratio = inner_brow_distance / (outer_eye_distance + 1e-6)
-        
-        is_active = (normalized_distance > -0.30 or brow_compression_ratio < 0.95)
-        intensity = min(100, max(0, (normalized_distance + 0.40) / 0.40 * 100))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU06Detector:
-    """AU06 - Cheek Raiser (Genuine Smile)"""
-    def __init__(self, window_size=30):
-        self.name = "AU06_CheekRaise"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        left_cheek = get_landmark_coords(landmarks, AU06_LANDMARKS['left_cheek'], frame_width, frame_height)
-        right_cheek = get_landmark_coords(landmarks, AU06_LANDMARKS['right_cheek'], frame_width, frame_height)
-        left_lower_lid = get_landmark_coords(landmarks, AU06_LANDMARKS['left_lower_eyelid'], frame_width, frame_height)
-        right_lower_lid = get_landmark_coords(landmarks, AU06_LANDMARKS['right_lower_eyelid'], frame_width, frame_height)
-        
-        # When cheeks raise, distance between cheek and lower eyelid decreases
-        left_distance = calculate_distance(left_cheek, left_lower_lid)
-        right_distance = calculate_distance(right_cheek, right_lower_lid)
-        avg_distance = (left_distance + right_distance) / 2
-        
-        # Also check if lower eyelid moves up
-        left_eye_outer = get_landmark_coords(landmarks, AU06_LANDMARKS['left_eye_outer'], frame_width, frame_height)
-        eye_height = abs(left_eye_outer[1] - left_lower_lid[1])
-        
-        cheek_raise_score = eye_height / (avg_distance + 1e-6)
-        
-        is_active = cheek_raise_score > 0.8
-        intensity = min(100, max(0, (cheek_raise_score - 0.5) * 200))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU07Detector:
-    """AU07 - Lid Tightener (Tension, Squinting)"""
-    def __init__(self, window_size=30):
-        self.name = "AU07_LidTighten"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        left_upper = get_landmark_coords(landmarks, AU07_LANDMARKS['left_upper_lid'], frame_width, frame_height)
-        right_upper = get_landmark_coords(landmarks, AU07_LANDMARKS['right_upper_lid'], frame_width, frame_height)
-        left_lower = get_landmark_coords(landmarks, AU07_LANDMARKS['left_lower_lid'], frame_width, frame_height)
-        right_lower = get_landmark_coords(landmarks, AU07_LANDMARKS['right_lower_lid'], frame_width, frame_height)
-        
-        # Eye opening (smaller = more tightened)
-        left_eye_opening = abs(left_upper[1] - left_lower[1])
-        right_eye_opening = abs(right_upper[1] - right_lower[1])
-        avg_eye_opening = (left_eye_opening + right_eye_opening) / 2
-        
-        # Normalize by face height
-        face_ref = calculate_distance(left_upper, 
-                                      get_landmark_coords(landmarks, 152, frame_width, frame_height))
-        normalized_opening = avg_eye_opening / (face_ref + 1e-6)
-        
-        is_active = normalized_opening < 0.025  # Eyes tightened/squinted
-        intensity = min(100, max(0, (0.035 - normalized_opening) / 0.035 * 100))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU12Detector:
-    """AU12 - Lip Corner Puller (Smile)"""
-    def __init__(self, window_size=30):
-        self.name = "AU12_LipCornerPull"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        left_corner = get_landmark_coords(landmarks, AU12_LANDMARKS['left_corner'], frame_width, frame_height)
-        right_corner = get_landmark_coords(landmarks, AU12_LANDMARKS['right_corner'], frame_width, frame_height)
-        upper_center = get_landmark_coords(landmarks, AU12_LANDMARKS['upper_center'], frame_width, frame_height)
-        lower_center = get_landmark_coords(landmarks, AU12_LANDMARKS['lower_center'], frame_width, frame_height)
-        
-        mouth_width = calculate_distance(left_corner, right_corner)
-        mouth_height = calculate_distance(upper_center, lower_center)
-        mouth_center_y = (upper_center[1] + lower_center[1]) / 2
-        
-        left_corner_lift = mouth_center_y - left_corner[1]
-        right_corner_lift = mouth_center_y - right_corner[1]
-        avg_corner_lift = (left_corner_lift + right_corner_lift) / 2
-        
-        mouth_ratio = mouth_width / (mouth_height + 1e-6)
-        normalized_lift = avg_corner_lift / mouth_height if mouth_height > 0 else 0
-        
-        lift_difference = abs(left_corner_lift - right_corner_lift)
-        symmetry_score = 1.0 - min(1.0, lift_difference / (mouth_height + 1e-6))
-        
-        is_active = (normalized_lift > 0.25 and mouth_ratio > 2.8 and symmetry_score > 0.6)
-        intensity = min(100, max(0, normalized_lift * 250))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU14Detector:
-    """AU14 - Dimpler (Smile Depth Indicator)"""
-    def __init__(self, window_size=30):
-        self.name = "AU14_Dimpler"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        left_dimple = get_landmark_coords(landmarks, AU14_LANDMARKS['left_dimple'], frame_width, frame_height)
-        right_dimple = get_landmark_coords(landmarks, AU14_LANDMARKS['right_dimple'], frame_width, frame_height)
-        left_corner = get_landmark_coords(landmarks, AU14_LANDMARKS['left_corner'], frame_width, frame_height)
-        right_corner = get_landmark_coords(landmarks, AU14_LANDMARKS['right_corner'], frame_width, frame_height)
-        
-        # Dimples appear when corners pull back and create indentation
-        left_depth = calculate_distance(left_dimple, left_corner)
-        right_depth = calculate_distance(right_dimple, right_corner)
-        avg_depth = (left_depth + right_depth) / 2
-        
-        # Check corner retraction
-        corner_distance = calculate_distance(left_corner, right_corner)
-        dimple_score = avg_depth / (corner_distance + 1e-6)
-        
-        is_active = dimple_score > 0.15
-        intensity = min(100, max(0, (dimple_score - 0.10) * 500))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU17Detector:
-    """AU17 - Chin Raiser (Doubt, Pouting, Sadness)"""
-    def __init__(self, window_size=30):
-        self.name = "AU17_ChinRaise"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        chin = get_landmark_coords(landmarks, AU17_LANDMARKS['chin_center'], frame_width, frame_height)
-        lower_lip = get_landmark_coords(landmarks, AU17_LANDMARKS['lower_lip'], frame_width, frame_height)
-        
-        # When chin raises, distance between chin and lower lip decreases
-        chin_lip_distance = calculate_distance(chin, lower_lip)
-        
-        # Normalize by face height
-        nose = get_landmark_coords(landmarks, 1, frame_width, frame_height)
-        face_height = calculate_distance(nose, chin)
-        normalized_distance = chin_lip_distance / (face_height + 1e-6)
-        
-        is_active = normalized_distance < 0.08  # Chin pushed up
-        intensity = min(100, max(0, (0.12 - normalized_distance) / 0.12 * 100))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU23Detector:
-    """AU23 - Lip Tightener (Anger, Tension)"""
-    def __init__(self, window_size=30):
-        self.name = "AU23_LipTighten"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        left_corner = get_landmark_coords(landmarks, AU23_LANDMARKS['left_corner'], frame_width, frame_height)
-        right_corner = get_landmark_coords(landmarks, AU23_LANDMARKS['right_corner'], frame_width, frame_height)
-        left_outer = get_landmark_coords(landmarks, AU23_LANDMARKS['left_outer'], frame_width, frame_height)
-        right_outer = get_landmark_coords(landmarks, AU23_LANDMARKS['right_outer'], frame_width, frame_height)
-        
-        corner_width = calculate_distance(left_corner, right_corner)
-        outer_width = calculate_distance(left_outer, right_outer)
-        tightness_ratio = corner_width / (outer_width + 1e-6)
-        
-        is_active = (tightness_ratio < 0.85)
-        intensity = min(100, max(0, (0.95 - tightness_ratio) / 0.20 * 100))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU24Detector:
-    """AU24 - Lip Pressor (Stress, Tension)"""
-    def __init__(self, window_size=30):
-        self.name = "AU24_LipPress"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        upper_lip_top = get_landmark_coords(landmarks, AU24_LANDMARKS['upper_lip_top'], frame_width, frame_height)
-        upper_lip_bottom = get_landmark_coords(landmarks, AU24_LANDMARKS['upper_lip_bottom'], frame_width, frame_height)
-        lower_lip_top = get_landmark_coords(landmarks, AU24_LANDMARKS['lower_lip_top'], frame_width, frame_height)
-        lower_lip_bottom = get_landmark_coords(landmarks, AU24_LANDMARKS['lower_lip_bottom'], frame_width, frame_height)
-        
-        upper_lip_thickness = calculate_distance(upper_lip_top, upper_lip_bottom)
-        lower_lip_thickness = calculate_distance(lower_lip_top, lower_lip_bottom)
-        total_lip_thickness = upper_lip_thickness + lower_lip_thickness
-        
-        mouth_opening = calculate_distance(upper_lip_bottom, lower_lip_top)
-        lip_press_score = mouth_opening / (total_lip_thickness + 1e-6)
-        
-        is_active = (lip_press_score < 0.4 and total_lip_thickness < 15)
-        intensity = min(100, max(0, (0.6 - lip_press_score) / 0.6 * 100))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-class AU26Detector:
-    """AU26 - Jaw Drop (Surprise, Shock)"""
-    def __init__(self, window_size=30):
-        self.name = "AU26_JawDrop"
-        self.activation_history = deque(maxlen=window_size)
-        self.intensity_history = deque(maxlen=window_size)
-        
-    def detect(self, landmarks, frame_width, frame_height):
-        upper_lip = get_landmark_coords(landmarks, AU26_LANDMARKS['upper_lip'], frame_width, frame_height)
-        lower_lip = get_landmark_coords(landmarks, AU26_LANDMARKS['lower_lip'], frame_width, frame_height)
-        chin = get_landmark_coords(landmarks, AU26_LANDMARKS['chin'], frame_width, frame_height)
-        nose = get_landmark_coords(landmarks, AU26_LANDMARKS['nose'], frame_width, frame_height)
-        
-        # Mouth opening
-        mouth_opening = calculate_distance(upper_lip, lower_lip)
-        
-        # Jaw drop (distance from nose to chin increases)
-        jaw_length = calculate_distance(nose, chin)
-        
-        # Normalize
-        mouth_opening_ratio = mouth_opening / (jaw_length + 1e-6)
-        
-        is_active = mouth_opening_ratio > 0.15  # Mouth significantly open
-        intensity = min(100, max(0, (mouth_opening_ratio - 0.10) / 0.20 * 100))
-        
-        self.activation_history.append(int(is_active))
-        self.intensity_history.append(intensity)
-        
-        return is_active, intensity
-
-
-# ==================== FEATURE EXTRACTOR ====================
-
-class MultiAUFeatureExtractor:
-    def __init__(self, detectors):
-        self.detectors = detectors
-        self.feature_log = []
-        
-    def extract_features(self, timestamp):
-        features = {'timestamp': timestamp}
-        
-        for detector in self.detectors:
-            is_active = detector.activation_history[-1] if detector.activation_history else 0
-            intensity = detector.intensity_history[-1] if detector.intensity_history else 0
-            
-            activation_rate = sum(detector.activation_history) / len(detector.activation_history) if detector.activation_history else 0
-            avg_intensity = np.mean(detector.intensity_history) if detector.intensity_history else 0
-            max_intensity = np.max(detector.intensity_history) if detector.intensity_history else 0
-            intensity_std = np.std(detector.intensity_history) if detector.intensity_history else 0
-            
-            features[f'{detector.name}_active'] = is_active
-            features[f'{detector.name}_intensity'] = intensity
-            features[f'{detector.name}_activation_rate'] = activation_rate
-            features[f'{detector.name}_avg_intensity'] = avg_intensity
-            features[f'{detector.name}_max_intensity'] = max_intensity
-            features[f'{detector.name}_intensity_std'] = intensity_std
-        
-        self.feature_log.append(features)
-        return features
-    
-    def get_dataframe(self):
-        return pd.DataFrame(self.feature_log)
-    
-    def save_features(self, filename):
-        df = self.get_dataframe()
-        df.to_csv(filename, index=False)
-        print(f"✓ Features saved to {filename}")
-
-
-# ==================== DETECTION SESSION ====================
-
-def run_detection_session(duration_seconds=15, save_data=True):
-    # Initialize all 10 AU detectors
-    au01 = AU01Detector()
-    au04 = AU04Detector()
-    au06 = AU06Detector()
-    au07 = AU07Detector()
-    au12 = AU12Detector()
-    au14 = AU14Detector()
-    au17 = AU17Detector()
-    au23 = AU23Detector()
-    au24 = AU24Detector()
-    au26 = AU26Detector()
-    
-    detectors = [au01, au04, au06, au07, au12, au14, au17, au23, au24, au26]
-    feature_extractor = MultiAUFeatureExtractor(detectors)
-    
-    cap = cv2.VideoCapture(0)
-    
-    print(f"\n{'='*70}")
-    print(f"  COMPLETE 10-AU STRESS DETECTION SYSTEM")
-    print(f"  Recording for {duration_seconds} seconds...")
-    print(f"{'='*70}\n")
-    
-    start_time = time.time()
-    frame_count = 0
-    
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-        
-        current_time = time.time()
-        elapsed = current_time - start_time
-        
-        if elapsed >= duration_seconds:
-            break
-        
-        frame = cv2.flip(frame, 1)
-        frame_height, frame_width = frame.shape[:2]
-        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        
-        results = face_mesh.process(rgb_frame)
-        
-        if results.multi_face_landmarks:
-            landmarks = results.multi_face_landmarks[0].landmark
-            
-            # Detect all 10 AUs
-            au01_active, au01_intensity = au01.detect(landmarks, frame_width, frame_height)
-            au04_active, au04_intensity = au04.detect(landmarks, frame_width, frame_height)
-            au06_active, au06_intensity = au06.detect(landmarks, frame_width, frame_height)
-            au07_active, au07_intensity = au07.detect(landmarks, frame_width, frame_height)
-            au12_active, au12_intensity = au12.detect(landmarks, frame_width, frame_height)
-            au14_active, au14_intensity = au14.detect(landmarks, frame_width, frame_height)
-            au17_active, au17_intensity = au17.detect(landmarks, frame_width, frame_height)
-            au23_active, au23_intensity = au23.detect(landmarks, frame_width, frame_height)
-            au24_active, au24_intensity = au24.detect(landmarks, frame_width, frame_height)
-            au26_active, au26_intensity = au26.detect(landmarks, frame_width, frame_height)
-            
-            features = feature_extractor.extract_features(elapsed)
-            
-            # Display (2 columns)
-            y_offset = 25
-            col1_x = 10
-            col2_x = frame_width // 2 + 10
-            
-            # Header
-            cv2.putText(frame, f"Time: {elapsed:.1f}s / {duration_seconds}s", 
-                       (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-            
-            y_offset += 35
-            
-            # Column 1: Stress Indicators
-            cv2.putText(frame, "STRESS INDICATORS:", (col1_x, y_offset), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
-            y_offset += 25
-            
-            stress_aus = [
-                (au01_active, au01_intensity, "AU01-BrowRaise"),
-                (au04_active, au04_intensity, "AU04-BrowLower"),
-                (au07_active, au07_intensity, "AU07-LidTight"),
-                (au17_active, au17_intensity, "AU17-ChinRaise"),
-                (au23_active, au23_intensity, "AU23-LipTight"),
-                (au24_active, au24_intensity, "AU24-LipPress")
-            ]
-            
-            for active, intensity, name in stress_aus:
-                color = (0, 0, 255) if active else (100, 100, 100)
-                cv2.putText(frame, f"{name}: {intensity:.0f}%", 
-                           (col1_x, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
-                y_offset += 20
-            
-            # Column 2: Positive Indicators
-            y_offset = 60
-            cv2.putText(frame, "POSITIVE INDICATORS:", (col2_x, y_offset), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-            y_offset += 25
-            
-            positive_aus = [
-                (au06_active, au06_intensity, "AU06-CheekRaise"),
-                (au12_active, au12_intensity, "AU12-SmilePull"),
-                (au14_active, au14_intensity, "AU14-Dimpler"),
-                (au26_active, au26_intensity, "AU26-JawDrop")
-            ]
-            
-            for active, intensity, name in positive_aus:
-                color = (0, 255, 0) if active else (100, 100, 100)
-                cv2.putText(frame, f"{name}: {intensity:.0f}%", 
-                           (col2_x, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
-                y_offset += 20
-            
-            # Bottom summary
-            stress_count = sum([au01_active, au04_active, au07_active, au17_active, au23_active, au24_active])
-            positive_count = sum([au06_active, au12_active, au14_active])
-            
-            cv2.rectangle(frame, (10, frame_height - 60), (frame_width - 10, frame_height - 10), (50, 50, 50), -1)
-            cv2.putText(frame, f"Stress AUs: {stress_count}/6  |  Positive AUs: {positive_count}/4", 
-                       (20, frame_height - 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
-            
-        cv2.imshow('Complete 10-AU Stress Detection', frame)
-        frame_count += 1
-        
-        if cv2.waitKey(1) & 0xFF == ord('q'):
-            break
-    
-    cap.release()
-    cv2.destroyAllWindows()
-    
-    if save_data:
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"complete_au_features_{timestamp}.csv"
-        feature_extractor.save_features(filename)
-    
-    print(f"\n✓ Session complete! Processed {frame_count} frames")
-    print(f"✓ Average FPS: {frame_count/duration_seconds:.1f}")
-    
-    return feature_extractor.get_dataframe()
-
-
-# ==================== ADVANCED ANALYSIS ====================
-
-def calculate_comprehensive_stress_score(df):
-    """
-    Research-based stress scoring using all 10 AUs
-    Weights based on affective computing literature
-    """
-    
-    # STRESS INDICATORS (weighted by research evidence)
-    # AU04 (Brow Lower) - Primary anger/stress indicator
-    au04_score = (df['AU04_BrowLower_intensity'].mean() / 100) * (df['AU04_BrowLower_activation_rate'].mean()) * 25
-    
-    # AU01 (Inner Brow Raise) - Worry/sadness indicator
-    au01_score = (df['AU01_InnerBrowRaise_intensity'].mean() / 100) * (df['AU01_InnerBrowRaise_activation_rate'].mean()) * 15
-    
-    # AU07 (Lid Tighten) - Tension indicator
-    au07_score = (df['AU07_LidTighten_intensity'].mean() / 100) * (df['AU07_LidTighten_activation_rate'].mean()) * 12
-    
-    # AU24 (Lip Press) - Stress/tension
-    au24_score = (df['AU24_LipPress_intensity'].mean() / 100) * (df['AU24_LipPress_activation_rate'].mean()) * 15
-    
-    # AU23 (Lip Tighten) - Anger/tension
-    au23_score = (df['AU23_LipTighten_intensity'].mean() / 100) * (df['AU23_LipTighten_activation_rate'].mean()) * 12
-    
-    # AU17 (Chin Raise) - Doubt/sadness
-    au17_score = (df['AU17_ChinRaise_intensity'].mean() / 100) * (df['AU17_ChinRaise_activation_rate'].mean()) * 8
-    
-    # POSITIVE INDICATORS (reduce stress score)
-    # AU06 + AU12 (Duchenne Smile - genuine happiness)
-    duchenne_smile = ((df['AU06_CheekRaise_active'] == 1) & (df['AU12_LipCornerPull_active'] == 1)).sum() / len(df)
-    positive_reduction = duchenne_smile * 15
-    
-    # AU12 alone (social smile - may mask stress)
-    social_smile = ((df['AU12_LipCornerPull_active'] == 1) & (df['AU06_CheekRaise_active'] == 0)).sum() / len(df)
-    masking_indicator = social_smile * 5  # Adds to stress if smiling without cheek raise
-    
-    # TEMPORAL PATTERNS
-    # Sustained stress (continuous activation 3+ seconds)
-    sustained_stress = 0
-    for au_name in ['AU04_BrowLower', 'AU24_LipPress', 'AU23_LipTighten']:
-        streak = 0
-        for val in df[f'{au_name}_active']:
-            if val == 1:
-                streak += 1
-                if streak >= 90:  # 3 seconds at 30fps
-                    sustained_stress += 1
-                    break
-            else:
-                streak = 0
-    sustained_score = min(10, sustained_stress * 3)
-    
-    # Co-occurrence of multiple stress AUs
-    stress_cols = ['AU01_InnerBrowRaise_active', 'AU04_BrowLower_active', 
-                   'AU07_LidTighten_active', 'AU23_LipTighten_active', 
-                   'AU24_LipPress_active', 'AU17_ChinRaise_active']
-    co_occurrence = (df[stress_cols].sum(axis=1) >= 3).sum() / len(df)
-    co_occurrence_score = co_occurrence * 8
-    
-    # COMBINED STRESS SCORE
-    raw_stress = (au04_score + au01_score + au07_score + au24_score + 
-                  au23_score + au17_score + sustained_score + 
-                  co_occurrence_score + masking_indicator - positive_reduction)
-    
-    stress_score = min(100, max(0, raw_stress))
-    
-    # Classification
-    if stress_score < 25:
-        classification = "NOT STRESSED"
-        color = "🟢"
-    elif stress_score < 55:
-        classification = "POSSIBLY STRESSED"
-        color = "🟡"
-    else:
-        classification = "STRESSED"
-        color = "🔴"
-    
-    return {
-        'classification': classification,
-        'color': color,
-        'stress_score': stress_score,
-        'components': {
-            'au04': au04_score,
-            'au01': au01_score,
-            'au07': au07_score,
-            'au24': au24_score,
-            'au23': au23_score,
-            'au17': au17_score,
-            'sustained': sustained_score,
-            'co_occurrence': co_occurrence_score,
-            'duchenne_smile': duchenne_smile,
-            'social_smile_masking': masking_indicator
-        },
-        'activation_percentages': {
-            'AU01': (df['AU01_InnerBrowRaise_active'].sum() / len(df)) * 100,
-            'AU04': (df['AU04_BrowLower_active'].sum() / len(df)) * 100,
-            'AU06': (df['AU06_CheekRaise_active'].sum() / len(df)) * 100,
-            'AU07': (df['AU07_LidTighten_active'].sum() / len(df)) * 100,
-            'AU12': (df['AU12_LipCornerPull_active'].sum() / len(df)) * 100,
-            'AU14': (df['AU14_Dimpler_active'].sum() / len(df)) * 100,
-            'AU17': (df['AU17_ChinRaise_active'].sum() / len(df)) * 100,
-            'AU23': (df['AU23_LipTighten_active'].sum() / len(df)) * 100,
-            'AU24': (df['AU24_LipPress_active'].sum() / len(df)) * 100,
-            'AU26': (df['AU26_JawDrop_active'].sum() / len(df)) * 100
-        }
-    }
-
-
-# ==================== COMPREHENSIVE VISUALIZATION ====================
-
-def plot_comprehensive_analysis(df):
-    """Create 10 publication-quality plots"""
-    
-    fig = plt.figure(figsize=(20, 16))
-    gs = GridSpec(5, 3, figure=fig, hspace=0.35, wspace=0.3)
-    
-    fig.suptitle('Comprehensive 10-AU Facial Expression Analysis\nStress Detection System', 
-                 fontsize=18, fontweight='bold', y=0.995)
-    
-    # Plot 1: All AU Activations Over Time
-    ax1 = fig.add_subplot(gs[0, :2])
-    stress_aus = ['AU01_InnerBrowRaise', 'AU04_BrowLower', 'AU07_LidTighten', 
-                  'AU17_ChinRaise', 'AU23_LipTighten', 'AU24_LipPress']
-    colors_stress = ['orange', 'red', 'darkred', 'brown', 'purple', 'magenta']
-    
-    for au, color in zip(stress_aus, colors_stress):
-        ax1.plot(df['timestamp'], df[f'{au}_active'], label=au.split('_')[1], 
-                color=color, linewidth=1.5, alpha=0.7)
-    
-    ax1.set_xlabel('Time (seconds)', fontweight='bold')
-    ax1.set_ylabel('Activation (Binary)', fontweight='bold')
-    ax1.set_title('Stress-Related AU Temporal Patterns')
-    ax1.legend(loc='upper right', ncol=3, fontsize=8)
-    ax1.grid(True, alpha=0.3)
-    ax1.set_ylim(-0.1, 1.1)
-    
-    # Plot 2: Positive AUs Over Time
-    ax2 = fig.add_subplot(gs[0, 2])
-    positive_aus = ['AU06_CheekRaise', 'AU12_LipCornerPull', 'AU14_Dimpler', 'AU26_JawDrop']
-    colors_pos = ['lightgreen', 'green', 'darkgreen', 'blue']
-    
-    for au, color in zip(positive_aus, colors_pos):
-        ax2.plot(df['timestamp'], df[f'{au}_active'], label=au.split('_')[1], 
-                color=color, linewidth=1.5, alpha=0.7)
-    
-    ax2.set_xlabel('Time (s)', fontweight='bold')
-    ax2.set_ylabel('Activation', fontweight='bold')
-    ax2.set_title('Positive AU Patterns')
-    ax2.legend(fontsize=7)
-    ax2.grid(True, alpha=0.3)
-    ax2.set_ylim(-0.1, 1.1)
-    
-    # Plot 3: Intensity Heatmap (All 10 AUs)
-    ax3 = fig.add_subplot(gs[1, :])
-    all_aus = ['AU01_InnerBrowRaise', 'AU04_BrowLower', 'AU06_CheekRaise', 
-               'AU07_LidTighten', 'AU12_LipCornerPull', 'AU14_Dimpler',
-               'AU17_ChinRaise', 'AU23_LipTighten', 'AU24_LipPress', 'AU26_JawDrop']
-    
-    intensity_data = df[[f'{au}_intensity' for au in all_aus]].T
-    im = ax3.imshow(intensity_data, aspect='auto', cmap='RdYlGn_r', interpolation='nearest')
-    ax3.set_yticks(range(10))
-    ax3.set_yticklabels([au.split('_')[0] for au in all_aus])
-    ax3.set_xlabel('Frame Number', fontweight='bold')
-    ax3.set_title('Complete AU Intensity Heatmap (All 10 Action Units)')
-    plt.colorbar(im, ax=ax3, label='Intensity (%)')
-    
-    # Plot 4: AU Activation Frequency Bar Chart
-    ax4 = fig.add_subplot(gs[2, 0])
-    result = calculate_comprehensive_stress_score(df)
-    au_names = list(result['activation_percentages'].keys())
-    au_values = list(result['activation_percentages'].values())
-    colors = ['red' if 'AU04' in au or 'AU24' in au or 'AU23' in au 
-              else 'orange' if 'AU01' in au or 'AU07' in au or 'AU17' in au
-              else 'green' for au in au_names]
-    
-    bars = ax4.barh(au_names, au_values, color=colors, alpha=0.7)
-    ax4.set_xlabel('Activation Percentage (%)', fontweight='bold')
-    ax4.set_title('AU Activation Frequencies')
-    ax4.grid(True, alpha=0.3, axis='x')
-    
-    # Plot 5: Duchenne vs Non-Duchenne Smile Detection
-    ax5 = fig.add_subplot(gs[2, 1])
-    duchenne = ((df['AU06_CheekRaise_active'] == 1) & (df['AU12_LipCornerPull_active'] == 1)).sum()
-    non_duchenne = ((df['AU12_LipCornerPull_active'] == 1) & (df['AU06_CheekRaise_active'] == 0)).sum()
-    no_smile = len(df) - duchenne - non_duchenne
-    
-    labels = ['Genuine\n(Duchenne)', 'Social\n(Masking)', 'No Smile']
-    sizes = [duchenne, non_duchenne, no_smile]
-    colors_pie = ['green', 'yellow', 'lightgray']
-    
-    ax5.pie(sizes, labels=labels, colors=colors_pie, autopct='%1.1f%%', startangle=90)
-    ax5.set_title('Smile Type Distribution')
-    
-    # Plot 6: Stress vs Positive Balance
-    ax6 = fig.add_subplot(gs[2, 2])
-    stress_intensity_avg = df[['AU01_InnerBrowRaise_intensity', 'AU04_BrowLower_intensity',
-                                'AU07_LidTighten_intensity', 'AU23_LipTighten_intensity',
-                                'AU24_LipPress_intensity', 'AU17_ChinRaise_intensity']].mean(axis=1)
-    positive_intensity_avg = df[['AU06_CheekRaise_intensity', 'AU12_LipCornerPull_intensity',
-                                  'AU14_Dimpler_intensity']].mean(axis=1)
-    
-    ax6.plot(df['timestamp'], stress_intensity_avg, color='red', linewidth=2, label='Stress AUs')
-    ax6.plot(df['timestamp'], positive_intensity_avg, color='green', linewidth=2, label='Positive AUs')
-    ax6.fill_between(df['timestamp'], stress_intensity_avg, alpha=0.3, color='red')
-    ax6.fill_between(df['timestamp'], positive_intensity_avg, alpha=0.3, color='green')
-    ax6.set_xlabel('Time (seconds)', fontweight='bold')
-    ax6.set_ylabel('Average Intensity (%)', fontweight='bold')
-    ax6.set_title('Stress vs Positive Affect Balance')
-    ax6.legend()
-    ax6.grid(True, alpha=0.3)
-    
-    # Plot 7: Correlation Matrix (All AUs)
-    ax7 = fig.add_subplot(gs[3, :2])
-    correlation_cols = [f'{au}_intensity' for au in all_aus]
-    corr_matrix = df[correlation_cols].corr()
-    
-    im = ax7.imshow(corr_matrix, cmap='coolwarm', vmin=-1, vmax=1, aspect='auto')
-    ax7.set_xticks(range(10))
-    ax7.set_yticks(range(10))
-    ax7.set_xticklabels([au.split('_')[0] for au in all_aus], rotation=45, ha='right')
-    ax7.set_yticklabels([au.split('_')[0] for au in all_aus])
-    ax7.set_title('Complete AU Correlation Matrix')
-    
-    # Add correlation values
-    for i in range(10):
-        for j in range(10):
-            if abs(corr_matrix.iloc[i, j]) > 0.3:  # Only show strong correlations
-                ax7.text(j, i, f'{corr_matrix.iloc[i, j]:.2f}',
-                        ha="center", va="center", color="black", fontsize=7)
-    
-    plt.colorbar(im, ax=ax7)
-    
-    # Plot 8: Time-Windowed Stress Evolution
-    ax8 = fig.add_subplot(gs[3, 2])
-    window_size = 90  # 3 seconds
-    windowed_stress = []
-    window_times = []
-    
-    for i in range(0, len(df) - window_size, window_size // 2):
-        window_df = df.iloc[i:i+window_size]
-        if len(window_df) > 0:
-            window_result = calculate_comprehensive_stress_score(window_df)
-            windowed_stress.append(window_result['stress_score'])
-            window_times.append(window_df['timestamp'].mean())
-    
-    ax8.plot(window_times, windowed_stress, color='red', linewidth=2, marker='o')
-    ax8.fill_between(window_times, windowed_stress, alpha=0.3, color='red')
-    ax8.axhline(y=25, color='green', linestyle='--', label='Low threshold', alpha=0.5)
-    ax8.axhline(y=55, color='orange', linestyle='--', label='High threshold', alpha=0.5)
-    ax8.set_xlabel('Time (seconds)', fontweight='bold')
-    ax8.set_ylabel('Stress Score', fontweight='bold')
-    ax8.set_title('Stress Score Evolution (3s windows)')
-    ax8.legend()
-    ax8.grid(True, alpha=0.3)
-    
-    # Plot 9: AU Co-occurrence Matrix
-    ax9 = fig.add_subplot(gs[4, 0])
-    stress_au_cols = [f'{au}_active' for au in stress_aus]
-    co_occur_matrix = np.zeros((6, 6))
-    
-    for i in range(6):
-        for j in range(6):
-            co_occur = ((df[stress_au_cols[i]] == 1) & (df[stress_au_cols[j]] == 1)).sum()
-            co_occur_matrix[i, j] = co_occur / len(df) * 100
-    
-    im = ax9.imshow(co_occur_matrix, cmap='Reds', aspect='auto')
-    ax9.set_xticks(range(6))
-    ax9.set_yticks(range(6))
-    ax9.set_xticklabels([au.split('_')[0] for au in stress_aus], rotation=45, ha='right')
-    ax9.set_yticklabels([au.split('_')[0] for au in stress_aus])
-    ax9.set_title('Stress AU Co-occurrence (%)')
-    plt.colorbar(im, ax=ax9)
-    
-    # Plot 10: Comprehensive Summary Report
-    ax10 = fig.add_subplot(gs[4, 1:])
-    ax10.axis('off')
-    
-    result = calculate_comprehensive_stress_score(df)
-    
-    summary_text = f"""
-╔═══════════════════════════════════════════════════════════════════════════════════════════════╗
-║                        COMPREHENSIVE STRESS ASSESSMENT REPORT                                 ║
-╠═══════════════════════════════════════════════════════════════════════════════════════════════╣
-║                                                                                               ║
-║  CLASSIFICATION: {result['color']} {result['classification']:<25}  |  STRESS SCORE: {result['stress_score']:.1f}/100        ║
-║                                                                                               ║
-╠═════════════════���═════════════════════════════════════════════════════════════════════════════╣
-║  COMPONENT CONTRIBUTIONS:                                                                     ║
-║    • AU04 (Brow Lower):      {result['components']['au04']:.2f}  / 25.0  [{result['activation_percentages']['AU04']:5.1f}% active]          ║
-║    • AU01 (Inner Brow):      {result['components']['au01']:.2f}  / 15.0  [{result['activation_percentages']['AU01']:5.1f}% active]          ║
-║    • AU07 (Lid Tighten):     {result['components']['au07']:.2f}  / 12.0  [{result['activation_percentages']['AU07']:5.1f}% active]          ║
-║    • AU24 (Lip Press):       {result['components']['au24']:.2f}  / 15.0  [{result['activation_percentages']['AU24']:5.1f}% active]          ║
-║    • AU23 (Lip Tighten):     {result['components']['au23']:.2f}  / 12.0  [{result['activation_percentages']['AU23']:5.1f}% active]          ║
-║    • AU17 (Chin Raise):      {result['components']['au17']:.2f}  / 8.0   [{result['activation_percentages']['AU17']:5.1f}% active]          ║
-║    • Sustained Activation:   {result['components']['sustained']:.2f}  / 10.0                                               ║
-║    • Co-occurrence Pattern:  {result['components']['co_occurrence']:.2f}  / 8.0                                                ║
-║    • Smile Masking Effect:   {result['components']['social_smile_masking']:.2f}  (adds stress if present)                          ║
-║    • Duchenne Smile Bonus:   -{result['components']['duchenne_smile']*15:.2f}  (reduces stress)                                  ║
-║                                                                                               ║
-╠═══════════════════════════════════════════════════════════════════════════════════════════════╣
-║  POSITIVE AFFECT INDICATORS:                                                                  ║
-║    • AU06 (Cheek Raise):     {result['activation_percentages']['AU06']:5.1f}% active                                             ║
-║    • AU12 (Lip Pull):        {result['activation_percentages']['AU12']:5.1f}% active                                             ║
-║    • AU14 (Dimpler):         {result['activation_percentages']['AU14']:5.1f}% active                                             ║
-║    • Duchenne Smile Rate:    {result['components']['duchenne_smile']*100:.1f}%                                                   ║
-║                                                                                               ║
-╠═══════════════════════════════════════════════════════════════════════════════════════════════╣
-║  RESEARCH BASIS:                                                                              ║
-║  Weights based on Facial Action Coding System (FACS) research:                               ║
-║  • AU04 highest weight (Ekman & Friesen, 1978) - primary anger/stress indicator              ║
-║  • AU06+AU12 combination identifies genuine happiness (Duchenne marker)                       ║
-║  • Sustained activation and co-occurrence patterns enhance stress detection accuracy          ║
-║  • Temporal windowing allows detection of acute stress episodes vs chronic patterns           ║
-╚═══════════════════════════════════════════════════════════════════════════════════════════════╝
-    """
-    
-    ax10.text(0.05, 0.5, summary_text, fontsize=8, family='monospace',
-             verticalalignment='center',
-             bbox=dict(boxstyle='round', facecolor='lightgray', alpha=0.2))
-    
-    plt.tight_layout()
-    return fig, result
-
-
-# ==================== MAIN EXECUTION ====================
-
-if __name__ == "__main__":
-    print("\n" + "="*70)
-    print("  COMPLETE 10-AU STRESS DETECTION SYSTEM")
-    print("  Based on Facial Action Coding System (FACS)")
-    print("  Research Guide: Prof. Anup Nandy")
-    print("="*70)
-    
-    print("\n  Action Units Detected:")
-    print("  STRESS: AU01, AU04, AU07, AU17, AU23, AU24")
-    print("  POSITIVE: AU06, AU12, AU14, AU26")
-    print("\n  Press Enter to start 15-second recording...")
-    
-    input()
-    
-    df = run_detection_session(duration_seconds=15, save_data=True)
-    
-    print("\n" + "="*70)
-    print("  Generating comprehensive analysis...")
-    print("="*70 + "\n")
-    
-    fig, result = plot_comprehensive_analysis(df)
-    
-    print(f"\n{result['color']} FINAL ASSESSMENT: {result['classification']}")
-    print(f"  Stress Score: {result['stress_score']:.1f}/100")
-    print(f"\n  Data saved with {len(df)} frames")
-    print(f"  Total features per frame: {len(df.columns) - 1}")
-    print("\n" + "="*70)
-    
-    plt.show()
-    
-    print("\n✓ Analysis complete!")