Upload StressDetection_V1 (1).ipynb

StressDetection_V1 (1).ipynb

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