pull from hugging face integration test

.gitignore

@@ -1,41 +0,0 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
-
-node_modules/
-dist/
-dist-ssr/
-*.local
-
-# Editor directories and files
-.vscode/
-.idea/
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
-*.py[cod]
-*$py.class
-*.so
-.Python
-venv/
-.venv/
-env/
-.env
-*.egg-info/
-.eggs/
-build/
-Thumbs.db
-
-# Project specific
-focus_guard.db
-static/
-__pycache__/
-docs/

Dockerfile

@@ -1,34 +0,0 @@
-FROM python:3.10-slim
-
-RUN useradd -m -u 1000 user
-ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
-
-ENV PYTHONUNBUFFERED=1
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libglib2.0-0 libsm6 libxrender1 libxext6 libxcb1 libgl1 libgomp1 \
-    ffmpeg libavcodec-dev libavformat-dev libavutil-dev libswscale-dev \
-    libavdevice-dev libopus-dev libvpx-dev libsrtp2-dev \
-    build-essential nodejs npm git \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
-
-COPY requirements.txt ./
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-RUN npm install && npm run build && mkdir -p /app/static && cp -R dist/* /app/static/
-
-ENV FOCUSGUARD_CACHE_DIR=/app/.cache/focusguard
-RUN python -c "from models.face_mesh import _ensure_model; _ensure_model()"
-
-RUN mkdir -p /app/data && chown -R user:user /app
-
-USER user
-EXPOSE 7860
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--log-level", "debug"]

README.md

@@ -1,94 +1,10 @@
 ---
-title: FocusGuard
+title: IntegrationTest
+emoji: 📚
 colorFrom: indigo
 colorTo: purple
 sdk: docker
 pinned: false
 ---
 
-# FocusGuard - Real-Time Focus Detection
-
-A web app that monitors whether you're focused on your screen using your webcam. Combines head pose estimation, eye behaviour analysis, and deep learning gaze tracking to detect attention in real time.
-
-## How It Works
-
-1. **Open the app** and click **Start** - your webcam feed appears with a face mesh overlay.
-2. **Pick a model** from the selector bar (Geometric, XGBoost, L2CS, etc.).
-3. The system analyses each frame and shows **FOCUSED** or **NOT FOCUSED** with a confidence score.
-4. A timeline tracks your focus over time. Session history is saved for review.
-
-## Models
-
-| Model | What it uses | Best for |
-|-------|-------------|----------|
-| **Geometric** | Head pose angles + eye aspect ratio (EAR) | Fast, no ML needed |
-| **XGBoost** | Trained classifier on head/eye features | Balanced accuracy/speed |
-| **MLP** | Neural network on same features | Higher accuracy |
-| **Hybrid** | Weighted MLP + Geometric ensemble | Best head-pose accuracy |
-| **L2CS** | Deep gaze estimation (ResNet50) | Detects eye-only gaze shifts |
-
-## L2CS Gaze Tracking
-
-L2CS-Net predicts where your eyes are looking, not just where your head is pointed. This catches the scenario where your head faces the screen but your eyes wander.
-
-### Standalone mode
-Select **L2CS** as the model - it handles everything.
-
-### Boost mode
-Select any other model, then click the **GAZE** toggle. L2CS runs alongside the base model:
-- Base model handles head pose and eye openness (35% weight)
-- L2CS handles gaze direction (65% weight)
-- If L2CS detects gaze is clearly off-screen, it **vetoes** the base model regardless of score
-
-### Calibration
-After enabling L2CS or Gaze Boost, click **Calibrate** while a session is running:
-1. A fullscreen overlay shows 9 target dots (3x3 grid)
-2. Look at each dot as the progress ring fills
-3. The first dot (centre) sets your baseline gaze offset
-4. After all 9 points, a polynomial model maps your gaze angles to screen coordinates
-5. A cyan tracking dot appears on the video showing where you're looking
-
-## Tech Stack
-
-- **Backend**: FastAPI + WebSocket, Python 3.10
-- **Frontend**: React + Vite
-- **Face detection**: MediaPipe Face Landmarker (478 landmarks)
-- **Gaze estimation**: L2CS-Net (ResNet50, Gaze360 weights)
-- **ML models**: XGBoost, PyTorch MLP
-- **Deployment**: Docker on Hugging Face Spaces
-
-## Running Locally
-
-```bash
-# install Python deps
-pip install -r requirements.txt
-
-# install frontend deps and build
-npm install && npm run build
-
-# start the server
-uvicorn main:app --port 8000
-```
-
-Open `http://localhost:8000` in your browser.
-
-## Project Structure
-
-```
-main.py                     # FastAPI app, WebSocket handler, API endpoints
-ui/pipeline.py              # All focus detection pipelines (Geometric, MLP, XGBoost, Hybrid, L2CS)
-models/
-  face_mesh.py              # MediaPipe face landmark detector
-  head_pose.py              # Head pose estimation from landmarks
-  eye_scorer.py             # EAR/eye behaviour scoring
-  gaze_calibration.py       # 9-point polynomial gaze calibration
-  gaze_eye_fusion.py        # Fuses calibrated gaze with eye openness
-  L2CS-Net/                 # In-tree L2CS-Net repo with Gaze360 weights
-src/
-  components/
-    FocusPageLocal.jsx      # Main focus page (camera, controls, model selector)
-    CalibrationOverlay.jsx  # Fullscreen calibration UI
-  utils/
-    VideoManagerLocal.js    # WebSocket client, frame capture, canvas rendering
-Dockerfile                  # Docker build for HF Spaces
-```
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

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

checkpoints/hybrid_focus_config.json

@@ -1,10 +0,0 @@
-{
-  "w_mlp": 0.6000000000000001,
-  "w_geo": 0.3999999999999999,
-  "threshold": 0.35,
-  "use_yawn_veto": true,
-  "geo_face_weight": 0.4,
-  "geo_eye_weight": 0.6,
-  "mar_yawn_threshold": 0.55,
-  "metric": "f1"
-}

checkpoints/meta_best.npz

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

checkpoints/mlp_best.pt

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

checkpoints/model_best.joblib

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

checkpoints/scaler_best.joblib

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

data/CNN/eye_crops/val/open/.gitkeep

@@ -1 +0,0 @@
-

data/README.md

@@ -1,47 +0,0 @@
-# data/
-
-Raw collected session data used for model training and evaluation.
-
-## 1. Contents
-
-Each `collected_<name>/` folder contains `.npz` files for one participant:
-
-| Folder | Participant | Samples |
-|--------|-------------|---------|
-| `collected_Abdelrahman/` | Abdelrahman | 15,870 |
-| `collected_Jarek/` | Jarek | 14,829 |
-| `collected_Junhao/` | Junhao | 8,901 |
-| `collected_Kexin/` | Kexin | 32,312 (2 sessions) |
-| `collected_Langyuan/` | Langyuan | 15,749 |
-| `collected_Mohamed/` | Mohamed | 13,218 |
-| `collected_Yingtao/` | Yingtao | 17,591 |
-| `collected_ayten/` | Ayten | 17,621 |
-| `collected_saba/` | Saba | 8,702 |
-| **Total** | **9 participants** | **144,793** |
-
-## 2. File Format
-
-Each `.npz` file contains:
-
-| Key | Shape | Description |
-|-----|-------|-------------|
-| `features` | (N, 17) | 17-dimensional feature vectors (float32) |
-| `labels` | (N,) | Binary labels: 0 = unfocused, 1 = focused |
-| `feature_names` | (17,) | Column names for the 17 features |
-
-## 3. Feature List
-
-`ear_left`, `ear_right`, `ear_avg`, `h_gaze`, `v_gaze`, `mar`, `yaw`, `pitch`, `roll`, `s_face`, `s_eye`, `gaze_offset`, `head_deviation`, `perclos`, `blink_rate`, `closure_duration`, `yawn_duration`
-
-10 of these are selected for training (see `data_preparation/prepare_dataset.py`).
-
-## 4. Collection
-
-```bash
-python -m models.collect_features --name yourname
-```
-
-1. Webcam opens with live overlay
-2. Press **1** = focused, **0** = unfocused (switch every 10–30 sec)
-3. Press **p** to pause/resume
-4. Press **q** to stop and save

data/collected_Abdelrahman/abdelrahman_20260306_023035.npz

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

data/collected_Jarek/Jarek_20260225_012931.npz

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

data/collected_Junhao/Junhao_20260303_113554.npz

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

data/collected_Kexin/kexin2_20260305_180229.npz

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

data/collected_Kexin/kexin_20260224_151043.npz

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

data/collected_Langyuan/Langyuan_20260303_153145.npz

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

data/collected_Mohamed/session_20260224_010131.npz

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

data/collected_Yingtao/Yingtao_20260306_023937.npz

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

data/collected_ayten/ayten_session_1.npz

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

data/collected_saba/saba_20260306_230710.npz

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

data_preparation/README.md

@@ -1,75 +0,0 @@
-# data_preparation/
-
-Shared data loading, cleaning, and exploratory analysis.
-
-## 1. Files
-
-| File | Description |
-|------|-------------|
-| `prepare_dataset.py` | Central data loading module used by all training scripts and notebooks |
-| `data_exploration.ipynb` | EDA notebook: feature distributions, class balance, correlations |
-
-## 2. prepare_dataset.py
-
-Provides a consistent pipeline for loading raw `.npz` data from `data/`:
-
-| Function | Purpose |
-|----------|---------|
-| `load_all_pooled(model_name)` | Load all participants, clean, select features, concatenate |
-| `load_per_person(model_name)` | Load grouped by person (for LOPO cross-validation) |
-| `get_numpy_splits(model_name)` | Load + stratified 70/15/15 split + StandardScaler |
-| `get_dataloaders(model_name)` | Same as above, wrapped in PyTorch DataLoaders |
-| `_split_and_scale(features, labels, ...)` | Reusable split + optional scaling |
-
-### Cleaning rules
-
-- `yaw` clipped to [-45, 45], `pitch`/`roll` to [-30, 30]
-- `ear_left`, `ear_right`, `ear_avg` clipped to [0, 0.85]
-
-### Selected features (face_orientation)
-
-`head_deviation`, `s_face`, `s_eye`, `h_gaze`, `pitch`, `ear_left`, `ear_avg`, `ear_right`, `gaze_offset`, `perclos`
-
-## 3. data_exploration.ipynb
-
-Run from this folder or from the project root. Covers:
-
-1. Per-feature statistics (mean, std, min, max)
-2. Class distribution (focused vs unfocused)
-3. Feature histograms and box plots
-4. Correlation matrix
-
-## 4. How to run
-
-`prepare_dataset.py` is a **library module**, not a standalone script. You don’t run it directly; you import it from code that needs data.
-
-**From repo root:**
-
-```bash
-# Optional: quick test that loading works
-python -c "
-from data_preparation.prepare_dataset import load_all_pooled
-X, y, names = load_all_pooled('face_orientation')
-print(f'Loaded {X.shape[0]} samples, {X.shape[1]} features: {names}')
-"
-```
-
-**Used by:**
-
-- `python -m models.mlp.train`
-- `python -m models.xgboost.train`
-- `notebooks/mlp.ipynb`, `notebooks/xgboost.ipynb`
-- `data_preparation/data_exploration.ipynb`
-
-## 5. Usage (in code)
-
-```python
-from data_preparation.prepare_dataset import load_all_pooled, get_numpy_splits
-
-# pooled data
-X, y, names = load_all_pooled("face_orientation")
-
-# ready-to-train splits
-splits, n_features, n_classes, scaler = get_numpy_splits("face_orientation")
-X_train, y_train = splits["X_train"], splits["y_train"]
-```

data_preparation/prepare_dataset.py

@@ -1,232 +0,0 @@
-import os
-import glob
-
-import numpy as np
-from sklearn.preprocessing import StandardScaler
-from sklearn.model_selection import train_test_split
-
-try:
-    import torch
-    from torch.utils.data import Dataset, DataLoader
-except ImportError:  # pragma: no cover
-    torch = None
-
-    class Dataset:  # type: ignore
-        pass
-
-    class _MissingTorchDataLoader:  # type: ignore
-        def __init__(self, *args, **kwargs):
-            raise ImportError(
-                "PyTorch not installed"
-            )
-
-    DataLoader = _MissingTorchDataLoader  # type: ignore
-
-DATA_DIR = os.path.join(os.path.dirname(__file__), "..", "data")
-
-SELECTED_FEATURES = {
-    "face_orientation": [
-        'head_deviation', 's_face', 's_eye', 'h_gaze', 'pitch',
-        'ear_left', 'ear_avg', 'ear_right', 'gaze_offset', 'perclos'
-    ],
-    "eye_behaviour": [
-        'ear_left', 'ear_right', 'ear_avg', 'mar',
-        'blink_rate', 'closure_duration', 'perclos', 'yawn_duration'
-    ]
-}
-
-
-class FeatureVectorDataset(Dataset):
-    def __init__(self, features: np.ndarray, labels: np.ndarray):
-        self.features = torch.tensor(features, dtype=torch.float32)
-        self.labels = torch.tensor(labels, dtype=torch.long)
-
-    def __len__(self):
-        return len(self.labels)
-
-    def __getitem__(self, idx):
-        return self.features[idx], self.labels[idx]
-
-
-# ── Low-level helpers ────────────────────────────────────────────────────
-
-def _clean_npz(raw, names):
-    """Apply clipping rules in-place. Shared by all loaders."""
-    for col, lo, hi in [('yaw', -45, 45), ('pitch', -30, 30), ('roll', -30, 30)]:
-        if col in names:
-            raw[:, names.index(col)] = np.clip(raw[:, names.index(col)], lo, hi)
-    for feat in ['ear_left', 'ear_right', 'ear_avg']:
-        if feat in names:
-            raw[:, names.index(feat)] = np.clip(raw[:, names.index(feat)], 0, 0.85)
-    return raw
-
-
-def _load_one_npz(npz_path, target_features):
-    """Load a single .npz file, clean and select features. Returns (X, y, selected_feature_names)."""
-    data = np.load(npz_path, allow_pickle=True)
-    raw = data['features'].astype(np.float32)
-    labels = data['labels'].astype(np.int64)
-    names = list(data['feature_names'])
-    raw = _clean_npz(raw, names)
-    selected = [f for f in target_features if f in names]
-    idx = [names.index(f) for f in selected]
-    return raw[:, idx], labels, selected
-
-
-# ── Public data loaders ──────────────────────────────────────────────────
-
-def load_all_pooled(model_name: str = "face_orientation", data_dir: str = None):
-    """Load all collected_*/*.npz, clean, select features, concatenate.
-
-    Returns (X_all, y_all, all_feature_names).
-    """
-    data_dir = data_dir or DATA_DIR
-    target_features = SELECTED_FEATURES.get(model_name, SELECTED_FEATURES["face_orientation"])
-    pattern = os.path.join(data_dir, "collected_*", "*.npz")
-    npz_files = sorted(glob.glob(pattern))
-
-    if not npz_files:
-        print("[DATA] Warning: No .npz files found. Falling back to synthetic.")
-        X, y = _generate_synthetic_data(model_name)
-        return X, y, target_features
-
-    all_X, all_y = [], []
-    all_names = None
-    for npz_path in npz_files:
-        X, y, names = _load_one_npz(npz_path, target_features)
-        if all_names is None:
-            all_names = names
-        all_X.append(X)
-        all_y.append(y)
-        print(f"[DATA]   + {os.path.basename(npz_path)}: {X.shape[0]} samples")
-
-    X_all = np.concatenate(all_X, axis=0)
-    y_all = np.concatenate(all_y, axis=0)
-    print(f"[DATA] Loaded {len(npz_files)} file(s) for '{model_name}': "
-          f"{X_all.shape[0]} total samples, {X_all.shape[1]} features")
-    return X_all, y_all, all_names
-
-
-def load_per_person(model_name: str = "face_orientation", data_dir: str = None):
-    """Load collected_*/*.npz grouped by person (folder name).
-
-    Returns dict { person_name: (X, y) } where X/y are per-person numpy arrays.
-    Also returns (X_all, y_all) as pooled data.
-    """
-    data_dir = data_dir or DATA_DIR
-    target_features = SELECTED_FEATURES.get(model_name, SELECTED_FEATURES["face_orientation"])
-    pattern = os.path.join(data_dir, "collected_*", "*.npz")
-    npz_files = sorted(glob.glob(pattern))
-
-    if not npz_files:
-        raise FileNotFoundError(f"No .npz files matching {pattern}")
-
-    by_person = {}
-    all_X, all_y = [], []
-    for npz_path in npz_files:
-        folder = os.path.basename(os.path.dirname(npz_path))
-        person = folder.replace("collected_", "", 1)
-        X, y, _ = _load_one_npz(npz_path, target_features)
-        all_X.append(X)
-        all_y.append(y)
-        if person not in by_person:
-            by_person[person] = []
-        by_person[person].append((X, y))
-        print(f"[DATA]   + {person}/{os.path.basename(npz_path)}: {X.shape[0]} samples")
-
-    for person, chunks in by_person.items():
-        by_person[person] = (
-            np.concatenate([c[0] for c in chunks], axis=0),
-            np.concatenate([c[1] for c in chunks], axis=0),
-        )
-
-    X_all = np.concatenate(all_X, axis=0)
-    y_all = np.concatenate(all_y, axis=0)
-    print(f"[DATA] {len(by_person)} persons, {X_all.shape[0]} total samples, {X_all.shape[1]} features")
-    return by_person, X_all, y_all
-
-
-def load_raw_npz(npz_path):
-    """Load a single .npz without cleaning or feature selection. For exploration notebooks."""
-    data = np.load(npz_path, allow_pickle=True)
-    features = data['features'].astype(np.float32)
-    labels = data['labels'].astype(np.int64)
-    names = list(data['feature_names'])
-    return features, labels, names
-
-
-# ── Legacy helpers (used by models/mlp/train.py and models/xgboost/train.py) ─
-
-def _load_real_data(model_name: str):
-    X, y, _ = load_all_pooled(model_name)
-    return X, y
-
-
-def _generate_synthetic_data(model_name: str):
-    target_features = SELECTED_FEATURES.get(model_name, SELECTED_FEATURES["face_orientation"])
-    n = 500
-    d = len(target_features)
-    c = 2
-    rng = np.random.RandomState(42)
-    features = rng.randn(n, d).astype(np.float32)
-    labels = rng.randint(0, c, size=n).astype(np.int64)
-    print(f"[DATA] Using synthetic data for '{model_name}': {n} samples, {d} features, {c} classes")
-    return features, labels
-
-
-def _split_and_scale(features, labels, split_ratios, seed, scale):
-    """Split data into train/val/test (stratified) and optionally scale."""
-    test_ratio = split_ratios[2]
-    val_ratio = split_ratios[1] / (split_ratios[0] + split_ratios[1])
-
-    X_train_val, X_test, y_train_val, y_test = train_test_split(
-        features, labels, test_size=test_ratio, random_state=seed, stratify=labels,
-    )
-    X_train, X_val, y_train, y_val = train_test_split(
-        X_train_val, y_train_val, test_size=val_ratio, random_state=seed, stratify=y_train_val,
-    )
-
-    scaler = None
-    if scale:
-        scaler = StandardScaler()
-        X_train = scaler.fit_transform(X_train)
-        X_val = scaler.transform(X_val)
-        X_test = scaler.transform(X_test)
-        print("[DATA] Applied StandardScaler (fitted on training split)")
-
-    splits = {
-        "X_train": X_train, "y_train": y_train,
-        "X_val": X_val,     "y_val": y_val,
-        "X_test": X_test,   "y_test": y_test,
-    }
-
-    print(f"[DATA] Split (stratified): train={len(y_train)}, val={len(y_val)}, test={len(y_test)}")
-    return splits, scaler
-
-
-def get_numpy_splits(model_name: str, split_ratios=(0.7, 0.15, 0.15), seed: int = 42, scale: bool = True):
-    """Return raw numpy arrays for non-PyTorch models (e.g. XGBoost)."""
-    features, labels = _load_real_data(model_name)
-    num_features = features.shape[1]
-    num_classes = int(labels.max()) + 1
-    splits, scaler = _split_and_scale(features, labels, split_ratios, seed, scale)
-    return splits, num_features, num_classes, scaler
-
-
-def get_dataloaders(model_name: str, batch_size: int = 32, split_ratios=(0.7, 0.15, 0.15), seed: int = 42, scale: bool = True):
-    """Return PyTorch DataLoaders for neural-network models."""
-    features, labels = _load_real_data(model_name)
-    num_features = features.shape[1]
-    num_classes = int(labels.max()) + 1
-    splits, scaler = _split_and_scale(features, labels, split_ratios, seed, scale)
-
-    train_ds = FeatureVectorDataset(splits["X_train"], splits["y_train"])
-    val_ds   = FeatureVectorDataset(splits["X_val"],   splits["y_val"])
-    test_ds  = FeatureVectorDataset(splits["X_test"],  splits["y_test"])
-
-    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
-    val_loader   = DataLoader(val_ds,   batch_size=batch_size, shuffle=False)
-    test_loader  = DataLoader(test_ds,  batch_size=batch_size, shuffle=False)
-
-    return train_loader, val_loader, test_loader, num_features, num_classes, scaler
-

docker-compose.yml

@@ -1,5 +0,0 @@
-services:
-  focus-guard:
-    build: .
-    ports:
-      - "7860:7860"

download_l2cs_weights.py

@@ -1,37 +0,0 @@
-#!/usr/bin/env python3
-# Downloads L2CS-Net Gaze360 weights into checkpoints/
-
-import os
-import sys
-
-CHECKPOINTS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "checkpoints")
-DEST = os.path.join(CHECKPOINTS_DIR, "L2CSNet_gaze360.pkl")
-GDRIVE_ID = "1dL2Jokb19_SBSHAhKHOxJsmYs5-GoyLo"
-
-
-def main():
-    if os.path.isfile(DEST):
-        print(f"[OK] Weights already at {DEST}")
-        return
-
-    try:
-        import gdown
-    except ImportError:
-        print("gdown not installed. Run: pip install gdown")
-        sys.exit(1)
-
-    os.makedirs(CHECKPOINTS_DIR, exist_ok=True)
-    print(f"Downloading L2CS-Net weights to {DEST} ...")
-    gdown.download(f"https://drive.google.com/uc?id={GDRIVE_ID}", DEST, quiet=False)
-
-    if os.path.isfile(DEST):
-        print(f"[OK] Downloaded ({os.path.getsize(DEST) / 1024 / 1024:.1f} MB)")
-    else:
-        print("[ERR] Download failed. Manual download:")
-        print("  https://drive.google.com/drive/folders/17p6ORr-JQJcw-eYtG2WGNiuS_qVKwdWd")
-        print(f"  Place L2CSNet_gaze360.pkl in {CHECKPOINTS_DIR}/")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

eslint.config.js

@@ -1,29 +0,0 @@
-import js from '@eslint/js'
-import globals from 'globals'
-import reactHooks from 'eslint-plugin-react-hooks'
-import reactRefresh from 'eslint-plugin-react-refresh'
-import { defineConfig, globalIgnores } from 'eslint/config'
-
-export default defineConfig([
-  globalIgnores(['dist']),
-  {
-    files: ['**/*.{js,jsx}'],
-    extends: [
-      js.configs.recommended,
-      reactHooks.configs.flat.recommended,
-      reactRefresh.configs.vite,
-    ],
-    languageOptions: {
-      ecmaVersion: 2020,
-      globals: globals.browser,
-      parserOptions: {
-        ecmaVersion: 'latest',
-        ecmaFeatures: { jsx: true },
-        sourceType: 'module',
-      },
-    },
-    rules: {
-      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
-    },
-  },
-])

evaluation/README.md

@@ -1,46 +0,0 @@
-# evaluation/
-
-Training logs and performance metrics.
-
-## 1. Contents
-
-```
-logs/
-├── face_orientation_training_log.json           # MLP (latest run)
-├── mlp_face_orientation_training_log.json       # MLP (alternate)
-└── xgboost_face_orientation_training_log.json   # XGBoost
-```
-
-## 2. Log Format
-
-Each JSON file records the full training history:
-
-**MLP logs:**
-```json
-{
-  "config": { "epochs": 30, "lr": 0.001, "batch_size": 32, ... },
-  "history": {
-    "train_loss": [0.287, 0.260, ...],
-    "val_loss":   [0.256, 0.245, ...],
-    "train_acc":  [0.889, 0.901, ...],
-    "val_acc":    [0.905, 0.909, ...]
-  },
-  "test": { "accuracy": 0.929, "f1": 0.929, "roc_auc": 0.971 }
-}
-```
-
-**XGBoost logs:**
-```json
-{
-  "config": { "n_estimators": 600, "max_depth": 8, "learning_rate": 0.149, ... },
-  "train_losses": [0.577, ...],
-  "val_losses":   [0.576, ...],
-  "test": { "accuracy": 0.959, "f1": 0.959, "roc_auc": 0.991 }
-}
-```
-
-## 3. Generated By
-
-- `python -m models.mlp.train` → writes MLP log
-- `python -m models.xgboost.train` → writes XGBoost log
-- Notebooks in `notebooks/` also save logs here

index.html

@@ -1,17 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-  <meta charset="UTF-8" />
-  <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>Focus Guard</title>
-  <link href="https://fonts.googleapis.com/css2?family=Nunito:wght@400;700&display=swap" rel="stylesheet">
-</head>
-
-<body>
-  <div id="root"></div>
-  <script type="module" src="/src/main.jsx"></script>
-</body>
-
-</html>

main.py

@@ -1,1210 +0,0 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Optional, List, Any
-import base64
-import cv2
-import numpy as np
-import aiosqlite
-import json
-from datetime import datetime, timedelta
-import math
-import os
-from pathlib import Path
-from typing import Callable
-import asyncio
-import concurrent.futures
-import threading
-
-from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
-from av import VideoFrame
-
-from mediapipe.tasks.python.vision import FaceLandmarksConnections
-from ui.pipeline import (
-    FaceMeshPipeline, MLPPipeline, HybridFocusPipeline, XGBoostPipeline,
-    L2CSPipeline, is_l2cs_weights_available,
-)
-from models.face_mesh import FaceMeshDetector
-
-# ================ FACE MESH DRAWING (server-side, for WebRTC) ================
-
-_FONT = cv2.FONT_HERSHEY_SIMPLEX
-_CYAN = (255, 255, 0)
-_GREEN = (0, 255, 0)
-_MAGENTA = (255, 0, 255)
-_ORANGE = (0, 165, 255)
-_RED = (0, 0, 255)
-_WHITE = (255, 255, 255)
-_LIGHT_GREEN = (144, 238, 144)
-
-_TESSELATION_CONNS = [(c.start, c.end) for c in FaceLandmarksConnections.FACE_LANDMARKS_TESSELATION]
-_CONTOUR_CONNS = [(c.start, c.end) for c in FaceLandmarksConnections.FACE_LANDMARKS_CONTOURS]
-_LEFT_EYEBROW = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
-_RIGHT_EYEBROW = [300, 293, 334, 296, 336, 285, 295, 282, 283, 276]
-_NOSE_BRIDGE = [6, 197, 195, 5, 4, 1, 19, 94, 2]
-_LIPS_OUTER = [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 409, 270, 269, 267, 0, 37, 39, 40, 185, 61]
-_LIPS_INNER = [78, 95, 88, 178, 87, 14, 317, 402, 318, 324, 308, 415, 310, 311, 312, 13, 82, 81, 80, 191, 78]
-_LEFT_EAR_POINTS = [33, 160, 158, 133, 153, 145]
-_RIGHT_EAR_POINTS = [362, 385, 387, 263, 373, 380]
-
-
-def _lm_px(lm, idx, w, h):
-    return (int(lm[idx, 0] * w), int(lm[idx, 1] * h))
-
-
-def _draw_polyline(frame, lm, indices, w, h, color, thickness):
-    for i in range(len(indices) - 1):
-        cv2.line(frame, _lm_px(lm, indices[i], w, h), _lm_px(lm, indices[i + 1], w, h), color, thickness, cv2.LINE_AA)
-
-
-def _draw_face_mesh(frame, lm, w, h):
-    """Draw tessellation, contours, eyebrows, nose, lips, eyes, irises, gaze lines."""
-    # Tessellation (gray triangular grid, semi-transparent)
-    overlay = frame.copy()
-    for s, e in _TESSELATION_CONNS:
-        cv2.line(overlay, _lm_px(lm, s, w, h), _lm_px(lm, e, w, h), (200, 200, 200), 1, cv2.LINE_AA)
-    cv2.addWeighted(overlay, 0.3, frame, 0.7, 0, frame)
-    # Contours
-    for s, e in _CONTOUR_CONNS:
-        cv2.line(frame, _lm_px(lm, s, w, h), _lm_px(lm, e, w, h), _CYAN, 1, cv2.LINE_AA)
-    # Eyebrows
-    _draw_polyline(frame, lm, _LEFT_EYEBROW, w, h, _LIGHT_GREEN, 2)
-    _draw_polyline(frame, lm, _RIGHT_EYEBROW, w, h, _LIGHT_GREEN, 2)
-    # Nose
-    _draw_polyline(frame, lm, _NOSE_BRIDGE, w, h, _ORANGE, 1)
-    # Lips
-    _draw_polyline(frame, lm, _LIPS_OUTER, w, h, _MAGENTA, 1)
-    _draw_polyline(frame, lm, _LIPS_INNER, w, h, (200, 0, 200), 1)
-    # Eyes
-    left_pts = np.array([_lm_px(lm, i, w, h) for i in FaceMeshDetector.LEFT_EYE_INDICES], dtype=np.int32)
-    cv2.polylines(frame, [left_pts], True, _GREEN, 2, cv2.LINE_AA)
-    right_pts = np.array([_lm_px(lm, i, w, h) for i in FaceMeshDetector.RIGHT_EYE_INDICES], dtype=np.int32)
-    cv2.polylines(frame, [right_pts], True, _GREEN, 2, cv2.LINE_AA)
-    # EAR key points
-    for indices in [_LEFT_EAR_POINTS, _RIGHT_EAR_POINTS]:
-        for idx in indices:
-            cv2.circle(frame, _lm_px(lm, idx, w, h), 3, (0, 255, 255), -1, cv2.LINE_AA)
-    # Irises + gaze lines
-    for iris_idx, eye_inner, eye_outer in [
-        (FaceMeshDetector.LEFT_IRIS_INDICES, 133, 33),
-        (FaceMeshDetector.RIGHT_IRIS_INDICES, 362, 263),
-    ]:
-        iris_pts = np.array([_lm_px(lm, i, w, h) for i in iris_idx], dtype=np.int32)
-        center = iris_pts[0]
-        if len(iris_pts) >= 5:
-            radii = [np.linalg.norm(iris_pts[j] - center) for j in range(1, 5)]
-            radius = max(int(np.mean(radii)), 2)
-            cv2.circle(frame, tuple(center), radius, _MAGENTA, 2, cv2.LINE_AA)
-            cv2.circle(frame, tuple(center), 2, _WHITE, -1, cv2.LINE_AA)
-        eye_cx = int((lm[eye_inner, 0] + lm[eye_outer, 0]) / 2.0 * w)
-        eye_cy = int((lm[eye_inner, 1] + lm[eye_outer, 1]) / 2.0 * h)
-        dx, dy = center[0] - eye_cx, center[1] - eye_cy
-        cv2.line(frame, tuple(center), (int(center[0] + dx * 3), int(center[1] + dy * 3)), _RED, 1, cv2.LINE_AA)
-
-
-def _draw_hud(frame, result, model_name):
-    """Draw status bar and detail overlay matching live_demo.py."""
-    h, w = frame.shape[:2]
-    is_focused = result["is_focused"]
-    status = "FOCUSED" if is_focused else "NOT FOCUSED"
-    color = _GREEN if is_focused else _RED
-
-    # Top bar
-    cv2.rectangle(frame, (0, 0), (w, 55), (0, 0, 0), -1)
-    cv2.putText(frame, status, (10, 28), _FONT, 0.8, color, 2, cv2.LINE_AA)
-    cv2.putText(frame, model_name.upper(), (w - 150, 28), _FONT, 0.45, _WHITE, 1, cv2.LINE_AA)
-
-    # Detail line
-    conf = result.get("mlp_prob", result.get("raw_score", 0.0))
-    mar_s = f" MAR:{result['mar']:.2f}" if result.get("mar") is not None else ""
-    sf = result.get("s_face", 0)
-    se = result.get("s_eye", 0)
-    detail = f"conf:{conf:.2f} S_face:{sf:.2f} S_eye:{se:.2f}{mar_s}"
-    cv2.putText(frame, detail, (10, 48), _FONT, 0.4, _WHITE, 1, cv2.LINE_AA)
-
-    # Head pose (top right)
-    if result.get("yaw") is not None:
-        cv2.putText(frame, f"yaw:{result['yaw']:+.0f} pitch:{result['pitch']:+.0f} roll:{result['roll']:+.0f}",
-                    (w - 280, 48), _FONT, 0.4, (180, 180, 180), 1, cv2.LINE_AA)
-
-    # Yawn indicator
-    if result.get("is_yawning"):
-        cv2.putText(frame, "YAWN", (10, 75), _FONT, 0.7, _ORANGE, 2, cv2.LINE_AA)
-
-# Landmark indices used for face mesh drawing on client (union of all groups).
-# Sending only these instead of all 478 saves ~60% of the landmarks payload.
-_MESH_INDICES = sorted(set(
-    [10,338,297,332,284,251,389,356,454,323,361,288,397,365,379,378,400,377,152,148,176,149,150,136,172,58,132,93,234,127,162,21,54,103,67,109]  # face oval
-    + [33,7,163,144,145,153,154,155,133,173,157,158,159,160,161,246]  # left eye
-    + [362,382,381,380,374,373,390,249,263,466,388,387,386,385,384,398]  # right eye
-    + [468,469,470,471,472, 473,474,475,476,477]  # irises
-    + [70,63,105,66,107,55,65,52,53,46]  # left eyebrow
-    + [300,293,334,296,336,285,295,282,283,276]  # right eyebrow
-    + [6,197,195,5,4,1,19,94,2]  # nose bridge
-    + [61,146,91,181,84,17,314,405,321,375,291,409,270,269,267,0,37,39,40,185]  # lips outer
-    + [78,95,88,178,87,14,317,402,318,324,308,415,310,311,312,13,82,81,80,191]  # lips inner
-    + [33,160,158,133,153,145]  # left EAR key points
-    + [362,385,387,263,373,380]  # right EAR key points
-))
-# Build a lookup: original_index -> position in sparse array, so client can reconstruct.
-_MESH_INDEX_SET = set(_MESH_INDICES)
-
-# Initialize FastAPI app
-app = FastAPI(title="Focus Guard API")
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global variables
-db_path = "focus_guard.db"
-pcs = set()
-_cached_model_name = "mlp"  # in-memory cache, updated via /api/settings
-_l2cs_boost_enabled = False  # when True, L2CS runs alongside the base model
-
-async def _wait_for_ice_gathering(pc: RTCPeerConnection):
-    if pc.iceGatheringState == "complete":
-        return
-    done = asyncio.Event()
-
-    @pc.on("icegatheringstatechange")
-    def _on_state_change():
-        if pc.iceGatheringState == "complete":
-            done.set()
-
-    await done.wait()
-
-# ================ DATABASE MODELS ================
-
-async def init_database():
-    """Initialize SQLite database with required tables"""
-    async with aiosqlite.connect(db_path) as db:
-        # FocusSessions table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS focus_sessions (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                start_time TIMESTAMP NOT NULL,
-                end_time TIMESTAMP,
-                duration_seconds INTEGER DEFAULT 0,
-                focus_score REAL DEFAULT 0.0,
-                total_frames INTEGER DEFAULT 0,
-                focused_frames INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        """)
-
-        # FocusEvents table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS focus_events (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                session_id INTEGER NOT NULL,
-                timestamp TIMESTAMP NOT NULL,
-                is_focused BOOLEAN NOT NULL,
-                confidence REAL NOT NULL,
-                detection_data TEXT,
-                FOREIGN KEY (session_id) REFERENCES focus_sessions (id)
-            )
-        """)
-
-        # UserSettings table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS user_settings (
-                id INTEGER PRIMARY KEY CHECK (id = 1),
-                sensitivity INTEGER DEFAULT 6,
-                notification_enabled BOOLEAN DEFAULT 1,
-                notification_threshold INTEGER DEFAULT 30,
-                frame_rate INTEGER DEFAULT 30,
-                model_name TEXT DEFAULT 'mlp'
-            )
-        """)
-
-        # Insert default settings if not exists
-        await db.execute("""
-            INSERT OR IGNORE INTO user_settings (id, sensitivity, notification_enabled, notification_threshold, frame_rate, model_name)
-            VALUES (1, 6, 1, 30, 30, 'mlp')
-        """)
-
-        await db.commit()
-
-# ================ PYDANTIC MODELS ================
-
-class SessionCreate(BaseModel):
-    pass
-
-class SessionEnd(BaseModel):
-    session_id: int
-
-class SettingsUpdate(BaseModel):
-    sensitivity: Optional[int] = None
-    notification_enabled: Optional[bool] = None
-    notification_threshold: Optional[int] = None
-    frame_rate: Optional[int] = None
-    model_name: Optional[str] = None
-    l2cs_boost: Optional[bool] = None
-
-class VideoTransformTrack(VideoStreamTrack):
-    def __init__(self, track, session_id: int, get_channel: Callable[[], Any]):
-        super().__init__()
-        self.track = track
-        self.session_id = session_id
-        self.get_channel = get_channel
-        self.last_inference_time = 0
-        self.min_inference_interval = 1 / 60
-        self.last_frame = None
-
-    async def recv(self):
-        frame = await self.track.recv()
-        img = frame.to_ndarray(format="bgr24")
-        if img is None:
-            return frame
-
-        # Normalize size for inference/drawing
-        img = cv2.resize(img, (640, 480))
-
-        now = datetime.now().timestamp()
-        do_infer = (now - self.last_inference_time) >= self.min_inference_interval
-
-        if do_infer:
-            self.last_inference_time = now
-            
-            model_name = _cached_model_name
-            if model_name == "l2cs" and pipelines.get("l2cs") is None:
-                _ensure_l2cs()
-            if model_name not in pipelines or pipelines.get(model_name) is None:
-                model_name = 'mlp'
-            active_pipeline = pipelines.get(model_name)
-
-            if active_pipeline is not None:
-                loop = asyncio.get_event_loop()
-                out = await loop.run_in_executor(
-                    _inference_executor,
-                    _process_frame_safe,
-                    active_pipeline,
-                    img,
-                    model_name,
-                )
-                is_focused = out["is_focused"]
-                confidence = out.get("mlp_prob", out.get("raw_score", 0.0))
-                metadata = {"s_face": out.get("s_face", 0.0), "s_eye": out.get("s_eye", 0.0), "mar": out.get("mar", 0.0), "model": model_name}
-
-                # Draw face mesh + HUD on the video frame
-                h_f, w_f = img.shape[:2]
-                lm = out.get("landmarks")
-                if lm is not None:
-                    _draw_face_mesh(img, lm, w_f, h_f)
-                _draw_hud(img, out, model_name)
-            else:
-                is_focused = False
-                confidence = 0.0
-                metadata = {"model": model_name}
-                cv2.rectangle(img, (0, 0), (img.shape[1], 55), (0, 0, 0), -1)
-                cv2.putText(img, "NO MODEL", (10, 28), _FONT, 0.8, _RED, 2, cv2.LINE_AA)
-        
-            if self.session_id:
-                await store_focus_event(self.session_id, is_focused, confidence, metadata)
-
-            channel = self.get_channel()
-            if channel and channel.readyState == "open":
-                try:
-                    channel.send(json.dumps({"type": "detection", "focused": is_focused, "confidence": round(confidence, 3), "detections": detections}))
-                except Exception:
-                    pass
-
-            self.last_frame = img
-        elif self.last_frame is not None:
-            img = self.last_frame
-
-        new_frame = VideoFrame.from_ndarray(img, format="bgr24")
-        new_frame.pts = frame.pts
-        new_frame.time_base = frame.time_base
-        return new_frame
-
-# ================ DATABASE OPERATIONS ================
-
-async def create_session():
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute(
-            "INSERT INTO focus_sessions (start_time) VALUES (?)",
-            (datetime.now().isoformat(),)
-        )
-        await db.commit()
-        return cursor.lastrowid
-
-async def end_session(session_id: int):
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute(
-            "SELECT start_time, total_frames, focused_frames FROM focus_sessions WHERE id = ?",
-            (session_id,)
-        )
-        row = await cursor.fetchone()
-
-        if not row:
-            return None
-
-        start_time_str, total_frames, focused_frames = row
-        start_time = datetime.fromisoformat(start_time_str)
-        end_time = datetime.now()
-        duration = (end_time - start_time).total_seconds()
-        focus_score = focused_frames / total_frames if total_frames > 0 else 0.0
-
-        await db.execute("""
-            UPDATE focus_sessions
-            SET end_time = ?, duration_seconds = ?, focus_score = ?
-            WHERE id = ?
-        """, (end_time.isoformat(), int(duration), focus_score, session_id))
-
-        await db.commit()
-
-        return {
-            'session_id': session_id,
-            'start_time': start_time_str,
-            'end_time': end_time.isoformat(),
-            'duration_seconds': int(duration),
-            'focus_score': round(focus_score, 3),
-            'total_frames': total_frames,
-            'focused_frames': focused_frames
-        }
-
-async def store_focus_event(session_id: int, is_focused: bool, confidence: float, metadata: dict):
-    async with aiosqlite.connect(db_path) as db:
-        await db.execute("""
-            INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
-            VALUES (?, ?, ?, ?, ?)
-        """, (session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
-
-        await db.execute("""
-            UPDATE focus_sessions
-            SET total_frames = total_frames + 1,
-                focused_frames = focused_frames + ?
-            WHERE id = ?
-        """, (1 if is_focused else 0, session_id))
-        await db.commit()
-
-
-class _EventBuffer:
-    """Buffer focus events in memory and flush to DB in batches to avoid per-frame DB writes."""
-
-    def __init__(self, flush_interval: float = 2.0):
-        self._buf: list = []
-        self._lock = asyncio.Lock()
-        self._flush_interval = flush_interval
-        self._task: asyncio.Task | None = None
-        self._total_frames = 0
-        self._focused_frames = 0
-
-    def start(self):
-        if self._task is None:
-            self._task = asyncio.create_task(self._flush_loop())
-
-    async def stop(self):
-        if self._task:
-            self._task.cancel()
-            try:
-                await self._task
-            except asyncio.CancelledError:
-                pass
-            self._task = None
-        await self._flush()
-
-    def add(self, session_id: int, is_focused: bool, confidence: float, metadata: dict):
-        self._buf.append((session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
-        self._total_frames += 1
-        if is_focused:
-            self._focused_frames += 1
-
-    async def _flush_loop(self):
-        while True:
-            await asyncio.sleep(self._flush_interval)
-            await self._flush()
-
-    async def _flush(self):
-        async with self._lock:
-            if not self._buf:
-                return
-            batch = self._buf[:]
-            total = self._total_frames
-            focused = self._focused_frames
-            self._buf.clear()
-            self._total_frames = 0
-            self._focused_frames = 0
-
-        if not batch:
-            return
-
-        session_id = batch[0][0]
-        try:
-            async with aiosqlite.connect(db_path) as db:
-                await db.executemany("""
-                    INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
-                    VALUES (?, ?, ?, ?, ?)
-                """, batch)
-                await db.execute("""
-                    UPDATE focus_sessions
-                    SET total_frames = total_frames + ?,
-                        focused_frames = focused_frames + ?
-                    WHERE id = ?
-                """, (total, focused, session_id))
-                await db.commit()
-        except Exception as e:
-            print(f"[DB] Flush error: {e}")
-
-# ================ STARTUP/SHUTDOWN ================
-
-pipelines = {
-    "geometric": None,
-    "mlp": None,
-    "hybrid": None,
-    "xgboost": None,
-    "l2cs": None,
-}
-
-# Thread pool for CPU-bound inference so the event loop stays responsive.
-_inference_executor = concurrent.futures.ThreadPoolExecutor(
-    max_workers=4,
-    thread_name_prefix="inference",
-)
-# One lock per pipeline so shared state (TemporalTracker, etc.) is not corrupted when
-# multiple frames are processed in parallel by the thread pool.
-_pipeline_locks = {name: threading.Lock() for name in ("geometric", "mlp", "hybrid", "xgboost", "l2cs")}
-
-_l2cs_load_lock = threading.Lock()
-_l2cs_error: str | None = None
-
-
-def _ensure_l2cs():
-    # lazy-load L2CS on first use, double-checked locking
-    global _l2cs_error
-    if pipelines["l2cs"] is not None:
-        return True
-    with _l2cs_load_lock:
-        if pipelines["l2cs"] is not None:
-            return True
-        if not is_l2cs_weights_available():
-            _l2cs_error = "Weights not found"
-            return False
-        try:
-            pipelines["l2cs"] = L2CSPipeline()
-            _l2cs_error = None
-            print("[OK] L2CSPipeline lazy-loaded")
-            return True
-        except Exception as e:
-            _l2cs_error = str(e)
-            print(f"[ERR] L2CS lazy-load failed: {e}")
-            return False
-
-
-def _process_frame_safe(pipeline, frame, model_name):
-    with _pipeline_locks[model_name]:
-        return pipeline.process_frame(frame)
-
-
-_BOOST_BASE_W = 0.35
-_BOOST_L2CS_W = 0.65
-_BOOST_VETO = 0.38  # L2CS below this -> forced not-focused
-
-
-def _process_frame_with_l2cs_boost(base_pipeline, frame, base_model_name):
-    # run base model
-    with _pipeline_locks[base_model_name]:
-        base_out = base_pipeline.process_frame(frame)
-
-    l2cs_pipe = pipelines.get("l2cs")
-    if l2cs_pipe is None:
-        base_out["boost_active"] = False
-        return base_out
-
-    # run L2CS
-    with _pipeline_locks["l2cs"]:
-        l2cs_out = l2cs_pipe.process_frame(frame)
-
-    base_score = base_out.get("mlp_prob", base_out.get("raw_score", 0.0))
-    l2cs_score = l2cs_out.get("raw_score", 0.0)
-
-    # veto: gaze clearly off-screen overrides base model
-    if l2cs_score < _BOOST_VETO:
-        fused_score = l2cs_score * 0.8
-        is_focused = False
-    else:
-        fused_score = _BOOST_BASE_W * base_score + _BOOST_L2CS_W * l2cs_score
-        is_focused = fused_score >= 0.52
-
-    base_out["raw_score"] = fused_score
-    base_out["is_focused"] = is_focused
-    base_out["boost_active"] = True
-    base_out["base_score"] = round(base_score, 3)
-    base_out["l2cs_score"] = round(l2cs_score, 3)
-
-    if l2cs_out.get("gaze_yaw") is not None:
-        base_out["gaze_yaw"] = l2cs_out["gaze_yaw"]
-        base_out["gaze_pitch"] = l2cs_out["gaze_pitch"]
-
-    return base_out
-
-@app.on_event("startup")
-async def startup_event():
-    global pipelines, _cached_model_name
-    print(" Starting Focus Guard API...")
-    await init_database()
-    # Load cached model name from DB
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT model_name FROM user_settings WHERE id = 1")
-        row = await cursor.fetchone()
-        if row:
-            _cached_model_name = row[0]
-    print("[OK] Database initialized")
-
-    try:
-        pipelines["geometric"] = FaceMeshPipeline()
-        print("[OK] FaceMeshPipeline (geometric) loaded")
-    except Exception as e:
-        print(f"[WARN] FaceMeshPipeline unavailable: {e}")
-
-    try:
-        pipelines["mlp"] = MLPPipeline()
-        print("[OK] MLPPipeline loaded")
-    except Exception as e:
-        print(f"[ERR] Failed to load MLPPipeline: {e}")
-
-    try:
-        pipelines["hybrid"] = HybridFocusPipeline()
-        print("[OK] HybridFocusPipeline loaded")
-    except Exception as e:
-        print(f"[WARN] HybridFocusPipeline unavailable: {e}")
-
-    try:
-        pipelines["xgboost"] = XGBoostPipeline()
-        print("[OK] XGBoostPipeline loaded")
-    except Exception as e:
-        print(f"[ERR] Failed to load XGBoostPipeline: {e}")
-
-    if is_l2cs_weights_available():
-        print("[OK] L2CS weights found — pipeline will be lazy-loaded on first use")
-    else:
-        print("[WARN] L2CS weights not found — l2cs model unavailable")
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    _inference_executor.shutdown(wait=False)
-    print(" Shutting down Focus Guard API...")
-
-# ================ WEBRTC SIGNALING ================
-
-@app.post("/api/webrtc/offer")
-async def webrtc_offer(offer: dict):
-    try:
-        print(f"Received WebRTC offer")
-
-        pc = RTCPeerConnection()
-        pcs.add(pc)
-
-        session_id = await create_session()
-        print(f"Created session: {session_id}")
-
-        channel_ref = {"channel": None}
-
-        @pc.on("datachannel")
-        def on_datachannel(channel):
-            print(f"Data channel opened")
-            channel_ref["channel"] = channel
-
-        @pc.on("track")
-        def on_track(track):
-            print(f"Received track: {track.kind}")
-            if track.kind == "video":
-                local_track = VideoTransformTrack(track, session_id, lambda: channel_ref["channel"])
-                pc.addTrack(local_track)
-                print(f"Video track added")
-
-            @track.on("ended")
-            async def on_ended():
-                print(f"Track ended")
-
-        @pc.on("connectionstatechange")
-        async def on_connectionstatechange():
-            print(f"Connection state changed: {pc.connectionState}")
-            if pc.connectionState in ("failed", "closed", "disconnected"):
-                try:
-                    await end_session(session_id)
-                except Exception as e:
-                    print(f"⚠Error ending session: {e}")
-                pcs.discard(pc)
-                await pc.close()
-
-        await pc.setRemoteDescription(RTCSessionDescription(sdp=offer["sdp"], type=offer["type"]))
-        print(f"Remote description set")
-
-        answer = await pc.createAnswer()
-        await pc.setLocalDescription(answer)
-        print(f"Answer created")
-
-        await _wait_for_ice_gathering(pc)
-        print(f"ICE gathering complete")
-
-        return {"sdp": pc.localDescription.sdp, "type": pc.localDescription.type, "session_id": session_id}
-
-    except Exception as e:
-        print(f"WebRTC offer error: {e}")
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"WebRTC error: {str(e)}")
-
-# ================ WEBSOCKET ================
-
-@app.websocket("/ws/video")
-async def websocket_endpoint(websocket: WebSocket):
-    from models.gaze_calibration import GazeCalibration
-    from models.gaze_eye_fusion import GazeEyeFusion
-
-    await websocket.accept()
-    session_id = None
-    frame_count = 0
-    running = True
-    event_buffer = _EventBuffer(flush_interval=2.0)
-
-    # Calibration state (per-connection)
-    _cal: dict = {"cal": None, "collecting": False, "fusion": None}
-
-    # Latest frame slot — only the most recent frame is kept, older ones are dropped.
-    _slot = {"frame": None}
-    _frame_ready = asyncio.Event()
-
-    async def _receive_loop():
-        """Receive messages as fast as possible. Binary = frame, text = control."""
-        nonlocal session_id, running
-        try:
-            while running:
-                msg = await websocket.receive()
-                msg_type = msg.get("type", "")
-
-                if msg_type == "websocket.disconnect":
-                    running = False
-                    _frame_ready.set()
-                    return
-
-                # Binary message → JPEG frame (fast path, no base64)
-                raw_bytes = msg.get("bytes")
-                if raw_bytes is not None and len(raw_bytes) > 0:
-                    _slot["frame"] = raw_bytes
-                    _frame_ready.set()
-                    continue
-
-                # Text message → JSON control command (or legacy base64 frame)
-                text = msg.get("text")
-                if not text:
-                    continue
-                data = json.loads(text)
-
-                if data["type"] == "frame":
-                    _slot["frame"] = base64.b64decode(data["image"])
-                    _frame_ready.set()
-
-                elif data["type"] == "start_session":
-                    session_id = await create_session()
-                    event_buffer.start()
-                    for p in pipelines.values():
-                        if p is not None and hasattr(p, "reset_session"):
-                            p.reset_session()
-                    await websocket.send_json({"type": "session_started", "session_id": session_id})
-
-                elif data["type"] == "end_session":
-                    if session_id:
-                        await event_buffer.stop()
-                        summary = await end_session(session_id)
-                        if summary:
-                            await websocket.send_json({"type": "session_ended", "summary": summary})
-                        session_id = None
-
-                # ---- Calibration commands ----
-                elif data["type"] == "calibration_start":
-                    loop = asyncio.get_event_loop()
-                    await loop.run_in_executor(_inference_executor, _ensure_l2cs)
-                    _cal["cal"] = GazeCalibration()
-                    _cal["collecting"] = True
-                    _cal["fusion"] = None
-                    cal = _cal["cal"]
-                    await websocket.send_json({
-                        "type": "calibration_started",
-                        "num_points": cal.num_points,
-                        "target": list(cal.current_target),
-                        "index": cal.current_index,
-                    })
-
-                elif data["type"] == "calibration_next":
-                    cal = _cal.get("cal")
-                    if cal is not None:
-                        more = cal.advance()
-                        if more:
-                            await websocket.send_json({
-                                "type": "calibration_point",
-                                "target": list(cal.current_target),
-                                "index": cal.current_index,
-                            })
-                        else:
-                            _cal["collecting"] = False
-                            ok = cal.fit()
-                            if ok:
-                                _cal["fusion"] = GazeEyeFusion(cal)
-                                await websocket.send_json({"type": "calibration_done", "success": True})
-                            else:
-                                await websocket.send_json({"type": "calibration_done", "success": False, "error": "Not enough samples"})
-
-                elif data["type"] == "calibration_cancel":
-                    _cal["cal"] = None
-                    _cal["collecting"] = False
-                    _cal["fusion"] = None
-                    await websocket.send_json({"type": "calibration_cancelled"})
-
-        except WebSocketDisconnect:
-            running = False
-            _frame_ready.set()
-        except Exception as e:
-            print(f"[WS] receive error: {e}")
-            running = False
-            _frame_ready.set()
-
-    async def _process_loop():
-        """Process only the latest frame, dropping stale ones."""
-        nonlocal frame_count, running
-        loop = asyncio.get_event_loop()
-        while running:
-            await _frame_ready.wait()
-            _frame_ready.clear()
-            if not running:
-                return
-
-            raw = _slot["frame"]
-            _slot["frame"] = None
-            if raw is None:
-                continue
-
-            try:
-                nparr = np.frombuffer(raw, np.uint8)
-                frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-                if frame is None:
-                    continue
-                frame = cv2.resize(frame, (640, 480))
-
-                # During calibration collection, always use L2CS
-                collecting = _cal.get("collecting", False)
-                if collecting:
-                    if pipelines.get("l2cs") is None:
-                        await loop.run_in_executor(_inference_executor, _ensure_l2cs)
-                    use_model = "l2cs" if pipelines.get("l2cs") is not None else _cached_model_name
-                else:
-                    use_model = _cached_model_name
-
-                model_name = use_model
-                if model_name == "l2cs" and pipelines.get("l2cs") is None:
-                    await loop.run_in_executor(_inference_executor, _ensure_l2cs)
-                if model_name not in pipelines or pipelines.get(model_name) is None:
-                    model_name = "mlp"
-                active_pipeline = pipelines.get(model_name)
-
-                # L2CS boost: run L2CS alongside base model
-                use_boost = (
-                    _l2cs_boost_enabled
-                    and model_name != "l2cs"
-                    and pipelines.get("l2cs") is not None
-                    and not collecting
-                )
-
-                landmarks_list = None
-                out = None
-                if active_pipeline is not None:
-                    if use_boost:
-                        out = await loop.run_in_executor(
-                            _inference_executor,
-                            _process_frame_with_l2cs_boost,
-                            active_pipeline,
-                            frame,
-                            model_name,
-                        )
-                    else:
-                        out = await loop.run_in_executor(
-                            _inference_executor,
-                            _process_frame_safe,
-                            active_pipeline,
-                            frame,
-                            model_name,
-                        )
-                    is_focused = out["is_focused"]
-                    confidence = out.get("mlp_prob", out.get("raw_score", 0.0))
-
-                    lm = out.get("landmarks")
-                    if lm is not None:
-                        landmarks_list = [
-                            [round(float(lm[i, 0]), 3), round(float(lm[i, 1]), 3)]
-                            for i in range(lm.shape[0])
-                        ]
-
-                    # Calibration sample collection (L2CS gaze angles)
-                    if collecting and _cal.get("cal") is not None:
-                        pipe_yaw = out.get("gaze_yaw")
-                        pipe_pitch = out.get("gaze_pitch")
-                        if pipe_yaw is not None and pipe_pitch is not None:
-                            _cal["cal"].collect_sample(pipe_yaw, pipe_pitch)
-
-                    # Gaze fusion (when L2CS active + calibration fitted)
-                    fusion = _cal.get("fusion")
-                    if (
-                        fusion is not None
-                        and model_name == "l2cs"
-                        and out.get("gaze_yaw") is not None
-                    ):
-                        fuse = fusion.update(
-                            out["gaze_yaw"], out["gaze_pitch"], lm
-                        )
-                        is_focused = fuse["focused"]
-                        confidence = fuse["focus_score"]
-
-                    if session_id:
-                        metadata = {
-                            "s_face": out.get("s_face", 0.0),
-                            "s_eye": out.get("s_eye", 0.0),
-                            "mar": out.get("mar", 0.0),
-                            "model": model_name,
-                        }
-                        event_buffer.add(session_id, is_focused, confidence, metadata)
-                else:
-                    is_focused = False
-                    confidence = 0.0
-
-                resp = {
-                    "type": "detection",
-                    "focused": is_focused,
-                    "confidence": round(confidence, 3),
-                    "model": model_name,
-                    "fc": frame_count,
-                }
-                if out is not None:
-                    if out.get("yaw") is not None:
-                        resp["yaw"] = round(out["yaw"], 1)
-                        resp["pitch"] = round(out["pitch"], 1)
-                        resp["roll"] = round(out["roll"], 1)
-                    if out.get("mar") is not None:
-                        resp["mar"] = round(out["mar"], 3)
-                    resp["sf"] = round(out.get("s_face", 0), 3)
-                    resp["se"] = round(out.get("s_eye", 0), 3)
-
-                    # Gaze fusion fields (L2CS standalone or boost mode)
-                    fusion = _cal.get("fusion")
-                    has_gaze = out.get("gaze_yaw") is not None
-                    if fusion is not None and has_gaze and (model_name == "l2cs" or use_boost):
-                        fuse = fusion.update(out["gaze_yaw"], out["gaze_pitch"], out.get("landmarks"))
-                        resp["gaze_x"] = fuse["gaze_x"]
-                        resp["gaze_y"] = fuse["gaze_y"]
-                        resp["on_screen"] = fuse["on_screen"]
-                        if model_name == "l2cs":
-                            resp["focused"] = fuse["focused"]
-                            resp["confidence"] = round(fuse["focus_score"], 3)
-
-                    if out.get("boost_active"):
-                        resp["boost"] = True
-                        resp["base_score"] = out.get("base_score", 0)
-                        resp["l2cs_score"] = out.get("l2cs_score", 0)
-
-                if landmarks_list is not None:
-                    resp["lm"] = landmarks_list
-                await websocket.send_json(resp)
-                frame_count += 1
-            except Exception as e:
-                print(f"[WS] process error: {e}")
-
-    try:
-        await asyncio.gather(_receive_loop(), _process_loop())
-    except Exception:
-        pass
-    finally:
-        running = False
-        if session_id:
-            await event_buffer.stop()
-            await end_session(session_id)
-
-# ================ API ENDPOINTS ================
-
-@app.post("/api/sessions/start")
-async def api_start_session():
-    session_id = await create_session()
-    return {"session_id": session_id}
-
-@app.post("/api/sessions/end")
-async def api_end_session(data: SessionEnd):
-    summary = await end_session(data.session_id)
-    if not summary: raise HTTPException(status_code=404, detail="Session not found")
-    return summary
-
-@app.get("/api/sessions")
-async def get_sessions(filter: str = "all", limit: int = 50, offset: int = 0):
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-
-        # NEW: If importing/exporting all, remove limit if special flag or high limit
-        # For simplicity: if limit is -1, return all
-        limit_clause = "LIMIT ? OFFSET ?"
-        params = []
-        
-        base_query = "SELECT * FROM focus_sessions"
-        where_clause = ""
-        
-        if filter == "today":
-            date_filter = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "week":
-            date_filter = datetime.now() - timedelta(days=7)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "month":
-            date_filter = datetime.now() - timedelta(days=30)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "all":
-            # Just ensure we only get completed sessions or all sessions
-            where_clause = " WHERE end_time IS NOT NULL"
-
-        query = f"{base_query}{where_clause} ORDER BY start_time DESC"
-        
-        # Handle Limit for Exports
-        if limit == -1: 
-            # No limit clause for export
-            pass
-        else:
-            query += f" {limit_clause}"
-            params.extend([limit, offset])
-
-        cursor = await db.execute(query, tuple(params))
-        rows = await cursor.fetchall()
-        return [dict(row) for row in rows]
-
-# --- NEW: Import Endpoint ---
-@app.post("/api/import")
-async def import_sessions(sessions: List[dict]):
-    count = 0
-    try:
-        async with aiosqlite.connect(db_path) as db:
-            for session in sessions:
-                # Use .get() to handle potential missing fields from older versions or edits
-                await db.execute("""
-                    INSERT INTO focus_sessions (start_time, end_time, duration_seconds, focus_score, total_frames, focused_frames, created_at)
-                    VALUES (?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    session.get('start_time'),
-                    session.get('end_time'),
-                    session.get('duration_seconds', 0),
-                    session.get('focus_score', 0.0),
-                    session.get('total_frames', 0),
-                    session.get('focused_frames', 0),
-                    session.get('created_at', session.get('start_time'))
-                ))
-                count += 1
-            await db.commit()
-        return {"status": "success", "count": count}
-    except Exception as e:
-        print(f"Import Error: {e}")
-        return {"status": "error", "message": str(e)}
-
-# --- NEW: Clear History Endpoint ---
-@app.delete("/api/history")
-async def clear_history():
-    try:
-        async with aiosqlite.connect(db_path) as db:
-            # Delete events first (foreign key good practice)
-            await db.execute("DELETE FROM focus_events")
-            await db.execute("DELETE FROM focus_sessions")
-            await db.commit()
-        return {"status": "success", "message": "History cleared"}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-@app.get("/api/sessions/{session_id}")
-async def get_session(session_id: int):
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute("SELECT * FROM focus_sessions WHERE id = ?", (session_id,))
-        row = await cursor.fetchone()
-        if not row: raise HTTPException(status_code=404, detail="Session not found")
-        session = dict(row)
-        cursor = await db.execute("SELECT * FROM focus_events WHERE session_id = ? ORDER BY timestamp", (session_id,))
-        events = [dict(r) for r in await cursor.fetchall()]
-        session['events'] = events
-        return session
-
-@app.get("/api/settings")
-async def get_settings():
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute("SELECT * FROM user_settings WHERE id = 1")
-        row = await cursor.fetchone()
-        result = dict(row) if row else {'sensitivity': 6, 'notification_enabled': True, 'notification_threshold': 30, 'frame_rate': 30, 'model_name': 'mlp'}
-        result['l2cs_boost'] = _l2cs_boost_enabled
-        return result
-
-@app.put("/api/settings")
-async def update_settings(settings: SettingsUpdate):
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT id FROM user_settings WHERE id = 1")
-        exists = await cursor.fetchone()
-        if not exists:
-            await db.execute("INSERT INTO user_settings (id, sensitivity) VALUES (1, 6)")
-            await db.commit()
-
-        updates = []
-        params = []
-        if settings.sensitivity is not None:
-            updates.append("sensitivity = ?")
-            params.append(max(1, min(10, settings.sensitivity)))
-        if settings.notification_enabled is not None:
-            updates.append("notification_enabled = ?")
-            params.append(settings.notification_enabled)
-        if settings.notification_threshold is not None:
-            updates.append("notification_threshold = ?")
-            params.append(max(5, min(300, settings.notification_threshold)))
-        if settings.frame_rate is not None:
-            updates.append("frame_rate = ?")
-            params.append(max(5, min(60, settings.frame_rate)))
-        if settings.model_name is not None and settings.model_name in pipelines:
-            if settings.model_name == "l2cs":
-                loop = asyncio.get_event_loop()
-                loaded = await loop.run_in_executor(_inference_executor, _ensure_l2cs)
-                if not loaded:
-                    raise HTTPException(status_code=400, detail=f"L2CS model unavailable: {_l2cs_error}")
-            elif pipelines[settings.model_name] is None:
-                raise HTTPException(status_code=400, detail=f"Model '{settings.model_name}' not loaded")
-            updates.append("model_name = ?")
-            params.append(settings.model_name)
-            global _cached_model_name
-            _cached_model_name = settings.model_name
-
-        if settings.l2cs_boost is not None:
-            global _l2cs_boost_enabled
-            if settings.l2cs_boost:
-                loop = asyncio.get_event_loop()
-                loaded = await loop.run_in_executor(_inference_executor, _ensure_l2cs)
-                if not loaded:
-                    raise HTTPException(status_code=400, detail=f"L2CS boost unavailable: {_l2cs_error}")
-            _l2cs_boost_enabled = settings.l2cs_boost
-
-        if updates:
-            query = f"UPDATE user_settings SET {', '.join(updates)} WHERE id = 1"
-            await db.execute(query, params)
-            await db.commit()
-        return {"status": "success", "updated": len(updates) > 0}
-
-@app.get("/api/stats/summary")
-async def get_stats_summary():
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT COUNT(*) FROM focus_sessions WHERE end_time IS NOT NULL")
-        total_sessions = (await cursor.fetchone())[0]
-        cursor = await db.execute("SELECT SUM(duration_seconds) FROM focus_sessions WHERE end_time IS NOT NULL")
-        total_focus_time = (await cursor.fetchone())[0] or 0
-        cursor = await db.execute("SELECT AVG(focus_score) FROM focus_sessions WHERE end_time IS NOT NULL")
-        avg_focus_score = (await cursor.fetchone())[0] or 0.0
-        cursor = await db.execute("SELECT DISTINCT DATE(start_time) as session_date FROM focus_sessions WHERE end_time IS NOT NULL ORDER BY session_date DESC")
-        dates = [row[0] for row in await cursor.fetchall()]
-
-        streak_days = 0
-        if dates:
-            current_date = datetime.now().date()
-            for i, date_str in enumerate(dates):
-                session_date = datetime.fromisoformat(date_str).date()
-                expected_date = current_date - timedelta(days=i)
-                if session_date == expected_date: streak_days += 1
-                else: break
-        return {
-            'total_sessions': total_sessions,
-            'total_focus_time': int(total_focus_time),
-            'avg_focus_score': round(avg_focus_score, 3),
-            'streak_days': streak_days
-        }
-
-@app.get("/api/models")
-async def get_available_models():
-    """Return model names, statuses, and which is currently active."""
-    statuses = {}
-    errors = {}
-    available = []
-    for name, p in pipelines.items():
-        if name == "l2cs":
-            if p is not None:
-                statuses[name] = "ready"
-                available.append(name)
-            elif is_l2cs_weights_available():
-                statuses[name] = "lazy"
-                available.append(name)
-            elif _l2cs_error:
-                statuses[name] = "error"
-                errors[name] = _l2cs_error
-            else:
-                statuses[name] = "unavailable"
-        elif p is not None:
-            statuses[name] = "ready"
-            available.append(name)
-        else:
-            statuses[name] = "unavailable"
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT model_name FROM user_settings WHERE id = 1")
-        row = await cursor.fetchone()
-        current = row[0] if row else "mlp"
-        if current not in available and available:
-            current = available[0]
-    l2cs_boost_available = (
-        statuses.get("l2cs") in ("ready", "lazy") and current != "l2cs"
-    )
-    return {
-        "available": available,
-        "current": current,
-        "statuses": statuses,
-        "errors": errors,
-        "l2cs_boost": _l2cs_boost_enabled,
-        "l2cs_boost_available": l2cs_boost_available,
-    }
-
-@app.get("/api/l2cs/status")
-async def l2cs_status():
-    """L2CS-specific status: weights available, loaded, and calibration info."""
-    loaded = pipelines.get("l2cs") is not None
-    return {
-        "weights_available": is_l2cs_weights_available(),
-        "loaded": loaded,
-        "error": _l2cs_error,
-    }
-
-@app.get("/api/mesh-topology")
-async def get_mesh_topology():
-    """Return tessellation edge pairs for client-side face mesh drawing (cached by client)."""
-    return {"tessellation": _TESSELATION_CONNS}
-
-@app.get("/health")
-async def health_check():
-    available = [name for name, p in pipelines.items() if p is not None]
-    return {"status": "healthy", "models_loaded": available, "database": os.path.exists(db_path)}
-
-# ================ STATIC FILES (SPA SUPPORT) ================
-
-FRONTEND_DIR = "dist" if os.path.exists("dist/index.html") else "static"
-
-assets_path = os.path.join(FRONTEND_DIR, "assets")
-if os.path.exists(assets_path):
-    app.mount("/assets", StaticFiles(directory=assets_path), name="assets")
-
-@app.get("/{full_path:path}")
-async def serve_react_app(full_path: str, request: Request):
-    if full_path.startswith("api") or full_path.startswith("ws"):
-        raise HTTPException(status_code=404, detail="Not Found")
-    
-    file_path = os.path.join(FRONTEND_DIR, full_path)
-    if os.path.isfile(file_path):
-        return FileResponse(file_path)
-    
-    index_path = os.path.join(FRONTEND_DIR, "index.html")
-    if os.path.exists(index_path):
-        return FileResponse(index_path)
-    else:
-        return {"message": "React app not found. Please run npm run build."}

models/L2CS-Net/.gitignore

@@ -1,140 +0,0 @@
-# Ignore the test data - sensitive
-datasets/
-evaluation/
-output/
-
-# Ignore debugging configurations
-/.vscode
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# Ignore other files
-my.secrets

models/L2CS-Net/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Ahmed Abdelrahman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

models/L2CS-Net/README.md

@@ -1,148 +0,0 @@
-
-
-
- <p align="center">
-  <img src="https://github.com/Ahmednull/Storage/blob/main/gaze.gif" alt="animated" />
-</p>
-
-
-___
-
-# L2CS-Net
-
-The official PyTorch implementation of L2CS-Net for gaze estimation and tracking.
-
-## Installation
-<img src="https://img.shields.io/badge/python%20-%2314354C.svg?&style=for-the-badge&logo=python&logoColor=white"/> <img src="https://img.shields.io/badge/PyTorch%20-%23EE4C2C.svg?&style=for-the-badge&logo=PyTorch&logoColor=white" />
-
-Install package with the following:
-
-```
-pip install git+https://github.com/Ahmednull/L2CS-Net.git@main
-```
-
-Or, you can git clone the repo and install with the following:
-
-```
-pip install [-e] .
-```
-
-Now you should be able to import the package with the following command:
-
-```
-$ python
->>> import l2cs
-```
-
-## Usage
-
-Detect face and predict gaze from webcam
-
-```python
-from l2cs import Pipeline, render
-import cv2
-
-gaze_pipeline = Pipeline(
-    weights=CWD / 'models' / 'L2CSNet_gaze360.pkl',
-    arch='ResNet50',
-    device=torch.device('cpu') # or 'gpu'
-)
- 
-cap = cv2.VideoCapture(cam)
-_, frame = cap.read()    
-
-# Process frame and visualize
-results = gaze_pipeline.step(frame)
-frame = render(frame, results)
-```
-
-## Demo
-* Download the pre-trained models from [here](https://drive.google.com/drive/folders/17p6ORr-JQJcw-eYtG2WGNiuS_qVKwdWd?usp=sharing) and Store it to *models/*.
-*  Run:
-```
- python demo.py \
- --snapshot models/L2CSNet_gaze360.pkl \
- --gpu 0 \
- --cam 0 \
-```
-This means the demo will run using *L2CSNet_gaze360.pkl* pretrained model
-
-## Community Contributions
-
-- [Gaze Detection and Eye Tracking: A How-To Guide](https://blog.roboflow.com/gaze-direction-position/): Use L2CS-Net through a HTTP interface with the open source Roboflow Inference project.
-
-## MPIIGaze
-We provide the code for train and test MPIIGaze dataset with leave-one-person-out evaluation.
-
-### Prepare datasets
-* Download **MPIIFaceGaze dataset** from [here](https://www.mpi-inf.mpg.de/departments/computer-vision-and-machine-learning/research/gaze-based-human-computer-interaction/its-written-all-over-your-face-full-face-appearance-based-gaze-estimation).
-* Apply data preprocessing from [here](http://phi-ai.buaa.edu.cn/Gazehub/3D-dataset/).
-* Store the dataset to *datasets/MPIIFaceGaze*.
-
-### Train
-```
- python train.py \
- --dataset mpiigaze \
- --snapshot output/snapshots \
- --gpu 0 \
- --num_epochs 50 \
- --batch_size 16 \
- --lr 0.00001 \
- --alpha 1 \
-
-```
-This means the code will perform leave-one-person-out training automatically and store the models to *output/snapshots*.
-
-### Test
-```
- python test.py \
- --dataset mpiigaze \
- --snapshot output/snapshots/snapshot_folder \
- --evalpath evaluation/L2CS-mpiigaze  \
- --gpu 0 \
-```
-This means the code will perform leave-one-person-out testing automatically and store the results to *evaluation/L2CS-mpiigaze*.
-
-To get the average leave-one-person-out accuracy use:
-```
- python leave_one_out_eval.py \
- --evalpath evaluation/L2CS-mpiigaze  \
- --respath evaluation/L2CS-mpiigaze  \
-```
-This means the code will take the evaluation path and outputs the leave-one-out gaze accuracy to the *evaluation/L2CS-mpiigaze*.
-
-## Gaze360
-We provide the code for train and test Gaze360 dataset with train-val-test evaluation.
-
-### Prepare datasets
-* Download **Gaze360 dataset** from [here](http://gaze360.csail.mit.edu/download.php).
-
-* Apply data preprocessing from [here](http://phi-ai.buaa.edu.cn/Gazehub/3D-dataset/).
-
-* Store the dataset to *datasets/Gaze360*.
-
-
-### Train
-```
- python train.py \
- --dataset gaze360 \
- --snapshot output/snapshots \
- --gpu 0 \
- --num_epochs 50 \
- --batch_size 16 \
- --lr 0.00001 \
- --alpha 1 \
-
-```
-This means the code will perform training and store the models to *output/snapshots*.
-
-### Test
-```
- python test.py \
- --dataset gaze360 \
- --snapshot output/snapshots/snapshot_folder \
- --evalpath evaluation/L2CS-gaze360  \
- --gpu 0 \
-```
-This means the code will perform testing on snapshot_folder and store the results to *evaluation/L2CS-gaze360*.
-

models/L2CS-Net/demo.py

@@ -1,87 +0,0 @@
-import argparse
-import pathlib
-import numpy as np
-import cv2
-import time
-
-import torch
-import torch.nn as nn
-from torch.autograd import Variable
-from torchvision import transforms
-import torch.backends.cudnn as cudnn
-import torchvision
-
-from PIL import Image
-from PIL import Image, ImageOps
-
-from face_detection import RetinaFace
-
-from l2cs import select_device, draw_gaze, getArch, Pipeline, render
-
-CWD = pathlib.Path.cwd()
-
-def parse_args():
-    """Parse input arguments."""
-    parser = argparse.ArgumentParser(
-        description='Gaze evalution using model pretrained with L2CS-Net on Gaze360.')
-    parser.add_argument(
-        '--device',dest='device', help='Device to run model: cpu or gpu:0',
-        default="cpu", type=str)
-    parser.add_argument(
-        '--snapshot',dest='snapshot', help='Path of model snapshot.', 
-        default='output/snapshots/L2CS-gaze360-_loader-180-4/_epoch_55.pkl', type=str)
-    parser.add_argument(
-        '--cam',dest='cam_id', help='Camera device id to use [0]',  
-        default=0, type=int)
-    parser.add_argument(
-        '--arch',dest='arch',help='Network architecture, can be: ResNet18, ResNet34, ResNet50, ResNet101, ResNet152',
-        default='ResNet50', type=str)
-
-    args = parser.parse_args()
-    return args
-
-if __name__ == '__main__':
-    args = parse_args()
-
-    cudnn.enabled = True
-    arch=args.arch
-    cam = args.cam_id
-    # snapshot_path = args.snapshot
-
-    gaze_pipeline = Pipeline(
-        weights=CWD / 'models' / 'L2CSNet_gaze360.pkl',
-        arch='ResNet50',
-        device = select_device(args.device, batch_size=1)
-    )
-     
-    cap = cv2.VideoCapture(cam)
-
-    # Check if the webcam is opened correctly
-    if not cap.isOpened():
-        raise IOError("Cannot open webcam")
-
-    with torch.no_grad():
-        while True:
-
-            # Get frame
-            success, frame = cap.read()    
-            start_fps = time.time()  
-
-            if not success:
-                print("Failed to obtain frame")
-                time.sleep(0.1)
-
-            # Process frame
-            results = gaze_pipeline.step(frame)
-
-            # Visualize output
-            frame = render(frame, results)
-           
-            myFPS = 1.0 / (time.time() - start_fps)
-            cv2.putText(frame, 'FPS: {:.1f}'.format(myFPS), (10, 20),cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 255, 0), 1, cv2.LINE_AA)
-
-            cv2.imshow("Demo",frame)
-            if cv2.waitKey(1) & 0xFF == ord('q'):
-                break
-            success,frame = cap.read()  
-    

models/L2CS-Net/l2cs/__init__.py

@@ -1,21 +0,0 @@
-from .utils import select_device, natural_keys, gazeto3d, angular, getArch
-from .vis import draw_gaze, render
-from .model import L2CS
-from .pipeline import Pipeline
-from .datasets import Gaze360, Mpiigaze
-
-__all__ = [
-    # Classes
-    'L2CS',
-    'Pipeline',
-    'Gaze360',
-    'Mpiigaze',
-    # Utils
-    'render',
-    'select_device',
-    'draw_gaze',
-    'natural_keys',
-    'gazeto3d',
-    'angular',
-    'getArch'
-]

models/L2CS-Net/l2cs/datasets.py

@@ -1,157 +0,0 @@
-import os
-import numpy as np
-import cv2
-
-
-import torch
-from torch.utils.data.dataset import Dataset
-from torchvision import transforms
-from PIL import Image, ImageFilter
-
-
-class Gaze360(Dataset):
-    def __init__(self, path, root, transform, angle, binwidth, train=True):
-        self.transform = transform
-        self.root = root
-        self.orig_list_len = 0
-        self.angle = angle
-        if train==False:
-          angle=90
-        self.binwidth=binwidth
-        self.lines = []
-        if isinstance(path, list):
-            for i in path:
-                with open(i) as f:
-                    print("here")
-                    line = f.readlines()
-                    line.pop(0)
-                    self.lines.extend(line)
-        else:
-            with open(path) as f:
-                lines = f.readlines()
-                lines.pop(0)
-                self.orig_list_len = len(lines)
-                for line in lines:
-                    gaze2d = line.strip().split(" ")[5]
-                    label = np.array(gaze2d.split(",")).astype("float")
-                    if abs((label[0]*180/np.pi)) <= angle and abs((label[1]*180/np.pi)) <= angle:
-                        self.lines.append(line)
-                    
-                        
-        print("{} items removed from dataset that have an angle > {}".format(self.orig_list_len-len(self.lines), angle))
-
-    def __len__(self):
-        return len(self.lines)
-
-    def __getitem__(self, idx):
-        line = self.lines[idx]
-        line = line.strip().split(" ")
-
-        face = line[0]
-        lefteye = line[1]
-        righteye = line[2]
-        name = line[3]
-        gaze2d = line[5]
-        label = np.array(gaze2d.split(",")).astype("float")
-        label = torch.from_numpy(label).type(torch.FloatTensor)
-
-        pitch = label[0]* 180 / np.pi
-        yaw = label[1]* 180 / np.pi
-
-        img = Image.open(os.path.join(self.root, face))
-
-        # fimg = cv2.imread(os.path.join(self.root, face))
-        # fimg = cv2.resize(fimg, (448, 448))/255.0
-        # fimg = fimg.transpose(2, 0, 1)
-        # img=torch.from_numpy(fimg).type(torch.FloatTensor)
-
-        if self.transform:
-            img = self.transform(img)        
-        
-        # Bin values
-        bins = np.array(range(-1*self.angle, self.angle, self.binwidth))
-        binned_pose = np.digitize([pitch, yaw], bins) - 1
-
-        labels = binned_pose
-        cont_labels = torch.FloatTensor([pitch, yaw])
-        
-
-        return img, labels, cont_labels, name
-
-class Mpiigaze(Dataset): 
-  def __init__(self, pathorg, root, transform, train, angle,fold=0):
-    self.transform = transform
-    self.root = root
-    self.orig_list_len = 0
-    self.lines = []
-    path=pathorg.copy()
-    if train==True:
-      path.pop(fold)
-    else:
-      path=path[fold]
-    if isinstance(path, list):
-        for i in path:
-            with open(i) as f:
-                lines = f.readlines()
-                lines.pop(0)
-                self.orig_list_len += len(lines)
-                for line in lines:
-                    gaze2d = line.strip().split(" ")[7]
-                    label = np.array(gaze2d.split(",")).astype("float")
-                    if abs((label[0]*180/np.pi)) <= angle and abs((label[1]*180/np.pi)) <= angle:
-                        self.lines.append(line)
-    else:
-      with open(path) as f:
-        lines = f.readlines()
-        lines.pop(0)
-        self.orig_list_len += len(lines)
-        for line in lines:
-            gaze2d = line.strip().split(" ")[7]
-            label = np.array(gaze2d.split(",")).astype("float")
-            if abs((label[0]*180/np.pi)) <= 42 and abs((label[1]*180/np.pi)) <= 42:
-                self.lines.append(line)
-   
-    print("{} items removed from dataset that have an angle > {}".format(self.orig_list_len-len(self.lines),angle))
-        
-  def __len__(self):
-    return len(self.lines)
-
-  def __getitem__(self, idx):
-    line = self.lines[idx]
-    line = line.strip().split(" ")
-
-    name = line[3]
-    gaze2d = line[7]
-    head2d = line[8]
-    lefteye = line[1]
-    righteye = line[2]
-    face = line[0]
-
-    label = np.array(gaze2d.split(",")).astype("float")
-    label = torch.from_numpy(label).type(torch.FloatTensor)
-
-
-    pitch = label[0]* 180 / np.pi
-    yaw = label[1]* 180 / np.pi
-
-    img = Image.open(os.path.join(self.root, face))
-
-    # fimg = cv2.imread(os.path.join(self.root, face))
-    # fimg = cv2.resize(fimg, (448, 448))/255.0
-    # fimg = fimg.transpose(2, 0, 1)
-    # img=torch.from_numpy(fimg).type(torch.FloatTensor)
-    
-    if self.transform:
-        img = self.transform(img)        
-    
-    # Bin values
-    bins = np.array(range(-42, 42,3))
-    binned_pose = np.digitize([pitch, yaw], bins) - 1
-
-    labels = binned_pose
-    cont_labels = torch.FloatTensor([pitch, yaw])
-
-
-    return img, labels, cont_labels, name
-
-

models/L2CS-Net/l2cs/model.py

@@ -1,73 +0,0 @@
-import torch
-import torch.nn as nn
-from torch.autograd import Variable
-import math
-import torch.nn.functional as F
-
-
-class L2CS(nn.Module):
-    def __init__(self, block, layers, num_bins):
-        self.inplanes = 64
-        super(L2CS, self).__init__()
-        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,bias=False)
-        self.bn1 = nn.BatchNorm2d(64)
-        self.relu = nn.ReLU(inplace=True)
-        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        self.layer1 = self._make_layer(block, 64, layers[0])
-        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
-        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
-        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-
-        self.fc_yaw_gaze = nn.Linear(512 * block.expansion, num_bins)
-        self.fc_pitch_gaze = nn.Linear(512 * block.expansion, num_bins)
-
-       # Vestigial layer from previous experiments
-        self.fc_finetune = nn.Linear(512 * block.expansion + 3, 3)
-
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
-                m.weight.data.normal_(0, math.sqrt(2. / n))
-            elif isinstance(m, nn.BatchNorm2d):
-                m.weight.data.fill_(1)
-                m.bias.data.zero_()
-
-    def _make_layer(self, block, planes, blocks, stride=1):
-        downsample = None
-        if stride != 1 or self.inplanes != planes * block.expansion:
-            downsample = nn.Sequential(
-                nn.Conv2d(self.inplanes, planes * block.expansion,
-                          kernel_size=1, stride=stride, bias=False),
-                nn.BatchNorm2d(planes * block.expansion),
-            )
-
-        layers = []
-        layers.append(block(self.inplanes, planes, stride, downsample))
-        self.inplanes = planes * block.expansion
-        for i in range(1, blocks):
-            layers.append(block(self.inplanes, planes))
-
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.maxpool(x)
-
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-        x = self.avgpool(x)
-        x = x.view(x.size(0), -1)
-
-        
-        # gaze
-        pre_yaw_gaze =  self.fc_yaw_gaze(x)
-        pre_pitch_gaze = self.fc_pitch_gaze(x)
-        return pre_yaw_gaze, pre_pitch_gaze
-
-
-

models/L2CS-Net/l2cs/pipeline.py

@@ -1,133 +0,0 @@
-import pathlib
-from typing import Union
-
-import cv2
-import numpy as np
-import torch
-import torch.nn as nn
-from dataclasses import dataclass
-from face_detection import RetinaFace
-
-from .utils import prep_input_numpy, getArch
-from .results import GazeResultContainer
-
-
-class Pipeline:
-
-    def __init__(
-        self, 
-        weights: pathlib.Path, 
-        arch: str,
-        device: str = 'cpu', 
-        include_detector:bool = True,
-        confidence_threshold:float = 0.5
-        ):
-
-        # Save input parameters
-        self.weights = weights
-        self.include_detector = include_detector
-        self.device = device
-        self.confidence_threshold = confidence_threshold
-
-        # Create L2CS model
-        self.model = getArch(arch, 90)
-        self.model.load_state_dict(torch.load(self.weights, map_location=device))
-        self.model.to(self.device)
-        self.model.eval()
-
-        # Create RetinaFace if requested
-        if self.include_detector:
-
-            if device.type == 'cpu':
-                self.detector = RetinaFace()
-            else:
-                self.detector = RetinaFace(gpu_id=device.index)
-
-            self.softmax = nn.Softmax(dim=1)
-            self.idx_tensor = [idx for idx in range(90)]
-            self.idx_tensor = torch.FloatTensor(self.idx_tensor).to(self.device)
-
-    def step(self, frame: np.ndarray) -> GazeResultContainer:
-
-        # Creating containers
-        face_imgs = []
-        bboxes = []
-        landmarks = []
-        scores = []
-
-        if self.include_detector:
-            faces = self.detector(frame)
-
-            if faces is not None: 
-                for box, landmark, score in faces:
-
-                    # Apply threshold
-                    if score < self.confidence_threshold:
-                        continue
-
-                    # Extract safe min and max of x,y
-                    x_min=int(box[0])
-                    if x_min < 0:
-                        x_min = 0
-                    y_min=int(box[1])
-                    if y_min < 0:
-                        y_min = 0
-                    x_max=int(box[2])
-                    y_max=int(box[3])
-                    
-                    # Crop image
-                    img = frame[y_min:y_max, x_min:x_max]
-                    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                    img = cv2.resize(img, (224, 224))
-                    face_imgs.append(img)
-
-                    # Save data
-                    bboxes.append(box)
-                    landmarks.append(landmark)
-                    scores.append(score)
-
-                # Predict gaze
-                pitch, yaw = self.predict_gaze(np.stack(face_imgs))
-
-            else:
-
-                pitch = np.empty((0,1))
-                yaw = np.empty((0,1))
-
-        else:
-            pitch, yaw = self.predict_gaze(frame)
-
-        # Save data
-        results = GazeResultContainer(
-            pitch=pitch,
-            yaw=yaw,
-            bboxes=np.stack(bboxes),
-            landmarks=np.stack(landmarks),
-            scores=np.stack(scores)
-        )
-
-        return results
-
-    def predict_gaze(self, frame: Union[np.ndarray, torch.Tensor]):
-        
-        # Prepare input
-        if isinstance(frame, np.ndarray):
-            img = prep_input_numpy(frame, self.device)
-        elif isinstance(frame, torch.Tensor):
-            img = frame
-        else:
-            raise RuntimeError("Invalid dtype for input")
-    
-        # Predict 
-        gaze_pitch, gaze_yaw = self.model(img)
-        pitch_predicted = self.softmax(gaze_pitch)
-        yaw_predicted = self.softmax(gaze_yaw)
-        
-        # Get continuous predictions in degrees.
-        pitch_predicted = torch.sum(pitch_predicted.data * self.idx_tensor, dim=1) * 4 - 180
-        yaw_predicted = torch.sum(yaw_predicted.data * self.idx_tensor, dim=1) * 4 - 180
-        
-        pitch_predicted= pitch_predicted.cpu().detach().numpy()* np.pi/180.0
-        yaw_predicted= yaw_predicted.cpu().detach().numpy()* np.pi/180.0
-
-        return pitch_predicted, yaw_predicted

models/L2CS-Net/l2cs/results.py

@@ -1,11 +0,0 @@
-from dataclasses import dataclass
-import numpy as np
-
-@dataclass
-class GazeResultContainer:
-
-    pitch: np.ndarray
-    yaw: np.ndarray
-    bboxes: np.ndarray
-    landmarks: np.ndarray
-    scores: np.ndarray

models/L2CS-Net/l2cs/utils.py

@@ -1,145 +0,0 @@
-import sys
-import os
-import math
-from math import cos, sin
-from pathlib import Path
-import subprocess
-import re
-
-import numpy as np
-import torch
-import torch.nn as nn
-import scipy.io as sio
-import cv2
-import torchvision
-from torchvision import transforms
-
-from .model import L2CS
-        
-transformations = transforms.Compose([
-    transforms.ToPILImage(),
-    transforms.Resize(448),
-    transforms.ToTensor(),
-    transforms.Normalize(
-        mean=[0.485, 0.456, 0.406],
-        std=[0.229, 0.224, 0.225]
-    )
-])
-
-def atoi(text):
-    return int(text) if text.isdigit() else text
-
-def natural_keys(text):
-    '''
-    alist.sort(key=natural_keys) sorts in human order
-    http://nedbatchelder.com/blog/200712/human_sorting.html
-    (See Toothy's implementation in the comments)
-    '''
-    return [ atoi(c) for c in re.split(r'(\d+)', text) ]
-
-def prep_input_numpy(img:np.ndarray, device:str):
-    """Preparing a Numpy Array as input to L2CS-Net."""
-
-    if len(img.shape) == 4:
-        imgs = []
-        for im in img:
-            imgs.append(transformations(im))
-        img = torch.stack(imgs)
-    else:
-        img = transformations(img)
-
-    img = img.to(device)
-
-    if len(img.shape) == 3:
-        img = img.unsqueeze(0)
-
-    return img
-
-def gazeto3d(gaze):
-    gaze_gt = np.zeros([3])
-    gaze_gt[0] = -np.cos(gaze[1]) * np.sin(gaze[0])
-    gaze_gt[1] = -np.sin(gaze[1])
-    gaze_gt[2] = -np.cos(gaze[1]) * np.cos(gaze[0])
-    return gaze_gt
-
-def angular(gaze, label):
-    total = np.sum(gaze * label)
-    return np.arccos(min(total/(np.linalg.norm(gaze)* np.linalg.norm(label)), 0.9999999))*180/np.pi
-
-def select_device(device='', batch_size=None):
-    # device = 'cpu' or '0' or '0,1,2,3'
-    s = f'YOLOv3 🚀 {git_describe() or date_modified()} torch {torch.__version__} '  # string
-    cpu = device.lower() == 'cpu'
-    if cpu:
-        os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # force torch.cuda.is_available() = False
-    elif device:  # non-cpu device requested
-        os.environ['CUDA_VISIBLE_DEVICES'] = device  # set environment variable
-        # assert torch.cuda.is_available(), f'CUDA unavailable, invalid device {device} requested'  # check availability
-
-    cuda = not cpu and torch.cuda.is_available()
-    if cuda:
-        devices = device.split(',') if device else range(torch.cuda.device_count())  # i.e. 0,1,6,7
-        n = len(devices)  # device count
-        if n > 1 and batch_size:  # check batch_size is divisible by device_count
-            assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'
-        space = ' ' * len(s)
-        for i, d in enumerate(devices):
-            p = torch.cuda.get_device_properties(i)
-            s += f"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / 1024 ** 2}MB)\n"  # bytes to MB
-    else:
-        s += 'CPU\n'
-
-    return torch.device('cuda:0' if cuda else 'cpu')
-
-def spherical2cartesial(x):
-    
-    output = torch.zeros(x.size(0),3)
-    output[:,2] = -torch.cos(x[:,1])*torch.cos(x[:,0])
-    output[:,0] = torch.cos(x[:,1])*torch.sin(x[:,0])
-    output[:,1] = torch.sin(x[:,1])
-
-    return output
-    
-def compute_angular_error(input,target):
-
-    input = spherical2cartesial(input)
-    target = spherical2cartesial(target)
-
-    input = input.view(-1,3,1)
-    target = target.view(-1,1,3)
-    output_dot = torch.bmm(target,input)
-    output_dot = output_dot.view(-1)
-    output_dot = torch.acos(output_dot)
-    output_dot = output_dot.data
-    output_dot = 180*torch.mean(output_dot)/math.pi
-    return output_dot
-
-def softmax_temperature(tensor, temperature):
-    result = torch.exp(tensor / temperature)
-    result = torch.div(result, torch.sum(result, 1).unsqueeze(1).expand_as(result))
-    return result
-   
-def git_describe(path=Path(__file__).parent):  # path must be a directory
-    # return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe
-    s = f'git -C {path} describe --tags --long --always'
-    try:
-        return subprocess.check_output(s, shell=True, stderr=subprocess.STDOUT).decode()[:-1]
-    except subprocess.CalledProcessError as e:
-        return ''  # not a git repository
-        
-def getArch(arch,bins):
-    # Base network structure
-    if arch == 'ResNet18':
-        model = L2CS( torchvision.models.resnet.BasicBlock,[2, 2,  2, 2], bins)
-    elif arch == 'ResNet34':
-        model = L2CS( torchvision.models.resnet.BasicBlock,[3, 4,  6, 3], bins)
-    elif arch == 'ResNet101':
-        model = L2CS( torchvision.models.resnet.Bottleneck,[3, 4, 23, 3], bins)
-    elif arch == 'ResNet152':
-        model = L2CS( torchvision.models.resnet.Bottleneck,[3, 8, 36, 3], bins)
-    else:
-        if arch != 'ResNet50':
-            print('Invalid value for architecture is passed! '
-                'The default value of ResNet50 will be used instead!')
-        model = L2CS( torchvision.models.resnet.Bottleneck, [3, 4, 6,  3], bins)
-    return model

models/L2CS-Net/l2cs/vis.py

@@ -1,64 +0,0 @@
-import cv2
-import numpy as np
-from .results import GazeResultContainer
-
-def draw_gaze(a,b,c,d,image_in, pitchyaw, thickness=2, color=(255, 255, 0),sclae=2.0):
-    """Draw gaze angle on given image with a given eye positions."""
-    image_out = image_in
-    (h, w) = image_in.shape[:2]
-    length = c
-    pos = (int(a+c / 2.0), int(b+d / 2.0))
-    if len(image_out.shape) == 2 or image_out.shape[2] == 1:
-        image_out = cv2.cvtColor(image_out, cv2.COLOR_GRAY2BGR)
-    dx = -length * np.sin(pitchyaw[0]) * np.cos(pitchyaw[1])
-    dy = -length * np.sin(pitchyaw[1])
-    cv2.arrowedLine(image_out, tuple(np.round(pos).astype(np.int32)),
-                   tuple(np.round([pos[0] + dx, pos[1] + dy]).astype(int)), color,
-                   thickness, cv2.LINE_AA, tipLength=0.18)
-    return image_out
-
-def draw_bbox(frame: np.ndarray, bbox: np.ndarray):
-    
-    x_min=int(bbox[0])
-    if x_min < 0:
-        x_min = 0
-    y_min=int(bbox[1])
-    if y_min < 0:
-        y_min = 0
-    x_max=int(bbox[2])
-    y_max=int(bbox[3])
-
-    cv2.rectangle(frame, (x_min, y_min), (x_max, y_max), (0,255,0), 1)
-
-    return frame
-
-def render(frame: np.ndarray, results: GazeResultContainer):
-
-    # Draw bounding boxes
-    for bbox in results.bboxes:
-        frame = draw_bbox(frame, bbox)
-
-    # Draw Gaze
-    for i in range(results.pitch.shape[0]):
-
-        bbox = results.bboxes[i]
-        pitch = results.pitch[i]
-        yaw = results.yaw[i]
-        
-        # Extract safe min and max of x,y
-        x_min=int(bbox[0])
-        if x_min < 0:
-            x_min = 0
-        y_min=int(bbox[1])
-        if y_min < 0:
-            y_min = 0
-        x_max=int(bbox[2])
-        y_max=int(bbox[3])
-
-        # Compute sizes
-        bbox_width = x_max - x_min
-        bbox_height = y_max - y_min
-
-        draw_gaze(x_min,y_min,bbox_width, bbox_height,frame,(pitch,yaw),color=(0,0,255))
-
-    return frame

models/L2CS-Net/leave_one_out_eval.py

@@ -1,54 +0,0 @@
-import os
-import argparse
-
-
-
-def parse_args():
-    """Parse input arguments."""
-    parser = argparse.ArgumentParser(
-        description='gaze estimation using binned loss function.')
-    parser.add_argument(
-        '--evalpath', dest='evalpath', help='path for evaluating gaze test.',
-        default="evaluation\L2CS-gaze360-_standard-10", type=str)
-    parser.add_argument(
-        '--respath', dest='respath', help='path for saving result.',
-        default="evaluation\L2CS-gaze360-_standard-10", type=str)
-
-if __name__ == '__main__':
-
-    args = parse_args()
-    evalpath =args.evalpath
-    respath=args.respath
-    if not os.path.exist(respath):
-            os.makedirs(respath)
-    with open(os.path.join(respath,"avg.log"), 'w') as outfile:    
-        outfile.write("Average equal\n")
-
-        min=10.0
-        dirlist = os.listdir(evalpath)
-        dirlist.sort()
-        l=0.0
-        for j in range(50):
-            j=20
-            avg=0.0
-            h=j+3
-            for i in dirlist:
-                with open(evalpath+"/"+i+"/mpiigaze_binned.log") as myfile:
-                    
-                    x=list(myfile)[h]
-                    str1 = "" 
-                    
-                    # traverse in the string  
-                    for ele in x: 
-                        str1 += ele  
-                    split_string = str1.split("MAE:",1)[1] 
-                    avg+=float(split_string)
-
-            avg=avg/15.0
-            if avg<min:
-                min=avg
-                l=j+1
-            outfile.write("epoch"+str(j+1)+"= "+str(avg)+"\n")
-
-        outfile.write("min angular error equal= "+str(min)+"at epoch= "+str(l)+"\n")
-    print(min)

models/L2CS-Net/models/L2CSNet_gaze360.pkl

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

models/L2CS-Net/models/README.md

@@ -1 +0,0 @@
-# Path to pre-trained models

models/L2CS-Net/pyproject.toml

@@ -1,44 +0,0 @@
-[project]
-name = "l2cs"
-version = "0.0.1"
-description = "The official PyTorch implementation of L2CS-Net for gaze estimation and tracking"
-authors = [
-    {name = "Ahmed Abderlrahman"},
-    {name = "Thorsten Hempel"}
-]
-license = {file = "LICENSE.txt"}
-readme = "README.md"
-requires-python = ">3.6"
-
-keywords = ["gaze", "estimation", "eye-tracking", "deep-learning", "pytorch"]
-
-classifiers = [
-    "Programming Language :: Python :: 3"
-]
-
-dependencies = [
-    'matplotlib>=3.3.4',
-    'numpy>=1.19.5',
-    'opencv-python>=4.5.5',
-    'pandas>=1.1.5',
-    'Pillow>=8.4.0',
-    'scipy>=1.5.4',
-    'torch>=1.10.1',
-    'torchvision>=0.11.2',
-    'face_detection@git+https://github.com/elliottzheng/face-detection'
-]
-
-[project.urls]
-homepath = "https://github.com/Ahmednull/L2CS-Net"
-repository = "https://github.com/Ahmednull/L2CS-Net"
-
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
-
-# https://setuptools.pypa.io/en/stable/userguide/datafiles.html
-[tool.setuptools]
-include-package-data = true
-
-[tool.setuptools.packages.find]
-where = ["."]