Fresh start

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+ffmpeg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,10 @@
+---
+title: CISS Web App
+emoji: 📊
+colorFrom: red
+colorTo: yellow
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

analysis_output/session_33d6d79f-952c-476a-9f36-cd5fdea84d3c/analysis.csv

@@ -0,0 +1,6 @@
+timestamp,second,proximity to parent,proximity to stranger,fear,freeze
+00:07:37,0,1,1,2,1
+00:07:38,1,1,1,2,1
+00:07:39,2,1,1,2,1
+00:07:40,3,1,1,2,1
+00:07:41,4,1,1,2,1

analysis_output/session_4c97bc51-b190-4205-b4dd-f9fc2cd9fc15/analysis.csv

@@ -0,0 +1,6 @@
+timestamp,second,proximity to parent,proximity to stranger,fear,freeze
+00:07:37,0,1,1,2,1
+00:07:38,1,1,1,2,1
+00:07:39,2,1,1,2,1
+00:07:40,3,1,1,2,1
+00:07:41,4,1,1,2,1

analysis_output/session_4cfe63bb-d56d-4457-8d2d-6e85af137d66/analysis.csv

@@ -0,0 +1,6 @@
+timestamp,second,proximity to parent,proximity to stranger,fear,freeze
+00:07:37,0,1,1,2,1
+00:07:38,1,1,1,2,1
+00:07:39,2,1,1,2,1
+00:07:40,3,1,1,2,1
+00:07:41,4,1,1,2,1

analysis_output/session_bb31a607-52b9-495f-aeb1-346c8f87bee1/analysis.csv

@@ -0,0 +1,6 @@
+timestamp,second,proximity to parent,proximity to stranger,fear,freeze
+00:07:37,0,1,1,2,1
+00:07:38,1,1,1,2,1
+00:07:39,2,1,1,2,1
+00:07:40,3,1,1,2,1
+00:07:41,4,1,1,2,1

analysis_output/session_d7af8070-871b-41bd-b611-fd2bd9773404/analysis.csv

@@ -0,0 +1,146 @@
+timestamp,second,proximity to parent,proximity to stranger,fear,freeze
+00:05:58,0,1,1,0,
+00:05:59,1,1,1,0,
+00:06:00,2,1,1,0,
+00:06:01,3,1,1,2,
+00:06:02,4,1,1,0,
+00:06:03,5,1,1,0,
+00:06:04,6,1,1,0,
+00:06:05,7,1,1,0,
+00:06:06,8,1,1,0,
+00:06:07,9,1,1,0,
+00:06:08,10,1,1,0,
+00:06:09,11,1,1,0,
+00:06:10,12,1,1,0,
+00:06:11,13,1,1,0,
+00:06:12,14,1,1,2,
+00:06:13,15,1,1,0,
+00:06:14,16,1,1,0,
+00:06:15,17,1,1,0,
+00:06:16,18,1,1,2,0
+00:06:17,19,1,1,2,0
+00:06:18,20,1,1,2,0
+00:06:19,21,1,1,0,
+00:06:20,22,1,1,2,
+00:06:21,23,1,1,0,
+00:06:22,24,1,1,0,
+00:06:23,25,1,1,0,
+00:06:24,26,1,1,2,
+00:06:25,27,1,1,0,
+00:06:26,28,1,1,0,
+00:06:27,29,1,1,0,
+00:06:28,30,1,1,2,0
+00:06:29,31,1,1,2,0
+00:06:30,32,1,1,2,0
+00:06:31,33,1,1,0,
+00:06:32,34,1,1,2,0
+00:06:33,35,1,1,2,0
+00:06:34,36,1,1,0,
+00:06:35,37,1,1,0,
+00:06:36,38,1,1,0,
+00:06:37,39,1,1,2,
+00:06:38,40,1,1,0,
+00:06:39,41,1,1,0,
+00:06:40,42,1,1,0,
+00:06:41,43,1,1,0,
+00:06:42,44,1,1,2,
+00:06:43,45,1,1,0,
+00:06:44,46,1,1,0,
+00:06:45,47,1,1,0,
+00:06:46,48,1,1,0,
+00:06:47,49,1,1,2,
+00:06:48,50,1,1,0,
+00:06:49,51,1,1,0,
+00:06:50,52,1,1,0,
+00:06:51,53,1,1,0,
+00:06:52,54,1,1,0,
+00:06:53,55,1,1,0,
+00:06:54,56,1,1,2,0
+00:06:55,57,1,1,2,0
+00:06:56,58,1,1,0,
+00:06:57,59,1,1,0,
+00:06:58,60,1,1,2,
+00:06:59,61,1,1,0,
+00:07:00,62,1,1,0,
+00:07:01,63,1,1,0,
+00:07:02,64,1,1,0,
+00:07:03,65,1,1,0,
+00:07:04,66,1,1,0,
+00:07:05,67,1,1,0,
+00:07:06,68,1,1,0,
+00:07:07,69,1,1,2,
+00:07:08,70,1,1,0,
+00:07:09,71,1,1,0,
+00:07:10,72,1,1,0,
+00:07:11,73,1,1,0,
+00:07:12,74,1,1,0,
+00:07:13,75,1,1,0,
+00:07:14,76,1,1,0,
+00:07:15,77,1,1,0,
+00:07:16,78,1,1,0,
+00:07:17,79,1,1,0,
+00:07:18,80,1,1,0,
+00:07:19,81,1,1,2,1
+00:07:20,82,1,1,2,1
+00:07:21,83,1,1,0,
+00:07:22,84,1,1,0,
+00:07:23,85,1,1,0,
+00:07:24,86,1,1,0,
+00:07:25,87,1,1,0,
+00:07:26,88,1,1,2,0
+00:07:27,89,1,1,2,0
+00:07:28,90,1,1,0,
+00:07:29,91,1,1,0,
+00:07:30,92,1,1,0,
+00:07:31,93,,,,
+00:07:32,94,0,2,0,
+00:07:33,95,0,2,1,
+00:07:34,96,0,2,0,
+00:07:35,97,,,,
+00:07:36,98,,,,
+00:07:37,99,1,1,0,
+00:07:38,100,1,1,0,
+00:07:39,101,1,1,0,
+00:07:40,102,1,1,0,
+00:07:41,103,1,1,0,
+00:07:42,104,1,1,1,0
+00:07:43,105,1,1,2,0
+00:07:44,106,1,1,2,0
+00:07:45,107,1,1,2,1
+00:07:46,108,1,1,2,1
+00:07:47,109,1,1,0,
+00:07:48,110,1,1,0,
+00:07:49,111,1,1,0,
+00:07:50,112,1,1,0,
+00:07:51,113,1,1,0,
+00:07:52,114,1,1,0,
+00:07:53,115,1,1,1,
+00:07:54,116,1,1,0,
+00:07:55,117,1,1,2,1
+00:07:56,118,1,1,2,1
+00:07:57,119,1,1,0,
+00:07:58,120,1,1,2,0
+00:07:59,121,1,1,2,0
+00:08:00,122,1,1,2,0
+00:08:01,123,1,1,0,
+00:08:02,124,1,1,0,
+00:08:03,125,1,1,0,
+00:08:04,126,1,1,0,
+00:08:05,127,1,1,0,
+00:08:06,128,1,1,0,
+00:08:07,129,1,1,0,
+00:08:08,130,1,1,0,
+00:08:09,131,1,1,0,
+00:08:10,132,1,1,0,
+00:08:11,133,1,1,2,0
+00:08:12,134,1,1,2,0
+00:08:13,135,1,1,2,0
+00:08:14,136,1,1,0,
+00:08:15,137,1,1,0,
+00:08:16,138,1,1,2,
+00:08:17,139,1,1,0,
+00:08:18,140,1,1,2,0
+00:08:19,141,1,1,2,0
+00:08:20,142,1,1,0,
+00:08:21,143,1,1,0,
+00:08:22,144,1,1,2,

analysis_output/session_ee8801d4-2515-4873-9db6-a8be6180e836/analysis.csv

@@ -0,0 +1,6 @@
+timestamp,second,proximity to parent,proximity to stranger,fear,freeze
+00:07:37,0,1,1,0,
+00:07:38,1,1,1,0,
+00:07:39,2,1,1,0,
+00:07:40,3,1,1,0,
+00:07:41,4,1,1,0,

app.py

@@ -0,0 +1 @@
+from backend.main import app

backend/main.py

@@ -0,0 +1,911 @@
+import datetime
+import os
+import cv2
+import uuid
+import json
+import time
+import re
+import subprocess
+import uuid
+import asyncio
+import joblib
+import logging
+import numpy as np
+import pandas as pd
+import tempfile
+import warnings
+import shutil
+from pathlib import Path
+from PIL import Image
+import ffmpeg
+import torch
+import torchvision.transforms as T
+from ultralytics import YOLO
+import mediapipe as mp
+from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks, Form, Request
+from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from backend.midas_utils.transforms import Compose, Resize, NormalizeImage, PrepareForNet
+
+################################################# 
+# Initialize application
+#################################################
+torch.serialization.add_safe_globals([
+    torch.nn.modules.conv.Conv2d,
+    torch.nn.modules.batchnorm.BatchNorm2d,
+    torch.nn.modules.linear.Linear,
+    torch.nn.modules.container.Sequential,
+    torch.nn.modules.activation.SiLU,
+    torch.nn.modules.container.ModuleList,
+    torch.nn.modules.upsampling.Upsample,
+    torch.nn.modules.pooling.MaxPool2d
+])
+
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+app = FastAPI()
+
+# CORS Configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Serve frontend files
+static_dir = Path(__file__).parent.parent / "frontend" / "static" 
+app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+# Configuration
+DETECTION_MODEL_PATH = Path(__file__).parent / 'models' / "yolo_retrained_model.pt"
+POSE_MODEL_PATH = Path(__file__).parent / 'models' / "yolov8n-pose.pt"
+MAX_VIDEO_SIZE = 500 * 1024 * 1024
+OUTPUT_DIR = Path("analysis_output")
+UPLOADED_VIDEOS = {}  # Track uploaded video session
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# Global state
+PROGRESS_STORE = {}
+ANALYSIS_ACTIVE = False
+
+@app.middleware("http")
+async def error_handling_middleware(request: Request, call_next):
+    try:
+        return await call_next(request)
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}")
+        return JSONResponse(
+            status_code=500,
+            content={"message": "Internal server error"}
+        )
+
+@app.on_event("startup")
+async def initialize_models():
+    """Initialize models with warmup inference"""
+    
+    try:
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        logger.info(f"Initializing models on {device}")
+
+        # Initialize detection model
+        app.state.detection_model = YOLO(DETECTION_MODEL_PATH).to(device)
+        dummy = np.zeros((640, 640, 3), dtype=np.uint8)
+        app.state.detection_model(dummy, verbose=False)  # Warmup
+        
+        # Initialize pose model
+        app.state.pose_model = YOLO(POSE_MODEL_PATH).to(device)
+        app.state.pose_model(dummy, verbose=False)  # Warmup
+        
+        logger.info("Models initialized successfully")
+    except Exception as e:
+        logger.error(f"Model initialization failed: {str(e)}")
+        raise RuntimeError(f"Model initialization failed: {str(e)}")
+
+def update_progress(process_id: str, current: int, total: int, message: str):
+    """Update progress store with analysis status"""
+    PROGRESS_STORE[process_id] = {
+        "percent": min(100, (current / total) * 100),
+        "message": message,
+        "current": current,
+        "total": total,
+        "status": "processing"
+    }
+
+################################################# 
+# Initialize Models
+#################################################
+
+# Child detection and image cropping
+def detect_child_and_crop(frame):
+    try:
+        results = app.state.detection_model.predict(frame, verbose=False)[0]
+        class_ids = results.boxes.cls.cpu().numpy()
+        confidences = results.boxes.conf.cpu().numpy()
+        bboxes = results.boxes.xyxy.cpu().numpy()
+        child_bbox = None
+        
+        for box, cls, conf in zip(bboxes, class_ids, confidences):
+            if conf > 0.6:
+                if cls == 1:
+                    child_bbox = box
+                elif cls == 0:
+                    adult_bbox = box
+                elif cls == 2:
+                    stranger_bbox = box
+
+        if child_bbox is None:
+            return None
+
+        x1, y1, x2, y2 = map(int, child_bbox)
+        # Validate and clamp coordinates
+        x1 = max(0, x1)
+        y1 = max(0, y1)
+        x2 = min(frame.shape[1], x2)
+        y2 = min(frame.shape[0], y2)
+        if x1 >= x2 or y1 >= y2:
+            logger.warning("Invalid child bounding box")
+            return None
+        
+        child_roi = frame[y1:y2, x1:x2]
+        if child_roi.size == 0:
+            logger.warning("Empty child ROI")
+            return None
+
+        return child_roi
+    
+    except Exception as e:
+        logger.error(f"Detection error: {str(e)}")
+        return None
+
+def load_depth_model():
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            model = torch.hub.load(
+                'intel-isl/MiDaS', 
+                'MiDaS_small',
+                pretrained=True,
+                trust_repo=True
+            ).float()
+        model.eval().to(device)
+        print("Successfully loaded MiDaS model from torch.hub")
+        return model
+    except Exception as e:
+        raise RuntimeError(f"Failed to load MiDaS model: {e}")
+
+# Load transforms
+midas_transforms = torch.hub.load("intel-isl/MiDaS", "transforms")
+Resize = midas_transforms.Resize
+NormalizeImage = midas_transforms.NormalizeImage
+PrepareForNet = midas_transforms.PrepareForNet
+
+# Define transform pipeline
+transform_pipeline = T.Compose([
+    lambda img: {"image": np.array(img.convert("RGB"), dtype=np.float32) / 255.0},
+    Resize(
+        256, 256, resize_target=None, keep_aspect_ratio=True,
+        ensure_multiple_of=32, resize_method="upper_bound",
+        image_interpolation_method=cv2.INTER_CUBIC
+    ),
+    NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    PrepareForNet(),
+    lambda sample: torch.from_numpy(sample["image"]),
+])
+
+# Load model once
+depth_model = load_depth_model()
+
+def calculate_distance_between_objects(frame, obj1_label, obj2_label):
+    results = app.state.detection_model.predict(frame, verbose=False)[0]
+    labels = results.names if hasattr(results, 'names') else {}
+
+    obj1_center = None
+    obj2_center = None
+
+    for box in results.boxes:
+        cls = int(box.cls[0].item())
+        label = labels.get(cls, str(cls))
+
+        x1, y1, x2, y2 = map(int, box.xyxy[0].cpu().numpy())
+        center = ((x1 + x2) // 2, (y1 + y2) // 2)
+
+        if label.lower() == obj1_label.lower():
+            obj1_center = center
+        elif label.lower() == obj2_label.lower():
+            obj2_center = center
+
+    # Validation checks with proper error handling
+    if obj1_center is None:
+        print(f"Important warning: {obj1_label} not detected.")
+        return None
+        
+    if obj2_center is None:
+        if obj2_label.lower() != "stranger":
+            print(f"Warning: {obj2_label} not detected.")
+        return None
+
+    # Add coordinate validation
+    def validate_coord(coord):
+        return isinstance(coord, tuple) and len(coord) == 2 and \
+               all(isinstance(v, (int, float)) for v in coord)
+
+    if not validate_coord(obj1_center) or not validate_coord(obj2_center):
+        print("Invalid coordinates detected")
+        return None
+
+    try:
+        # Estimate depth
+        img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img_pil = Image.fromarray(img_rgb)  # Convert to PIL Image first
+        input_tensor = transform_pipeline(img_pil).to(device)
+
+        if input_tensor.dim() == 3:
+            input_tensor = input_tensor.unsqueeze(0)
+        input_tensor = input_tensor.to(device)
+
+        with torch.no_grad():
+            output = depth_model(input_tensor)
+            depth_map = output.squeeze().cpu().numpy()
+
+        # Rescale object centers with safety checks
+        original_h, original_w = frame.shape[:2]
+        depth_h, depth_w = depth_map.shape
+
+        def safe_scale(coord, orig_dim, target_dim):
+            try:
+                return int((coord / orig_dim) * target_dim)
+            except ZeroDivisionError:
+                return 0
+
+        # Corrected scaling calls
+        x1 = safe_scale(obj1_center[0], original_w, depth_w)
+        y1 = safe_scale(obj1_center[1], original_h, depth_h)
+        x2 = safe_scale(obj2_center[0], original_w, depth_w)
+        y2 = safe_scale(obj2_center[1], original_h, depth_h)
+        
+        # Depth calculation with bounds checking
+        def get_depth(x, y):
+            x = max(0, min(depth_w-1, x))
+            y = max(0, min(depth_h-1, y))
+            return depth_map[y, x]
+
+        d1 = get_depth(x1, y1)
+        d2 = get_depth(x2, y2)
+
+        if d1 <= 0 or d2 <= 0:
+            return None
+
+        # 3D coordinate conversion
+        fx = fy = 1109  # Focal length assumption
+        cx, cy = depth_w // 2, depth_h // 2
+
+        point1 = (
+            (x1 - cx) * d1 / fx,
+            (y1 - cy) * d1 / fy,
+            d1
+        )
+        point2 = (
+            (x2 - cx) * d2 / fx,
+            (y2 - cy) * d2 / fy,
+            d2
+        )
+
+        return float(np.linalg.norm(np.array(point1) - np.array(point2)))
+
+    except Exception as e:
+        logger.error(f"Distance calculation error: {str(e)}")
+        return None
+
+# MediaPipe initialization
+mp_face_mesh = mp.solutions.face_mesh
+face_mesh = mp_face_mesh.FaceMesh(
+    static_image_mode=False,
+    max_num_faces=1,
+    min_detection_confidence=0.5
+)
+
+LANDMARKS = {
+    "left_eye": [33, 133, 159, 145, 160, 144],
+    "right_eye": [362, 263, 386, 374, 387, 373],
+    "left_eyebrow": [70, 63, 105],
+    "right_eyebrow": [300, 293, 334],
+    "mouth": [13, 14, 78, 308],
+    "jaw": [152]
+}
+
+def facial_keypoints(image, prev_landmarks=None):
+    if image is None:
+        logger.error("Received None frame")
+        return 0, None
+    try:
+        h, w = image.shape[:2]
+    except AttributeError:
+        logger.error("Invalid image type")
+        return 0, None
+    if h == 0 or w == 0 or image.size == 0:
+        logger.error("Received empty frame")
+        return 0, None
+
+    try:
+        results = face_mesh.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        if not results.multi_face_landmarks:
+            return 0, None
+
+        current_landmarks = {}
+        for key, indices in LANDMARKS.items():
+            current_landmarks[key] = [
+                (int(lm.x * image.shape[1]), int(lm.y * image.shape[0]))
+                for lm in [results.multi_face_landmarks[0].landmark[i] for i in indices]
+            ]
+
+        movement_score = 0
+        if prev_landmarks:
+            total_diff = sum(
+                np.sqrt((cx - px)**2 + (cy - py)**2)
+                for key in LANDMARKS
+                for (px, py), (cx, cy) in zip(prev_landmarks.get(key, []), current_landmarks.get(key, []))
+            )
+            valid_points = sum(len(landmarks) for landmarks in current_landmarks.values())
+            movement_score = 2 if (total_diff/valid_points) > 6 else 1 if (total_diff/valid_points) > 3 else 0
+
+        return movement_score, current_landmarks
+    except Exception as e:
+        logger.error(f"Facial processing error: {str(e)}")
+        return 0, None
+
+def process_pose(image):
+    if image is None:
+        return None
+    try:
+        results = app.state.pose_model(image, verbose=False)
+        if results and hasattr(results[0], 'keypoints'):
+            return results[0].keypoints.xy[0].cpu().numpy()
+        return None
+    except Exception as e:
+        logger.error(f"Pose processing error: {str(e)}")
+        return None
+
+def calculate_body_movement(current_pose, previous_pose):
+    if current_pose is None or previous_pose is None:
+        return 0.0
+    
+    valid_points = 0
+    total_movement = 0.0
+    
+    for prev, curr in zip(previous_pose, current_pose):
+        if not (np.isnan(prev).any() or np.isnan(curr).any()):
+            valid_points += 1
+            total_movement += abs(np.linalg.norm(curr - prev))
+    
+    return total_movement
+
+#################################################
+# Preparing for Video Processing
+#################################################
+
+def time_to_seconds(timestamp):
+    return sum(x * int(t) for x, t in zip([3600, 60, 1], timestamp.split(':')))
+
+def format_progress_message(stage, current, total, extras=None):
+    base = f"{stage} - Frame {current}/{total}"
+    if extras:
+        return f"{base} - {', '.join(f'{k}: {v}' for k,v in extras.items())}"
+    return base
+
+def crop_video(process_id: str, video_path: str, timestamp1: str, timestamp2: str, 
+              timestamp3: str, temp_dir: str, ffmpeg_path: str = 'ffmpeg') -> tuple[str, str]:
+    """
+    Crop the video into two clips with cancellation support
+    """
+    temp_dir_path = Path(temp_dir)
+    
+    # Create temp directory if it doesn't exist
+    temp_dir_path.mkdir(parents=True, exist_ok=True)
+
+    # Generate temporary filenames
+    first_clip_path = temp_dir_path / f"clip1_{uuid.uuid4()}.mp4"
+    second_clip_path = temp_dir_path / f"clip2_{uuid.uuid4()}.mp4"
+
+    def check_cancellation():
+        """Check if processing was cancelled (replace with your actual progress store)"""
+        # You'll need to import or access your PROGRESS_STORE here
+        if PROGRESS_STORE.get(process_id, {}).get('status') == 'cancelled':
+            raise asyncio.CancelledError("Processing cancelled by user during video cropping")
+
+    def run_ffmpeg_with_cancel_check(command: list, output_file: Path) -> None:
+        """Run ffmpeg command with cancellation checks"""
+        try:
+            # Start the process
+            process = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True
+            )
+
+            # Poll process while checking for cancellation
+            while True:
+                check_cancellation()
+                if process.poll() is not None:  # Process finished
+                    break
+                time.sleep(0.5)  # Check every 500ms
+
+            # Check final status
+            if process.returncode != 0:
+                raise subprocess.CalledProcessError(
+                    process.returncode,
+                    command,
+                    output=process.stdout,
+                    stderr=process.stderr
+                )
+
+        except asyncio.CancelledError:
+            # Cleanup and terminate process
+            if process.poll() is None:  # Still running
+                process.terminate()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+            
+            # Remove partial output file
+            if output_file.exists():
+                output_file.unlink()
+            
+            raise
+
+    # Convert timestamps
+    ts1 = time_to_seconds(timestamp1)
+    ts2 = time_to_seconds(timestamp2)
+    ts3 = time_to_seconds(timestamp3)
+
+    # Build commands
+    commands = [
+        (
+            [
+                ffmpeg_path, '-y', '-i', video_path,
+                '-ss', str(ts1), '-t', str(ts2 - ts1),
+                '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
+                '-c:a', 'aac', str(first_clip_path)
+            ],
+            first_clip_path
+        ),
+        (
+            [
+                ffmpeg_path, '-y', '-i', video_path,
+                '-ss', str(ts2), '-t', str(ts3 - ts2),
+                '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
+                '-c:a', 'aac', str(second_clip_path)
+            ],
+            second_clip_path
+        )
+    ]
+
+    try:
+        # Process both clips
+        for cmd, output_path in commands:
+            logger.info("Running command: %s", ' '.join(cmd))
+            run_ffmpeg_with_cancel_check(cmd, output_path)
+        
+        return str(first_clip_path), str(second_clip_path)
+
+    except asyncio.CancelledError:
+        # Cleanup both files if either was cancelled
+        for path in [first_clip_path, second_clip_path]:
+            if path.exists():
+                path.unlink()
+        raise
+
+#################################################
+# Video Processing Loop
+#################################################
+
+def process_freeplay(process_id: str, freeplay_video: str) -> float:
+    """
+    Sample one frame per second from the freeplay clip,
+    compute body‐movement metrics and return the average.
+    """
+    PROGRESS_STORE[process_id].update({"message": "Processing freeplay"})
+    cap = cv2.VideoCapture(freeplay_video)
+    if not cap.isOpened():
+        raise RuntimeError(f"Failed to open freeplay video at {freeplay_video}")
+
+    # Determine clip duration in seconds
+    fps = cap.get(cv2.CAP_PROP_FPS) or 1.0
+    total_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0
+    duration = total_frames / fps
+
+    movements = []
+    prev_pose = None
+
+    for sec in range(int(duration)):
+        if PROGRESS_STORE.get(process_id, {}).get('status') == 'cancelled':
+            raise asyncio.CancelledError("Processing cancelled")
+        print(f"Processing freeplay frame {sec}")
+        if PROGRESS_STORE[process_id]["status"] == "cancelled":
+            break
+
+        # Seek by time (ms)
+        cap.set(cv2.CAP_PROP_POS_MSEC, sec * 1000)
+        ret, frame = cap.read()
+        if not ret or frame is None or frame.size == 0:
+            logger.warning(f"Freeplay: no frame at {sec}s")
+            continue
+
+        PROGRESS_STORE[process_id].update({
+            "current": sec,
+            "percent": 10 + int((sec + 1) / duration * 30)
+        })
+
+        try:
+            child_roi = detect_child_and_crop(frame)
+            pose_kps = process_pose(child_roi)
+            mv = calculate_body_movement(pose_kps, prev_pose)
+            movements.append(mv)
+            prev_pose = pose_kps
+        except Exception as e:
+            logger.error(f"Freeplay error at {sec}s: {e}", exc_info=True)
+
+    cap.release()
+    return float(np.mean(movements)) if movements else 0.0
+
+def process_experiment(process_id: str, experiment_video: str, freeplay_movement: float) -> pd.DataFrame:
+    """
+    Sample one frame per second from the experiment clip,
+    compute all metrics, and return a DataFrame.
+    """
+    PROGRESS_STORE[process_id].update({"message": "Analyzing experiment"})
+    cap = cv2.VideoCapture(experiment_video)
+    if not cap.isOpened():
+        raise RuntimeError(f"Failed to open experiment video at {experiment_video}")
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 1.0
+    total_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0
+    duration = total_frames / fps
+    PROGRESS_STORE[process_id].update({"total": int(duration)})
+
+    results = []
+    prev_landmarks = None
+    prev_pose = None
+
+    for sec in range(int(duration)):
+        if PROGRESS_STORE.get(process_id, {}).get('status') == 'cancelled':
+            raise asyncio.CancelledError("Processing cancelled")
+        print(f"Processing experiment frame {sec}")
+        if PROGRESS_STORE[process_id]["status"] == "cancelled":
+            break
+
+        cap.set(cv2.CAP_PROP_POS_MSEC, sec * 1000)
+        ret, frame = cap.read()
+        if not ret or frame is None or frame.size == 0:
+            logger.warning(f"Experiment: no frame at {sec}s")
+            results.append({
+                "second": sec,
+                "parent_dist": None,
+                "stranger_dist": None,
+                "face_movement": None,
+                "body_movement": None
+            })
+            continue
+
+        PROGRESS_STORE[process_id].update({
+            "current": sec,
+            "percent": 40 + int((sec + 1) / duration * 60)
+        })
+
+        try:
+            child_roi = detect_child_and_crop(frame)
+            face_score, curr_landmarks = facial_keypoints(child_roi, prev_landmarks)
+            pose_kps = process_pose(child_roi)
+            body_mv = calculate_body_movement(pose_kps, prev_pose)
+            mov_ratio = body_mv / freeplay_movement if freeplay_movement else 0.0
+
+            parent_dist = calculate_distance_between_objects(frame, "Child", "Adult")
+            stranger_dist = calculate_distance_between_objects(frame, "Child", "Stranger")
+
+            results.append({
+                "second": sec,
+                "distance_adult": parent_dist,
+                "distance_stranger": stranger_dist,
+                "facial_movement": face_score,
+                "body_movement": mov_ratio
+            })
+
+            prev_landmarks = curr_landmarks
+            prev_pose = pose_kps
+
+        except Exception as e:
+            logger.error(f"Experiment error at {sec}s: {e}", exc_info=True)
+            # still append a row so CSV timestamps remain aligned
+            results.append({
+                "second": sec,
+                "distance_adult": None,
+                "distance_stranger": None,
+                "facial_movement": None,
+                "body_movement": None
+            })
+
+    cap.release()
+    return pd.DataFrame(results)
+
+def apply_classes(df, timestamp_start, timestamp_end,
+                  distance_model_name='distance_classifier.pkl',
+                  fear_model_name='fear_classifier.pkl',
+                  freeze_model_name='freeze_classifier.pkl'):
+
+    
+    distance_tree_path = Path(__file__).parent / 'models' / distance_model_name
+    fear_tree_path = Path(__file__).parent / 'models' / fear_model_name
+    freeze_tree_path = Path(__file__).parent / 'models' / freeze_model_name
+    
+    # Load models
+    distance_clf = joblib.load(distance_tree_path)
+    fear_clf     = joblib.load(fear_tree_path)
+    freeze_clf   = joblib.load(freeze_tree_path)
+
+    # 1) Initialize outputs
+    df['proximity to parent']   = None
+    df['proximity to stranger'] = None
+    df['fear']                  = None
+    df['freeze']                = pd.Series([pd.NA] * len(df), dtype="Int64")
+
+    # 2) Distance → proximity classes
+    valid_mask = df[['distance_adult','body_movement','facial_movement']].notnull().all(axis=1)
+    preds_parent = distance_clf.predict(df.loc[valid_mask, ['distance_adult']])
+    df.loc[valid_mask, 'proximity to parent'] = preds_parent
+    df.loc[valid_mask, 'proximity to stranger'] = pd.Series(preds_parent).map({0:2, 1:1, 2:0}).values
+
+    # 3) Fear classifier
+    fear_cols = ['proximity to parent','proximity to stranger','body_movement','facial_movement']
+    fear_mask = df[fear_cols].notnull().all(axis=1)
+    df.loc[fear_mask, 'fear'] = fear_clf.predict(df.loc[fear_mask, fear_cols])
+
+    # 4) Build pairwise DataFrame (includes 'second')
+    df1 = df.iloc[:-1].reset_index(drop=True).add_suffix('_1')
+    df2 = df.iloc[1:].reset_index(drop=True).add_suffix('_2')
+    df_pairs = pd.concat([df1, df2], axis=1)
+
+    # 5) Filter pairs where both fears > 0
+    mask = (df_pairs['fear_1'] > 0) & (df_pairs['fear_2'] > 0)
+    df_filtered = df_pairs[mask].copy()
+    df_filtered['body_movement_avg'] = (df_filtered['body_movement_1'] + df_filtered['body_movement_2']) / 2
+
+    # 6) Predict freeze and backfill to both seconds
+    if not df_filtered.empty:
+        df_filtered['freeze'] = freeze_clf.predict(df_filtered[['body_movement_avg']])
+        for _, row in df_filtered.iterrows():
+            for sec_col in ('second_1', 'second_2'):
+                sec = int(row[sec_col])
+                idx = df.index[df['second'] == sec][0]
+                current = df.at[idx, 'freeze']
+                if not (pd.notna(current) and current == 1):
+                    df.at[idx, 'freeze'] = row['freeze']
+
+    # 7) Add timestamps column based on timestamp_start and 'second'
+    time_format = '%H:%M:%S'
+    ts_start = datetime.datetime.strptime(timestamp_start, time_format)
+    df['timestamp'] = df['second'].apply(
+        lambda x: (ts_start + datetime.timedelta(seconds=int(x))).time().strftime(time_format)
+    )
+
+    # 8) Return only the final columns
+    return df[['timestamp', 'second', 'proximity to parent', 'proximity to stranger', 'fear', 'freeze']]
+
+async def process_video_async(process_id: str, video_path: Path, session_dir: Path,
+                              timestamp1: str, timestamp2: str, timestamp3: str, temp_dir: Path):
+
+    if PROGRESS_STORE.get(process_id, {}).get("started"):
+        return
+    
+    # Initialize progress tracking
+    PROGRESS_STORE[process_id] = {
+        "started": True,
+        "status":  "processing",
+        "percent": 0,
+        "message": "Initializing",
+        "result":  None,
+        "error":   None
+    }
+
+    # Validate timestamps
+    def validate_timestamp(t):
+        parts = t.split(':')
+        return (len(parts) == 3 and all(p.isdigit() for p in parts))
+    
+    if not all(validate_timestamp(ts) for ts in [timestamp1, timestamp2, timestamp3]):
+        raise ValueError("Invalid timestamp format")
+
+    # Crop video
+    PROGRESS_STORE[process_id].update({
+        "message": "Cropping video segments",
+        "percent": 5
+    })
+    
+    
+    try:
+        freeplay_video, experiment_video = await asyncio.to_thread(
+            crop_video,
+            process_id,
+            str(video_path),
+            timestamp1,
+            timestamp2,
+            timestamp3,
+            str(temp_dir)
+        )
+
+
+        # Process freeplay segment
+        PROGRESS_STORE[process_id].update({
+            "message": "Analyzing freeplay movement",
+            "percent": 10
+        })
+        freeplay_movement = await asyncio.to_thread(
+            process_freeplay,
+            process_id,
+            freeplay_video
+        )
+
+        # Process experiment segment in a thread
+        PROGRESS_STORE[process_id].update({
+            "message": "Analyzing experiment",
+            "percent": 40
+        })
+        result_df = await asyncio.to_thread(
+            process_experiment,
+            process_id,
+            experiment_video,
+            freeplay_movement
+        )
+
+        final_df = apply_classes(result_df, timestamp2, timestamp3)
+        
+        result_path = session_dir / "analysis.csv"
+        final_df.to_csv(result_path, index=False)
+        os.sync()
+
+        PROGRESS_STORE[process_id].update({
+            "status": "completed",
+            "result": str(result_path),
+            "percent": 100,
+            "message": "Analysis complete"
+        })
+        
+    except Exception as e:
+        logger.error(f"Processing error: {str(e)}", exc_info=True)
+        PROGRESS_STORE[process_id].update({
+            "status": "error",
+            "error": str(e),
+            "percent": 100
+        })
+    
+    finally:
+        if video_path.exists():
+            video_path.unlink()
+            
+#################################################
+# API Endpoints
+#################################################
+
+@app.post("/api/process-video")
+async def start_processing(
+    video: UploadFile = File(...),
+    timestamp1: str = Form(...),
+    timestamp2: str = Form(...),
+    timestamp3: str = Form(...)
+):
+    # 1) Generate IDs & dirs
+    process_id = str(uuid.uuid4())
+    temp_dir = Path(tempfile.mkdtemp())
+    session_dir = OUTPUT_DIR / f"session_{process_id}"
+    session_dir.mkdir(exist_ok=True)
+
+    # 2) Seed progress (so /api/progress can pick it up immediately)
+    PROGRESS_STORE[process_id] = {
+        "started": False,
+        "status":  "queued",
+        "percent": 0,
+        "message": "Queued for processing",
+        "result":  None,
+        "error":   None
+    }
+
+    # 3) Save the upload
+    video_path = temp_dir / video.filename
+    with open(video_path, "wb") as f:
+        f.write(await video.read())
+
+    # 4) Kick off the async worker on the loop directly
+    asyncio.create_task(
+        process_video_async(
+            process_id, video_path, session_dir,
+            timestamp1, timestamp2, timestamp3, temp_dir
+        )
+    )
+
+    # 5) Return the process_id immediately
+    return {"process_id": process_id}
+    
+@app.get("/api/progress/{process_id}")
+async def progress_stream(process_id: str):
+    async def event_generator():
+        last = {}
+        while True:
+            if process_id in PROGRESS_STORE:
+                current = PROGRESS_STORE[process_id]
+                if current != last:
+                    last = current.copy()    # snapshot instead of alias
+                    yield f"data: {json.dumps(current)}\n\n"
+                if current["status"] in ["completed", "error", "cancelled"]:
+                    break
+            await asyncio.sleep(0.5)
+    
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection":    "keep-alive"   # ensure the stream stays open
+        }
+    )
+
+@app.get("/api/results/{process_id}")
+async def results(process_id: str):
+    if process_id not in PROGRESS_STORE:
+        raise HTTPException(404, detail="Process ID not found")
+    
+    status = PROGRESS_STORE[process_id]
+    
+    if status["status"] == "completed":
+        csv_path = Path(status["result"])
+        try:
+            # Validate file exists and is readable
+            if not csv_path.exists() or csv_path.stat().st_size == 0:
+                raise FileNotFoundError("Result file missing or empty")
+                
+            return FileResponse(
+                csv_path,
+                media_type="text/csv",
+                filename="stranger_danger_analysis.csv",
+                headers={"X-Analysis-Complete": "true"}
+            )
+        except Exception as e:
+            logger.error(f"Results delivery failed: {str(e)}")
+            raise HTTPException(500, detail="Results generation failed")
+    
+    raise HTTPException(425, detail="Analysis not complete yet")
+
+@app.post("/api/cancel-analysis")
+async def cancel_analysis(process_id: str = Form(...)):
+    if process_id in PROGRESS_STORE:
+        PROGRESS_STORE[process_id].update({"status": "cancelled", "message": "Cancelled by user"})
+    return {"status": "cancelled"}
+
+@app.post("/api/delete-video")
+async def delete_video(process_id: str = Form(...)):
+    if process_id in PROGRESS_STORE:
+        PROGRESS_STORE.pop(process_id, None)
+        return {"status": "deleted"}
+    raise HTTPException(404, detail="Video not found")
+
+@app.get("/{full_path:path}")
+async def serve_frontend(full_path: str):
+    if full_path.startswith(("api/", "static/")):
+        raise HTTPException(status_code=404)
+    frontend = Path("frontend/index.html")
+    if not frontend.exists():
+        raise HTTPException(status_code=404, detail="Frontend not found")
+    return FileResponse(frontend)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)
+
+

backend/midas_utils/fresh_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70d6b9c891758c67f974a6097fb0c608c7ee67fb81ac3e5588847d5596d56fca
+size 85761505

backend/midas_utils/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70d6b9c891758c67f974a6097fb0c608c7ee67fb81ac3e5588847d5596d56fca
+size 85761505

backend/midas_utils/transforms.py

@@ -0,0 +1,40 @@
+import cv2
+import numpy as np
+import torch
+from torchvision import transforms
+
+class Resize(object):
+    def __init__(self, size):
+        self.size = size
+
+    def __call__(self, image):
+        image = cv2.resize(image, (self.size, self.size))
+        return image
+
+class NormalizeImage(object):
+    def __init__(self, mean, std):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, image):
+        image = image.astype(np.float32) / 255.0
+        image -= np.array(self.mean)
+        image /= np.array(self.std)
+        return image
+
+class PrepareForNet(object):
+    def __call__(self, image):
+        image = torch.from_numpy(image)
+        if len(image.shape) == 3:
+            image = image.permute(2, 0, 1)
+        image = image.unsqueeze(0)
+        return image
+
+class Compose:
+    def __init__(self, transforms):
+        self.transforms = transforms
+
+    def __call__(self, img):
+        for t in self.transforms:
+            img = t(img)
+        return img

backend/models/distance_classifier.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5e48f5a4ec6ad18315c3a4c3a97cd76a506b35147008db0ca420056b6767a5e
+size 2241

backend/models/fear_classifier.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea252c3a845a28cac79a1b1ed944f4929a3e510286a772b3dccf6ba8412697c1
+size 4273

backend/models/freeze_classifier.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75491fb862b4c0bfdc79c214bdf5bdaa32622c5908cc2215e7a467754923bfe6
+size 3129

backend/models/yolo_retrained_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f09573aee77e183bad25d85a07f58be838d9e02bfbfcb0fdefb73bd59dddc117
+size 52045563

backend/models/yolov8n-pose.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6fa93dd1ee4a2c18c900a45c1d864a1c6f7aba75d84f91648a30b7fb641d212
+size 6832633

ffmpeg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7e7fb30477f717e6f55f9180a70386c62677ef8a4d4d1a5d948f4098aa3eb99
+size 79826272

frontend/index.html

@@ -0,0 +1,141 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Experiment Auto-Labeler</title>
+    <base href="/">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+    <link rel="stylesheet" href="/static/style.css">
+</head>
+<body>
+    <div class="container">
+        <!-- Initial Screen -->
+        <div class="card" id="initialScreen">
+            <h1>Stranger Danger Auto-Labeling</h1>
+            <div class="option-grid">
+                <div class="option-card" onclick="showUploadScreen('sharepoint')">
+                    <i class="fab fa-microsoft"></i>
+                    <h3>SharePoint</h3>
+                    <p>Access videos from SharePoint</p>
+                </div>
+                <div class="option-card" onclick="showUploadScreen('local')">
+                    <i class="fas fa-upload"></i>
+                    <h3>Local Upload</h3>
+                    <p>Upload from your device</p>
+                </div>
+            </div>
+        </div>
+
+        <!-- SharePoint Credentials Screen -->
+        <div class="card hidden" id="sharepointCredScreen">
+            <h2>SharePoint Connection</h2>
+            <form id="spCredForm" onsubmit="handleSpCredSubmit(event)">
+                <div class="form-group">
+                    <label>Site URL</label>
+                    <input type="url" id="spSiteUrl" required placeholder="https://yourdomain.sharepoint.com/sites/yoursite">
+                </div>
+                <div class="form-group">
+                    <label>Client ID</label>
+                    <input type="text" id="spClientId" required placeholder="a1b2c3d4-e5f6-7g8h-9i0j-k1l2m3n4o5p6">
+                </div>
+                <div class="form-group">
+                    <label>Client Secret</label>
+                    <input type="password" id="spClientSecret" required placeholder="ABC123~abcdefghijklmnopqrstuvwxyz">
+                </div>
+                <div class="form-group">
+                    <label>Document Library</label>
+                    <input type="text" id="spDocLibrary" value="Documents" required>
+                </div>
+                <button type="submit" class="btn">
+                    <i class="fas fa-check"></i> Connect
+                </button>
+                <button type="button" class="btn secondary" onclick="showScreen('initialScreen')">
+                    <i class="fas fa-arrow-left"></i> Back
+                </button>
+            </form>
+        </div>
+
+        <!-- SharePoint File Selection -->
+        <div class="card hidden" id="sharepointFileScreen">
+            <h2>Select SharePoint File</h2>
+            <div id="spFileList"></div>
+            <button class="btn secondary" onclick="showScreen('sharepointCredScreen')">
+                <i class="fas fa-arrow-left"></i> Back
+            </button>
+        </div>
+
+        <!-- Local Upload Screen -->
+        <div class="card hidden" id="localUploadScreen">
+            <h2>Upload Video</h2>
+            <div class="upload-area" id="dropZone">
+                <i class="fas fa-cloud-upload-alt"></i>
+                <p>Drag & drop or click to upload</p>
+                <input type="file" id="videoInput" hidden accept="video/*">
+            </div>
+            <div class="preview-container">
+                <video id="videoPreview" class="hidden" controls></video>
+            </div>
+            
+            <!-- Add timestamp inputs -->
+            <div class="timestamp-group">
+                <div class="form-group">
+                    <label>Start Time (HH:MM:SS)</label>
+                    <input type="text" id="timestamp1" required 
+                           pattern="^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"
+                           placeholder="00:00:00">
+                </div>
+                <div class="form-group">
+                    <label>Transition Time (HH:MM:SS)</label>
+                    <input type="text" id="timestamp2" required 
+                           pattern="^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"
+                           placeholder="00:00:00">
+                </div>
+                <div class="form-group">
+                    <label>End Time (HH:MM:SS)</label>
+                    <input type="text" id="timestamp3" required 
+                           pattern="^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"
+                           placeholder="00:00:00">
+                </div>
+            </div>
+        
+            <button class="btn" id="analyzeBtn" disabled>
+                <i class="fas fa-play"></i> Start Analysis
+            </button>
+            <button class="btn secondary" onclick="showScreen('initialScreen')">
+                <i class="fas fa-arrow-left"></i> Back
+            </button>
+        </div>
+
+        <!-- Progress Screen -->
+        <div class="card hidden" id="progressScreen">
+            <h2>Analyzing Video</h2>
+            <div class="progress-container">
+                <div class="progress-bar" id="progressBar"></div>
+                <div id="frameCounter"></div>
+            </div>
+            <p id="progressMessage">Initializing analysis... Do not cancel</p>
+            <div class="button-group">
+                <button class="btn danger" id="cancelBtn" onclick="cancelAnalysis()">
+                    <i class="fas fa-stop-circle"></i> Cancel Analysis
+                </button>
+            </div>
+        </div>
+
+        <!-- Results Screen -->
+        <div class="card hidden" id="resultsScreen">
+            <h2>Analysis Complete!</h2>
+            <div class="result-badge">
+                <i class="fas fa-check-circle"></i>
+            </div>
+            <button class="btn" id="downloadBtn">
+                <i class="fas fa-download"></i> Download Report
+            </button>
+            <button class="btn secondary" id="newAnalysisBtn">
+                <i class="fas fa-redo"></i> New Analysis
+            </button>
+        </div>
+    </div>
+    <script src="/static/script.js"></script>
+</body>
+</html>

frontend/static/script.js

@@ -0,0 +1,429 @@
+// ==================== Constants & Global State ====================
+const API_BASE_URL = window.location.origin; // Base URL for API calls, using current origin
+
+let currentFile = null; // Holds the currently selected video file (Blob or File)
+let analysisAbortController = null; // Controller to abort video analysis requests
+let spCredentials = {}; // Stores SharePoint credentials after connection
+let isSharePointFile = false; // Flag indicating if the file came from SharePoint
+let progressSource = null; // EventSource for server-sent events during processing
+
+// ==================== Initialization ====================
+
+document.addEventListener('DOMContentLoaded', () => {
+    initApp(); // Kick off app setup
+});
+
+function initApp() {
+    initEventListeners(); // Attach all UI event handlers
+    showScreen('initialScreen'); // Display the upload/timestamp screen
+}
+
+function initEventListeners() {
+    // File upload via click
+    document.getElementById('dropZone').addEventListener('click', () => {
+        document.getElementById('videoInput').click(); // Trigger hidden file input
+    });
+
+    // File input change handler
+    document.getElementById('videoInput').addEventListener('change', handleFileSelect);
+
+    // Drag-and-drop handlers
+    const dropZone = document.getElementById('dropZone');
+    dropZone.addEventListener('dragover', handleDragOver); // Highlight zone on drag over
+    dropZone.addEventListener('drop', handleDrop);        // Handle file drop
+    dropZone.addEventListener('dragleave', () => dropZone.classList.remove('dragover')); // Remove highlight
+
+    // Navigation buttons to switch screens
+    document.querySelectorAll('[data-screen]').forEach(btn => {
+        btn.addEventListener('click', () => {
+            if (analysisAbortController) {
+                // If analysis in flight, cancel then switch
+                cancelAnalysis().finally(() => showScreen(btn.dataset.screen));
+            } else {
+                showScreen(btn.dataset.screen);
+            }
+        });
+    });
+
+    // "New Analysis" button on results screen
+    document.querySelector('#resultsScreen .btn.secondary').addEventListener('click', handleNewAnalysis);
+
+    // Analysis control buttons
+    document.getElementById('analyzeBtn').addEventListener('click', startAnalysis); // Start processing
+    document.getElementById('cancelBtn').addEventListener('click', cancelAnalysis); // Cancel processing
+    document.getElementById('downloadBtn').addEventListener('click', () => {
+        // Download handled dynamically in setupDownload()
+    });
+
+    // Timestamp input validation handlers
+    document.getElementById('timestamp1').addEventListener('input', validateTimestamps);
+    document.getElementById('timestamp2').addEventListener('input', validateTimestamps);
+    document.getElementById('timestamp3').addEventListener('input', validateTimestamps);
+}
+
+// ==================== High-Level Workflows ====================
+
+// Start a brand new analysis (from results screen)
+async function handleNewAnalysis() {
+    try {
+        await cancelAnalysis(); // Abort any running job
+        resetApp();            // Clear form and state
+        resetAnalyzeButton();  // Restore Analyze button
+        showScreen('initialScreen'); // Go back to upload
+    } catch (error) {
+        showError(`Failed to start new analysis: ${error.message}`); // Show error
+    }
+}
+
+// Handle SharePoint credentials submission and file listing
+async function handleSpCredSubmit(event) {
+    event.preventDefault();
+
+    const submitBtn = event.target.querySelector('button[type="submit"]');
+    const originalText = submitBtn.innerHTML;
+    submitBtn.disabled = true; // Prevent double submits
+    submitBtn.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Connecting...'; // Show spinner
+
+    // Collect credentials from form
+    spCredentials = {
+        siteUrl: document.getElementById('spSiteUrl').value.trim(),
+        clientId: document.getElementById('spClientId').value.trim(),
+        clientSecret: document.getElementById('spClientSecret').value.trim(),
+        docLibrary: document.getElementById('spDocLibrary').value.trim()
+    };
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/sharepoint/files`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                ...spCredentials,
+                doc_library: spCredentials.docLibrary
+            })
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.detail || response.statusText);
+        }
+
+        const files = await response.json(); // Array of SharePoint files
+        renderSpFileList(files);             // Populate file list UI
+        showScreen('sharepointFileScreen');  // Switch to file selection
+    } catch (error) {
+        showError(`SharePoint connection failed: ${error.message}`);
+    } finally {
+        submitBtn.disabled = false;       // Restore button
+        submitBtn.innerHTML = originalText;
+    }
+}
+
+// Render list of SharePoint files with Select buttons
+function renderSpFileList(files) {
+    const fileList = document.getElementById('spFileList');
+    if (!fileList) return;
+
+    fileList.innerHTML = files.map(file => `
+        <div class="sp-file-item">
+            <span>${file.name}</span>
+            <button class="btn" onclick="handleSpFile('${file.id}')">
+                <i class="fas fa-play"></i> Select
+            </button>
+        </div>
+    `).join('');
+}
+
+// Handle selecting and downloading a file from SharePoint
+async function handleSpFile(fileId) {
+    const selectBtn = event.target;
+    const originalText = selectBtn.innerHTML;
+    selectBtn.disabled = true;
+    selectBtn.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Loading...';
+
+    try {
+        const formData = new URLSearchParams({
+            ...spCredentials,
+            file_id: fileId
+        });
+
+        const response = await fetch(`${API_BASE_URL}/api/sharepoint/download`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: formData
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.detail || response.statusText);
+        }
+
+        currentFile = await response.blob(); // Store the downloaded blob
+        isSharePointFile = true;             // Mark as SharePoint source
+        await startAnalysis();               // Begin processing
+    } catch (error) {
+        showError(`File download failed: ${error.message}`);
+    } finally {
+        selectBtn.disabled = false;           // Restore button
+        selectBtn.innerHTML = originalText;
+    }
+}
+
+// Kick off video analysis by sending file and timestamps to backend
+async function startAnalysis() {
+    const analyzeBtn = document.getElementById('analyzeBtn');
+    analyzeBtn.disabled = true; // Prevent re-click
+    analyzeBtn.onclick = null;
+    analyzeBtn.innerText = 'Analyzing…'; // Update label
+
+    if (!currentFile) {
+        showError('Please select a file first!');
+        resetAnalyzeButton();
+        return;
+    }
+
+    const t1 = document.getElementById('timestamp1').value;
+    const t2 = document.getElementById('timestamp2').value;
+    const t3 = document.getElementById('timestamp3').value;
+    if (!validateTimeOrder(t1, t2, t3)) {
+        showError('Timestamps must be in ascending order');
+        resetAnalyzeButton();
+        return;
+    }
+
+    showScreen('progressScreen'); // Show progress UI
+    analysisAbortController = new AbortController(); // New controller
+
+    try {
+        const formData = new FormData();
+        formData.append('video', currentFile);
+        formData.append('timestamp1', t1);
+        formData.append('timestamp2', t2);
+        formData.append('timestamp3', t3);
+
+        const response = await fetch(`${API_BASE_URL}/api/process-video`, {
+            method: 'POST',
+            body: formData,
+            signal: analysisAbortController.signal
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.detail || response.statusText);
+        }
+
+        const { process_id } = await response.json();
+        setupProgressTracker(process_id);
+
+    } catch (error) {
+        if (error.name !== 'AbortError') {
+            showError(`Analysis failed: ${error.message}`);
+            showScreen('initialScreen');
+        }
+    }
+}
+
+// ==================== File Upload/Selection Handlers ====================
+
+function handleFileSelect(e) {
+    const file = e.target.files[0];
+    if (file) handleFile(file);
+}
+
+function handleDragOver(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    e.currentTarget.classList.add('dragover');
+}
+
+function handleDrop(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    e.currentTarget.classList.remove('dragover');
+    const file = e.dataTransfer.files[0];
+    if (file) handleFile(file);
+}
+
+function handleFile(file) {
+    if (!file || !file.type.startsWith('video/')) {
+        showError('Please upload a valid video file (MP4, MOV, or AVI)');
+        return;
+    }
+
+    currentFile = file;
+    isSharePointFile = false;
+
+    const preview = document.getElementById('videoPreview');
+    const analyzeBtn = document.getElementById('analyzeBtn');
+
+    if (preview.src) URL.revokeObjectURL(preview.src);
+
+    preview.src = URL.createObjectURL(file);
+    preview.classList.remove('hidden');
+    analyzeBtn.disabled = false;
+
+    document.getElementById('timestamp1').value = '';
+    document.getElementById('timestamp2').value = '';
+    document.getElementById('timestamp3').value = '';
+    validateTimestamps();
+}
+
+function showUploadScreen(type) {
+    if (type === 'sharepoint') {
+        showScreen('sharepointCredScreen');
+    } else {
+        showScreen('localUploadScreen');
+    }
+}
+
+// ==================== Progress Tracking ====================
+
+function setupProgressTracker(processId) {
+    if (progressSource) progressSource.close();
+
+    progressSource = new EventSource(`${API_BASE_URL}/api/progress/${processId}`);
+
+    progressSource.onmessage = (event) => {
+        try {
+            const data = JSON.parse(event.data);
+
+            if (data.status === 'completed') {
+                handleAnalysisComplete(processId);
+                progressSource.close();
+            } else if (data.status === 'error') {
+                showError(data.error || 'Analysis failed');
+                progressSource.close();
+                showScreen('initialScreen');
+            } else {
+                updateProgressUI(data);
+            }
+        } catch (error) {
+            console.error('Error parsing progress:', error);
+        }
+    };
+
+    progressSource.onerror = () => {
+        console.log('SSE error - attempting reconnect');
+        setTimeout(() => setupProgressTracker(processId), 2000);
+    };
+}
+
+function updateProgressUI(progress) {
+    const progressBar = document.getElementById('progressBar');
+    const progressMessage = document.getElementById('progressMessage');
+
+    progressBar.style.width = `${progress.percent}%`;
+    progressMessage.textContent = progress.message;
+
+    if (progress.current && progress.total) {
+        document.getElementById('frameCounter').textContent = `${progress.current}/${progress.total} seconds processed`;
+    }
+}
+
+async function handleAnalysisComplete(processId) {
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/results/${processId}`);
+        const blob = await response.blob();
+        setupDownload(blob);
+        showScreen('resultsScreen');
+    } catch (error) {
+        showError('Failed to retrieve results');
+    }
+}
+
+// ==================== Utilities ====================
+
+function showScreen(screenId) {
+    document.querySelectorAll('.card').forEach(el => el.classList.add('hidden'));
+    const targetScreen = document.getElementById(screenId);
+    if (targetScreen) {
+        targetScreen.classList.remove('hidden');
+        window.scrollTo(0, 0);
+    } else {
+        console.error(`Screen with ID ${screenId} not found`);
+    }
+}
+
+function showError(message) {
+    const errorDiv = document.createElement('div');
+    errorDiv.className = 'error-message';
+    errorDiv.innerHTML = `<i class="fas fa-exclamation-circle"></i><span>${message}</span>`;
+    document.body.prepend(errorDiv);
+    setTimeout(() => { errorDiv.classList.add('fade-out'); setTimeout(() => errorDiv.remove(), 500); }, 5000);
+}
+
+function validateTimestamps() {
+    const t1 = document.getElementById('timestamp1');
+    const t2 = document.getElementById('timestamp2');
+    const t3 = document.getElementById('timestamp3');
+    const analyzeBtn = document.getElementById('analyzeBtn');
+    const isValid = t1.checkValidity() && t2.checkValidity() && t3.checkValidity() && t1.value !== '' && t2.value !== '' && t3.value !== '';
+    analyzeBtn.disabled = !isValid;
+}
+
+function validateTimeOrder(t1, t2, t3) {
+    const toSeconds = t => { const [h, m, s] = t.split(':').map(Number); return h*3600 + m*60 + s; };
+    return toSeconds(t1) < toSeconds(t2) && toSeconds(t2) < toSeconds(t3);
+}
+
+function resetAnalyzeButton() {
+    const btn = document.getElementById('analyzeBtn');
+    btn.disabled = false;
+    btn.innerText = 'Start Analysis';
+    btn.onclick = startAnalysis;
+}
+
+function resetApp() {
+    const preview = document.getElementById('videoPreview');
+    if (preview.src) URL.revokeObjectURL(preview.src);
+        preview.src = '';
+        preview.classList.add('hidden');
+        document.getElementById('videoInput').value = '';
+        const progressBar = document.getElementById('progressBar'); if (progressBar) progressBar.style.width = '0%';
+        const progressMessage = document.getElementById('progressMessage'); if (progressMessage) progressMessage.textContent = '';
+        const spForm = document.getElementById('spCredForm'); if (spForm) spForm.reset();
+    if (progressSource) { progressSource.close(); progressSource = null; }
+        currentFile = null;
+        isSharePointFile = false;
+        spCredentials = {};
+}
+
+async function cancelAnalysis() {
+    try {
+        if (progressSource) {
+            progressSource.close(); 
+            progressSource = null;
+          }
+        if (!analysisAbortController) return;
+        const progressMessage = document.getElementById('progressMessage'); if (progressMessage) progressMessage.textContent = "Cancelling analysis...";
+        analysisAbortController.abort();
+        await fetch(`${API_BASE_URL}/api/cancel-analysis`, { method: 'POST' });
+    } catch (error) {
+        console.error('Cancellation error:', error);
+        throw error;
+    } finally {
+        analysisAbortController = null;
+    }
+}
+
+function setupDownload(blob) {
+    const url = URL.createObjectURL(blob);
+    const downloadBtn = document.getElementById('downloadBtn');
+    downloadBtn.onclick = null;
+    downloadBtn.onclick = () => {
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `stranger_danger_analysis_${new Date().toISOString().slice(0,10)}.csv`;
+        document.body.appendChild(a);
+        a.click();
+        setTimeout(() => { document.body.removeChild(a); URL.revokeObjectURL(url); }, 100);
+    };
+}
+
+// ==================== Global Exports ====================
+
+window.showUploadScreen = showUploadScreen;
+window.handleSpCredSubmit = handleSpCredSubmit;
+window.handleSpFile = handleSpFile;
+window.startAnalysis = startAnalysis;
+window.cancelAnalysis = cancelAnalysis;
+window.resetApp = resetApp;

frontend/static/style.css

@@ -0,0 +1,251 @@
+:root {
+    --primary: #2A2F4F;
+    --secondary: #917FB3;
+    --background: #FDE2F3;
+    --text: #2A2F4F;
+    --success: #4CAF50;
+    --danger: #dc3545;
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: var(--background);
+    color: var(--text);
+    min-height: 100vh;
+    line-height: 1.6;
+    padding: 0;
+    margin: 0;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 2rem;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+}
+
+.card {
+    background: white;
+    border-radius: 1rem;
+    padding: 2rem;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.1);
+    margin: 1rem auto;
+    width: 100%;
+    max-width: 800px;
+}
+
+h1, h2, h3 {
+    color: var(--primary);
+    margin-bottom: 1rem;
+}
+
+.option-grid {
+    display: grid;
+    gap: 1.5rem;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    margin: 2rem 0;
+}
+
+.option-card {
+    padding: 2rem;
+    border: 2px solid var(--primary);
+    border-radius: 1rem;
+    cursor: pointer;
+    transition: transform 0.2s;
+}
+
+.option-card:hover {
+    transform: translateY(-5px);
+}
+
+.btn {
+    background: var(--primary);
+    color: white;
+    border: none;
+    padding: 1rem 2rem;
+    border-radius: 0.5rem;
+    cursor: pointer;
+    font-size: 1rem;
+    transition: transform 0.2s;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.btn:hover {
+    transform: translateY(-2px);
+}
+
+.secondary {
+    background: var(--secondary);
+}
+
+.upload-area {
+    border: 2px dashed var(--primary);
+    border-radius: 1rem;
+    padding: 3rem 2rem;
+    margin: 2rem 0;
+    cursor: pointer;
+}
+
+.preview-container {
+    width: 100%;
+    max-width: 600px;
+    margin: 1rem auto;
+}
+
+#videoPreview {
+    width: 100%;
+    max-width: 100%;
+    border-radius: 0.5rem;
+    display: block;
+    margin: 1rem 0;
+}
+
+.progress-container {
+    width: 100%;
+    margin: 2rem 0;
+}
+
+.progress-bar {
+    height: 20px;
+    background: var(--primary);
+    border-radius: 10px;
+    transition: width 0.3s ease;
+    width: 0%;
+}
+
+.hidden {
+    display: none !important;
+}
+
+.result-badge {
+    font-size: 4rem;
+    color: var(--primary);
+    margin: 2rem 0;
+}
+
+.form-group {
+    margin: 1rem 0;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+}
+
+.form-group input {
+    width: 100%;
+    padding: 0.8rem;
+    border: 1px solid #ddd;
+    border-radius: 0.5rem;
+    font-size: 1rem;
+}
+
+.sp-file-item {
+    padding: 1rem;
+    margin: 0.5rem 0;
+    border: 1px solid #ddd;
+    border-radius: 0.5rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: #fff;
+}
+
+.sp-file-item:hover {
+    background: #f8f9fa;
+}
+
+#analyzeBtn {
+    margin-top: 1rem;
+}
+
+#frameCounter {
+    text-align: center;
+    margin-top: 0.5rem;
+    font-size: 0.9em;
+    color: #666;
+}
+
+#cancelBtn {
+    margin-top: 1rem;
+    background: #dc3545;
+}
+
+#cancelBtn:hover {
+    background: #c82333;
+    transform: translateY(-2px);
+}
+
+.btn.danger {
+    background: #dc3545;
+    color: white;
+}
+
+.btn.danger:hover {
+    background: #c82333;
+    transform: translateY(-2px);
+}
+
+.button-group {
+    display: flex;
+    gap: 1rem;
+    justify-content: center;
+    margin-top: 1.5rem;
+}
+
+/* Add to your existing CSS */
+#progressBar {
+    height: 20px;
+    background: var(--primary);
+    border-radius: 10px;
+    transition: width 0.3s ease;
+    width: 0%;
+}
+
+#frameCounter {
+    display: block;
+    text-align: center;
+    margin-top: 0.5rem;
+    color: var(--text);
+    font-size: 0.9em;
+}
+
+#newAnalysisBtn {
+    margin-top: 1rem;
+}
+
+/* Add to style.css */
+.timestamp-group {
+    display: grid;
+    gap: 1rem;
+    margin: 1.5rem 0;
+}
+
+.timestamp-group .form-group {
+    margin: 0;
+}
+
+input[type="text"] {
+    width: 100%;
+    padding: 0.8rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 1rem;
+}
+
+input:invalid {
+    border-color: #ff4444;
+    box-shadow: 0 0 3px #ff4444;
+}

requirements.txt

@@ -0,0 +1,13 @@
+fastapi>=0.68.0
+uvicorn>=0.15.0
+opencv-python-headless>=4.5.3
+ultralytics>=8.0.0
+mediapipe>=0.8.9.1
+pandas>=1.3.0
+numpy>=1.21.0
+python-multipart>=0.0.5
+aiohttp>=3.7.4
+office365-rest-python-client>=2.3.12
+ffmpeg>=0.2.0
+joblib>=1.4.2
+scikit-learn>=1.6.1