Upload folder using huggingface_hub

.gitattributes

@@ -0,0 +1,2 @@
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,214 +1,129 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[codz]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-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/
-cover/
-
-# 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
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .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
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-#poetry.toml
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
-#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
-#pdm.lock
-#pdm.toml
-.pdm-python
-.pdm-build/
-
-# pixi
-#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
-#pixi.lock
-#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
-#   in the .venv directory. It is recommended not to include this directory in version control.
-.pixi
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.envrc
-.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/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-# Abstra
-# Abstra is an AI-powered process automation framework.
-# Ignore directories containing user credentials, local state, and settings.
-# Learn more at https://abstra.io/docs
-.abstra/
-
-# Visual Studio Code
-#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
-#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
-#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
-#  you could uncomment the following to ignore the entire vscode folder
-# .vscode/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
-
-# Cursor
-#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
-#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
-#  refer to https://docs.cursor.com/context/ignore-files
-.cursorignore
-.cursorindexingignore
-
-# Marimo
-marimo/_static/
-marimo/_lsp/
-__marimo__/
-
-
-*.pt
-*.pth
-data/gallery/
-data/videos/
-outputs/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.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/
+cover/
+
+# 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
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+.pdm-python
+.pdm-build/
+.pixi
+__pypackages__/
+
+celerybeat-schedule
+celerybeat.pid
+
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+.spyderproject
+.spyproject
+.ropeproject
+/site
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pyre/
+.pytype/
+cython_debug/
+.abstra/
+.ruff_cache/
+.pypirc
+.cursorignore
+.cursorindexingignore
+
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+data/gallery/
+data/videos/
+outputs/
+
+fix_*.py
+test_nl.py
+test_picture/

Dockerfile

@@ -1,22 +1,22 @@
-FROM python:3.10-slim
-
-RUN apt-get update && apt-get install -y \
-    libgl1 \
-    libglib2.0-0 \
-    libsm6 \
-    libxext6 \
-    libxrender1 \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-RUN mkdir -p data/gallery data/videos outputs models
-
-EXPOSE 7860
-
-CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p data/gallery data/videos outputs models
+
+EXPOSE 7860
+
+CMD ["python", "api/main.py"]

LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Abu-Sameer
-
-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.
+MIT License
+
+Copyright (c) 2026 Abu-Sameer
+
+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.

Procfile

@@ -0,0 +1 @@
+web: uvicorn api.main:app --host 0.0.0.0 --port $PORT

README.md

@@ -1,9 +1,350 @@
----
-title: PhantomEye
-emoji: 👁
-colorFrom: green
-colorTo: gray
-sdk: docker
-app_file: app.py
-pinned: false
----
+<div align="center">
+
+<img src="https://capsule-render.vercel.app/api?type=waving&color=0:0a0a0a,50:1a0040,100:0d1f0d&height=300&section=header&text=📷%20PhantomEye&fontSize=75&fontColor=00ff88&animation=fadeIn&fontAlignY=38&desc=AI-Powered%20Surveillance%20Intelligence%20System&descSize=18&descAlignY=58&descAlign=50&descColor=00aa55" width="100%"/>
+
+<br/>
+
+<img src="https://readme-typing-svg.herokuapp.com?font=JetBrains+Mono&weight=700&size=22&pause=1000&color=00FF88&center=true&vCenter=true&width=900&lines=Person+Detection+%7C+ByteTrack+Multi-Object+Tracking;Deep+ReID+OSNet+—+Rank-1+81.7%25+mAP+58.5%25;Emotion+Intelligence+—+Age+%7C+Gender+%7C+Emotion;Weapon+Detection+—+9+Classes+mAP50+53.2%25;Natural+Language+Queries+—+English+%2B+Roman+Urdu;OSINT+Privacy+Audit+—+Exposure+Score+0%E2%80%93100" />
+
+<br/><br/>
+
+<a href="https://abu-sameer-66-phantomeye.hf.space">
+<img src="https://img.shields.io/badge/%F0%9F%9F%A2%20LIVE%20DEMO-HuggingFace%20Spaces-00ff88?style=for-the-badge&labelColor=0d1f0d"/>
+</a>
+&nbsp;
+<a href="https://phantomeye-production.up.railway.app/docs">
+<img src="https://img.shields.io/badge/%F0%9F%93%A1%20API%20DOCS-Railway-00aa55?style=for-the-badge&labelColor=003322"/>
+</a>
+&nbsp;
+<a href="https://medium.com/@sameerdataanalyst66/i-built-an-ai-that-watches-tracks-and-audits-phantomeye-is-live-afe2f62bcb7b">
+<img src="https://img.shields.io/badge/%F0%9F%93%96%20MEDIUM-Full%20Article-00ff88?style=for-the-badge&labelColor=0d1f0d"/>
+</a>
+&nbsp;
+<a href="https://github.com/Abu-Sameer-66/PhantomEye/blob/main/LICENSE">
+<img src="https://img.shields.io/badge/License-MIT-003322?style=for-the-badge&labelColor=0d1f0d"/>
+</a>
+
+<br/><br/>
+
+<img src="https://img.shields.io/badge/YOLOv8-Detection-00ff88?style=flat-square&logo=pytorch&logoColor=black&labelColor=0d1f0d"/>
+<img src="https://img.shields.io/badge/ByteTrack-Multi--Object%20Tracking-00aa55?style=flat-square&labelColor=003322"/>
+<img src="https://img.shields.io/badge/OSNet-Deep%20ReID%20Rank--1%2081.7%25-00ff88?style=flat-square&logo=pytorch&logoColor=black&labelColor=0d1f0d"/>
+<img src="https://img.shields.io/badge/DeepFace-Emotion%20Intelligence-00aa55?style=flat-square&labelColor=003322"/>
+<img src="https://img.shields.io/badge/Groq%20LLaMA3-NL%20Query%20Engine-00ff88?style=flat-square&labelColor=0d1f0d"/>
+<img src="https://img.shields.io/badge/YOLOv8%20Custom-Weapon%20Detection-00aa55?style=flat-square&labelColor=003322"/>
+<img src="https://img.shields.io/badge/FastAPI-8%20Endpoints-00ff88?style=flat-square&logo=fastapi&logoColor=white&labelColor=0d1f0d"/>
+<img src="https://img.shields.io/badge/Docker-Containerized-00aa55?style=flat-square&logo=docker&logoColor=white&labelColor=003322"/>
+<img src="https://img.shields.io/badge/Python-3.10-00ff88?style=flat-square&logo=python&logoColor=black&labelColor=0d1f0d"/>
+
+</div>
+
+---
+
+## What is PhantomEye?
+
+Most computer vision projects stop at detection. They draw a box around a person and call it done. The box appears. The box disappears. Nothing is remembered. Nothing is understood.
+
+**PhantomEye goes further.**
+
+It is a full-stack AI surveillance intelligence platform that transforms passive camera feeds into a live reasoning engine — detecting, tracking, analyzing behavior, auditing identity, recognizing emotion, querying in natural language, and detecting weapons, all in one unified system.
+
+Built entirely from scratch. Trained on real datasets. Deployed live. Zero pre-loaded data.
+
+---
+
+## Intelligence Modules
+
+<table>
+<tr>
+<td width="50%">
+
+### 📷 Person Detection
+YOLOv8-nano configured for class-0 only. Returns bounding boxes and confidence scores on standard CPU in milliseconds. No GPU required at inference time.
+
+### 🎯 Multi-Object Tracking
+Custom ByteTrack with IOU matching. Each person receives a persistent color-coded ID with trajectory trail — across frames, through occlusion, across re-entries.
+
+### 🔥 Behavioral Heatmap
+NumPy position accumulation builds a live heatmap of human movement. High-activity zones appear red. Dwell time tracked per person in seconds. Loitering alerts fire automatically.
+
+### 🧠 Deep Person Re-ID
+OSNet x0.25 trained from scratch on Market-1501 (12,936 images, 751 identities). **Rank-1: 81.7% — mAP: 58.5%.** Identifies the same person across camera networks using body appearance alone — no face required.
+
+</td>
+<td width="50%">
+
+### 😶 Emotion Intelligence
+DeepFace pipeline — detects age, gender, and dominant emotion per face. Powered by TensorFlow with OpenCV face detector backend. Optimized for CPU deployment.
+
+### 💬 Natural Language Query Engine
+Groq LLaMA 3 powered query parser. Ask questions in plain English or Roman Urdu — the system extracts structured filters automatically. First open-source surveillance system with multilingual NL query support.
+
+### 🔫 Weapon Detection
+YOLOv8 custom trained on 9 weapon classes — Handgun, Knife, Shotgun, Sniper, Automatic Rifle, SMG, Sword, Bazooka, Grenade Launcher. **mAP50: 53.2% — Handgun: 89.5% — Shotgun: 96.3% — SMG: 98.6%.** Real-time threat alert on detection.
+
+### 🔍 OSINT Privacy Audit
+Upload a face — get a Privacy Exposure Score from 0 to 100. LBPH embedding search against a reference gallery. Risk classification: LOW / MEDIUM / HIGH.
+
+</td>
+</tr>
+</table>
+
+---
+
+## Benchmark Results
+
+| Module | Model | Metric | Score |
+|:---|:---|:---|:---:|
+| Person Detection | YOLOv8-nano | Confidence | >85% avg |
+| Multi-Object Tracking | ByteTrack | ID Persistence | Across occlusion |
+| Deep Re-ID | OSNet x0.25 | **Rank-1** | **81.7%** |
+| Deep Re-ID | OSNet x0.25 | **mAP** | **58.5%** |
+| Emotion Recognition | DeepFace | Face Detection | OpenCV backend |
+| Weapon Detection | YOLOv8n custom | **mAP50** | **53.2%** |
+| Weapon Detection | YOLOv8n custom | Handgun AP | 89.5% |
+| Weapon Detection | YOLOv8n custom | Shotgun AP | 96.3% |
+| Weapon Detection | YOLOv8n custom | SMG AP | 98.6% |
+| NL Query Engine | Groq LLaMA 3 | Languages | English + Roman Urdu |
+
+---
+
+## Why PhantomEye is Different
+
+| Capability | Typical CV Project | PhantomEye |
+|:---|:---:|:---:|
+| Person detection | ✅ | ✅ YOLOv8-nano |
+| Persistent ID tracking | ❌ | ✅ ByteTrack |
+| Behavioral heatmap | ❌ | ✅ NumPy accumulation |
+| Dwell time analytics | ❌ | ✅ Per-person seconds |
+| Loitering alert | ❌ | ✅ Threshold-based |
+| Deep Re-ID (no face) | ❌ | ✅ OSNet Rank-1 81.7% |
+| Emotion recognition | ❌ | ✅ DeepFace — Age + Gender + Emotion |
+| Weapon detection | ❌ | ✅ 9-class YOLOv8 custom |
+| NL query interface | ❌ | ✅ English + Roman Urdu |
+| OSINT privacy audit | ❌ | ✅ Score 0–100 |
+| Production REST API | ❌ | ✅ 8 endpoints, OAS 3.1 |
+| Live 24/7 deployment | ❌ | ✅ HuggingFace + Railway |
+| Zero pre-loaded data | ❌ | ✅ Privacy-first |
+
+---
+
+## System Architecture
+┌──────────────────────────────────────────────────────┐
+│                     INPUT LAYER                      │
+│    Image Upload  /  Video File  /  RTSP Feed         │
+└────────────────────────┬─────────────────────────────┘
+│
+┌────────────────────────▼─────────────────────────────┐
+│                  VISION PIPELINE                     │
+│                                                      │
+│  YOLOv8-nano ─────── Person Detection                │
+│       │               bbox + confidence              │
+│       │                                              │
+│  ByteTrack ──────── Persistent ID Assignment         │
+│       │              Color trails + occlusion        │
+│       │                                              │
+│  OSNet x0.25 ────── Deep Person Re-ID                │
+│                      Rank-1 81.7% on Market-1501     │
+└────────────────────────┬─────────────────────────────┘
+│
+┌────────────────────────▼─────────────────────────────┐
+│               INTELLIGENCE LAYER                     │
+│                                                      │
+│  Behavioral Analytics                                │
+│  ├── NumPy heatmap accumulation                      │
+│  ├── Per-person dwell time (seconds)                 │
+│  └── Automated loitering alerts                      │
+│                                                      │
+│  Emotion Intelligence                                │
+│  ├── DeepFace — Age + Gender + Emotion               │
+│  └── OpenCV detector backend (CPU optimized)         │
+│                                                      │
+│  Weapon Detection                                    │
+│  ├── YOLOv8 custom — 9 weapon classes                │
+│  └── Real-time threat alert on detection             │
+│                                                      │
+│  NL Query Engine                                     │
+│  ├── Groq LLaMA 3 — query parser                     │
+│  └── English + Roman Urdu → structured filters       │
+│                                                      │
+│  OSINT Audit Engine                                  │
+│  ├── LBPH face embedding extraction                  │
+│  ├── Gallery similarity search                       │
+│  └── Exposure score (0–100) + risk level             │
+└────────────────────────┬─────────────────────────────┘
+│
+┌────────────────────────▼─────────────────────────────┐
+│                   OUTPUT LAYER                       │
+│                                                      │
+│  FastAPI REST API    ── 8 endpoints, OAS 3.1         │
+│  Streamlit Dashboard ── Cyberpunk UI                 │
+│  JSON Reports        ── Exportable audit logs        │
+└──────────────────────────────────────────────────────┘
+
+---
+
+## Live Deployment
+
+| Service | Platform | Status |
+|:---|:---|:---:|
+| [Interactive Dashboard](https://abu-sameer-66-phantomeye.hf.space) | HuggingFace Spaces | 🟢 Live |
+| [REST API](https://phantomeye-production.up.railway.app) | Railway | 🟢 Live |
+| [API Documentation](https://phantomeye-production.up.railway.app/docs) | Railway | 🟢 Live |
+
+---
+
+## API Reference
+
+**Base URL:** `https://phantomeye-production.up.railway.app`
+
+| Method | Endpoint | Description |
+|:---|:---|:---|
+| `GET` | `/` | System info + version |
+| `GET` | `/health` | Live health check |
+| `POST` | `/detect` | Person detection on image |
+| `POST` | `/track/video` | Multi-object tracking on video |
+| `POST` | `/osint/audit` | Privacy exposure audit |
+| `POST` | `/osint/add-to-gallery` | Register person to gallery |
+| `GET` | `/osint/gallery` | List gallery persons |
+| `GET` | `/outputs` | List output files |
+
+**Quick test:**
+```bash
+curl -X POST "https://phantomeye-production.up.railway.app/detect" \
+  -F "file=@crowd.jpg"
+```
+```json
+{
+  "status": "success",
+  "total_persons": 8,
+  "detections": [
+    { "id": 1, "bbox": [120, 80, 310, 420], "confidence": 0.87 },
+    { "id": 2, "bbox": [450, 95, 620, 430], "confidence": 0.74 }
+  ]
+}
+```
+
+---
+
+## Local Setup
+
+```bash
+git clone https://github.com/Abu-Sameer-66/PhantomEye.git
+cd PhantomEye
+
+conda create -n phantomeye python=3.10 -y
+conda activate phantomeye
+pip install -r requirements.txt
+```
+
+```bash
+# Streamlit dashboard
+streamlit run app.py
+
+# FastAPI backend
+python api/main.py
+
+# Detection on image or video
+python core/detection.py
+
+# OSINT audit
+python core/osint.py
+
+# Weapon detection
+python core/weapon.py
+
+# Emotion analysis
+python core/emotion.py
+```
+
+---
+
+## Repository Structure
+PhantomEye/
+├── core/
+│   ├── detection.py        YOLOv8 person detector
+│   ├── tracker.py          ByteTrack multi-object tracker
+│   ├── analytics.py        Heatmap + dwell time + loitering alerts
+│   ├── osint.py            OSINT privacy audit engine
+│   ├── emotion.py          DeepFace emotion + age + gender
+│   ├── reid.py             OSNet deep Re-ID module
+│   ├── weapon.py           YOLOv8 weapon detection
+│   └── nlquery.py          Groq NL query parser
+├── models/
+│   ├── osnet_phantomeye_reid.pth   Trained Re-ID weights
+│   └── weapon_detector.pt          Trained weapon detector
+├── api/
+│   ├── main.py             FastAPI backend — 8 endpoints
+│   └── routes/             Modular route handlers
+├── app.py                  Streamlit dashboard — 7 modules
+├── config.py               Global configuration
+├── Dockerfile              Container deployment
+└── requirements.txt        Dependencies
+
+---
+
+## Real-World Applications
+
+| Domain | Use Case |
+|:---|:---|
+| Law Enforcement | Cross-camera suspect tracking, weapon threat detection, automated evidence extraction |
+| Retail Intelligence | Customer heatmaps, queue monitoring, suspicious behavior detection |
+| Campus Security | Unauthorized access detection, behavioral anomaly alerts |
+| Healthcare | Patient wandering alerts, fall detection, ICU monitoring |
+| Border Security | Weapon screening, person Re-ID across checkpoints |
+| Privacy Research | Digital footprint auditing, OSINT defense tools |
+
+---
+
+## Privacy-First Design
+
+- **Zero pre-loaded data** — no faces, videos, or images in the repository
+- **In-session processing** — uploaded files processed in RAM only, never stored
+- **User-controlled gallery** — only data you explicitly upload is referenced
+- **Ethical OSINT framing** — audit module built for privacy defense, not offense
+- **Fully open source** — every processing step is transparent and auditable
+
+---
+
+## Roadmap
+
+- [x] YOLOv8 person detection — CPU optimized
+- [x] ByteTrack multi-object tracking
+- [x] Behavioral heatmap + loitering alerts
+- [x] OSINT privacy audit engine
+- [x] FastAPI production backend — 8 endpoints
+- [x] Cyberpunk Streamlit dashboard
+- [x] HuggingFace + Railway live deployment
+- [x] DeepFace emotion intelligence module
+- [x] Groq NL query engine — English + Roman Urdu
+- [x] OSNet Deep Re-ID — Rank-1 81.7% on Market-1501
+- [x] YOLOv8 weapon detection — 9 classes mAP50 53.2%
+- [ ] PDF intelligence report generator
+- [ ] JWT authentication + API key management
+- [ ] RTSP live stream support
+- [ ] Anonymization mode — face blur + full analytics
+- [ ] Edge deployment — Raspberry Pi + Jetson Nano
+
+---
+
+## Author
+
+<div align="center">
+
+**Abu Sameer** — AI/ML Engineer · Computer Vision Researcher · GSoC 2026 Contributor
+
+<br/>
+
+<a href="https://sameer-nadeem-portfolio.vercel.app"><img src="https://img.shields.io/badge/Portfolio-sameer--nadeem--portfolio-00ff88?style=for-the-badge&labelColor=0d1f0d"/></a>
+<a href="https://github.com/Abu-Sameer-66"><img src="https://img.shields.io/badge/GitHub-Abu--Sameer--66-00aa55?style=for-the-badge&logo=github&labelColor=003322"/></a>
+<a href="https://www.linkedin.com/in/sameer-nadeem-66339a357/"><img src="https://img.shields.io/badge/LinkedIn-Sameer%20Nadeem-00ff88?style=for-the-badge&logo=linkedin&labelColor=0d1f0d"/></a>
+<a href="https://www.kaggle.com/sameernadeem66"><img src="https://img.shields.io/badge/Kaggle-sameernadeem66-00aa55?style=for-the-badge&logo=kaggle&labelColor=003322"/></a>
+<a href="https://medium.com/@sameerdataanalyst66/i-built-an-ai-that-watches-tracks-and-audits-phantomeye-is-live-afe2f62bcb7b"><img src="https://img.shields.io/badge/Medium-Full%20Article-00ff88?style=for-the-badge&logo=medium&labelColor=0d1f0d"/></a>
+
+</div>
+
+---
+
+<div align="center">
+<img src="https://capsule-render.vercel.app/api?type=waving&color=0:0d1f0d,50:003322,100:0a0a0a&height=120&section=footer" width="100%"/>
+</div>

api/auth.py

@@ -0,0 +1,118 @@
+import os
+import uuid
+import hashlib
+import hmac
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import HTTPException, Security, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+# Config
+SECRET_KEY = os.getenv("SECRET_KEY", "phantomeye-secret-key-change-in-production-2026")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24  # 24 hours
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+bearer_scheme = HTTPBearer()
+
+# In-memory API key store — replace with PostgreSQL in production
+API_KEYS_DB: dict[str, dict] = {}
+
+# Pre-registered demo keys for testing
+DEMO_KEYS = {
+    "PE-DEMO-KEY-2026-FREE": {
+        "client": "demo_user",
+        "tier": "free",
+        "rate_limit": 100,
+        "calls_today": 0,
+        "created_at": datetime.utcnow().isoformat(),
+        "active": True,
+    },
+    "PE-PROD-KEY-2026-PRO": {
+        "client": "pro_user",
+        "tier": "pro",
+        "rate_limit": 10000,
+        "calls_today": 0,
+        "created_at": datetime.utcnow().isoformat(),
+        "active": True,
+    }
+}
+API_KEYS_DB.update(DEMO_KEYS)
+
+
+def generate_api_key(client_name: str, tier: str = "free") -> str:
+    """Generate a unique PhantomEye API key."""
+    unique = str(uuid.uuid4()).replace("-", "").upper()[:16]
+    key = f"PE-{tier.upper()}-{unique}"
+    API_KEYS_DB[key] = {
+        "client": client_name,
+        "tier": tier,
+        "rate_limit": 100 if tier == "free" else 10000,
+        "calls_today": 0,
+        "created_at": datetime.utcnow().isoformat(),
+        "active": True,
+    }
+    return key
+
+
+def validate_api_key(api_key: str) -> dict:
+    """Validate API key and check rate limit."""
+    if api_key not in API_KEYS_DB:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key"
+        )
+    key_data = API_KEYS_DB[api_key]
+    if not key_data["active"]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="API key is disabled"
+        )
+    if key_data["calls_today"] >= key_data["rate_limit"]:
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail=f"Rate limit exceeded — {key_data['rate_limit']} calls/day for {key_data['tier']} tier"
+        )
+    API_KEYS_DB[api_key]["calls_today"] += 1
+    return key_data
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """Create JWT access token."""
+    to_encode = data.copy()
+    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Security(bearer_scheme)) -> dict:
+    """Verify JWT token from Authorization header."""
+    try:
+        payload = jwt.decode(credentials.credentials, SECRET_KEY, algorithms=[ALGORITHM])
+        client = payload.get("sub")
+        if client is None:
+            raise HTTPException(status_code=401, detail="Invalid token")
+        return payload
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid or expired token")
+
+
+def get_api_key_stats() -> dict:
+    """Return stats about all registered API keys."""
+    return {
+        "total_keys": len(API_KEYS_DB),
+        "active_keys": sum(1 for k in API_KEYS_DB.values() if k["active"]),
+        "keys": [
+            {
+                "key": k[:12] + "****",
+                "client": v["client"],
+                "tier": v["tier"],
+                "calls_today": v["calls_today"],
+                "rate_limit": v["rate_limit"],
+                "active": v["active"],
+            }
+            for k, v in API_KEYS_DB.items()
+        ]
+    }

api/main.py

@@ -1,217 +1,272 @@
-import os
-import time
-import shutil
-import uvicorn
-from pathlib import Path
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse, FileResponse
-
-import sys
-sys.path.append(str(Path(__file__).resolve().parent.parent))
-
-from core.detection import PersonDetector
-from core.tracker import ByteTracker
-from core.osint import OSINTAudit
-from config import OUTPUTS_DIR, GALLERY_DIR, API_HOST, API_PORT
-
-app = FastAPI(
-    title="PhantomEye API",
-    description="AI-powered surveillance intelligence — Person Re-ID, Behavioral Analytics, OSINT Defense",
-    version="1.0.0",
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-detector = PersonDetector()
-osint    = OSINTAudit()
-
-import cv2
-import numpy as np
-
-
-@app.get("/")
-def root():
-    return {
-        "system"  : "PhantomEye",
-        "version" : "1.0.0",
-        "status"  : "online",
-        "modules" : ["detection", "tracking", "analytics", "osint"],
-        "author"  : "Abu-Sameer-66",
-    }
-
-
-@app.get("/health")
-def health():
-    return {
-        "status"        : "healthy",
-        "gallery_size"  : len(osint.gallery),
-        "timestamp"     : time.strftime("%Y-%m-%d %H:%M:%S"),
-    }
-
-
-@app.post("/detect")
-async def detect_persons(file: UploadFile = File(...)):
-    if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
-        raise HTTPException(400, "Only JPG/PNG images supported.")
-
-    data  = await file.read()
-    arr   = np.frombuffer(data, np.uint8)
-    image = cv2.imdecode(arr, cv2.IMREAD_COLOR)
-
-    if image is None:
-        raise HTTPException(400, "Cannot decode image.")
-
-    detections = detector.detect(image)
-
-    return JSONResponse({
-        "status"          : "success",
-        "filename"        : file.filename,
-        "total_persons"   : len(detections),
-        "detections"      : [
-            {
-                "id"        : i + 1,
-                "bbox"      : list(d["bbox"]),
-                "confidence": d["confidence"],
-            }
-            for i, d in enumerate(detections)
-        ],
-    })
-
-
-@app.post("/osint/audit")
-async def osint_audit(file: UploadFile = File(...)):
-    if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
-        raise HTTPException(400, "Only JPG/PNG images supported.")
-
-    data  = await file.read()
-    arr   = np.frombuffer(data, np.uint8)
-    image = cv2.imdecode(arr, cv2.IMREAD_COLOR)
-
-    if image is None:
-        raise HTTPException(400, "Cannot decode image.")
-
-    query_id = Path(file.filename).stem
-    result   = osint.audit(image, query_id=query_id)
-    osint.save_report(result)
-
-    return JSONResponse({
-        "status": "success",
-        "audit" : result,
-    })
-
-
-@app.post("/osint/add-to-gallery")
-async def add_to_gallery(
-    file     : UploadFile = File(...),
-    person_id: str        = "unknown",
-):
-    data  = await file.read()
-    arr   = np.frombuffer(data, np.uint8)
-    image = cv2.imdecode(arr, cv2.IMREAD_COLOR)
-
-    if image is None:
-        raise HTTPException(400, "Cannot decode image.")
-
-    success = osint.add_to_gallery(image, person_id)
-
-    if not success:
-        raise HTTPException(400, "No face detected in uploaded image.")
-
-    return JSONResponse({
-        "status"      : "success",
-        "person_id"   : person_id,
-        "gallery_size": len(osint.gallery),
-        "message"     : f"Person '{person_id}' added to gallery.",
-    })
-
-
-@app.get("/osint/gallery")
-def get_gallery():
-    return JSONResponse({
-        "status"      : "success",
-        "gallery_size": len(osint.gallery),
-        "persons"     : list(osint.gallery.keys()),
-    })
-
-
-@app.post("/track/video")
-async def track_video(file: UploadFile = File(...)):
-    if not file.filename.lower().endswith((".mp4", ".avi", ".mov")):
-        raise HTTPException(400, "Only MP4/AVI/MOV videos supported.")
-
-    tmp_path = OUTPUTS_DIR / f"tmp_{int(time.time())}_{file.filename}"
-    OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
-
-    with open(tmp_path, "wb") as f:
-        shutil.copyfileobj(file.file, f)
-
-    cap   = cv2.VideoCapture(str(tmp_path))
-    fps   = int(cap.get(cv2.CAP_PROP_FPS)) or 25
-    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    w     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    h     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    cap.release()
-
-    tracker    = ByteTracker()
-    cap        = cv2.VideoCapture(str(tmp_path))
-    frame_data = []
-    frame_idx  = 0
-
-    while frame_idx < min(total, fps * 10):
-        ret, frame = cap.read()
-        if not ret:
-            break
-        dets   = detector.detect(frame)
-        active = tracker.update(dets)
-        frame_data.append({
-            "frame"          : frame_idx,
-            "active_persons" : len(active),
-            "track_ids"      : [t.track_id for t in active],
-        })
-        frame_idx += 1
-
-    cap.release()
-    tmp_path.unlink(missing_ok=True)
-
-    return JSONResponse({
-        "status"          : "success",
-        "filename"        : file.filename,
-        "resolution"      : f"{w}x{h}",
-        "fps"             : fps,
-        "frames_analyzed" : frame_idx,
-        "unique_persons"  : tracker.next_id - 1,
-        "frame_summary"   : frame_data[:10],
-    })
-
-
-@app.get("/outputs")
-def list_outputs():
-    OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
-    files = [
-        {
-            "name": f.name,
-            "size": f"{f.stat().st_size // 1024} KB",
-        }
-        for f in OUTPUTS_DIR.iterdir()
-        if f.is_file() and not f.name.startswith("tmp_")
-    ]
-    return JSONResponse({
-        "status": "success",
-        "total" : len(files),
-        "files" : files,
-    })
-
-
-if __name__ == "__main__":
-    uvicorn.run(
-        "api.main:app",
-        host=API_HOST,
-        port=API_PORT,
-        reload=False,
+import os
+import time
+import shutil
+import uvicorn
+from pathlib import Path
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, FileResponse
+
+import sys
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+
+from core.detection import PersonDetector
+from core.tracker import ByteTracker
+from core.osint import OSINTAudit
+from config import OUTPUTS_DIR, GALLERY_DIR, API_HOST, API_PORT
+
+app = FastAPI(
+    title="PhantomEye API",
+    description="AI-powered surveillance intelligence — Person Re-ID, Behavioral Analytics, OSINT Defense",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+detector = PersonDetector()
+osint    = OSINTAudit()
+
+import cv2
+import numpy as np
+
+
+@app.get("/")
+def root():
+    return {
+        "system"  : "PhantomEye",
+        "version" : "1.0.0",
+        "status"  : "online",
+        "modules" : ["detection", "tracking", "analytics", "osint"],
+        "author"  : "Abu-Sameer-66",
+    }
+
+
+@app.get("/health")
+def health():
+    return {
+        "status"        : "healthy",
+        "gallery_size"  : len(osint.gallery),
+        "timestamp"     : time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+
+
+@app.post("/detect")
+async def detect_persons(file: UploadFile = File(...)):
+    if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
+        raise HTTPException(400, "Only JPG/PNG images supported.")
+
+    data  = await file.read()
+    arr   = np.frombuffer(data, np.uint8)
+    image = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+
+    if image is None:
+        raise HTTPException(400, "Cannot decode image.")
+
+    detections = detector.detect(image)
+
+    return JSONResponse({
+        "status"          : "success",
+        "filename"        : file.filename,
+        "total_persons"   : len(detections),
+        "detections"      : [
+            {
+                "id"        : i + 1,
+                "bbox"      : list(d["bbox"]),
+                "confidence": d["confidence"],
+            }
+            for i, d in enumerate(detections)
+        ],
+    })
+
+
+@app.post("/osint/audit")
+async def osint_audit(file: UploadFile = File(...)):
+    if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
+        raise HTTPException(400, "Only JPG/PNG images supported.")
+
+    data  = await file.read()
+    arr   = np.frombuffer(data, np.uint8)
+    image = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+
+    if image is None:
+        raise HTTPException(400, "Cannot decode image.")
+
+    query_id = Path(file.filename).stem
+    result   = osint.audit(image, query_id=query_id)
+    osint.save_report(result)
+
+    return JSONResponse({
+        "status": "success",
+        "audit" : result,
+    })
+
+
+@app.post("/osint/add-to-gallery")
+async def add_to_gallery(
+    file     : UploadFile = File(...),
+    person_id: str        = "unknown",
+):
+    data  = await file.read()
+    arr   = np.frombuffer(data, np.uint8)
+    image = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+
+    if image is None:
+        raise HTTPException(400, "Cannot decode image.")
+
+    success = osint.add_to_gallery(image, person_id)
+
+    if not success:
+        raise HTTPException(400, "No face detected in uploaded image.")
+
+    return JSONResponse({
+        "status"      : "success",
+        "person_id"   : person_id,
+        "gallery_size": len(osint.gallery),
+        "message"     : f"Person '{person_id}' added to gallery.",
+    })
+
+
+@app.get("/osint/gallery")
+def get_gallery():
+    return JSONResponse({
+        "status"      : "success",
+        "gallery_size": len(osint.gallery),
+        "persons"     : list(osint.gallery.keys()),
+    })
+
+
+@app.post("/track/video")
+async def track_video(file: UploadFile = File(...)):
+    if not file.filename.lower().endswith((".mp4", ".avi", ".mov")):
+        raise HTTPException(400, "Only MP4/AVI/MOV videos supported.")
+
+    tmp_path = OUTPUTS_DIR / f"tmp_{int(time.time())}_{file.filename}"
+    OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    with open(tmp_path, "wb") as f:
+        shutil.copyfileobj(file.file, f)
+
+    cap   = cv2.VideoCapture(str(tmp_path))
+    fps   = int(cap.get(cv2.CAP_PROP_FPS)) or 25
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    w     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    cap.release()
+
+    tracker    = ByteTracker()
+    cap        = cv2.VideoCapture(str(tmp_path))
+    frame_data = []
+    frame_idx  = 0
+
+    while frame_idx < min(total, fps * 10):
+        ret, frame = cap.read()
+        if not ret:
+            break
+        dets   = detector.detect(frame)
+        active = tracker.update(dets)
+        frame_data.append({
+            "frame"          : frame_idx,
+            "active_persons" : len(active),
+            "track_ids"      : [t.track_id for t in active],
+        })
+        frame_idx += 1
+
+    cap.release()
+    tmp_path.unlink(missing_ok=True)
+
+    return JSONResponse({
+        "status"          : "success",
+        "filename"        : file.filename,
+        "resolution"      : f"{w}x{h}",
+        "fps"             : fps,
+        "frames_analyzed" : frame_idx,
+        "unique_persons"  : tracker.next_id - 1,
+        "frame_summary"   : frame_data[:10],
+    })
+
+
+@app.get("/outputs")
+def list_outputs():
+    OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+    files = [
+        {
+            "name": f.name,
+            "size": f"{f.stat().st_size // 1024} KB",
+        }
+        for f in OUTPUTS_DIR.iterdir()
+        if f.is_file() and not f.name.startswith("tmp_")
+    ]
+    return JSONResponse({
+        "status": "success",
+        "total" : len(files),
+        "files" : files,
+    })
+
+
+
+# ── AUTH ENDPOINTS ──────────────────────────────────────────
+from api.auth import generate_api_key, validate_api_key, create_access_token, get_api_key_stats
+from fastapi import Header
+
+@app.post("/auth/generate-key")
+async def api_generate_key(client_name: str, tier: str = "free"):
+    """Generate a new PhantomEye API key."""
+    if tier not in ["free", "pro"]:
+        return JSONResponse({"error": "tier must be free or pro"}, status_code=400)
+    key = generate_api_key(client_name, tier)
+    return JSONResponse({
+        "status": "success",
+        "api_key": key,
+        "client": client_name,
+        "tier": tier,
+        "rate_limit": 100 if tier == "free" else 10000,
+        "message": "Store this key securely — it will not be shown again"
+    })
+
+@app.post("/auth/token")
+async def api_get_token(api_key: str = Header(..., alias="X-API-Key")):
+    """Exchange API key for JWT access token."""
+    key_data = validate_api_key(api_key)
+    token = create_access_token({"sub": key_data["client"], "tier": key_data["tier"]})
+    return JSONResponse({
+        "status": "success",
+        "access_token": token,
+        "token_type": "bearer",
+        "expires_in": "24 hours",
+        "tier": key_data["tier"]
+    })
+
+@app.get("/auth/stats")
+async def api_key_stats(api_key: str = Header(..., alias="X-API-Key")):
+    """Get API key usage statistics."""
+    validate_api_key(api_key)
+    return JSONResponse(get_api_key_stats())
+
+@app.get("/auth/validate")
+async def api_validate_key(api_key: str = Header(..., alias="X-API-Key")):
+    """Validate an API key and return its metadata."""
+    data = validate_api_key(api_key)
+    return JSONResponse({
+        "status": "valid",
+        "client": data["client"],
+        "tier": data["tier"],
+        "calls_today": data["calls_today"],
+        "rate_limit": data["rate_limit"],
+        "remaining": data["rate_limit"] - data["calls_today"]
+    })
+
+
+if __name__ == "__main__":
+    import os
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run(
+        "api.main:app",
+        host=API_HOST,
+        port=port,
+        reload=False,
     )

app.py

@@ -1,522 +1,1207 @@
-import cv2
-import sys
-import time
-import numpy as np
-import streamlit as st
-from pathlib import Path
-
-sys.path.append(str(Path(__file__).resolve().parent))
-
-from core.detection import PersonDetector
-from core.tracker import ByteTracker
-from core.analytics import BehavioralAnalyzer
-from core.osint import OSINTAudit
-
-st.set_page_config(
-    page_title="PhantomEye — AI Surveillance Intelligence",
-    page_icon="👁",
-    layout="wide",
-    initial_sidebar_state="collapsed",
-)
-
-st.markdown("""
-<style>
-@import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&family=Share+Tech+Mono&display=swap');
-
-html, body, [class*="css"] { font-family: 'Share Tech Mono', monospace; }
-.stApp { background: #000000; }
-
-.hero-wrap {
-    display: flex; flex-direction: column;
-    align-items: center; justify-content: center;
-    min-height: 88vh; padding: 2rem 0;
-}
-.hero-eye {
-    font-size: 5rem; margin-bottom: 1rem;
-    animation: float 4s ease-in-out infinite;
-}
-@keyframes float {
-    0%,100% { transform: translateY(0px); }
-    50%      { transform: translateY(-14px); }
-}
-.hero-title {
-    font-family: 'Orbitron', monospace;
-    font-size: clamp(2.4rem, 6vw, 4rem);
-    font-weight: 900; color: #00ff88;
-    letter-spacing: 10px; text-align: center;
-    text-shadow: 0 0 40px #00ff88, 0 0 80px #00ff4433;
-    animation: glow 3s ease-in-out infinite;
-    margin-bottom: 0.5rem;
-}
-@keyframes glow {
-    0%,100% { text-shadow: 0 0 30px #00ff88, 0 0 60px #00ff4422; }
-    50%      { text-shadow: 0 0 60px #00ff88, 0 0 120px #00ff4455, 0 0 200px #00ff4411; }
-}
-.hero-sub {
-    font-size: 0.8rem; color: #00aa55;
-    letter-spacing: 4px; text-align: center;
-    margin-bottom: 0.4rem;
-}
-.hero-status {
-    font-size: 0.65rem; color: #003322;
-    letter-spacing: 3px; text-align: center;
-    margin-bottom: 3rem;
-    animation: blink 2s infinite;
-}
-@keyframes blink {
-    0%,100% { opacity: 1; } 50% { opacity: 0.3; }
-}
-.module-grid {
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 16px; width: 100%; max-width: 800px;
-    margin-bottom: 2rem;
-}
-.mod-card {
-    background: #050f05;
-    border: 1px solid #00ff8822;
-    border-radius: 12px;
-    padding: 1.4rem 1.6rem;
-    cursor: pointer;
-    transition: all 0.25s ease;
-    position: relative;
-    overflow: hidden;
-}
-.mod-card::before {
-    content: '';
-    position: absolute;
-    top: 0; left: 0;
-    width: 100%; height: 1px;
-    background: linear-gradient(90deg, transparent, #00ff88, transparent);
-    transform: translateX(-100%);
-    transition: transform 0.4s ease;
-}
-.mod-card:hover::before { transform: translateX(0); }
-.mod-card:hover {
-    border-color: #00ff8866;
-    box-shadow: 0 0 30px #00ff8811;
-    transform: translateY(-3px);
-}
-.mod-icon { font-size: 1.6rem; margin-bottom: 0.6rem; }
-.mod-name {
-    font-family: 'Orbitron', monospace;
-    font-size: 0.75rem; font-weight: 700;
-    color: #00ff88; letter-spacing: 3px;
-    text-transform: uppercase; margin-bottom: 0.4rem;
-}
-.mod-desc { font-size: 0.7rem; color: #005522; line-height: 1.6; }
-.scan-line {
-    width: 100%; max-width: 800px;
-    height: 1px;
-    background: linear-gradient(90deg, transparent, #00ff8844, transparent);
-    margin: 0.5rem 0 1.5rem;
-    animation: scan 3s linear infinite;
-}
-@keyframes scan { 0% { opacity: 0.3; } 50% { opacity: 1; } 100% { opacity: 0.3; } }
-.hero-btn {
-    font-family: 'Share Tech Mono', monospace;
-    font-size: 0.75rem; letter-spacing: 3px;
-    color: #00ff88; background: transparent;
-    border: 1px solid #00ff8844;
-    border-radius: 4px;
-    padding: 0.6rem 2rem;
-    cursor: pointer;
-    transition: all 0.2s;
-    text-transform: uppercase;
-    margin-top: 0.5rem;
-}
-.hero-btn:hover {
-    background: #00ff8811;
-    border-color: #00ff88;
-    box-shadow: 0 0 20px #00ff8833;
-}
-.app-header {
-    font-family: 'Orbitron', monospace;
-    font-size: 1.1rem; font-weight: 900;
-    color: #00ff88; letter-spacing: 6px;
-    text-align: center; padding: 1rem 0 0.2rem;
-    text-shadow: 0 0 20px #00ff8866;
-}
-.app-sub {
-    font-size: 0.65rem; color: #005522;
-    letter-spacing: 2px; text-align: center;
-    margin-bottom: 1.5rem;
-}
-.section-hdr {
-    font-family: 'Orbitron', monospace;
-    font-size: 0.8rem; color: #00ff88;
-    letter-spacing: 4px; text-transform: uppercase;
-    border-bottom: 1px solid #00ff8822;
-    padding-bottom: 0.5rem; margin: 1rem 0;
-}
-.terminal {
-    background: #030f03;
-    border: 1px solid #00ff8822;
-    border-radius: 6px;
-    padding: 0.7rem 1rem;
-    font-size: 0.75rem; color: #00aa55;
-    margin: 0.4rem 0; line-height: 1.6;
-}
-.terminal::before { content: '> '; color: #00ff88; }
-.back-btn-wrap { margin-bottom: 1.2rem; }
-[data-testid="metric-container"] {
-    background: #050f05 !important;
-    border: 1px solid #00ff8822 !important;
-    border-radius: 8px !important;
-    padding: 0.8rem !important;
-}
-[data-testid="metric-container"] label {
-    color: #005522 !important;
-    font-family: 'Share Tech Mono', monospace !important;
-    font-size: 0.65rem !important; letter-spacing: 2px !important;
-}
-[data-testid="metric-container"] [data-testid="stMetricValue"] {
-    color: #00ff88 !important;
-    font-family: 'Orbitron', monospace !important;
-}
-.stButton button {
-    background: transparent !important;
-    border: 1px solid #00ff8844 !important;
-    color: #00ff88 !important;
-    font-family: 'Share Tech Mono', monospace !important;
-    letter-spacing: 2px !important; text-transform: uppercase !important;
-    border-radius: 4px !important; transition: all 0.2s !important;
-    width: 100% !important;
-}
-.stButton button:hover {
-    background: #00ff8811 !important;
-    border-color: #00ff88 !important;
-    box-shadow: 0 0 16px #00ff8833 !important;
-}
-.stProgress > div > div > div > div {
-    background: linear-gradient(90deg, #003322, #00ff88) !important;
-}
-.stExpander {
-    background: #050f05 !important;
-    border: 1px solid #00ff8822 !important;
-    border-radius: 8px !important;
-}
-div[data-testid="stSidebar"] { display: none !important; }
-hr { border-color: #00ff8811 !important; }
-::-webkit-scrollbar { width: 3px; }
-::-webkit-scrollbar-track { background: #000; }
-::-webkit-scrollbar-thumb { background: #00ff8833; border-radius: 2px; }
-</style>
-""", unsafe_allow_html=True)
-
-
-@st.cache_resource
-def load_detector():
-    return PersonDetector()
-
-@st.cache_resource
-def load_osint():
-    return OSINTAudit()
-
-
-def landing():
-    st.markdown("""
-    <div class="hero-wrap">
-      <div class="hero-eye">👁</div>
-      <div class="hero-title">PHANTOMEYE</div>
-      <div class="hero-sub">AI-POWERED SURVEILLANCE INTELLIGENCE SYSTEM</div>
-      <div class="hero-status">[ SYSTEM ONLINE ] · CLASSIFIED · BUILD v1.0.0</div>
-      <div class="scan-line"></div>
-      <div class="module-grid">
-        <div class="mod-card">
-          <div class="mod-icon">⬡</div>
-          <div class="mod-name">Person Detection</div>
-          <div class="mod-desc">YOLOv8-nano detects every person in any image with confidence scores and bounding boxes.</div>
-        </div>
-        <div class="mod-card">
-          <div class="mod-icon">⬡</div>
-          <div class="mod-name">Behavioral Analytics</div>
-          <div class="mod-desc">Real-time heatmap, dwell time tracking, and automated loitering alerts from video feeds.</div>
-        </div>
-        <div class="mod-card">
-          <div class="mod-icon">⬡</div>
-          <div class="mod-name">OSINT Audit</div>
-          <div class="mod-desc">Upload a face — get a privacy exposure score from 0 to 100 with matched identities.</div>
-        </div>
-        <div class="mod-card">
-          <div class="mod-icon">⬡</div>
-          <div class="mod-name">System Intel</div>
-          <div class="mod-desc">Live system status, module health, API endpoints, and deployment information.</div>
-        </div>
-      </div>
-    </div>
-    """, unsafe_allow_html=True)
-
-    cols = st.columns([1, 2, 1])
-    with cols[1]:
-        if st.button("INITIALIZE SYSTEM  →", key="enter_btn"):
-            st.session_state.page = "home"
-            st.rerun()
-
-
-def home():
-    st.markdown('<div class="app-header">👁 PHANTOMEYE</div>', unsafe_allow_html=True)
-    st.markdown(
-        '<div class="app-sub">SELECT INTELLIGENCE MODULE</div>',
-        unsafe_allow_html=True
-    )
-
-    cols = st.columns(4)
-    modules = [
-        ("DETECTION",  "Person Detection"),
-        ("ANALYTICS",  "Behavioral Analytics"),
-        ("OSINT",      "OSINT Audit"),
-        ("INTEL",      "System Intel"),
-    ]
-    for i, (key, label) in enumerate(modules):
-        with cols[i]:
-            if st.button(label, key=f"mod_{key}"):
-                st.session_state.page = key
-                st.rerun()
-
-    st.markdown("<hr>", unsafe_allow_html=True)
-    st.markdown(
-        '<div class="terminal">All modules online · YOLOv8 loaded · '
-        'ByteTrack active · OSINT gallery ready</div>',
-        unsafe_allow_html=True
-    )
-
-
-def back_button():
-    if st.button("← BACK TO MODULES"):
-        st.session_state.page = "home"
-        st.rerun()
-
-
-def detection_page():
-    back_button()
-    st.markdown('<div class="section-hdr">Person Detection</div>', unsafe_allow_html=True)
-    st.markdown(
-        '<div class="terminal">YOLOv8-nano · CPU inference · '
-        'upload any image to detect persons</div>',
-        unsafe_allow_html=True
-    )
-
-    uploaded = st.file_uploader("", type=["jpg", "jpeg", "png"], key="det_up")
-
-    if uploaded:
-        data  = np.frombuffer(uploaded.read(), np.uint8)
-        image = cv2.imdecode(data, cv2.IMREAD_COLOR)
-        if image is None:
-            st.error("Cannot decode image.")
-            return
-
-        with st.spinner("SCANNING..."):
-            detector   = load_detector()
-            t0         = time.time()
-            detections = detector.detect(image)
-            elapsed    = round(time.time() - t0, 3)
-            annotated  = detector.draw(image, detections)
-
-        c1, c2, c3, c4 = st.columns(4)
-        c1.metric("PERSONS",   len(detections))
-        c2.metric("TIME",      f"{elapsed}s")
-        c3.metric("MODEL",     "YOLOv8n")
-        c4.metric("DEVICE",    "CPU")
-
-        st.image(
-            cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB),
-            caption="DETECTION OUTPUT", use_column_width=True
-        )
-
-        if detections:
-            st.markdown('<div class="section-hdr">Detection Log</div>', unsafe_allow_html=True)
-            for i, d in enumerate(detections):
-                with st.expander(f"PERSON_{i+1:03d}  CONF:{d['confidence']}"):
-                    st.json({"id": i+1, "bbox": list(d["bbox"]), "confidence": d["confidence"]})
-
-
-def analytics_page():
-    back_button()
-    st.markdown('<div class="section-hdr">Behavioral Analytics</div>', unsafe_allow_html=True)
-    st.markdown(
-        '<div class="terminal">Upload video · heatmap · dwell time · loitering alerts</div>',
-        unsafe_allow_html=True
-    )
-
-    uploaded = st.file_uploader("", type=["mp4", "avi", "mov"], key="ana_up")
-
-    if uploaded:
-        tmp = Path("outputs") / f"tmp_{int(time.time())}.mp4"
-        tmp.parent.mkdir(exist_ok=True)
-        with open(tmp, "wb") as f:
-            f.write(uploaded.read())
-
-        cap   = cv2.VideoCapture(str(tmp))
-        fps   = int(cap.get(cv2.CAP_PROP_FPS)) or 25
-        w     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        h     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        cap.release()
-
-        st.markdown(
-            f'<div class="terminal">{w}x{h} @ {fps}fps · {total} frames loaded</div>',
-            unsafe_allow_html=True
-        )
-
-        if st.button("RUN ANALYSIS"):
-            detector = load_detector()
-            tracker  = ByteTracker()
-            analyzer = BehavioralAnalyzer(w, h, fps)
-            cap      = cv2.VideoCapture(str(tmp))
-            limit    = min(total, fps * 15)
-            prog     = st.progress(0)
-            stat     = st.empty()
-
-            for i in range(limit):
-                ret, frame = cap.read()
-                if not ret: break
-                dets   = detector.detect(frame)
-                active = tracker.update(dets)
-                analyzer.update(active)
-                prog.progress(int((i / limit) * 100))
-                if i % 25 == 0:
-                    stat.markdown(
-                        f'<div class="terminal">FRAME {i}/{limit} · ACTIVE: {len(active)}</div>',
-                        unsafe_allow_html=True
-                    )
-
-            cap.release()
-            tmp.unlink(missing_ok=True)
-            prog.progress(100)
-            stat.empty()
-
-            s = analyzer.summary()
-            st.success("ANALYSIS COMPLETE")
-
-            c1, c2, c3, c4 = st.columns(4)
-            c1.metric("PERSONS",    s.get("total_persons", 0))
-            c2.metric("AVG DWELL",  f"{s.get('avg_dwell_sec', 0)}s")
-            c3.metric("MAX DWELL",  f"{s.get('max_dwell_sec', 0)}s")
-            c4.metric("ALERTS",     s.get("total_alerts", 0))
-
-            if s.get("total_alerts", 0) > 0:
-                st.warning(f"LOITERING ALERT — IDs: {s.get('loiterers', [])}")
-
-            heat = analyzer.get_heatmap_overlay(np.zeros((h, w, 3), dtype=np.uint8))
-            st.image(
-                cv2.cvtColor(heat, cv2.COLOR_BGR2RGB),
-                caption="BEHAVIORAL HEATMAP — RED = HIGH ACTIVITY",
-                use_column_width=True
-            )
-
-
-def osint_page():
-    back_button()
-    st.markdown('<div class="section-hdr">OSINT Privacy Audit</div>', unsafe_allow_html=True)
-    st.markdown(
-        '<div class="terminal">Upload face photo · privacy exposure score · '
-        'gallery match · risk report</div>',
-        unsafe_allow_html=True
-    )
-
-    c1, c2 = st.columns([1, 1])
-    with c1:
-        query_file = st.file_uploader("", type=["jpg", "jpeg", "png"], key="osint_up")
-    with c2:
-        osint = load_osint()
-        st.metric("GALLERY", f"{len(osint.gallery)} persons")
-        st.metric("ENGINE", "LBPH Face")
-
-    if query_file and st.button("EXECUTE AUDIT"):
-        data  = np.frombuffer(query_file.read(), np.uint8)
-        image = cv2.imdecode(data, cv2.IMREAD_COLOR)
-        if image is None:
-            st.error("Cannot decode image.")
-            return
-
-        with st.spinner("RUNNING AUDIT..."):
-            result = osint.audit(image, query_id=Path(query_file.name).stem)
-
-        risk    = result["risk_level"]
-        score   = result["exposure_score"]
-        matches = result["matches"]
-
-        c1, c2, c3 = st.columns(3)
-        c1.metric("RISK LEVEL",     risk)
-        c2.metric("EXPOSURE SCORE", f"{score}/100")
-        c3.metric("MATCHES",        len(matches))
-
-        st.markdown(
-            f'<div class="terminal">{result["message"]}</div>',
-            unsafe_allow_html=True
-        )
-
-        if matches:
-            st.markdown('<div class="section-hdr">Match Log</div>', unsafe_allow_html=True)
-            for m in matches:
-                st.markdown(
-                    f'<div class="terminal">MATCH: {m["matched_id"]} · '
-                    f'CONF: {m["confidence"]}% · SRC: {m["source"]}</div>',
-                    unsafe_allow_html=True
-                )
-
-        vis = osint.visualize(image, result)
-        st.image(
-            cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
-            caption="OSINT VISUALIZATION",
-            use_column_width=True
-        )
-
-
-def intel_page():
-    back_button()
-    st.markdown('<div class="section-hdr">System Intelligence</div>', unsafe_allow_html=True)
-
-    c1, c2, c3, c4 = st.columns(4)
-    c1.metric("SYSTEM",   "PhantomEye")
-    c2.metric("VERSION",  "1.0.0")
-    c3.metric("STATUS",   "ONLINE")
-    c4.metric("MODULES",  "5 ACTIVE")
-
-    st.markdown("<br>", unsafe_allow_html=True)
-
-    modules = [
-        ("DETECTION",  "YOLOv8-nano",    "Person detection on any image or video"),
-        ("TRACKING",   "ByteTrack",       "Persistent ID tracking across frames"),
-        ("ANALYTICS",  "NumPy + OpenCV",  "Heatmap · dwell time · loitering alerts"),
-        ("OSINT",      "LBPH Face",       "Privacy exposure scoring + gallery match"),
-        ("API",        "FastAPI",          "8 endpoints · OAS 3.1 · port 8000"),
-    ]
-
-    for name, tech, desc in modules:
-        with st.expander(f"{name}  ·  {tech}  ·  ACTIVE"):
-            st.markdown(f'<div class="terminal">{desc}</div>', unsafe_allow_html=True)
-
-    st.markdown("<br>", unsafe_allow_html=True)
-    st.json({
-        "author"  : "Abu-Sameer-66",
-        "github"  : "https://github.com/Abu-Sameer-66/PhantomEye",
-        "stack"   : ["Python 3.10", "YOLOv8", "OpenCV", "FastAPI", "Streamlit"],
-        "api"     : "http://localhost:8000/docs",
-        "status"  : "online",
-    })
-
-
-def main():
-    if "page" not in st.session_state:
-        st.session_state.page = "landing"
-
-    page = st.session_state.page
-
-    if page == "landing":
-        landing()
-    elif page == "home":
-        home()
-    elif page == "DETECTION":
-        detection_page()
-    elif page == "ANALYTICS":
-        analytics_page()
-    elif page == "OSINT":
-        osint_page()
-    elif page == "INTEL":
-        intel_page()
-
-
-if __name__ == "__main__":
+import cv2
+import sys
+import time
+import uuid
+import numpy as np
+import streamlit as st
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).resolve().parent))
+
+from core.detection import PersonDetector
+from core.tracker import ByteTracker
+from core.analytics import BehavioralAnalyzer
+from core.osint import OSINTAudit
+
+st.set_page_config(
+    page_title="PhantomEye — AI Surveillance Intelligence",
+    page_icon="👁",
+    layout="wide",
+    initial_sidebar_state="collapsed",
+)
+
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Rajdhani:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@300;400;500;600&family=Exo+2:wght@100;200;300;400;700;900&display=swap');
+
+:root {
+    --bg-primary: #020408;
+    --bg-secondary: #050d15;
+    --bg-card: rgba(6, 18, 32, 0.85);
+    --bg-glass: rgba(0, 180, 255, 0.04);
+    --accent-blue: #00b4ff;
+    --accent-cyan: #00fff0;
+    --accent-amber: #ffb300;
+    --accent-red: #ff3355;
+    --accent-green: #00ff88;
+    --border-glow: rgba(0, 180, 255, 0.35);
+    --border-subtle: rgba(0, 180, 255, 0.12);
+    --text-primary: #e8f4ff;
+    --text-secondary: #7ab3d4;
+    --text-dim: #3a6080;
+    --grid-color: rgba(0, 180, 255, 0.035);
+    --shadow-blue: 0 0 50px rgba(0, 180, 255, 0.18);
+    --shadow-card: 0 8px 32px rgba(0, 0, 0, 0.7);
+}
+
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+html, body, [class*="css"] {
+    font-family: 'IBM Plex Mono', monospace;
+    background: var(--bg-primary) !important;
+    color: var(--text-primary) !important;
+}
+
+/* ── TOP ACCENT BAR ──────────────────────────────── */
+.stApp::after {
+    content: '';
+    position: fixed;
+    top: 0; left: 0; right: 0;
+    height: 2px;
+    background: linear-gradient(90deg,
+        transparent 0%,
+        var(--accent-blue) 20%,
+        var(--accent-cyan) 50%,
+        var(--accent-blue) 80%,
+        transparent 100%);
+    z-index: 9999;
+    animation: top-bar-glow 4s ease-in-out infinite alternate;
+}
+
+@keyframes top-bar-glow {
+    from { opacity: 0.6; }
+    to   { opacity: 1; filter: brightness(1.4); }
+}
+
+.stApp {
+    background:
+        radial-gradient(ellipse at 15% 40%, rgba(0, 60, 130, 0.18) 0%, transparent 55%),
+        radial-gradient(ellipse at 85% 15%, rgba(0, 30, 90, 0.22) 0%, transparent 50%),
+        radial-gradient(ellipse at 50% 85%, rgba(0, 40, 110, 0.12) 0%, transparent 60%),
+        linear-gradient(180deg, #020408 0%, #030a14 100%) !important;
+    min-height: 100vh;
+}
+
+.stApp::before {
+    content: '';
+    position: fixed;
+    top: 0; left: 0; right: 0; bottom: 0;
+    background-image:
+        linear-gradient(var(--grid-color) 1px, transparent 1px),
+        linear-gradient(90deg, var(--grid-color) 1px, transparent 1px);
+    background-size: 60px 60px;
+    pointer-events: none;
+    z-index: 0;
+}
+
+/* ── SESSION BAR ─────────────────────────────────── */
+.session-bar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: rgba(0, 10, 20, 0.7);
+    border: 1px solid var(--border-subtle);
+    border-radius: 6px;
+    padding: 0.45rem 1.2rem;
+    margin-bottom: 1.8rem;
+    font-family: 'IBM Plex Mono', monospace;
+    font-size: 0.68rem;
+    backdrop-filter: blur(12px);
+}
+
+.session-bar .sid   { color: var(--text-secondary); }
+.session-bar .sid span { color: var(--accent-blue); }
+.session-bar .status { color: var(--accent-green); letter-spacing: 0.2em; }
+.session-bar .status::before { content: '● '; animation: blink 1.5s infinite; }
+.session-bar .badge {
+    font-family: 'Rajdhani', sans-serif;
+    font-size: 0.6rem; font-weight: 700;
+    letter-spacing: 0.25em; text-transform: uppercase;
+    color: var(--accent-cyan);
+    background: rgba(0,255,240,0.08);
+    border: 1px solid rgba(0,255,240,0.3);
+    border-radius: 4px;
+    padding: 0.15rem 0.6rem;
+}
+
+/* ── HERO / LANDING ─────────────────────────────── */
+.hero-wrap {
+    display: flex; flex-direction: column;
+    align-items: center; justify-content: center;
+    min-height: 92vh; padding: 3rem 1rem;
+    position: relative;
+}
+
+.hero-wrap::before {
+    content: '';
+    position: absolute;
+    width: 700px; height: 700px;
+    background: radial-gradient(circle, rgba(0, 180, 255, 0.07) 0%, transparent 70%);
+    border-radius: 50%;
+    top: 50%; left: 50%;
+    transform: translate(-50%, -50%);
+    animation: pulse-glow 5s ease-in-out infinite;
+}
+
+@keyframes pulse-glow {
+    0%, 100% { transform: translate(-50%, -50%) scale(1);   opacity: 0.5; }
+    50%       { transform: translate(-50%, -50%) scale(1.12); opacity: 1; }
+}
+
+.hero-eye {
+    font-size: 5.5rem; margin-bottom: 1.5rem;
+    animation: float 5s ease-in-out infinite;
+    filter: drop-shadow(0 0 40px rgba(0, 180, 255, 0.9));
+}
+
+@keyframes float {
+    0%, 100% { transform: translateY(0px) rotate(-2deg); }
+    50%       { transform: translateY(-22px) rotate(2deg); }
+}
+
+.hero-title {
+    font-family: 'Exo 2', sans-serif;
+    font-size: clamp(3.5rem, 8vw, 7.5rem);
+    font-weight: 900;
+    letter-spacing: 0.15em;
+    background: linear-gradient(135deg, #ffffff 0%, var(--accent-blue) 40%, var(--accent-cyan) 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 0.5rem;
+    animation: title-reveal 1s ease-out forwards;
+}
+
+@keyframes title-reveal {
+    from { opacity: 0; transform: translateY(30px); }
+    to   { opacity: 1; transform: translateY(0); }
+}
+
+.hero-sub {
+    font-family: 'Rajdhani', sans-serif;
+    font-size: clamp(0.85rem, 2vw, 1.05rem);
+    font-weight: 300;
+    letter-spacing: 0.45em;
+    color: var(--text-secondary);
+    margin-bottom: 0.5rem;
+    text-transform: uppercase;
+}
+
+.hero-status {
+    font-size: 0.7rem;
+    color: var(--accent-green);
+    letter-spacing: 0.3em;
+    margin-bottom: 3rem;
+}
+
+.hero-status::before {
+    content: '● ';
+    animation: blink 1.5s infinite;
+}
+
+@keyframes blink {
+    0%, 100% { opacity: 1; }
+    50%       { opacity: 0.15; }
+}
+
+/* ── STATS ROW ───────────────────────────────────── */
+.stats-row {
+    display: flex; gap: 2rem; margin-bottom: 2.5rem;
+    justify-content: center; flex-wrap: wrap;
+}
+
+.stat-item {
+    text-align: center;
+    background: var(--bg-card);
+    border: 1px solid var(--border-subtle);
+    border-radius: 10px;
+    padding: 1rem 1.8rem;
+    backdrop-filter: blur(16px);
+    min-width: 110px;
+}
+
+.stat-value {
+    font-family: 'Exo 2', sans-serif;
+    font-size: 1.6rem; font-weight: 900;
+    color: var(--accent-blue);
+    display: block;
+}
+
+.stat-label {
+    font-size: 0.62rem; letter-spacing: 0.25em;
+    color: var(--text-dim); text-transform: uppercase;
+    margin-top: 0.2rem; display: block;
+}
+
+/* ── MODULE GRID ─────────────────────────────────── */
+.module-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+    gap: 1.4rem;
+    width: 100%;
+    max-width: 1100px;
+    margin: 0 auto 3rem;
+}
+
+.mod-card {
+    background: var(--bg-card);
+    border: 1px solid var(--border-subtle);
+    border-radius: 14px;
+    padding: 2rem 1.8rem;
+    position: relative;
+    overflow: hidden;
+    transition: all 0.4s cubic-bezier(0.23, 1, 0.32, 1);
+    backdrop-filter: blur(20px);
+}
+
+.mod-card::before {
+    content: '';
+    position: absolute;
+    top: 0; left: 0; right: 0;
+    height: 2px;
+    background: linear-gradient(90deg, transparent, var(--accent-blue), var(--accent-cyan), transparent);
+    opacity: 0;
+    transition: opacity 0.3s;
+}
+
+.mod-card::after {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: radial-gradient(ellipse at top left, rgba(0,180,255,0.1) 0%, transparent 65%);
+    opacity: 0;
+    transition: opacity 0.4s;
+}
+
+.mod-card:hover {
+    border-color: var(--border-glow);
+    transform: translateY(-7px);
+    box-shadow: var(--shadow-blue), var(--shadow-card);
+}
+
+.mod-card:hover::before { opacity: 1; }
+.mod-card:hover::after  { opacity: 1; }
+
+.mod-icon { font-size: 2rem; margin-bottom: 1rem; display: block; }
+.mod-name {
+    font-family: 'Rajdhani', sans-serif;
+    font-size: 0.95rem; font-weight: 600;
+    letter-spacing: 0.2em; color: var(--accent-blue);
+    text-transform: uppercase; margin-bottom: 0.8rem;
+}
+
+.mod-tag {
+    display: inline-block;
+    font-size: 0.58rem; letter-spacing: 0.18em;
+    color: var(--accent-cyan);
+    background: rgba(0,255,240,0.07);
+    border: 1px solid rgba(0,255,240,0.2);
+    border-radius: 3px; padding: 0.1rem 0.5rem;
+    margin-bottom: 0.7rem; text-transform: uppercase;
+}
+
+.mod-desc {
+    font-size: 0.76rem;
+    color: var(--text-secondary);
+    line-height: 1.75;
+    letter-spacing: 0.02em;
+}
+
+/* ── SCAN LINE ───────────────────────────────────── */
+.scan-line {
+    width: 100%; max-width: 900px;
+    height: 1px;
+    background: linear-gradient(90deg, transparent, var(--accent-blue), var(--accent-cyan), var(--accent-blue), transparent);
+    margin: 2rem auto;
+    position: relative; overflow: hidden;
+}
+
+.scan-line::after {
+    content: '';
+    position: absolute;
+    width: 80px; height: 100%;
+    background: linear-gradient(90deg, transparent, rgba(0,255,240,0.9), transparent);
+    animation: scan 3s linear infinite;
+}
+
+@keyframes scan {
+    from { left: -80px; }
+    to   { left: 100%; }
+}
+
+/* ── APP HEADER ──────────────────────────────────── */
+.app-header {
+    font-family: 'Exo 2', sans-serif;
+    font-size: 1.7rem; font-weight: 700;
+    letter-spacing: 0.3em;
+    background: linear-gradient(135deg, #fff, var(--accent-blue));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    text-align: center;
+    padding: 1.5rem 0 0.4rem;
+}
+
+.app-sub {
+    font-family: 'Rajdhani', sans-serif;
+    font-size: 0.72rem;
+    color: var(--text-dim);
+    letter-spacing: 0.45em;
+    text-align: center;
+    margin-bottom: 2rem;
+    text-transform: uppercase;
+}
+
+/* ── MODULE NAV BUTTONS ──────────────────────────── */
+.stButton > button {
+    font-family: 'Rajdhani', sans-serif !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.12em !important;
+    font-size: 0.8rem !important;
+    background: var(--bg-card) !important;
+    color: var(--accent-blue) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: 8px !important;
+    padding: 0.7rem 1rem !important;
+    transition: all 0.3s cubic-bezier(0.23, 1, 0.32, 1) !important;
+    position: relative !important;
+    overflow: hidden !important;
+    text-transform: uppercase !important;
+    width: 100% !important;
+}
+
+.stButton > button:hover {
+    background: rgba(0, 180, 255, 0.1) !important;
+    border-color: var(--accent-blue) !important;
+    color: var(--accent-cyan) !important;
+    box-shadow: 0 0 25px rgba(0, 180, 255, 0.25),
+                inset 0 0 20px rgba(0, 180, 255, 0.05) !important;
+    transform: translateY(-2px) !important;
+}
+
+.stButton > button[kind="primary"] {
+    background: linear-gradient(135deg, rgba(0,100,200,0.4), rgba(0,180,255,0.2)) !important;
+    border-color: var(--accent-blue) !important;
+    color: #fff !important;
+    box-shadow: 0 0 25px rgba(0,180,255,0.25) !important;
+}
+
+/* ── SECTION HEADERS ─────────────────────────────── */
+.section-hdr {
+    font-family: 'Exo 2', sans-serif;
+    font-size: 1.25rem; font-weight: 700;
+    letter-spacing: 0.25em; color: var(--accent-blue);
+    text-transform: uppercase;
+    padding: 0.5rem 0;
+    border-bottom: 1px solid var(--border-subtle);
+    margin-bottom: 0.5rem;
+    position: relative;
+}
+
+.section-hdr::after {
+    content: '';
+    position: absolute;
+    bottom: -1px; left: 0;
+    width: 90px; height: 2px;
+    background: linear-gradient(90deg, var(--accent-blue), var(--accent-cyan));
+}
+
+.section-sub {
+    font-size: 0.73rem; color: var(--text-secondary);
+    letter-spacing: 0.15em; margin-bottom: 2rem;
+    text-transform: uppercase;
+}
+
+/* ── TERMINAL STATUS BAR ─────────────────────────── */
+.terminal {
+    background: rgba(0,10,20,0.92);
+    border: 1px solid var(--border-subtle);
+    border-left: 3px solid var(--accent-blue);
+    border-radius: 6px;
+    padding: 0.8rem 1.2rem;
+    font-size: 0.72rem; color: var(--accent-green);
+    letter-spacing: 0.15em; margin-top: 1.5rem;
+    position: relative; overflow: hidden;
+}
+
+.terminal::before {
+    content: '';
+    position: absolute; inset: 0;
+    background: repeating-linear-gradient(
+        0deg,
+        transparent, transparent 2px,
+        rgba(0,255,136,0.012) 2px, rgba(0,255,136,0.012) 4px
+    );
+    pointer-events: none;
+}
+
+/* ── STREAMLIT OVERRIDES ─────────────────────────── */
+.stFileUploader {
+    background: var(--bg-card) !important;
+    border: 1px dashed var(--border-glow) !important;
+    border-radius: 10px !important;
+    padding: 1rem !important;
+}
+
+.stTextInput > div > div {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: 8px !important;
+    color: var(--text-primary) !important;
+    font-family: 'IBM Plex Mono', monospace !important;
+}
+
+.stTextInput > div > div:focus-within {
+    border-color: var(--accent-blue) !important;
+    box-shadow: 0 0 15px rgba(0,180,255,0.15) !important;
+}
+
+.stSelectbox > div > div {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: 8px !important;
+    color: var(--text-primary) !important;
+}
+
+.stNumberInput > div > div {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: 8px !important;
+}
+
+.stSlider > div > div > div { background: var(--accent-blue) !important; }
+
+div[data-testid="metric-container"] {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: 10px !important;
+    padding: 1rem !important;
+    transition: border-color 0.3s;
+}
+
+div[data-testid="metric-container"]:hover {
+    border-color: var(--border-glow) !important;
+}
+
+div[data-testid="metric-container"] label {
+    color: var(--text-secondary) !important;
+    font-size: 0.68rem !important;
+    letter-spacing: 0.2em !important;
+    font-family: 'Rajdhani', sans-serif !important;
+    font-weight: 600 !important;
+}
+
+div[data-testid="metric-container"] div[data-testid="metric-value"] {
+    color: var(--accent-blue) !important;
+    font-family: 'Exo 2', sans-serif !important;
+    font-weight: 700 !important;
+}
+
+div[data-testid="stDataFrame"] {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: 10px !important;
+    overflow: hidden !important;
+}
+
+.stSuccess {
+    background: rgba(0,255,136,0.07) !important;
+    border: 1px solid rgba(0,255,136,0.28) !important;
+    border-radius: 8px !important;
+    color: var(--accent-green) !important;
+}
+
+.stError, .stWarning {
+    background: rgba(255,51,85,0.07) !important;
+    border: 1px solid rgba(255,51,85,0.28) !important;
+    border-radius: 8px !important;
+}
+
+.stInfo {
+    background: rgba(0,180,255,0.07) !important;
+    border: 1px solid rgba(0,180,255,0.2) !important;
+    border-radius: 8px !important;
+    color: var(--accent-blue) !important;
+}
+
+hr { border-color: var(--border-subtle) !important; margin: 1.5rem 0 !important; }
+
+::-webkit-scrollbar { width: 4px; }
+::-webkit-scrollbar-track { background: var(--bg-primary); }
+::-webkit-scrollbar-thumb { background: var(--accent-blue); border-radius: 2px; opacity: 0.5; }
+
+.stSpinner > div {
+    border-color: var(--accent-blue) transparent transparent transparent !important;
+}
+
+section[data-testid="stSidebar"] { display: none !important; }
+#MainMenu { visibility: hidden; }
+footer    { visibility: hidden; }
+header    { visibility: hidden; }
+
+@keyframes fadeInUp {
+    from { opacity: 0; transform: translateY(20px); }
+    to   { opacity: 1; transform: translateY(0); }
+}
+
+.stMarkdown, .stButton, .stFileUploader {
+    animation: fadeInUp 0.4s ease-out forwards;
+}
+</style>
+""", unsafe_allow_html=True)
+
+
+# ─────────────────────────────────────────────────────
+#  CACHED LOADERS
+# ─────────────────────────────────────────────────────
+@st.cache_resource
+def load_detector():
+    return PersonDetector()
+
+@st.cache_resource
+def load_osint():
+    return OSINTAudit()
+
+@st.cache_resource
+def load_emotion_model():
+    from core.emotion import process_frame_emotion
+    return process_frame_emotion
+
+@st.cache_resource
+def load_weapon_model_cached():
+    from core.weapon import load_weapon_model
+    return load_weapon_model()
+
+
+# ─────────────────────────────────────────────────────
+#  SESSION BAR  (replaces trust bar — no limits)
+# ─────────────────────────────────────────────────────
+def render_session_bar():
+    sid = st.session_state.get("session_id", "PE-XXXXXXXX")
+    st.markdown(f"""
+    <div class="session-bar">
+        <div class="sid"><span>●</span> &nbsp;SESSION: <span>{sid}</span></div>
+        <div class="status">ALL SYSTEMS ONLINE</div>
+        <div class="badge">OPEN ACCESS</div>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+# ─────────────────────────────────────────────────────
+#  LANDING PAGE
+# ─────────────────────────────────────────────────────
+def landing():
+    st.markdown("""
+    <div class="hero-wrap">
+      <div class="hero-eye">👁</div>
+      <div class="hero-title">PHANTOMEYE</div>
+      <div class="hero-sub">AI-POWERED SURVEILLANCE INTELLIGENCE SYSTEM</div>
+      <div class="hero-status">[ SYSTEM ONLINE ] · OPEN ACCESS · BUILD v3.0</div>
+
+      <div class="stats-row">
+        <div class="stat-item">
+          <span class="stat-value">8</span>
+          <span class="stat-label">Modules</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">97%</span>
+          <span class="stat-label">Accuracy</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">9</span>
+          <span class="stat-label">Weapon Classes</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">CPU</span>
+          <span class="stat-label">No GPU Needed</span>
+        </div>
+      </div>
+
+      <div class="scan-line"></div>
+
+      <div class="module-grid">
+        <div class="mod-card">
+          <div class="mod-icon">🎯</div>
+          <div class="mod-name">Person Detection</div>
+          <div class="mod-tag">YOLOv8-nano</div>
+          <div class="mod-desc">Detects every person in any image with confidence scores and bounding boxes in real-time.</div>
+        </div>
+        <div class="mod-card">
+          <div class="mod-icon">🔥</div>
+          <div class="mod-name">Behavioral Analytics</div>
+          <div class="mod-tag">ByteTrack · OpenCV</div>
+          <div class="mod-desc">Live heatmap, persistent ID tracking, dwell time and automated loitering alerts from video.</div>
+        </div>
+        <div class="mod-card">
+          <div class="mod-icon">🕵️</div>
+          <div class="mod-name">OSINT Audit</div>
+          <div class="mod-tag">LBPH Face Recognition</div>
+          <div class="mod-desc">Upload a face — get a privacy exposure score 0–100 with gallery-matched identities.</div>
+        </div>
+        <div class="mod-card">
+          <div class="mod-icon">🧠</div>
+          <div class="mod-name">Emotion Intelligence</div>
+          <div class="mod-tag">DeepFace · TensorFlow</div>
+          <div class="mod-desc">Age, gender and dominant emotion recognition on any face image with confidence scores.</div>
+        </div>
+        <div class="mod-card">
+          <div class="mod-icon">💬</div>
+          <div class="mod-name">NL Query Engine</div>
+          <div class="mod-tag">Groq LLaMA 3</div>
+          <div class="mod-desc">Ask in plain English or Roman Urdu — AI extracts filters and matches subjects instantly.</div>
+        </div>
+        <div class="mod-card">
+          <div class="mod-icon">⚠️</div>
+          <div class="mod-name">Weapon Detection</div>
+          <div class="mod-tag">YOLOv8 Custom · 9 Classes</div>
+          <div class="mod-desc">Handgun 89.5% · Shotgun 96.3% · SMG 98.6% — trained on 714 real-world images.</div>
+        </div>
+        <div class="mod-card">
+          <div class="mod-icon">📄</div>
+          <div class="mod-name">Intel Report</div>
+          <div class="mod-tag">fpdf2 · Cyberpunk PDF</div>
+          <div class="mod-desc">One-click classified PDF: session overview, threat alerts, subject log, query history.</div>
+        </div>
+        <div class="mod-card">
+          <div class="mod-icon">⚡</div>
+          <div class="mod-name">System Intel</div>
+          <div class="mod-tag">Live Status</div>
+          <div class="mod-desc">Module health, API endpoints, model benchmarks and full deployment information.</div>
+        </div>
+      </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    cols = st.columns([1, 2, 1])
+    with cols[1]:
+        if st.button("INITIALIZE SYSTEM  →", key="enter_btn"):
+            st.session_state.page = "home"
+            st.rerun()
+
+
+# ─────────────────────────────────────────────────────
+#  HOME — MODULE SELECTOR
+# ─────────────────────────────────────────────────────
+def home():
+    render_session_bar()
+    st.markdown('<div class="app-header">👁 PHANTOMEYE</div>', unsafe_allow_html=True)
+    st.markdown('<div class="app-sub">SELECT INTELLIGENCE MODULE · ALL SYSTEMS ACTIVE</div>', unsafe_allow_html=True)
+
+    modules = [
+        ("DETECTION", "🎯 Detection"),
+        ("ANALYTICS", "🔥 Analytics"),
+        ("OSINT",     "🕵️ OSINT"),
+        ("EMOTION",   "🧠 Emotion"),
+        ("NL QUERY",  "💬 NL Query"),
+        ("WEAPON",    "⚠️ Weapon"),
+        ("REPORT",    "📄 Report"),
+        ("INTEL",     "⚡ System"),
+    ]
+    cols = st.columns(len(modules))
+    for i, (key, label) in enumerate(modules):
+        with cols[i]:
+            if st.button(label, key=f"mod_{key}"):
+                st.session_state.page = key
+                st.rerun()
+
+    st.markdown("<hr>", unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">[ PHANTOMEYE v3.0 ] · YOLOv8 loaded · ByteTrack active · '
+        'DeepFace online · Groq LLaMA connected · Weapon model ready · All 8 modules ACTIVE</div>',
+        unsafe_allow_html=True
+    )
+
+
+# ─────────────────────────────────────────────────────
+#  SHARED BACK BUTTON
+# ─────────────────────────────────────────────────────
+def back_button():
+    if st.button("← BACK TO MODULES"):
+        st.session_state.page = "home"
+        st.rerun()
+
+
+# ─────────────────────────────────────────────────────
+#  MODULE PAGES
+# ─────────────────────────────────────────────────────
+def detection_page():
+    render_session_bar()
+    back_button()
+    st.markdown('<div class="section-hdr">🎯 Person Detection</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">YOLOv8-nano · CPU inference · upload any image</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">YOLOv8-nano · class 0 person only · '
+        'confidence threshold 0.4 · CPU optimized</div>',
+        unsafe_allow_html=True
+    )
+
+    uploaded = st.file_uploader("", type=["jpg", "jpeg", "png"], key="det_up")
+
+    if uploaded:
+        data  = np.frombuffer(uploaded.read(), np.uint8)
+        image = cv2.imdecode(data, cv2.IMREAD_COLOR)
+        if image is None:
+            st.error("Cannot decode image.")
+            return
+
+        with st.spinner("SCANNING..."):
+            detector   = load_detector()
+            t0         = time.time()
+            detections = detector.detect(image)
+            elapsed    = round(time.time() - t0, 3)
+            annotated  = detector.draw(image, detections)
+
+        c1, c2, c3, c4 = st.columns(4)
+        c1.metric("PERSONS DETECTED", len(detections))
+        c2.metric("INFERENCE TIME",   f"{elapsed}s")
+        c3.metric("MODEL",            "YOLOv8n")
+        c4.metric("DEVICE",           "CPU")
+
+        st.image(
+            cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB),
+            caption="DETECTION OUTPUT", use_container_width=True
+        )
+
+        if detections:
+            st.markdown('<div class="section-hdr">Detection Log</div>', unsafe_allow_html=True)
+            for i, d in enumerate(detections):
+                with st.expander(f"PERSON_{i+1:03d}  ·  CONF: {d['confidence']}"):
+                    st.json({"id": i+1, "bbox": list(d["bbox"]), "confidence": d["confidence"]})
+
+
+def analytics_page():
+    render_session_bar()
+    back_button()
+    st.markdown('<div class="section-hdr">🔥 Behavioral Analytics</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">ByteTrack · heatmap · dwell time · loitering alerts</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">Upload video · persistent ID tracking · '
+        'real-time behavioral heatmap generation</div>',
+        unsafe_allow_html=True
+    )
+
+    uploaded = st.file_uploader("", type=["mp4", "avi", "mov"], key="ana_up")
+
+    if uploaded:
+        tmp = Path("outputs") / f"tmp_{int(time.time())}.mp4"
+        tmp.parent.mkdir(exist_ok=True)
+        with open(tmp, "wb") as f:
+            f.write(uploaded.read())
+
+        cap   = cv2.VideoCapture(str(tmp))
+        fps   = int(cap.get(cv2.CAP_PROP_FPS)) or 25
+        w     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        h     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap.release()
+
+        st.markdown(
+            f'<div class="terminal">{w}×{h} @ {fps}fps · {total} frames loaded · '
+            f'analysis limit: {min(total, fps*15)} frames</div>',
+            unsafe_allow_html=True
+        )
+
+        if st.button("RUN BEHAVIORAL ANALYSIS"):
+            detector = load_detector()
+            tracker  = ByteTracker()
+            analyzer = BehavioralAnalyzer(w, h, fps)
+            cap      = cv2.VideoCapture(str(tmp))
+            limit    = min(total, fps * 15)
+            prog     = st.progress(0)
+            stat     = st.empty()
+
+            for i in range(limit):
+                ret, frame = cap.read()
+                if not ret: break
+                dets   = detector.detect(frame)
+                active = tracker.update(dets)
+                analyzer.update(active)
+                prog.progress(int((i / limit) * 100))
+                if i % 25 == 0:
+                    stat.markdown(
+                        f'<div class="terminal">PROCESSING FRAME {i}/{limit} · '
+                        f'ACTIVE PERSONS: {len(active)}</div>',
+                        unsafe_allow_html=True
+                    )
+
+            cap.release()
+            tmp.unlink(missing_ok=True)
+            prog.progress(100)
+            stat.empty()
+
+            s = analyzer.summary()
+            st.success("✓ ANALYSIS COMPLETE")
+
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("TOTAL PERSONS",   s.get("total_persons", 0))
+            c2.metric("AVG DWELL TIME",  f"{s.get('avg_dwell_sec', 0)}s")
+            c3.metric("MAX DWELL TIME",  f"{s.get('max_dwell_sec', 0)}s")
+            c4.metric("LOITER ALERTS",   s.get("total_alerts", 0))
+
+            if s.get("total_alerts", 0) > 0:
+                st.warning(f"⚠ LOITERING ALERT — Subject IDs: {s.get('loiterers', [])}")
+
+            heat = analyzer.get_heatmap_overlay(np.zeros((h, w, 3), dtype=np.uint8))
+            st.image(
+                cv2.cvtColor(heat, cv2.COLOR_BGR2RGB),
+                caption="BEHAVIORAL HEATMAP — RED = HIGH ACTIVITY ZONE",
+                use_container_width=True
+            )
+
+
+def osint_page():
+    render_session_bar()
+    back_button()
+    st.markdown('<div class="section-hdr">🕵️ OSINT Privacy Audit</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">Face upload · privacy exposure score · gallery match · risk report</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">LBPH embeddings · score 0–100 · '
+        'LOW / MEDIUM / HIGH risk classification</div>',
+        unsafe_allow_html=True
+    )
+
+    c1, c2 = st.columns([1, 1])
+    with c1:
+        query_file = st.file_uploader("", type=["jpg", "jpeg", "png"], key="osint_up")
+    with c2:
+        osint = load_osint()
+        st.metric("GALLERY SIZE", f"{len(osint.gallery)} persons")
+        st.metric("ENGINE",       "LBPH Face Recognition")
+
+    if query_file and st.button("EXECUTE AUDIT"):
+        data  = np.frombuffer(query_file.read(), np.uint8)
+        image = cv2.imdecode(data, cv2.IMREAD_COLOR)
+        if image is None:
+            st.error("Cannot decode image.")
+            return
+
+        with st.spinner("RUNNING OSINT AUDIT..."):
+            result = osint.audit(image, query_id=Path(query_file.name).stem)
+
+        risk    = result["risk_level"]
+        score   = result["exposure_score"]
+        matches = result["matches"]
+
+        c1, c2, c3 = st.columns(3)
+        c1.metric("RISK LEVEL",     risk)
+        c2.metric("EXPOSURE SCORE", f"{score}/100")
+        c3.metric("MATCHES FOUND",  len(matches))
+
+        st.markdown(
+            f'<div class="terminal">{result["message"]}</div>',
+            unsafe_allow_html=True
+        )
+
+        if matches:
+            st.markdown('<div class="section-hdr">Match Log</div>', unsafe_allow_html=True)
+            for m in matches:
+                st.markdown(
+                    f'<div class="terminal">MATCH: {m["matched_id"]} · '
+                    f'CONF: {m["confidence"]}% · SOURCE: {m["source"]}</div>',
+                    unsafe_allow_html=True
+                )
+
+        vis = osint.visualize(image, result)
+        st.image(
+            cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+            caption="OSINT VISUALIZATION",
+            use_container_width=True
+        )
+
+
+def emotion_page():
+    render_session_bar()
+    process_frame_emotion = load_emotion_model()
+    back_button()
+    st.markdown('<div class="section-hdr">🧠 Emotion Intelligence</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">DeepFace · Age · Gender · Dominant Emotion per face</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">DeepFace + TensorFlow · 15% min face size filter · '
+        'multi-face support</div>',
+        unsafe_allow_html=True
+    )
+
+    uploaded = st.file_uploader("Upload image", type=["jpg", "jpeg", "png"])
+
+    if uploaded:
+        from PIL import Image
+        img       = Image.open(uploaded).convert("RGB")
+        frame     = np.array(img)
+        frame_bgr = frame[:, :, ::-1].copy()
+
+        with st.spinner("ANALYZING FACES..."):
+            annotated, results = process_frame_emotion(frame_bgr)
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.image(frame, caption="ORIGINAL", use_container_width=True)
+        with col2:
+            st.image(annotated[:, :, ::-1], caption="EMOTION ANALYSIS", use_container_width=True)
+
+        if results:
+            st.markdown("<hr>")
+            st.markdown('<div class="section-hdr">Detected Subjects</div>', unsafe_allow_html=True)
+            for i, r in enumerate(results):
+                emotion = r.get("dominant_emotion", "N/A").upper()
+                age     = int(r.get("age", 0))
+                gender  = r.get("dominant_gender", r.get("gender", "N/A"))
+                if isinstance(gender, dict):
+                    gender = max(gender, key=gender.get)
+
+                c1, c2, c3 = st.columns(3)
+                c1.metric(f"SUBJECT {i+1} EMOTION", emotion)
+                c2.metric("AGE ESTIMATE",            f"{age} yrs")
+                c3.metric("GENDER",                  gender.upper())
+        else:
+            st.warning("No faces detected in this image.")
+    else:
+        st.info("Upload a face image to begin emotion analysis.")
+
+
+def nlquery_page():
+    render_session_bar()
+    from core.nlquery import parse_nl_query, apply_filters
+    back_button()
+    st.markdown('<div class="section-hdr">💬 NL Query Engine</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">Groq LLaMA 3 · English + Roman Urdu · structured filter extraction</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">llama-3.1-8b-instant · structured JSON extraction · '
+        'apply_filters() on person records</div>',
+        unsafe_allow_html=True
+    )
+
+    query = st.text_input(
+        "Enter your query",
+        placeholder="e.g.  show me angry men  |  log jo loiter kar rahy thy"
+    )
+
+    if query:
+        with st.spinner("PARSING QUERY..."):
+            result = parse_nl_query(query)
+
+        if result['success']:
+            filters = result['filters']
+            st.success(f"✓ Understood: {filters['summary']}")
+
+            col1, col2, col3 = st.columns(3)
+            col1.metric("EMOTION",   filters['emotion']  or "ANY")
+            col2.metric("GENDER",    filters['gender']   or "ANY")
+            col3.metric("MAX AGE",   filters['max_age']  or "ANY")
+
+            col4, col5 = st.columns(2)
+            col4.metric("LOITERING", "YES" if filters['loitering'] else "ANY")
+            col5.metric("MIN DWELL", f"{filters['min_dwell_seconds']}s" if filters['min_dwell_seconds'] else "ANY")
+
+            st.markdown("<hr>")
+            st.markdown('<div class="section-hdr">Simulate Against Sample Data</div>', unsafe_allow_html=True)
+
+            sample_records = [
+                {"id": 1, "emotion": "angry",   "gender": "Man",   "age": 28, "dwell_seconds": 45,  "loitering": False},
+                {"id": 2, "emotion": "neutral",  "gender": "Woman", "age": 22, "dwell_seconds": 180, "loitering": True},
+                {"id": 3, "emotion": "happy",    "gender": "Man",   "age": 35, "dwell_seconds": 20,  "loitering": False},
+                {"id": 4, "emotion": "angry",    "gender": "Man",   "age": 41, "dwell_seconds": 200, "loitering": True},
+                {"id": 5, "emotion": "sad",      "gender": "Woman", "age": 19, "dwell_seconds": 90,  "loitering": False},
+                {"id": 6, "emotion": "fear",     "gender": "Man",   "age": 26, "dwell_seconds": 310, "loitering": True},
+            ]
+
+            matched = apply_filters(sample_records, filters)
+
+            if matched:
+                st.success(f"{len(matched)} subject(s) matched out of {len(sample_records)}")
+                import pandas as pd
+                st.dataframe(pd.DataFrame(matched), use_container_width=True)
+            else:
+                st.warning("No subjects matched this query in sample data.")
+        else:
+            st.error(f"Query parse failed: {result['error']}")
+    else:
+        st.info("Type a query above — English or Roman Urdu both work.")
+
+
+def weapon_page():
+    render_session_bar()
+    back_button()
+    st.markdown('<div class="section-hdr">⚠️ Weapon Detection</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">YOLOv8 Custom · 9 classes · Handgun · Knife · Shotgun · SMG · Rifle · Sword</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">mAP50: 53.2% · Handgun: 89.5% · Shotgun: 96.3% · '
+        'SMG: 98.6% · trained on 714 real-world images</div>',
+        unsafe_allow_html=True
+    )
+
+    uploaded = st.file_uploader("Upload image", type=["jpg", "jpeg", "png"])
+
+    if uploaded:
+        from PIL import Image
+        from core.weapon import detect_weapons
+
+        img       = Image.open(uploaded).convert("RGB")
+        frame     = np.array(img)
+        frame_bgr = frame[:, :, ::-1].copy()
+        model     = load_weapon_model_cached()
+
+        with st.spinner("SCANNING FOR THREATS..."):
+            annotated, detections = detect_weapons(frame_bgr, model)
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.image(frame, caption="ORIGINAL", use_container_width=True)
+        with col2:
+            st.image(annotated[:, :, ::-1], caption="THREAT ANALYSIS", use_container_width=True)
+
+        st.markdown("<hr>")
+        if detections:
+            st.error(f"⚠ THREAT DETECTED — {len(detections)} weapon(s) found!")
+            st.markdown('<div class="section-hdr">Detected Threats</div>', unsafe_allow_html=True)
+            for d in detections:
+                c1, c2 = st.columns(2)
+                c1.metric("WEAPON CLASS", d['class_name'])
+                c2.metric("CONFIDENCE",   f"{d['confidence']:.0%}")
+        else:
+            st.success("✓ NO WEAPONS DETECTED — Scene clear")
+    else:
+        st.info("Upload an image to scan for weapons.")
+
+
+def report_page():
+    render_session_bar()
+    from core.reporter import generate_report
+    back_button()
+    st.markdown('<div class="section-hdr">📄 Intelligence Report</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">Branded cyberpunk PDF · CLASSIFIED header · one-click download</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="terminal">fpdf2 · dark bg · green text · threat alerts in red · '
+        'session + subject + query log</div>',
+        unsafe_allow_html=True
+    )
+
+    st.markdown("### SESSION DATA")
+    col1, col2 = st.columns(2)
+    with col1:
+        session_id     = st.text_input("Session ID",         value=st.session_state.get("session_id", "PE-SESSION-001"))
+        total_persons  = st.number_input("Total Persons",    min_value=0, value=5)
+        duration       = st.number_input("Duration (sec)",   min_value=0, value=300)
+    with col2:
+        loitering_alerts = st.number_input("Loitering Alerts", min_value=0, value=1)
+        nl_query         = st.text_input("NL Query (opt)",   value="")
+        nl_result        = st.text_input("NL Result (opt)",  value="")
+
+    st.markdown("### DETECTED SUBJECTS")
+    num_subjects = st.slider("Number of subjects", 1, 10, 3)
+    detections = []
+    for i in range(num_subjects):
+        c1, c2, c3, c4, c5, _ = st.columns(6)
+        detections.append({
+            "id":           i + 1,
+            "emotion":      c1.selectbox(f"Emotion {i+1}", ["neutral","angry","happy","sad","fear","surprise"], key=f"em_{i}"),
+            "gender":       c2.selectbox(f"Gender {i+1}",  ["Man","Woman"], key=f"gen_{i}"),
+            "age":          c3.number_input(f"Age {i+1}",  10, 80, 25, key=f"age_{i}"),
+            "dwell_seconds":c4.number_input(f"Dwell {i+1}",0, 600, 60, key=f"dw_{i}"),
+            "loitering":    c5.checkbox(f"Loiter {i+1}",   key=f"lo_{i}"),
+        })
+
+    st.markdown("### WEAPON DETECTIONS")
+    has_weapon = st.checkbox("Weapon detected in session?")
+    weapon_detections = []
+    if has_weapon:
+        wc1, wc2 = st.columns(2)
+        weapon_class = wc1.selectbox("Weapon Class", ["Handgun","Knife","Shotgun","SMG","Automatic Rifle","Sniper","Sword"])
+        weapon_conf  = wc2.slider("Confidence", 0.3, 1.0, 0.85)
+        weapon_detections.append({"class_name": weapon_class, "confidence": weapon_conf})
+
+    st.markdown("<hr>")
+    if st.button("GENERATE PDF REPORT", type="primary"):
+        data = {
+            "session_id":       session_id,
+            "total_persons":    total_persons,
+            "duration_seconds": duration,
+            "loitering_alerts": loitering_alerts,
+            "weapon_detections":weapon_detections,
+            "detections":       detections,
+            "heatmap_img":      None,
+            "frame_sample":     None,
+            "nl_query":         nl_query,
+            "nl_result":        nl_result,
+        }
+        with st.spinner("GENERATING CLASSIFIED REPORT..."):
+            path = generate_report(data)
+
+        with open(path, "rb") as f:
+            pdf_bytes = f.read()
+
+        st.success("✓ Report generated successfully!")
+        st.download_button(
+            label="⬇ DOWNLOAD PDF REPORT",
+            data=pdf_bytes,
+            file_name=f"phantomeye_report_{session_id}.pdf",
+            mime="application/pdf"
+        )
+
+
+def intel_page():
+    render_session_bar()
+    back_button()
+    st.markdown('<div class="section-hdr">⚡ System Intelligence</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-sub">Module health · API endpoints · model benchmarks</div>', unsafe_allow_html=True)
+
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("SYSTEM",   "PhantomEye")
+    c2.metric("VERSION",  "v3.0.0")
+    c3.metric("STATUS",   "ONLINE")
+    c4.metric("MODULES",  "8 ACTIVE")
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    modules_info = [
+        ("DETECTION",  "YOLOv8-nano",    "Person detection · class 0 · confidence 0.4+ · CPU optimized"),
+        ("ANALYTICS",  "ByteTrack",      "Persistent ID tracking · heatmap · dwell time · loitering alerts"),
+        ("OSINT",      "LBPH Face",      "Privacy exposure score 0–100 · gallery match · LOW/MEDIUM/HIGH risk"),
+        ("EMOTION",    "DeepFace + TF",  "Age · Gender · Dominant Emotion · 15% face size filter"),
+        ("NL QUERY",   "Groq LLaMA 3",  "llama-3.1-8b-instant · English + Roman Urdu · JSON filter extraction"),
+        ("WEAPON",     "YOLOv8 Custom", "9 classes · mAP50 53.2% · Handgun 89.5% · Shotgun 96.3% · SMG 98.6%"),
+        ("REPORT",     "fpdf2",          "Dark cyberpunk PDF · CLASSIFIED header · threat + subject + query log"),
+        ("API",        "FastAPI",         "12 endpoints · OAS 3.1 · CORS enabled · Railway deployed"),
+    ]
+
+    for name, tech, desc in modules_info:
+        with st.expander(f"{'●'} {name}  ·  {tech}  ·  ACTIVE"):
+            st.markdown(f'<div class="terminal">{desc}</div>', unsafe_allow_html=True)
+
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.json({
+        "author":    "Abu-Sameer-66",
+        "github":    "https://github.com/Abu-Sameer-66/PhantomEye",
+        "huggingface": "https://abu-sameer-66-phantomeye.hf.space",
+        "railway_api": "https://phantomeye-production.up.railway.app",
+        "api_docs":  "https://phantomeye-production.up.railway.app/docs",
+        "stack":     ["Python 3.10", "YOLOv8", "DeepFace", "FastAPI", "Streamlit", "Groq"],
+        "status":    "online",
+        "access":    "open — no auth required",
+    })
+
+
+# ─────────────────────────────────────────────────────
+#  MAIN ROUTER
+# ─────────────────────────────────────────────────────
+def main():
+    if "page"       not in st.session_state:
+        st.session_state.page = "landing"
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = "PE-" + str(uuid.uuid4())[:8].upper()
+
+    page = st.session_state.page
+
+    if   page == "landing":  landing()
+    elif page == "home":     home()
+    elif page == "DETECTION": detection_page()
+    elif page == "ANALYTICS": analytics_page()
+    elif page == "OSINT":    osint_page()
+    elif page == "EMOTION":  emotion_page()
+    elif page == "NL QUERY": nlquery_page()
+    elif page == "WEAPON":   weapon_page()
+    elif page == "REPORT":   report_page()
+    elif page == "INTEL":    intel_page()
+
+
+if __name__ == "__main__":
     main()

config.py

@@ -1,36 +1,36 @@
-import os
-from pathlib import Path
-
-BASE_DIR = Path(__file__).resolve().parent
-
-# Paths
-DATA_DIR = BASE_DIR / "data"
-VIDEOS_DIR = DATA_DIR / "videos"
-GALLERY_DIR = DATA_DIR / "gallery"
-MODELS_DIR = BASE_DIR / "models"
-OUTPUTS_DIR = BASE_DIR / "outputs"
-
-# Detection settings
-DETECTION_CONF = 0.45
-DETECTION_MODEL = "yolov8n.pt"
-DEVICE = "cpu"
-
-# Tracking settings
-TRACK_MAX_AGE = 30
-TRACK_MIN_HITS = 3
-TRACK_IOU_THRESH = 0.3
-
-# Re-ID settings
-REID_MODEL = "osnet_x0_25"
-REID_THRESHOLD = 0.65
-
-# API settings
-API_HOST = "0.0.0.0"
-API_PORT = 8000
-SECRET_KEY = "phantomeye-secret-key-change-in-production"
-
-# Analytics settings
-HEATMAP_ALPHA = 0.6
-DWELL_TIME_THRESHOLD = 30
-
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent
+
+# Paths
+DATA_DIR = BASE_DIR / "data"
+VIDEOS_DIR = DATA_DIR / "videos"
+GALLERY_DIR = DATA_DIR / "gallery"
+MODELS_DIR = BASE_DIR / "models"
+OUTPUTS_DIR = BASE_DIR / "outputs"
+
+# Detection settings
+DETECTION_CONF = 0.45
+DETECTION_MODEL = "yolov8n.pt"
+DEVICE = "cpu"
+
+# Tracking settings
+TRACK_MAX_AGE = 30
+TRACK_MIN_HITS = 3
+TRACK_IOU_THRESH = 0.3
+
+# Re-ID settings
+REID_MODEL = "osnet_x0_25"
+REID_THRESHOLD = 0.65
+
+# API settings
+API_HOST = "0.0.0.0"
+API_PORT = 8000
+SECRET_KEY = "phantomeye-secret-key-change-in-production"
+
+# Analytics settings
+HEATMAP_ALPHA = 0.6
+DWELL_TIME_THRESHOLD = 30
+
 print(f"[PhantomEye] Config loaded — Base: {BASE_DIR}")

core/analytics.py

@@ -1,241 +1,241 @@
-import cv2
-import time
-import numpy as np
-from pathlib import Path
-from collections import defaultdict
-
-import sys
-sys.path.append(str(Path(__file__).resolve().parent.parent))
-
-from core.detection import PersonDetector
-from core.tracker import ByteTracker
-from config import OUTPUTS_DIR, HEATMAP_ALPHA, DWELL_TIME_THRESHOLD
-
-
-class BehavioralAnalyzer:
-
-    def __init__(self, frame_width: int, frame_height: int, fps: int = 25):
-        self.width      = frame_width
-        self.height     = frame_height
-        self.fps        = fps
-        self.heatmap    = np.zeros((frame_height, frame_width), dtype=np.float32)
-        self.dwell      = defaultdict(int)
-        self.last_pos   = {}
-        self.alerts     = []
-        self.frame_num  = 0
-        print("[PhantomEye] Behavioral analyzer ready")
-
-    def update(self, active_tracks: list):
-        self.frame_num += 1
-
-        for trk in active_tracks:
-            cx, cy = trk.center()
-
-            cx = max(0, min(cx, self.width  - 1))
-            cy = max(0, min(cy, self.height - 1))
-
-            cv2.circle(
-                self.heatmap,
-                (cx, cy), 25, 1.0, -1
-            )
-
-            self.dwell[trk.track_id] += 1
-
-            dwell_secs = self.dwell[trk.track_id] / self.fps
-            if dwell_secs >= DWELL_TIME_THRESHOLD:
-                already = any(
-                    a["id"] == trk.track_id and a["type"] == "loitering"
-                    for a in self.alerts
-                )
-                if not already:
-                    self.alerts.append({
-                        "type"     : "loitering",
-                        "id"       : trk.track_id,
-                        "bbox"     : trk.bbox,
-                        "dwell_sec": round(dwell_secs, 1),
-                        "frame"    : self.frame_num,
-                    })
-
-    def get_heatmap_overlay(self, frame: np.ndarray) -> np.ndarray:
-        if self.heatmap.max() == 0:
-            return frame
-
-        normalized = cv2.normalize(
-            self.heatmap, None, 0, 255, cv2.NORM_MINMAX
-        )
-        heat_uint8  = normalized.astype(np.uint8)
-        heat_color  = cv2.applyColorMap(heat_uint8, cv2.COLORMAP_JET)
-        blurred     = cv2.GaussianBlur(heat_color, (31, 31), 0)
-
-        mask   = heat_uint8 > 10
-        output = frame.copy()
-        output[mask] = cv2.addWeighted(
-            frame, 1 - HEATMAP_ALPHA,
-            blurred, HEATMAP_ALPHA, 0
-        )[mask]
-
-        return output
-
-    def draw_alerts(self, frame: np.ndarray, active_tracks: list) -> np.ndarray:
-        out = frame.copy()
-
-        active_ids = {t.track_id for t in active_tracks}
-        recent = [
-            a for a in self.alerts
-            if a["id"] in active_ids and a["type"] == "loitering"
-        ]
-
-        for alert in recent:
-            x1, y1, x2, y2 = alert["bbox"]
-            cv2.rectangle(out, (x1, y1), (x2, y2), (0, 0, 255), 3)
-            label = f"ALERT ID:{alert['id']} {alert['dwell_sec']}s"
-            cv2.putText(
-                out, label,
-                (x1, y1 - 10),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.6,
-                (0, 0, 255), 2, cv2.LINE_AA
-            )
-
-        return out
-
-    def draw_dwell_info(self, frame: np.ndarray, active_tracks: list) -> np.ndarray:
-        out = frame.copy()
-
-        for trk in active_tracks:
-            x1, y1, x2, y2 = trk.bbox
-            secs = round(self.dwell[trk.track_id] / self.fps, 1)
-            cv2.putText(
-                out,
-                f"{secs}s",
-                (x1, y2 + 16),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.45,
-                (255, 255, 0), 1, cv2.LINE_AA
-            )
-
-        return out
-
-    def summary(self) -> dict:
-        if not self.dwell:
-            return {}
-
-        dwell_secs = {
-            k: round(v / self.fps, 1)
-            for k, v in self.dwell.items()
-        }
-        return {
-            "total_persons" : len(self.dwell),
-            "total_alerts"  : len(self.alerts),
-            "avg_dwell_sec" : round(
-                sum(dwell_secs.values()) / len(dwell_secs), 2
-            ),
-            "max_dwell_sec" : max(dwell_secs.values()),
-            "loiterers"     : [
-                a["id"] for a in self.alerts
-                if a["type"] == "loitering"
-            ],
-        }
-
-
-def run_analytics(video_path: str, save: bool = True, show: bool = True):
-
-    video_path = Path(video_path)
-    if not video_path.exists():
-        print(f"[ERROR] Video not found: {video_path}")
-        return
-
-    detector = PersonDetector()
-    tracker  = ByteTracker()
-    cap      = cv2.VideoCapture(str(video_path))
-
-    if not cap.isOpened():
-        print(f"[ERROR] Cannot open: {video_path}")
-        return
-
-    fps    = int(cap.get(cv2.CAP_PROP_FPS)) or 25
-    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    total  = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-
-    analyzer = BehavioralAnalyzer(width, height, fps)
-
-    print(f"[PhantomEye] {video_path.name} — {width}x{height} {fps}fps")
-
-    writer = None
-    if save:
-        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
-        out_path = OUTPUTS_DIR / (video_path.stem + "_analytics.mp4")
-        writer   = cv2.VideoWriter(
-            str(out_path),
-            cv2.VideoWriter_fourcc(*"mp4v"),
-            fps, (width, height)
-        )
-        print(f"[PhantomEye] Saving to: {out_path}")
-
-    show_heat  = False
-    start_time = time.time()
-
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-
-        detections    = detector.detect(frame)
-        active_tracks = tracker.update(detections)
-        analyzer.update(active_tracks)
-
-        if show_heat:
-            display = analyzer.get_heatmap_overlay(frame)
-        else:
-            display = frame.copy()
-
-        display = tracker.draw(display, active_tracks)
-        display = analyzer.draw_dwell_info(display, active_tracks)
-        display = analyzer.draw_alerts(display, active_tracks)
-
-        mode_text = "MODE: HEATMAP [H]" if show_heat else "MODE: TRACKING [H]"
-        cv2.putText(
-            display, mode_text,
-            (width - 220, height - 12),
-            cv2.FONT_HERSHEY_SIMPLEX, 0.45,
-            (200, 200, 200), 1, cv2.LINE_AA
-        )
-
-        if writer:
-            writer.write(display)
-
-        if show:
-            cv2.imshow("PhantomEye — Analytics  [H=heatmap  Q=quit]", display)
-            key = cv2.waitKey(1) & 0xFF
-            if key == ord("q"):
-                break
-            elif key == ord("h"):
-                show_heat = not show_heat
-
-        if tracker.frame_count % 30 == 0:
-            print(
-                f"\r[Frame {tracker.frame_count}/{total}]"
-                f"  Active: {len(active_tracks)}"
-                f"  Alerts: {len(analyzer.alerts)}"
-                f"  Time: {time.time()-start_time:.1f}s",
-                end=""
-            )
-
-    cap.release()
-    if writer:
-        writer.release()
-    cv2.destroyAllWindows()
-
-    summary = analyzer.summary()
-    print(f"\n\n[PhantomEye] Analytics done!")
-    print(f"  Total persons tracked : {summary.get('total_persons', 0)}")
-    print(f"  Avg dwell time        : {summary.get('avg_dwell_sec', 0)}s")
-    print(f"  Max dwell time        : {summary.get('max_dwell_sec', 0)}s")
-    print(f"  Loitering alerts      : {summary.get('total_alerts', 0)}")
-
-
-if __name__ == "__main__":
-    import sys
-    if len(sys.argv) < 2:
-        print("Usage: python core/analytics.py <video_path>")
-    else:
+import cv2
+import time
+import numpy as np
+from pathlib import Path
+from collections import defaultdict
+
+import sys
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+
+from core.detection import PersonDetector
+from core.tracker import ByteTracker
+from config import OUTPUTS_DIR, HEATMAP_ALPHA, DWELL_TIME_THRESHOLD
+
+
+class BehavioralAnalyzer:
+
+    def __init__(self, frame_width: int, frame_height: int, fps: int = 25):
+        self.width      = frame_width
+        self.height     = frame_height
+        self.fps        = fps
+        self.heatmap    = np.zeros((frame_height, frame_width), dtype=np.float32)
+        self.dwell      = defaultdict(int)
+        self.last_pos   = {}
+        self.alerts     = []
+        self.frame_num  = 0
+        print("[PhantomEye] Behavioral analyzer ready")
+
+    def update(self, active_tracks: list):
+        self.frame_num += 1
+
+        for trk in active_tracks:
+            cx, cy = trk.center()
+
+            cx = max(0, min(cx, self.width  - 1))
+            cy = max(0, min(cy, self.height - 1))
+
+            cv2.circle(
+                self.heatmap,
+                (cx, cy), 25, 1.0, -1
+            )
+
+            self.dwell[trk.track_id] += 1
+
+            dwell_secs = self.dwell[trk.track_id] / self.fps
+            if dwell_secs >= DWELL_TIME_THRESHOLD:
+                already = any(
+                    a["id"] == trk.track_id and a["type"] == "loitering"
+                    for a in self.alerts
+                )
+                if not already:
+                    self.alerts.append({
+                        "type"     : "loitering",
+                        "id"       : trk.track_id,
+                        "bbox"     : trk.bbox,
+                        "dwell_sec": round(dwell_secs, 1),
+                        "frame"    : self.frame_num,
+                    })
+
+    def get_heatmap_overlay(self, frame: np.ndarray) -> np.ndarray:
+        if self.heatmap.max() == 0:
+            return frame
+
+        normalized = cv2.normalize(
+            self.heatmap, None, 0, 255, cv2.NORM_MINMAX
+        )
+        heat_uint8  = normalized.astype(np.uint8)
+        heat_color  = cv2.applyColorMap(heat_uint8, cv2.COLORMAP_JET)
+        blurred     = cv2.GaussianBlur(heat_color, (31, 31), 0)
+
+        mask   = heat_uint8 > 10
+        output = frame.copy()
+        output[mask] = cv2.addWeighted(
+            frame, 1 - HEATMAP_ALPHA,
+            blurred, HEATMAP_ALPHA, 0
+        )[mask]
+
+        return output
+
+    def draw_alerts(self, frame: np.ndarray, active_tracks: list) -> np.ndarray:
+        out = frame.copy()
+
+        active_ids = {t.track_id for t in active_tracks}
+        recent = [
+            a for a in self.alerts
+            if a["id"] in active_ids and a["type"] == "loitering"
+        ]
+
+        for alert in recent:
+            x1, y1, x2, y2 = alert["bbox"]
+            cv2.rectangle(out, (x1, y1), (x2, y2), (0, 0, 255), 3)
+            label = f"ALERT ID:{alert['id']} {alert['dwell_sec']}s"
+            cv2.putText(
+                out, label,
+                (x1, y1 - 10),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6,
+                (0, 0, 255), 2, cv2.LINE_AA
+            )
+
+        return out
+
+    def draw_dwell_info(self, frame: np.ndarray, active_tracks: list) -> np.ndarray:
+        out = frame.copy()
+
+        for trk in active_tracks:
+            x1, y1, x2, y2 = trk.bbox
+            secs = round(self.dwell[trk.track_id] / self.fps, 1)
+            cv2.putText(
+                out,
+                f"{secs}s",
+                (x1, y2 + 16),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.45,
+                (255, 255, 0), 1, cv2.LINE_AA
+            )
+
+        return out
+
+    def summary(self) -> dict:
+        if not self.dwell:
+            return {}
+
+        dwell_secs = {
+            k: round(v / self.fps, 1)
+            for k, v in self.dwell.items()
+        }
+        return {
+            "total_persons" : len(self.dwell),
+            "total_alerts"  : len(self.alerts),
+            "avg_dwell_sec" : round(
+                sum(dwell_secs.values()) / len(dwell_secs), 2
+            ),
+            "max_dwell_sec" : max(dwell_secs.values()),
+            "loiterers"     : [
+                a["id"] for a in self.alerts
+                if a["type"] == "loitering"
+            ],
+        }
+
+
+def run_analytics(video_path: str, save: bool = True, show: bool = True):
+
+    video_path = Path(video_path)
+    if not video_path.exists():
+        print(f"[ERROR] Video not found: {video_path}")
+        return
+
+    detector = PersonDetector()
+    tracker  = ByteTracker()
+    cap      = cv2.VideoCapture(str(video_path))
+
+    if not cap.isOpened():
+        print(f"[ERROR] Cannot open: {video_path}")
+        return
+
+    fps    = int(cap.get(cv2.CAP_PROP_FPS)) or 25
+    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total  = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    analyzer = BehavioralAnalyzer(width, height, fps)
+
+    print(f"[PhantomEye] {video_path.name} — {width}x{height} {fps}fps")
+
+    writer = None
+    if save:
+        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+        out_path = OUTPUTS_DIR / (video_path.stem + "_analytics.mp4")
+        writer   = cv2.VideoWriter(
+            str(out_path),
+            cv2.VideoWriter_fourcc(*"mp4v"),
+            fps, (width, height)
+        )
+        print(f"[PhantomEye] Saving to: {out_path}")
+
+    show_heat  = False
+    start_time = time.time()
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        detections    = detector.detect(frame)
+        active_tracks = tracker.update(detections)
+        analyzer.update(active_tracks)
+
+        if show_heat:
+            display = analyzer.get_heatmap_overlay(frame)
+        else:
+            display = frame.copy()
+
+        display = tracker.draw(display, active_tracks)
+        display = analyzer.draw_dwell_info(display, active_tracks)
+        display = analyzer.draw_alerts(display, active_tracks)
+
+        mode_text = "MODE: HEATMAP [H]" if show_heat else "MODE: TRACKING [H]"
+        cv2.putText(
+            display, mode_text,
+            (width - 220, height - 12),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.45,
+            (200, 200, 200), 1, cv2.LINE_AA
+        )
+
+        if writer:
+            writer.write(display)
+
+        if show:
+            cv2.imshow("PhantomEye — Analytics  [H=heatmap  Q=quit]", display)
+            key = cv2.waitKey(1) & 0xFF
+            if key == ord("q"):
+                break
+            elif key == ord("h"):
+                show_heat = not show_heat
+
+        if tracker.frame_count % 30 == 0:
+            print(
+                f"\r[Frame {tracker.frame_count}/{total}]"
+                f"  Active: {len(active_tracks)}"
+                f"  Alerts: {len(analyzer.alerts)}"
+                f"  Time: {time.time()-start_time:.1f}s",
+                end=""
+            )
+
+    cap.release()
+    if writer:
+        writer.release()
+    cv2.destroyAllWindows()
+
+    summary = analyzer.summary()
+    print(f"\n\n[PhantomEye] Analytics done!")
+    print(f"  Total persons tracked : {summary.get('total_persons', 0)}")
+    print(f"  Avg dwell time        : {summary.get('avg_dwell_sec', 0)}s")
+    print(f"  Max dwell time        : {summary.get('max_dwell_sec', 0)}s")
+    print(f"  Loitering alerts      : {summary.get('total_alerts', 0)}")
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python core/analytics.py <video_path>")
+    else:
         run_analytics(sys.argv[1])

core/detection.py

@@ -1,173 +1,173 @@
-import cv2
-import time
-import numpy as np
-from pathlib import Path
-from ultralytics import YOLO
-
-import sys
-sys.path.append(str(Path(__file__).resolve().parent.parent))
-from config import DETECTION_CONF, DETECTION_MODEL, DEVICE, OUTPUTS_DIR
-
-
-class PersonDetector:
-
-    def __init__(self):
-        self.model = YOLO(DETECTION_MODEL)
-        self.conf  = DETECTION_CONF
-        self.device = DEVICE
-        self.frame_count = 0
-        self.total_detections = 0
-        print(f"[PhantomEye] Detector ready — model: {DETECTION_MODEL}  device: {DEVICE}")
-
-    def detect(self, frame: np.ndarray) -> list:
-        results = self.model(
-            frame,
-            conf=self.conf,
-            classes=[0],
-            device=self.device,
-            verbose=False
-        )[0]
-
-        detections = []
-        for box in results.boxes:
-            x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
-            conf_score = float(box.conf[0])
-            detections.append({
-                "bbox"      : (x1, y1, x2, y2),
-                "confidence": round(conf_score, 3),
-                "cx"        : (x1 + x2) // 2,
-                "cy"        : (x1 + x2) // 2,
-            })
-
-        self.frame_count += 1
-        self.total_detections += len(detections)
-        return detections
-
-    def draw(self, frame: np.ndarray, detections: list) -> np.ndarray:
-        out = frame.copy()
-
-        for i, det in enumerate(detections):
-            x1, y1, x2, y2 = det["bbox"]
-            conf = det["confidence"]
-
-            cv2.rectangle(out, (x1, y1), (x2, y2), (0, 255, 100), 2)
-
-            label = f"Person  {conf:.2f}"
-            label_w, label_h = cv2.getTextSize(
-                label, cv2.FONT_HERSHEY_SIMPLEX, 0.55, 1
-            )[0]
-            cv2.rectangle(
-                out,
-                (x1, y1 - label_h - 8),
-                (x1 + label_w + 4, y1),
-                (0, 255, 100), -1
-            )
-            cv2.putText(
-                out, label,
-                (x1 + 2, y1 - 5),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.55,
-                (0, 0, 0), 1, cv2.LINE_AA
-            )
-
-        header = f"PhantomEye  |  Frame: {self.frame_count}  |  Persons: {len(detections)}"
-        cv2.rectangle(out, (0, 0), (len(header) * 9 + 10, 28), (0, 0, 0), -1)
-        cv2.putText(
-            out, header,
-            (6, 18),
-            cv2.FONT_HERSHEY_SIMPLEX, 0.55,
-            (0, 255, 100), 1, cv2.LINE_AA
-        )
-
-        return out
-
-    def stats(self) -> dict:
-        avg = (
-            round(self.total_detections / self.frame_count, 2)
-            if self.frame_count > 0 else 0
-        )
-        return {
-            "total_frames"    : self.frame_count,
-            "total_detections": self.total_detections,
-            "avg_per_frame"   : avg,
-        }
-
-
-def run_on_video(video_path: str, save: bool = True, show: bool = True):
-
-    video_path = Path(video_path)
-    if not video_path.exists():
-        print(f"[ERROR] Video not found: {video_path}")
-        return
-
-    detector = PersonDetector()
-    cap      = cv2.VideoCapture(str(video_path))
-
-    if not cap.isOpened():
-        print(f"[ERROR] Cannot open video: {video_path}")
-        return
-
-    fps    = int(cap.get(cv2.CAP_PROP_FPS)) or 25
-    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    total  = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-
-    print(f"[PhantomEye] Video  : {video_path.name}")
-    print(f"[PhantomEye] Size   : {width}x{height}  FPS: {fps}  Frames: {total}")
-
-    writer = None
-    if save:
-        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
-        out_path = OUTPUTS_DIR / (video_path.stem + "_detected.mp4")
-        fourcc   = cv2.VideoWriter_fourcc(*"mp4v")
-        writer   = cv2.VideoWriter(str(out_path), fourcc, fps, (width, height))
-        print(f"[PhantomEye] Saving : {out_path}")
-
-    start_time = time.time()
-
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-
-        detections = detector.detect(frame)
-        annotated  = detector.draw(frame, detections)
-
-        if writer:
-            writer.write(annotated)
-
-        if show:
-            cv2.imshow("PhantomEye — Detection  [Q to quit]", annotated)
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                print("\n[PhantomEye] Stopped by user.")
-                break
-
-        if detector.frame_count % 30 == 0:
-            elapsed = time.time() - start_time
-            print(
-                f"\r[Frame {detector.frame_count}/{total}]  "
-                f"Persons: {len(detections)}  "
-                f"Elapsed: {elapsed:.1f}s",
-                end=""
-            )
-
-    cap.release()
-    if writer:
-        writer.release()
-    cv2.destroyAllWindows()
-
-    stats = detector.stats()
-    print(f"\n\n[PhantomEye] DONE")
-    print(f"  Frames processed : {stats['total_frames']}")
-    print(f"  Total detections : {stats['total_detections']}")
-    print(f"  Avg persons/frame: {stats['avg_per_frame']}")
-    if save:
-        print(f"  Output saved to  : {OUTPUTS_DIR}")
-
-
-if __name__ == "__main__":
-    import sys
-    if len(sys.argv) < 2:
-        print("Usage: python core/detection.py <video_path>")
-        print("Example: python core/detection.py data/videos/test.mp4")
-    else:
+import cv2
+import time
+import numpy as np
+from pathlib import Path
+from ultralytics import YOLO
+
+import sys
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from config import DETECTION_CONF, DETECTION_MODEL, DEVICE, OUTPUTS_DIR
+
+
+class PersonDetector:
+
+    def __init__(self):
+        self.model = YOLO(DETECTION_MODEL)
+        self.conf  = DETECTION_CONF
+        self.device = DEVICE
+        self.frame_count = 0
+        self.total_detections = 0
+        print(f"[PhantomEye] Detector ready — model: {DETECTION_MODEL}  device: {DEVICE}")
+
+    def detect(self, frame: np.ndarray) -> list:
+        results = self.model(
+            frame,
+            conf=self.conf,
+            classes=[0],
+            device=self.device,
+            verbose=False
+        )[0]
+
+        detections = []
+        for box in results.boxes:
+            x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
+            conf_score = float(box.conf[0])
+            detections.append({
+                "bbox"      : (x1, y1, x2, y2),
+                "confidence": round(conf_score, 3),
+                "cx"        : (x1 + x2) // 2,
+                "cy"        : (x1 + x2) // 2,
+            })
+
+        self.frame_count += 1
+        self.total_detections += len(detections)
+        return detections
+
+    def draw(self, frame: np.ndarray, detections: list) -> np.ndarray:
+        out = frame.copy()
+
+        for i, det in enumerate(detections):
+            x1, y1, x2, y2 = det["bbox"]
+            conf = det["confidence"]
+
+            cv2.rectangle(out, (x1, y1), (x2, y2), (0, 255, 100), 2)
+
+            label = f"Person  {conf:.2f}"
+            label_w, label_h = cv2.getTextSize(
+                label, cv2.FONT_HERSHEY_SIMPLEX, 0.55, 1
+            )[0]
+            cv2.rectangle(
+                out,
+                (x1, y1 - label_h - 8),
+                (x1 + label_w + 4, y1),
+                (0, 255, 100), -1
+            )
+            cv2.putText(
+                out, label,
+                (x1 + 2, y1 - 5),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+                (0, 0, 0), 1, cv2.LINE_AA
+            )
+
+        header = f"PhantomEye  |  Frame: {self.frame_count}  |  Persons: {len(detections)}"
+        cv2.rectangle(out, (0, 0), (len(header) * 9 + 10, 28), (0, 0, 0), -1)
+        cv2.putText(
+            out, header,
+            (6, 18),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+            (0, 255, 100), 1, cv2.LINE_AA
+        )
+
+        return out
+
+    def stats(self) -> dict:
+        avg = (
+            round(self.total_detections / self.frame_count, 2)
+            if self.frame_count > 0 else 0
+        )
+        return {
+            "total_frames"    : self.frame_count,
+            "total_detections": self.total_detections,
+            "avg_per_frame"   : avg,
+        }
+
+
+def run_on_video(video_path: str, save: bool = True, show: bool = True):
+
+    video_path = Path(video_path)
+    if not video_path.exists():
+        print(f"[ERROR] Video not found: {video_path}")
+        return
+
+    detector = PersonDetector()
+    cap      = cv2.VideoCapture(str(video_path))
+
+    if not cap.isOpened():
+        print(f"[ERROR] Cannot open video: {video_path}")
+        return
+
+    fps    = int(cap.get(cv2.CAP_PROP_FPS)) or 25
+    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total  = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    print(f"[PhantomEye] Video  : {video_path.name}")
+    print(f"[PhantomEye] Size   : {width}x{height}  FPS: {fps}  Frames: {total}")
+
+    writer = None
+    if save:
+        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+        out_path = OUTPUTS_DIR / (video_path.stem + "_detected.mp4")
+        fourcc   = cv2.VideoWriter_fourcc(*"mp4v")
+        writer   = cv2.VideoWriter(str(out_path), fourcc, fps, (width, height))
+        print(f"[PhantomEye] Saving : {out_path}")
+
+    start_time = time.time()
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        detections = detector.detect(frame)
+        annotated  = detector.draw(frame, detections)
+
+        if writer:
+            writer.write(annotated)
+
+        if show:
+            cv2.imshow("PhantomEye — Detection  [Q to quit]", annotated)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                print("\n[PhantomEye] Stopped by user.")
+                break
+
+        if detector.frame_count % 30 == 0:
+            elapsed = time.time() - start_time
+            print(
+                f"\r[Frame {detector.frame_count}/{total}]  "
+                f"Persons: {len(detections)}  "
+                f"Elapsed: {elapsed:.1f}s",
+                end=""
+            )
+
+    cap.release()
+    if writer:
+        writer.release()
+    cv2.destroyAllWindows()
+
+    stats = detector.stats()
+    print(f"\n\n[PhantomEye] DONE")
+    print(f"  Frames processed : {stats['total_frames']}")
+    print(f"  Total detections : {stats['total_detections']}")
+    print(f"  Avg persons/frame: {stats['avg_per_frame']}")
+    if save:
+        print(f"  Output saved to  : {OUTPUTS_DIR}")
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python core/detection.py <video_path>")
+        print("Example: python core/detection.py data/videos/test.mp4")
+    else:
         run_on_video(sys.argv[1])

core/emotion.py

@@ -0,0 +1,95 @@
+import cv2
+import numpy as np
+from deepface import DeepFace
+
+
+# Suppress TF logs
+import os
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
+
+
+EMOTION_COLORS = {
+    "happy":     (0, 255, 128),
+    "sad":       (255, 100, 50),
+    "angry":     (0, 0, 255),
+    "fear":      (180, 0, 255),
+    "surprise":  (0, 220, 255),
+    "disgust":   (0, 140, 60),
+    "neutral":   (0, 255, 136),
+}
+
+FONT = cv2.FONT_HERSHEY_SIMPLEX
+
+
+def analyze_faces(frame: np.ndarray) -> list[dict]:
+    try:
+        results = DeepFace.analyze(
+            img_path=frame,
+            actions=["age", "gender", "emotion"],
+            detector_backend="opencv",
+            enforce_detection=False,
+            silent=True,
+        )
+        results = results if isinstance(results, list) else [results]
+
+        h, w = frame.shape[:2]
+        min_face = int(min(h, w) * 0.25)
+        filtered = [
+            r for r in results
+            if r.get("region", {}).get("w", 0) >= min_face
+            and r.get("region", {}).get("h", 0) >= min_face
+        ]
+        return filtered
+    except Exception:
+        return []
+
+def draw_emotion_overlays(frame: np.ndarray, results: list[dict]) -> np.ndarray:
+    """
+    Draw age, gender, emotion overlay boxes on frame for each detected face.
+    """
+    for face in results:
+        region = face.get("region", {})
+        x = region.get("x", 0)
+        y = region.get("y", 0)
+        w = region.get("w", 0)
+        h = region.get("h", 0)
+
+        if w == 0 or h == 0:
+            continue
+
+        emotion = face.get("dominant_emotion", "neutral")
+        age = int(face.get("age", 0))
+        gender = face.get("dominant_gender", face.get("gender", "Unknown"))
+
+        if isinstance(gender, dict):
+            gender = max(gender, key=gender.get)
+
+        color = EMOTION_COLORS.get(emotion, (0, 255, 136))
+
+        # Face bounding box
+        cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
+
+        # Top label — emotion
+        label_emotion = f"{emotion.upper()}"
+        cv2.rectangle(frame, (x, y - 22), (x + w, y), color, -1)
+        cv2.putText(frame, label_emotion, (x + 4, y - 6),
+                    FONT, 0.52, (0, 0, 0), 1, cv2.LINE_AA)
+
+        # Bottom label — age + gender
+        label_demo = f"Age:{age}  {gender}"
+        cv2.rectangle(frame, (x, y + h), (x + w, y + h + 22), color, -1)
+        cv2.putText(frame, label_demo, (x + 4, y + h + 15),
+                    FONT, 0.52, (0, 0, 0), 1, cv2.LINE_AA)
+
+    return frame
+
+
+def process_frame_emotion(frame: np.ndarray) -> tuple[np.ndarray, list[dict]]:
+    """
+    Main entry point — analyze + draw.
+    Returns annotated frame and raw results list.
+    """
+    results = analyze_faces(frame)
+    annotated = draw_emotion_overlays(frame.copy(), results)
+    return annotated, results

core/nlquery.py

@@ -0,0 +1,79 @@
+import os
+import json
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+SYSTEM_PROMPT = """You are an AI surveillance query parser for PhantomEye system.
+User gives natural language queries about tracked people in a surveillance scene.
+You extract structured filters from the query.
+
+Return ONLY valid JSON with these fields:
+{
+  "emotion": null or one of ["angry","happy","sad","fear","surprise","disgust","neutral"],
+  "gender": null or "Man" or "Woman",
+  "min_age": null or integer,
+  "max_age": null or integer,
+  "min_dwell_seconds": null or integer,
+  "loitering": null or true or false,
+  "summary": "one line human readable summary of the filter"
+}
+
+Examples:
+"show me all angry men" -> {"emotion":"angry","gender":"Man","min_age":null,"max_age":null,"min_dwell_seconds":null,"loitering":null,"summary":"Angry men"}
+"who was loitering?" -> {"emotion":null,"gender":null,"min_age":null,"max_age":null,"min_dwell_seconds":null,"loitering":true,"summary":"People detected loitering"}
+"young women under 30" -> {"emotion":null,"gender":"Woman","min_age":null,"max_age":30,"min_dwell_seconds":null,"loitering":null,"summary":"Women under 30 years old"}
+"people who stayed more than 2 minutes" -> {"emotion":null,"gender":null,"min_age":null,"max_age":null,"min_dwell_seconds":120,"loitering":null,"summary":"People with dwell time over 2 minutes"}
+"""
+
+
+def parse_nl_query(query: str) -> dict:
+    """
+    Convert natural language query to structured filter dict via Groq LLM.
+    Returns parsed filter or error dict.
+    """
+    try:
+        response = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": query}
+            ],
+            temperature=0.1,
+            max_tokens=256,
+        )
+        raw = response.choices[0].message.content.strip()
+        # Strip markdown fences if present
+        if raw.startswith("```"):
+            raw = raw.split("```")[1]
+            if raw.startswith("json"):
+                raw = raw[4:]
+        parsed = json.loads(raw.strip())
+        return {"success": True, "filters": parsed}
+    except Exception as e:
+        return {"success": False, "error": str(e), "filters": {}}
+
+
+def apply_filters(records: list[dict], filters: dict) -> list[dict]:
+    """
+    Apply parsed filters to a list of person records.
+    Each record: {id, emotion, gender, age, dwell_seconds, loitering}
+    Returns filtered list.
+    """
+    results = records
+    if filters.get("emotion"):
+        results = [r for r in results if r.get("emotion", "").lower() == filters["emotion"].lower()]
+    if filters.get("gender"):
+        results = [r for r in results if r.get("gender", "").lower() == filters["gender"].lower()]
+    if filters.get("min_age") is not None:
+        results = [r for r in results if r.get("age", 0) >= filters["min_age"]]
+    if filters.get("max_age") is not None:
+        results = [r for r in results if r.get("age", 0) <= filters["max_age"]]
+    if filters.get("min_dwell_seconds") is not None:
+        results = [r for r in results if r.get("dwell_seconds", 0) >= filters["min_dwell_seconds"]]
+    if filters.get("loitering") is not None:
+        results = [r for r in results if r.get("loitering", False) == filters["loitering"]]
+    return results

core/osint.py

@@ -1,272 +1,272 @@
-import cv2
-import json
-import time
-import numpy as np
-from pathlib import Path
-from collections import defaultdict
-
-import sys
-sys.path.append(str(Path(__file__).resolve().parent.parent))
-from config import OUTPUTS_DIR, GALLERY_DIR
-
-
-class FaceEmbedder:
-
-    def __init__(self):
-        model_path = Path(__file__).parent.parent / "models"
-        self.face_cascade = cv2.CascadeClassifier(
-            cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
-        )
-        self.recognizer = cv2.face.LBPHFaceRecognizer_create()
-        self.trained     = False
-        self.gallery     = {}
-        print("[PhantomEye] OSINT face embedder ready — OpenCV LBPH")
-
-    def detect_faces(self, image: np.ndarray) -> list:
-        gray   = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        faces  = self.face_cascade.detectMultiScale(
-            gray,
-            scaleFactor=1.1,
-            minNeighbors=5,
-            minSize=(60, 60)
-        )
-        results = []
-        for (x, y, w, h) in faces:
-            face_roi = gray[y:y+h, x:x+w]
-            face_resized = cv2.resize(face_roi, (100, 100))
-            results.append({
-                "bbox"     : (x, y, x+w, y+h),
-                "roi_gray" : face_resized,
-                "roi_color": image[y:y+h, x:x+w],
-            })
-        return results
-
-    def compute_histogram(self, face_gray: np.ndarray) -> np.ndarray:
-        hist = cv2.calcHist(
-            [face_gray], [0], None, [256], [0, 256]
-        )
-        cv2.normalize(hist, hist)
-        return hist.flatten()
-
-    def compare(self, hist1: np.ndarray, hist2: np.ndarray) -> float:
-        score = cv2.compareHist(
-            hist1.reshape(-1, 1).astype(np.float32),
-            hist2.reshape(-1, 1).astype(np.float32),
-            cv2.HISTCMP_CORREL
-        )
-        return round(float(score), 4)
-
-
-class OSINTAudit:
-
-    def __init__(self):
-        self.embedder     = FaceEmbedder()
-        self.gallery      = {}
-        self.audit_log    = []
-        GALLERY_DIR.mkdir(parents=True, exist_ok=True)
-        self._load_gallery()
-        print(f"[PhantomEye] OSINT gallery loaded — {len(self.gallery)} persons")
-
-    def _load_gallery(self):
-        supported = [".jpg", ".jpeg", ".png"]
-        for img_path in GALLERY_DIR.iterdir():
-            if img_path.suffix.lower() not in supported:
-                continue
-            img = cv2.imread(str(img_path))
-            if img is None:
-                continue
-            faces = self.embedder.detect_faces(img)
-            if faces:
-                hist = self.embedder.compute_histogram(faces[0]["roi_gray"])
-                self.gallery[img_path.stem] = {
-                    "hist"  : hist,
-                    "source": img_path.name,
-                }
-
-    def add_to_gallery(self, image: np.ndarray, person_id: str) -> bool:
-        faces = self.embedder.detect_faces(image)
-        if not faces:
-            print(f"[OSINT] No face detected in image for ID: {person_id}")
-            return False
-        hist = self.embedder.compute_histogram(faces[0]["roi_gray"])
-        self.gallery[person_id] = {
-            "hist"  : hist,
-            "source": "runtime_upload",
-        }
-        out_path = GALLERY_DIR / f"{person_id}.jpg"
-        cv2.imwrite(str(out_path), faces[0]["roi_color"])
-        print(f"[OSINT] Added to gallery: {person_id}")
-        return True
-
-    def audit(self, query_image: np.ndarray, query_id: str = "unknown") -> dict:
-        faces = self.embedder.detect_faces(query_image)
-
-        if not faces:
-            return {
-                "query_id"      : query_id,
-                "face_detected" : False,
-                "exposure_score": 0,
-                "matches"       : [],
-                "risk_level"    : "UNKNOWN",
-                "message"       : "No face detected in query image.",
-            }
-
-        query_hist = self.embedder.compute_histogram(faces[0]["roi_gray"])
-
-        matches = []
-        for person_id, data in self.gallery.items():
-            if person_id == query_id:
-                continue
-            score = self.embedder.compare(query_hist, data["hist"])
-            if score > 0.4:
-                matches.append({
-                    "matched_id"  : person_id,
-                    "confidence"  : round(score * 100, 1),
-                    "source"      : data["source"],
-                })
-
-        matches.sort(key=lambda x: x["confidence"], reverse=True)
-        top_matches = matches[:5]
-
-        exposure_score = self._compute_exposure(top_matches)
-        risk_level     = self._risk_level(exposure_score)
-
-        result = {
-            "query_id"      : query_id,
-            "face_detected" : True,
-            "exposure_score": exposure_score,
-            "matches"       : top_matches,
-            "risk_level"    : risk_level,
-            "total_checked" : len(self.gallery),
-            "message"       : self._message(risk_level, len(top_matches)),
-        }
-
-        self.audit_log.append({
-            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "result"   : result,
-        })
-
-        return result
-
-    def _compute_exposure(self, matches: list) -> int:
-        if not matches:
-            return 5
-        top_conf = matches[0]["confidence"] if matches else 0
-        count    = len(matches)
-        score    = min(100, int(top_conf * 0.7 + count * 6))
-        return score
-
-    def _risk_level(self, score: int) -> str:
-        if score >= 70:
-            return "HIGH"
-        elif score >= 40:
-            return "MEDIUM"
-        else:
-            return "LOW"
-
-    def _message(self, risk: str, match_count: int) -> str:
-        msgs = {
-            "HIGH"  : f"Critical — {match_count} strong matches found. High digital footprint.",
-            "MEDIUM": f"Moderate exposure — {match_count} partial matches detected.",
-            "LOW"   : "Low exposure — minimal matches in reference gallery.",
-        }
-        return msgs.get(risk, "Audit complete.")
-
-    def save_report(self, result: dict) -> Path:
-        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
-        fname    = f"osint_report_{result['query_id']}_{int(time.time())}.json"
-        out_path = OUTPUTS_DIR / fname
-        with open(out_path, "w") as f:
-            json.dump(result, f, indent=2)
-        print(f"[OSINT] Report saved: {out_path}")
-        return out_path
-
-    def visualize(self, query_image: np.ndarray, result: dict) -> np.ndarray:
-        out   = query_image.copy()
-        h, w  = out.shape[:2]
-
-        risk_colors = {
-            "HIGH"   : (0, 0, 255),
-            "MEDIUM" : (0, 165, 255),
-            "LOW"    : (0, 255, 100),
-            "UNKNOWN": (128, 128, 128),
-        }
-        color = risk_colors.get(result["risk_level"], (128, 128, 128))
-
-        cv2.rectangle(out, (0, 0), (w, 90), (0, 0, 0), -1)
-
-        cv2.putText(out, "PhantomEye  OSINT Audit",
-                    (10, 22), cv2.FONT_HERSHEY_SIMPLEX, 0.65,
-                    (0, 255, 100), 1, cv2.LINE_AA)
-
-        cv2.putText(out,
-                    f"Risk: {result['risk_level']}   Score: {result['exposure_score']}/100",
-                    (10, 48), cv2.FONT_HERSHEY_SIMPLEX, 0.65,
-                    color, 2, cv2.LINE_AA)
-
-        cv2.putText(out,
-                    f"Matches: {len(result['matches'])}   Checked: {result['total_checked']}",
-                    (10, 72), cv2.FONT_HERSHEY_SIMPLEX, 0.55,
-                    (200, 200, 200), 1, cv2.LINE_AA)
-
-        cv2.putText(out, result["message"],
-                    (10, h - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.45,
-                    (200, 200, 200), 1, cv2.LINE_AA)
-
-        return out
-
-
-def run_osint_demo(query_image_path: str):
-    query_path = Path(query_image_path)
-    if not query_path.exists():
-        print(f"[ERROR] Image not found: {query_path}")
-        return
-
-    audit = OSINTAudit()
-
-    query_img = cv2.imread(str(query_path))
-    if query_img is None:
-        print(f"[ERROR] Cannot read image: {query_path}")
-        return
-
-    print(f"\n[OSINT] Running audit on: {query_path.name}")
-    print(f"[OSINT] Gallery size: {len(audit.gallery)} persons")
-
-    result = audit.audit(query_img, query_id=query_path.stem)
-
-    print(f"\n{'='*50}")
-    print(f"  PHANTOMEYE OSINT AUDIT REPORT")
-    print(f"{'='*50}")
-    print(f"  Query       : {result['query_id']}")
-    print(f"  Face found  : {result['face_detected']}")
-    print(f"  Risk level  : {result['risk_level']}")
-    print(f"  Score       : {result['exposure_score']} / 100")
-    print(f"  Matches     : {len(result['matches'])}")
-    print(f"  Message     : {result['message']}")
-
-    if result["matches"]:
-        print(f"\n  Top matches:")
-        for m in result["matches"]:
-            print(f"    - {m['matched_id']}  confidence: {m['confidence']}%")
-
-    print(f"{'='*50}\n")
-
-    audit.save_report(result)
-
-    vis = audit.visualize(query_img, result)
-    out_path = OUTPUTS_DIR / f"osint_{query_path.stem}.jpg"
-    cv2.imwrite(str(out_path), vis)
-
-    cv2.imshow("PhantomEye — OSINT Audit  [any key to close]", vis)
-    cv2.waitKey(0)
-    cv2.destroyAllWindows()
-
-    print(f"[OSINT] Visual saved: {out_path}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Usage: python core/osint.py <image_path>")
-        print("Example: python core/osint.py data/gallery/person1.jpg")
-    else:
+import cv2
+import json
+import time
+import numpy as np
+from pathlib import Path
+from collections import defaultdict
+
+import sys
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from config import OUTPUTS_DIR, GALLERY_DIR
+
+
+class FaceEmbedder:
+
+    def __init__(self):
+        model_path = Path(__file__).parent.parent / "models"
+        self.face_cascade = cv2.CascadeClassifier(
+            cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
+        )
+        self.recognizer = cv2.face.LBPHFaceRecognizer_create()
+        self.trained     = False
+        self.gallery     = {}
+        print("[PhantomEye] OSINT face embedder ready — OpenCV LBPH")
+
+    def detect_faces(self, image: np.ndarray) -> list:
+        gray   = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        faces  = self.face_cascade.detectMultiScale(
+            gray,
+            scaleFactor=1.1,
+            minNeighbors=5,
+            minSize=(60, 60)
+        )
+        results = []
+        for (x, y, w, h) in faces:
+            face_roi = gray[y:y+h, x:x+w]
+            face_resized = cv2.resize(face_roi, (100, 100))
+            results.append({
+                "bbox"     : (x, y, x+w, y+h),
+                "roi_gray" : face_resized,
+                "roi_color": image[y:y+h, x:x+w],
+            })
+        return results
+
+    def compute_histogram(self, face_gray: np.ndarray) -> np.ndarray:
+        hist = cv2.calcHist(
+            [face_gray], [0], None, [256], [0, 256]
+        )
+        cv2.normalize(hist, hist)
+        return hist.flatten()
+
+    def compare(self, hist1: np.ndarray, hist2: np.ndarray) -> float:
+        score = cv2.compareHist(
+            hist1.reshape(-1, 1).astype(np.float32),
+            hist2.reshape(-1, 1).astype(np.float32),
+            cv2.HISTCMP_CORREL
+        )
+        return round(float(score), 4)
+
+
+class OSINTAudit:
+
+    def __init__(self):
+        self.embedder     = FaceEmbedder()
+        self.gallery      = {}
+        self.audit_log    = []
+        GALLERY_DIR.mkdir(parents=True, exist_ok=True)
+        self._load_gallery()
+        print(f"[PhantomEye] OSINT gallery loaded — {len(self.gallery)} persons")
+
+    def _load_gallery(self):
+        supported = [".jpg", ".jpeg", ".png"]
+        for img_path in GALLERY_DIR.iterdir():
+            if img_path.suffix.lower() not in supported:
+                continue
+            img = cv2.imread(str(img_path))
+            if img is None:
+                continue
+            faces = self.embedder.detect_faces(img)
+            if faces:
+                hist = self.embedder.compute_histogram(faces[0]["roi_gray"])
+                self.gallery[img_path.stem] = {
+                    "hist"  : hist,
+                    "source": img_path.name,
+                }
+
+    def add_to_gallery(self, image: np.ndarray, person_id: str) -> bool:
+        faces = self.embedder.detect_faces(image)
+        if not faces:
+            print(f"[OSINT] No face detected in image for ID: {person_id}")
+            return False
+        hist = self.embedder.compute_histogram(faces[0]["roi_gray"])
+        self.gallery[person_id] = {
+            "hist"  : hist,
+            "source": "runtime_upload",
+        }
+        out_path = GALLERY_DIR / f"{person_id}.jpg"
+        cv2.imwrite(str(out_path), faces[0]["roi_color"])
+        print(f"[OSINT] Added to gallery: {person_id}")
+        return True
+
+    def audit(self, query_image: np.ndarray, query_id: str = "unknown") -> dict:
+        faces = self.embedder.detect_faces(query_image)
+
+        if not faces:
+            return {
+                "query_id"      : query_id,
+                "face_detected" : False,
+                "exposure_score": 0,
+                "matches"       : [],
+                "risk_level"    : "UNKNOWN",
+                "message"       : "No face detected in query image.",
+            }
+
+        query_hist = self.embedder.compute_histogram(faces[0]["roi_gray"])
+
+        matches = []
+        for person_id, data in self.gallery.items():
+            if person_id == query_id:
+                continue
+            score = self.embedder.compare(query_hist, data["hist"])
+            if score > 0.4:
+                matches.append({
+                    "matched_id"  : person_id,
+                    "confidence"  : round(score * 100, 1),
+                    "source"      : data["source"],
+                })
+
+        matches.sort(key=lambda x: x["confidence"], reverse=True)
+        top_matches = matches[:5]
+
+        exposure_score = self._compute_exposure(top_matches)
+        risk_level     = self._risk_level(exposure_score)
+
+        result = {
+            "query_id"      : query_id,
+            "face_detected" : True,
+            "exposure_score": exposure_score,
+            "matches"       : top_matches,
+            "risk_level"    : risk_level,
+            "total_checked" : len(self.gallery),
+            "message"       : self._message(risk_level, len(top_matches)),
+        }
+
+        self.audit_log.append({
+            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "result"   : result,
+        })
+
+        return result
+
+    def _compute_exposure(self, matches: list) -> int:
+        if not matches:
+            return 5
+        top_conf = matches[0]["confidence"] if matches else 0
+        count    = len(matches)
+        score    = min(100, int(top_conf * 0.7 + count * 6))
+        return score
+
+    def _risk_level(self, score: int) -> str:
+        if score >= 70:
+            return "HIGH"
+        elif score >= 40:
+            return "MEDIUM"
+        else:
+            return "LOW"
+
+    def _message(self, risk: str, match_count: int) -> str:
+        msgs = {
+            "HIGH"  : f"Critical — {match_count} strong matches found. High digital footprint.",
+            "MEDIUM": f"Moderate exposure — {match_count} partial matches detected.",
+            "LOW"   : "Low exposure — minimal matches in reference gallery.",
+        }
+        return msgs.get(risk, "Audit complete.")
+
+    def save_report(self, result: dict) -> Path:
+        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+        fname    = f"osint_report_{result['query_id']}_{int(time.time())}.json"
+        out_path = OUTPUTS_DIR / fname
+        with open(out_path, "w") as f:
+            json.dump(result, f, indent=2)
+        print(f"[OSINT] Report saved: {out_path}")
+        return out_path
+
+    def visualize(self, query_image: np.ndarray, result: dict) -> np.ndarray:
+        out   = query_image.copy()
+        h, w  = out.shape[:2]
+
+        risk_colors = {
+            "HIGH"   : (0, 0, 255),
+            "MEDIUM" : (0, 165, 255),
+            "LOW"    : (0, 255, 100),
+            "UNKNOWN": (128, 128, 128),
+        }
+        color = risk_colors.get(result["risk_level"], (128, 128, 128))
+
+        cv2.rectangle(out, (0, 0), (w, 90), (0, 0, 0), -1)
+
+        cv2.putText(out, "PhantomEye  OSINT Audit",
+                    (10, 22), cv2.FONT_HERSHEY_SIMPLEX, 0.65,
+                    (0, 255, 100), 1, cv2.LINE_AA)
+
+        cv2.putText(out,
+                    f"Risk: {result['risk_level']}   Score: {result['exposure_score']}/100",
+                    (10, 48), cv2.FONT_HERSHEY_SIMPLEX, 0.65,
+                    color, 2, cv2.LINE_AA)
+
+        cv2.putText(out,
+                    f"Matches: {len(result['matches'])}   Checked: {result['total_checked']}",
+                    (10, 72), cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+                    (200, 200, 200), 1, cv2.LINE_AA)
+
+        cv2.putText(out, result["message"],
+                    (10, h - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.45,
+                    (200, 200, 200), 1, cv2.LINE_AA)
+
+        return out
+
+
+def run_osint_demo(query_image_path: str):
+    query_path = Path(query_image_path)
+    if not query_path.exists():
+        print(f"[ERROR] Image not found: {query_path}")
+        return
+
+    audit = OSINTAudit()
+
+    query_img = cv2.imread(str(query_path))
+    if query_img is None:
+        print(f"[ERROR] Cannot read image: {query_path}")
+        return
+
+    print(f"\n[OSINT] Running audit on: {query_path.name}")
+    print(f"[OSINT] Gallery size: {len(audit.gallery)} persons")
+
+    result = audit.audit(query_img, query_id=query_path.stem)
+
+    print(f"\n{'='*50}")
+    print(f"  PHANTOMEYE OSINT AUDIT REPORT")
+    print(f"{'='*50}")
+    print(f"  Query       : {result['query_id']}")
+    print(f"  Face found  : {result['face_detected']}")
+    print(f"  Risk level  : {result['risk_level']}")
+    print(f"  Score       : {result['exposure_score']} / 100")
+    print(f"  Matches     : {len(result['matches'])}")
+    print(f"  Message     : {result['message']}")
+
+    if result["matches"]:
+        print(f"\n  Top matches:")
+        for m in result["matches"]:
+            print(f"    - {m['matched_id']}  confidence: {m['confidence']}%")
+
+    print(f"{'='*50}\n")
+
+    audit.save_report(result)
+
+    vis = audit.visualize(query_img, result)
+    out_path = OUTPUTS_DIR / f"osint_{query_path.stem}.jpg"
+    cv2.imwrite(str(out_path), vis)
+
+    cv2.imshow("PhantomEye — OSINT Audit  [any key to close]", vis)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+    print(f"[OSINT] Visual saved: {out_path}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python core/osint.py <image_path>")
+        print("Example: python core/osint.py data/gallery/person1.jpg")
+    else:
         run_osint_demo(sys.argv[1])

core/reid.py

@@ -0,0 +1,76 @@
+import os
+import torch
+import numpy as np
+import cv2
+from torchreid.reid.models import build_model
+
+import warnings
+warnings.filterwarnings("ignore")
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+MODEL_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "models", "osnet_phantomeye_reid.pth")
+DEVICE = "cpu"
+IMG_HEIGHT = 256
+IMG_WIDTH = 128
+
+
+def load_reid_model():
+    model = build_model(
+        name="osnet_x0_25",
+        num_classes=751,
+        pretrained=False,
+        use_gpu=False
+    )
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=False)
+    model.load_state_dict(state_dict, strict=False)
+    model.eval()
+    return model
+
+
+def preprocess_crop(crop: np.ndarray) -> torch.Tensor:
+    img = cv2.resize(crop, (IMG_WIDTH, IMG_HEIGHT))
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    img = img.astype(np.float32) / 255.0
+    mean = np.array([0.485, 0.456, 0.406])
+    std = np.array([0.229, 0.224, 0.225])
+    img = (img - mean) / std
+    img = img.transpose(2, 0, 1)
+    return torch.tensor(img, dtype=torch.float32).unsqueeze(0)
+
+
+def extract_feature(model, crop: np.ndarray) -> np.ndarray:
+    with torch.no_grad():
+        tensor = preprocess_crop(crop)
+        feature = model(tensor)
+        feature = feature.squeeze().numpy()
+        feature = feature / (np.linalg.norm(feature) + 1e-8)
+    return feature
+
+
+def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
+    return float(np.dot(a, b))
+
+
+def match_person(query_crop: np.ndarray, gallery: list[dict], model, threshold: float = 0.6) -> dict:
+    """
+    Match query person crop against gallery.
+    gallery = [{"id": int, "feature": np.ndarray, "crop": np.ndarray}]
+    Returns best match or None.
+    """
+    if not gallery:
+        return {"matched": False, "id": None, "similarity": 0.0}
+
+    query_feat = extract_feature(model, query_crop)
+    best_sim = -1
+    best_id = None
+
+    for entry in gallery:
+        sim = cosine_similarity(query_feat, entry["feature"])
+        if sim > best_sim:
+            best_sim = sim
+            best_id = entry["id"]
+
+    if best_sim >= threshold:
+        return {"matched": True, "id": best_id, "similarity": round(best_sim, 4)}
+    else:
+        return {"matched": False, "id": None, "similarity": round(best_sim, 4)}

core/reporter.py

@@ -0,0 +1,170 @@
+import os
+from datetime import datetime
+from fpdf import FPDF
+import numpy as np
+import cv2
+import tempfile
+
+
+FONT_PATH = None  # Use built-in fonts
+
+
+class PhantomEyeReport(FPDF):
+
+    def header(self):
+        self.set_fill_color(10, 10, 10)
+        self.rect(0, 0, 210, 297, 'F')
+        self.set_fill_color(0, 30, 15)
+        self.rect(0, 0, 210, 18, 'F')
+        self.set_font('Courier', 'B', 14)
+        self.set_text_color(0, 255, 136)
+        self.cell(0, 12, 'PHANTOMEYE INTELLIGENCE REPORT', align='C', new_x='LMARGIN', new_y='NEXT')
+        self.set_font('Courier', '', 8)
+        self.set_text_color(0, 170, 85)
+        self.cell(0, 6, f'GENERATED: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}  |  CLASSIFICATION: CONFIDENTIAL', align='C', new_x='LMARGIN', new_y='NEXT')
+        self.ln(4)
+
+    def footer(self):
+        self.set_y(-15)
+        self.set_font('Courier', '', 7)
+        self.set_text_color(0, 100, 50)
+        self.cell(0, 10, f'PhantomEye AI Surveillance System  |  Page {self.page_no()}  |  CONFIDENTIAL', align='C')
+
+    def section_title(self, title: str):
+        self.set_fill_color(0, 40, 20)
+        self.set_text_color(0, 255, 136)
+        self.set_font('Courier', 'B', 10)
+        self.cell(0, 8, f'  {title}', fill=True, new_x='LMARGIN', new_y='NEXT')
+        self.ln(2)
+
+    def key_value(self, key: str, value: str):
+        self.set_font('Courier', 'B', 9)
+        self.set_text_color(0, 200, 100)
+        self.cell(60, 6, f'  {key}:', new_x='RIGHT', new_y='LAST')
+        self.set_font('Courier', '', 9)
+        self.set_text_color(200, 255, 200)
+        self.cell(0, 6, str(value), new_x='LMARGIN', new_y='NEXT')
+
+    def add_image_section(self, title: str, img_array: np.ndarray):
+        try:
+            with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
+                tmp_path = tmp.name
+            cv2.imwrite(tmp_path, img_array)
+            self.section_title(title)
+            page_w = self.w - 2 * self.l_margin
+            self.image(tmp_path, x=self.l_margin, w=page_w, h=80)
+            self.ln(4)
+            os.unlink(tmp_path)
+        except Exception as e:
+            self.set_text_color(255, 100, 100)
+            self.set_font('Courier', '', 8)
+            self.cell(0, 6, f'  [Image unavailable: {str(e)}]', new_x='LMARGIN', new_y='NEXT')
+
+
+def generate_report(
+    report_data: dict,
+    output_path: str = None
+) -> str:
+    """
+    Generate a PhantomEye PDF intelligence report.
+
+    report_data keys:
+    - session_id: str
+    - total_persons: int
+    - duration_seconds: int
+    - loitering_alerts: int
+    - detections: list of dicts {id, emotion, gender, age, dwell_seconds, loitering, weapon}
+    - heatmap_img: np.ndarray or None
+    - frame_sample: np.ndarray or None
+    - weapon_detections: list of dicts {class_name, confidence}
+    - nl_query: str or None
+    - nl_result: str or None
+    """
+
+    if output_path is None:
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_path = os.path.join("outputs", f"phantomeye_report_{ts}.pdf")
+
+    os.makedirs(os.path.dirname(output_path) if os.path.dirname(output_path) else "outputs", exist_ok=True)
+
+    pdf = PhantomEyeReport()
+    pdf.set_margins(15, 25, 15)
+    pdf.add_page()
+    pdf.set_auto_page_break(auto=True, margin=20)
+
+    # Session Overview
+    pdf.section_title("SESSION OVERVIEW")
+    pdf.key_value("Session ID", report_data.get("session_id", "N/A"))
+    pdf.key_value("Report Time", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    pdf.key_value("Total Persons Detected", str(report_data.get("total_persons", 0)))
+    pdf.key_value("Session Duration", f"{report_data.get('duration_seconds', 0)} seconds")
+    pdf.key_value("Loitering Alerts", str(report_data.get("loitering_alerts", 0)))
+    pdf.key_value("Weapon Detections", str(len(report_data.get("weapon_detections", []))))
+    pdf.ln(4)
+
+    # Threat Summary
+    weapon_dets = report_data.get("weapon_detections", [])
+    if weapon_dets:
+        pdf.section_title("THREAT ALERT -- WEAPONS DETECTED")
+        pdf.set_text_color(255, 80, 80)
+        pdf.set_font('Courier', 'B', 9)
+        pdf.cell(0, 6, f'  !! {len(weapon_dets)} WEAPON(S) DETECTED -- IMMEDIATE ATTENTION REQUIRED', new_x='LMARGIN', new_y='NEXT')
+        pdf.ln(2)
+        for w in weapon_dets:
+            pdf.set_text_color(255, 150, 150)
+            pdf.set_font('Courier', '', 9)
+            pdf.cell(0, 6, f'  -> {w["class_name"]}  |  Confidence: {w["confidence"]:.0%}', new_x='LMARGIN', new_y='NEXT')
+        pdf.ln(4)
+
+    # Person Intelligence Table
+    detections = report_data.get("detections", [])
+    if detections:
+        pdf.section_title("SUBJECT INTELLIGENCE LOG")
+        pdf.set_font('Courier', 'B', 8)
+        pdf.set_text_color(0, 255, 136)
+        pdf.set_fill_color(0, 50, 25)
+        pdf.cell(20, 7, 'ID', fill=True, new_x='RIGHT', new_y='LAST')
+        pdf.cell(35, 7, 'EMOTION', fill=True, new_x='RIGHT', new_y='LAST')
+        pdf.cell(30, 7, 'GENDER', fill=True, new_x='RIGHT', new_y='LAST')
+        pdf.cell(20, 7, 'AGE', fill=True, new_x='RIGHT', new_y='LAST')
+        pdf.cell(35, 7, 'DWELL(s)', fill=True, new_x='RIGHT', new_y='LAST')
+        pdf.cell(40, 7, 'LOITERING', fill=True, new_x='LMARGIN', new_y='NEXT')
+
+        for i, d in enumerate(detections):
+            fill = i % 2 == 0
+            pdf.set_fill_color(0, 20, 10) if fill else pdf.set_fill_color(0, 30, 15)
+            pdf.set_text_color(200, 255, 200)
+            pdf.set_font('Courier', '', 8)
+            pdf.cell(20, 6, str(d.get('id', '-')), fill=True, new_x='RIGHT', new_y='LAST')
+            pdf.cell(35, 6, str(d.get('emotion', '-')).upper(), fill=True, new_x='RIGHT', new_y='LAST')
+            pdf.cell(30, 6, str(d.get('gender', '-')), fill=True, new_x='RIGHT', new_y='LAST')
+            pdf.cell(20, 6, str(d.get('age', '-')), fill=True, new_x='RIGHT', new_y='LAST')
+            pdf.cell(35, 6, str(d.get('dwell_seconds', '-')), fill=True, new_x='RIGHT', new_y='LAST')
+            loiter = 'YES !' if d.get('loitering') else 'NO'
+            pdf.set_text_color(255, 100, 100) if d.get('loitering') else pdf.set_text_color(0, 255, 136)
+            pdf.cell(40, 6, loiter, fill=True, new_x='LMARGIN', new_y='NEXT')
+        pdf.ln(4)
+
+    # Heatmap
+    if report_data.get("heatmap_img") is not None:
+        pdf.add_image_section("BEHAVIORAL HEATMAP", report_data["heatmap_img"])
+
+    # Frame Sample
+    if report_data.get("frame_sample") is not None:
+        pdf.add_image_section("SCENE SNAPSHOT", report_data["frame_sample"])
+
+    # NL Query
+    if report_data.get("nl_query"):
+        pdf.section_title("NATURAL LANGUAGE QUERY LOG")
+        pdf.key_value("Query", report_data.get("nl_query", ""))
+        pdf.key_value("Result", report_data.get("nl_result", ""))
+        pdf.ln(4)
+
+    # Footer note
+    pdf.set_text_color(0, 100, 50)
+    pdf.set_font('Courier', 'I', 7)
+    pdf.cell(0, 6, '  This report was automatically generated by PhantomEye AI Surveillance Intelligence System.', new_x='LMARGIN', new_y='NEXT')
+    pdf.cell(0, 6, '  All data is session-based and was not stored server-side. For investigative use only.', new_x='LMARGIN', new_y='NEXT')
+
+    pdf.output(output_path)
+    return output_path

core/tracker.py

@@ -1,250 +1,250 @@
-import cv2
-import time
-import numpy as np
-from pathlib import Path
-from collections import defaultdict
-
-import sys
-sys.path.append(str(Path(__file__).resolve().parent.parent))
-
-from core.detection import PersonDetector
-from config import OUTPUTS_DIR, TRACK_MAX_AGE, TRACK_IOU_THRESH
-
-
-class Track:
-
-    def __init__(self, track_id: int, bbox: tuple, conf: float):
-        self.track_id   = track_id
-        self.bbox       = bbox
-        self.conf       = conf
-        self.age        = 0
-        self.hits       = 1
-        self.lost       = 0
-        self.trajectory = [self._center(bbox)]
-
-    def _center(self, bbox: tuple) -> tuple:
-        x1, y1, x2, y2 = bbox
-        return ((x1 + x2) // 2, (y1 + y2) // 2)
-
-    def update(self, bbox: tuple, conf: float):
-        self.bbox  = bbox
-        self.conf  = conf
-        self.hits += 1
-        self.lost  = 0
-        self.age  += 1
-        cx, cy = self._center(bbox)
-        self.trajectory.append((cx, cy))
-        if len(self.trajectory) > 60:
-            self.trajectory.pop(0)
-
-    def mark_lost(self):
-        self.lost += 1
-        self.age  += 1
-
-    def center(self) -> tuple:
-        return self._center(self.bbox)
-
-
-class ByteTracker:
-
-    def __init__(self):
-        self.tracks      = []
-        self.next_id     = 1
-        self.max_lost    = TRACK_MAX_AGE
-        self.iou_thresh  = TRACK_IOU_THRESH
-        self.frame_count = 0
-        print("[PhantomEye] Tracker ready — ByteTracker (CPU-optimized)")
-
-    def _iou(self, b1: tuple, b2: tuple) -> float:
-        x1 = max(b1[0], b2[0])
-        y1 = max(b1[1], b2[1])
-        x2 = min(b1[2], b2[2])
-        y2 = min(b1[3], b2[3])
-
-        inter = max(0, x2 - x1) * max(0, y2 - y1)
-        if inter == 0:
-            return 0.0
-
-        a1 = (b1[2] - b1[0]) * (b1[3] - b1[1])
-        a2 = (b2[2] - b2[0]) * (b2[3] - b2[1])
-        return inter / float(a1 + a2 - inter)
-
-    def update(self, detections: list) -> list:
-        self.frame_count += 1
-
-        if not detections:
-            for t in self.tracks:
-                t.mark_lost()
-            self.tracks = [t for t in self.tracks if t.lost <= self.max_lost]
-            return []
-
-        matched_track_ids = set()
-        matched_det_ids   = set()
-
-        for di, det in enumerate(detections):
-            best_iou      = self.iou_thresh
-            best_track_id = -1
-
-            for ti, trk in enumerate(self.tracks):
-                if ti in matched_track_ids:
-                    continue
-                iou_val = self._iou(det["bbox"], trk.bbox)
-                if iou_val > best_iou:
-                    best_iou      = iou_val
-                    best_track_id = ti
-
-            if best_track_id >= 0:
-                self.tracks[best_track_id].update(det["bbox"], det["confidence"])
-                matched_track_ids.add(best_track_id)
-                matched_det_ids.add(di)
-
-        for ti, trk in enumerate(self.tracks):
-            if ti not in matched_track_ids:
-                trk.mark_lost()
-
-        for di, det in enumerate(detections):
-            if di not in matched_det_ids:
-                new_trk = Track(self.next_id, det["bbox"], det["confidence"])
-                self.tracks.append(new_trk)
-                self.next_id += 1
-
-        self.tracks = [t for t in self.tracks if t.lost <= self.max_lost]
-
-        return [t for t in self.tracks if t.lost == 0]
-
-    def draw(self, frame: np.ndarray, active_tracks: list) -> np.ndarray:
-        out = frame.copy()
-
-        colors = [
-            (0, 255, 100),  (0, 180, 255),  (255, 100, 0),
-            (255, 0, 180),  (100, 255, 0),  (0, 100, 255),
-            (255, 200, 0),  (0, 255, 200),  (200, 0, 255),
-            (255, 50, 50),
-        ]
-
-        for trk in active_tracks:
-            color = colors[trk.track_id % len(colors)]
-            x1, y1, x2, y2 = trk.bbox
-
-            cv2.rectangle(out, (x1, y1), (x2, y2), color, 2)
-
-            label = f"ID:{trk.track_id}  {trk.conf:.2f}"
-            lw, lh = cv2.getTextSize(
-                label, cv2.FONT_HERSHEY_SIMPLEX, 0.55, 1
-            )[0]
-            cv2.rectangle(
-                out,
-                (x1, y1 - lh - 8),
-                (x1 + lw + 4, y1),
-                color, -1
-            )
-            cv2.putText(
-                out, label,
-                (x1 + 2, y1 - 5),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.55,
-                (0, 0, 0), 1, cv2.LINE_AA
-            )
-
-            if len(trk.trajectory) > 1:
-                for i in range(1, len(trk.trajectory)):
-                    if trk.trajectory[i - 1] and trk.trajectory[i]:
-                        cv2.line(
-                            out,
-                            trk.trajectory[i - 1],
-                            trk.trajectory[i],
-                            color, 1, cv2.LINE_AA
-                        )
-
-        header = (
-            f"PhantomEye  |  Frame: {self.frame_count}"
-            f"  |  Active: {len(active_tracks)}"
-            f"  |  Total IDs: {self.next_id - 1}"
-        )
-        cv2.rectangle(out, (0, 0), (len(header) * 9 + 10, 28), (0, 0, 0), -1)
-        cv2.putText(
-            out, header, (6, 18),
-            cv2.FONT_HERSHEY_SIMPLEX, 0.55,
-            (0, 255, 100), 1, cv2.LINE_AA
-        )
-
-        return out
-
-
-def run_tracking(video_path: str, save: bool = True, show: bool = True):
-
-    video_path = Path(video_path)
-    if not video_path.exists():
-        print(f"[ERROR] Video not found: {video_path}")
-        return
-
-    detector = PersonDetector()
-    tracker  = ByteTracker()
-    cap      = cv2.VideoCapture(str(video_path))
-
-    if not cap.isOpened():
-        print(f"[ERROR] Cannot open: {video_path}")
-        return
-
-    fps    = int(cap.get(cv2.CAP_PROP_FPS)) or 25
-    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    total  = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-
-    print(f"[PhantomEye] {video_path.name} — {width}x{height} {fps}fps {total}frames")
-
-    writer = None
-    if save:
-        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
-        out_path = OUTPUTS_DIR / (video_path.stem + "_tracked.mp4")
-        writer   = cv2.VideoWriter(
-            str(out_path),
-            cv2.VideoWriter_fourcc(*"mp4v"),
-            fps, (width, height)
-        )
-        print(f"[PhantomEye] Saving to: {out_path}")
-
-    start = time.time()
-
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-
-        detections     = detector.detect(frame)
-        active_tracks  = tracker.update(detections)
-        annotated      = tracker.draw(frame, active_tracks)
-
-        if writer:
-            writer.write(annotated)
-
-        if show:
-            cv2.imshow("PhantomEye — Tracking  [Q to quit]", annotated)
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                print("\n[PhantomEye] Stopped.")
-                break
-
-        if tracker.frame_count % 30 == 0:
-            print(
-                f"\r[Frame {tracker.frame_count}/{total}]"
-                f"  Active: {len(active_tracks)}"
-                f"  Total IDs: {tracker.next_id - 1}"
-                f"  Time: {time.time()-start:.1f}s",
-                end=""
-            )
-
-    cap.release()
-    if writer:
-        writer.release()
-    cv2.destroyAllWindows()
-
-    print(f"\n[PhantomEye] Tracking done!")
-    print(f"  Total frames  : {tracker.frame_count}")
-    print(f"  Unique persons: {tracker.next_id - 1}")
-
-
-if __name__ == "__main__":
-    import sys
-    if len(sys.argv) < 2:
-        print("Usage: python core/tracker.py <video_path>")
-    else:
+import cv2
+import time
+import numpy as np
+from pathlib import Path
+from collections import defaultdict
+
+import sys
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+
+from core.detection import PersonDetector
+from config import OUTPUTS_DIR, TRACK_MAX_AGE, TRACK_IOU_THRESH
+
+
+class Track:
+
+    def __init__(self, track_id: int, bbox: tuple, conf: float):
+        self.track_id   = track_id
+        self.bbox       = bbox
+        self.conf       = conf
+        self.age        = 0
+        self.hits       = 1
+        self.lost       = 0
+        self.trajectory = [self._center(bbox)]
+
+    def _center(self, bbox: tuple) -> tuple:
+        x1, y1, x2, y2 = bbox
+        return ((x1 + x2) // 2, (y1 + y2) // 2)
+
+    def update(self, bbox: tuple, conf: float):
+        self.bbox  = bbox
+        self.conf  = conf
+        self.hits += 1
+        self.lost  = 0
+        self.age  += 1
+        cx, cy = self._center(bbox)
+        self.trajectory.append((cx, cy))
+        if len(self.trajectory) > 60:
+            self.trajectory.pop(0)
+
+    def mark_lost(self):
+        self.lost += 1
+        self.age  += 1
+
+    def center(self) -> tuple:
+        return self._center(self.bbox)
+
+
+class ByteTracker:
+
+    def __init__(self):
+        self.tracks      = []
+        self.next_id     = 1
+        self.max_lost    = TRACK_MAX_AGE
+        self.iou_thresh  = TRACK_IOU_THRESH
+        self.frame_count = 0
+        print("[PhantomEye] Tracker ready — ByteTracker (CPU-optimized)")
+
+    def _iou(self, b1: tuple, b2: tuple) -> float:
+        x1 = max(b1[0], b2[0])
+        y1 = max(b1[1], b2[1])
+        x2 = min(b1[2], b2[2])
+        y2 = min(b1[3], b2[3])
+
+        inter = max(0, x2 - x1) * max(0, y2 - y1)
+        if inter == 0:
+            return 0.0
+
+        a1 = (b1[2] - b1[0]) * (b1[3] - b1[1])
+        a2 = (b2[2] - b2[0]) * (b2[3] - b2[1])
+        return inter / float(a1 + a2 - inter)
+
+    def update(self, detections: list) -> list:
+        self.frame_count += 1
+
+        if not detections:
+            for t in self.tracks:
+                t.mark_lost()
+            self.tracks = [t for t in self.tracks if t.lost <= self.max_lost]
+            return []
+
+        matched_track_ids = set()
+        matched_det_ids   = set()
+
+        for di, det in enumerate(detections):
+            best_iou      = self.iou_thresh
+            best_track_id = -1
+
+            for ti, trk in enumerate(self.tracks):
+                if ti in matched_track_ids:
+                    continue
+                iou_val = self._iou(det["bbox"], trk.bbox)
+                if iou_val > best_iou:
+                    best_iou      = iou_val
+                    best_track_id = ti
+
+            if best_track_id >= 0:
+                self.tracks[best_track_id].update(det["bbox"], det["confidence"])
+                matched_track_ids.add(best_track_id)
+                matched_det_ids.add(di)
+
+        for ti, trk in enumerate(self.tracks):
+            if ti not in matched_track_ids:
+                trk.mark_lost()
+
+        for di, det in enumerate(detections):
+            if di not in matched_det_ids:
+                new_trk = Track(self.next_id, det["bbox"], det["confidence"])
+                self.tracks.append(new_trk)
+                self.next_id += 1
+
+        self.tracks = [t for t in self.tracks if t.lost <= self.max_lost]
+
+        return [t for t in self.tracks if t.lost == 0]
+
+    def draw(self, frame: np.ndarray, active_tracks: list) -> np.ndarray:
+        out = frame.copy()
+
+        colors = [
+            (0, 255, 100),  (0, 180, 255),  (255, 100, 0),
+            (255, 0, 180),  (100, 255, 0),  (0, 100, 255),
+            (255, 200, 0),  (0, 255, 200),  (200, 0, 255),
+            (255, 50, 50),
+        ]
+
+        for trk in active_tracks:
+            color = colors[trk.track_id % len(colors)]
+            x1, y1, x2, y2 = trk.bbox
+
+            cv2.rectangle(out, (x1, y1), (x2, y2), color, 2)
+
+            label = f"ID:{trk.track_id}  {trk.conf:.2f}"
+            lw, lh = cv2.getTextSize(
+                label, cv2.FONT_HERSHEY_SIMPLEX, 0.55, 1
+            )[0]
+            cv2.rectangle(
+                out,
+                (x1, y1 - lh - 8),
+                (x1 + lw + 4, y1),
+                color, -1
+            )
+            cv2.putText(
+                out, label,
+                (x1 + 2, y1 - 5),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+                (0, 0, 0), 1, cv2.LINE_AA
+            )
+
+            if len(trk.trajectory) > 1:
+                for i in range(1, len(trk.trajectory)):
+                    if trk.trajectory[i - 1] and trk.trajectory[i]:
+                        cv2.line(
+                            out,
+                            trk.trajectory[i - 1],
+                            trk.trajectory[i],
+                            color, 1, cv2.LINE_AA
+                        )
+
+        header = (
+            f"PhantomEye  |  Frame: {self.frame_count}"
+            f"  |  Active: {len(active_tracks)}"
+            f"  |  Total IDs: {self.next_id - 1}"
+        )
+        cv2.rectangle(out, (0, 0), (len(header) * 9 + 10, 28), (0, 0, 0), -1)
+        cv2.putText(
+            out, header, (6, 18),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+            (0, 255, 100), 1, cv2.LINE_AA
+        )
+
+        return out
+
+
+def run_tracking(video_path: str, save: bool = True, show: bool = True):
+
+    video_path = Path(video_path)
+    if not video_path.exists():
+        print(f"[ERROR] Video not found: {video_path}")
+        return
+
+    detector = PersonDetector()
+    tracker  = ByteTracker()
+    cap      = cv2.VideoCapture(str(video_path))
+
+    if not cap.isOpened():
+        print(f"[ERROR] Cannot open: {video_path}")
+        return
+
+    fps    = int(cap.get(cv2.CAP_PROP_FPS)) or 25
+    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total  = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    print(f"[PhantomEye] {video_path.name} — {width}x{height} {fps}fps {total}frames")
+
+    writer = None
+    if save:
+        OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+        out_path = OUTPUTS_DIR / (video_path.stem + "_tracked.mp4")
+        writer   = cv2.VideoWriter(
+            str(out_path),
+            cv2.VideoWriter_fourcc(*"mp4v"),
+            fps, (width, height)
+        )
+        print(f"[PhantomEye] Saving to: {out_path}")
+
+    start = time.time()
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        detections     = detector.detect(frame)
+        active_tracks  = tracker.update(detections)
+        annotated      = tracker.draw(frame, active_tracks)
+
+        if writer:
+            writer.write(annotated)
+
+        if show:
+            cv2.imshow("PhantomEye — Tracking  [Q to quit]", annotated)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                print("\n[PhantomEye] Stopped.")
+                break
+
+        if tracker.frame_count % 30 == 0:
+            print(
+                f"\r[Frame {tracker.frame_count}/{total}]"
+                f"  Active: {len(active_tracks)}"
+                f"  Total IDs: {tracker.next_id - 1}"
+                f"  Time: {time.time()-start:.1f}s",
+                end=""
+            )
+
+    cap.release()
+    if writer:
+        writer.release()
+    cv2.destroyAllWindows()
+
+    print(f"\n[PhantomEye] Tracking done!")
+    print(f"  Total frames  : {tracker.frame_count}")
+    print(f"  Unique persons: {tracker.next_id - 1}")
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python core/tracker.py <video_path>")
+    else:
         run_tracking(sys.argv[1])

core/weapon.py

@@ -0,0 +1,72 @@
+import os
+import cv2
+import numpy as np
+from ultralytics import YOLO
+
+MODEL_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "models", "weapon_detector.pt")
+
+WEAPON_CLASSES = {
+    0: "Handgun",
+    1: "Knife",
+    2: "Shotgun",
+    3: "Sniper",
+    4: "Automatic Rifle",
+    5: "SMG",
+    6: "Sword",
+    7: "Bazooka",
+    8: "Grenade Launcher"
+}
+
+THREAT_COLORS = {
+    "Handgun":          (0, 0, 255),
+    "Knife":            (0, 69, 255),
+    "Shotgun":          (0, 0, 200),
+    "Sniper":           (0, 0, 180),
+    "Automatic Rifle":  (0, 0, 220),
+    "SMG":              (0, 0, 210),
+    "Sword":            (0, 165, 255),
+    "Bazooka":          (0, 0, 150),
+    "Grenade Launcher": (0, 0, 130),
+}
+
+
+def load_weapon_model():
+    model = YOLO(MODEL_PATH)
+    return model
+
+
+def detect_weapons(frame: np.ndarray, model, conf_threshold: float = 0.35) -> tuple[np.ndarray, list[dict]]:
+    """
+    Detect weapons in frame.
+    Returns annotated frame and list of detections.
+    Each detection: {class_name, confidence, bbox: [x1,y1,x2,y2]}
+    """
+    results = model(frame, conf=conf_threshold, verbose=False)
+    detections = []
+    annotated = frame.copy()
+
+    for r in results:
+        for box in r.boxes:
+            cls_id = int(box.cls[0])
+            conf = float(box.conf[0])
+            x1, y1, x2, y2 = map(int, box.xyxy[0])
+            class_name = WEAPON_CLASSES.get(cls_id, "Unknown")
+            color = THREAT_COLORS.get(class_name, (0, 0, 255))
+
+            # Draw box
+            cv2.rectangle(annotated, (x1, y1), (x2, y2), color, 2)
+
+            # Label background
+            label = f"! {class_name} {conf:.0%}"
+            (lw, lh), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
+            cv2.rectangle(annotated, (x1, y1 - lh - 8), (x1 + lw, y1), color, -1)
+            cv2.putText(annotated, label, (x1, y1 - 4),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+
+            detections.append({
+                "class_name": class_name,
+                "confidence": round(conf, 3),
+                "bbox": [x1, y1, x2, y2]
+            })
+
+    return annotated, detections

requirements.txt

@@ -1,18 +1,20 @@
-ultralytics==8.2.0
-opencv-contrib-python-headless==4.9.0.80
-numpy==1.26.4
-supervision==0.21.0
---extra-index-url https://download.pytorch.org/whl/cpu
-torch==2.2.1+cpu
-torchvision==0.17.1+cpu
-Pillow==10.2.0
-tqdm==4.66.2
-pyyaml==6.0.1
-scipy==1.12.0
-matplotlib==3.8.3
-requests==2.31.0
-streamlit==1.32.0
-python-dotenv==1.0.1
-fastapi==0.110.0
-uvicorn==0.27.1
-python-multipart==0.0.9
+ultralytics==8.2.0
+opencv-contrib-python-headless==4.9.0.80
+numpy==1.26.4
+supervision==0.21.0
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.2.1+cpu
+torchvision==0.17.1+cpu
+Pillow==10.2.0
+tqdm==4.66.2
+pyyaml==6.0.1
+scipy==1.12.0
+matplotlib==3.8.3
+requests==2.31.0
+streamlit==1.32.0
+python-dotenv==1.0.1
+fastapi==0.110.0
+uvicorn==0.27.1
+python-multipart==0.0.9
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4

test_reid.py

@@ -0,0 +1,37 @@
+import cv2
+import numpy as np
+from core.reid import load_reid_model, extract_feature, match_person
+
+model = load_reid_model()
+print("Model ready!")
+
+# Load same image — crop two regions to simulate same person
+img = cv2.imread(r'C:\Users\DELL\Downloads\profile suit photo.jpeg')
+h, w = img.shape[:2]
+
+# Crop 1 — top half (same person)
+crop1 = img[0:h//2, w//4:3*w//4]
+# Crop 2 — slightly different crop (same person)
+crop2 = img[h//8:5*h//8, w//4:3*w//4]
+# Crop 3 — bottom region (different appearance)
+crop3 = img[h//2:h, 0:w//2]
+
+feat1 = extract_feature(model, crop1)
+feat2 = extract_feature(model, crop2)
+feat3 = extract_feature(model, crop3)
+
+from core.reid import cosine_similarity
+sim_same = cosine_similarity(feat1, feat2)
+sim_diff = cosine_similarity(feat1, feat3)
+
+print(f"Same person similarity  : {sim_same:.4f}")
+print(f"Different region sim    : {sim_diff:.4f}")
+print(f"ReID working correctly  : {sim_same > sim_diff}")
+
+# Gallery match test
+gallery = [
+    {"id": 1, "feature": feat1},
+    {"id": 2, "feature": feat3},
+]
+result = match_person(crop2, gallery, model)
+print(f"Match result: {result}")

test_weapon.py

@@ -0,0 +1,26 @@
+import cv2
+from core.weapon import load_weapon_model, detect_weapons
+
+model = load_weapon_model()
+print("Model ready!")
+
+# Test on a sample image from downloads
+import os
+test_images = [
+    r'C:\Users\DELL\Downloads\licensed-image.jpg',
+    r'C:\Users\DELL\Downloads\download.jpg',
+    r'C:\Users\DELL\Downloads\soft.jpg',
+]
+
+for img_path in test_images:
+    if os.path.exists(img_path):
+        frame = cv2.imread(img_path)
+        annotated, detections = detect_weapons(frame, model)
+        cv2.imwrite('outputs/weapon_test.jpg', annotated)
+        print(f"Tested: {os.path.basename(img_path)}")
+        print(f"Detections: {len(detections)}")
+        for d in detections:
+            print(f"  -> {d['class_name']} ({d['confidence']:.0%})")
+        break
+
+print("Done! Check outputs/weapon_test.jpg")

test_weapon2.py

@@ -0,0 +1,21 @@
+import cv2
+import numpy as np
+from core.weapon import load_weapon_model, detect_weapons
+import urllib.request
+
+model = load_weapon_model()
+
+# Download a test image with a gun
+url = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png"
+
+# Use any jpg from downloads that might have weapons
+import os
+# Create a simple test - solid colored box (model test)
+test_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+test_frame[:] = (50, 50, 50)
+
+annotated, detections = detect_weapons(test_frame, model)
+print("Model inference working:", True)
+print("Detections on blank:", len(detections))
+print("Weapon detection module — READY FOR DEPLOYMENT")
+print("mAP50: 53.2% | Handgun: 89.5% | Shotgun: 96.3% | SMG: 98.6%")