first commit

.env.example

@@ -0,0 +1,81 @@
+# Fichier d'exemple des variables d'environnement
+# Créé par Marino ATOHOUN - FireWatch AI Project
+# Copiez ce fichier vers .env et modifiez les valeurs selon vos besoins
+
+# Configuration Django
+DEBUG=True
+SECRET_KEY=votre-cle-secrete-django-ici-changez-en-production
+ALLOWED_HOSTS=localhost,127.0.0.1,0.0.0.0
+
+# Base de données
+# Pour SQLite (développement)
+DATABASE_URL=sqlite:///db.sqlite3
+
+# Pour PostgreSQL (production)
+# DATABASE_URL=postgresql://user:password@localhost:5432/firewatch_db
+
+# Chemins des modèles YOLOv8
+FIRE_MODEL_PATH=models/incendies.pt
+INTRUSION_MODEL_PATH=models/intrusion.pt
+
+# Configuration des fichiers media
+MEDIA_ROOT=media
+STATIC_ROOT=staticfiles
+
+# Limites de fichiers (en bytes)
+FILE_UPLOAD_MAX_MEMORY_SIZE=52428800  # 50MB
+DATA_UPLOAD_MAX_MEMORY_SIZE=52428800  # 50MB
+
+# Configuration email (pour les notifications)
+EMAIL_BACKEND=django.core.mail.backends.console.EmailBackend
+EMAIL_HOST=smtp.gmail.com
+EMAIL_PORT=587
+EMAIL_USE_TLS=True
+EMAIL_HOST_USER=votre-email@gmail.com
+EMAIL_HOST_PASSWORD=votre-mot-de-passe-app
+
+# Configuration Redis (pour le cache et Celery)
+REDIS_URL=redis://localhost:6379/0
+
+# Configuration AWS S3 (pour le stockage en production)
+AWS_ACCESS_KEY_ID=votre-access-key
+AWS_SECRET_ACCESS_KEY=votre-secret-key
+AWS_STORAGE_BUCKET_NAME=firewatch-media
+AWS_S3_REGION_NAME=eu-west-1
+
+# Configuration de sécurité
+SECURE_SSL_REDIRECT=False
+SECURE_HSTS_SECONDS=0
+SECURE_HSTS_INCLUDE_SUBDOMAINS=False
+SECURE_HSTS_PRELOAD=False
+
+# Logging
+LOG_LEVEL=INFO
+LOG_FILE=logs/firewatch.log
+
+# Configuration Celery (pour les tâches asynchrones)
+CELERY_BROKER_URL=redis://localhost:6379/0
+CELERY_RESULT_BACKEND=redis://localhost:6379/0
+
+# Configuration de monitoring
+SENTRY_DSN=votre-sentry-dsn-ici
+
+# Configuration spécifique à FireWatch AI
+# Seuil de confiance minimum pour les détections
+MIN_CONFIDENCE_THRESHOLD=0.5
+
+# Nombre maximum de détections par image/vidéo
+MAX_DETECTIONS_PER_ANALYSIS=100
+
+# Durée de conservation des fichiers uploadés (en jours)
+FILE_RETENTION_DAYS=30
+
+# Configuration de l'analyse vidéo
+VIDEO_FRAME_SKIP=30  # Analyser une frame toutes les 30 frames
+MAX_VIDEO_DURATION=300  # Durée maximale de vidéo en secondes (5 minutes)
+
+# Configuration de la caméra en temps réel
+CAMERA_ANALYSIS_INTERVAL=5  # Intervalle d'analyse en secondes
+CAMERA_RESOLUTION_WIDTH=1280
+CAMERA_RESOLUTION_HEIGHT=720
+

.gitignore

@@ -0,0 +1,249 @@
+# Gitignore pour FireWatch AI - Créé par Marino ATOHOUN
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Django specific
+media/uploads/
+media/results/
+staticfiles/
+static/admin/
+static/rest_framework/
+
+# Logs
+logs/
+*.log
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Modèles YOLOv8 (trop volumineux pour git)
+models/*.pt
+models/*.onnx
+models/*.engine
+
+# Fichiers temporaires
+tmp/
+temp/
+*.tmp
+
+# Sauvegardes
+*.bak
+*.backup
+
+# Docker
+.dockerignore
+
+# Certificats SSL
+ssl/
+*.pem
+*.crt
+*.key
+
+# Variables d'environnement sensibles
+.env.local
+.env.production
+.env.staging
+
+# Fichiers de configuration spécifiques
+local_settings.py
+production_settings.py
+
+# Cache
+.cache/
+*.cache
+
+# Fichiers de données
+data/
+datasets/
+
+# Notebooks Jupyter
+*.ipynb
+
+# Fichiers de test volumineux
+test_data/
+test_images/
+test_videos/
+
+# Rapports de performance
+profiling/
+benchmarks/
+
+# Documentation générée
+docs/build/
+docs/_build/
+
+# Fichiers de déploiement sensibles
+deploy_keys/
+secrets/
+
+# Monitoring
+monitoring/
+metrics/
+
+# Sauvegardes de base de données
+*.sql
+*.dump
+
+# Fichiers de migration personnalisés (garder les migrations par défaut)
+# detection/migrations/0*_custom_*.py
+
+# Fichiers de configuration Nginx/Apache
+nginx.conf.local
+apache.conf.local
+
+# Fichiers de session
+django_session/
+
+# Fichiers de cache Redis
+dump.rdb
+
+# Fichiers de configuration Docker personnalisés
+docker-compose.override.yml
+docker-compose.local.yml
+
+# Scripts personnalisés
+scripts/custom_*.sh
+scripts/local_*.sh
+
+# Fichiers de test personnalisés
+tests/custom/
+tests/local/
+
+# Signature Marino ATOHOUN
+# Projet FireWatch AI - Système de détection d'incendie et d'intrusion
+

CHANGELOG.md

@@ -0,0 +1,190 @@
+# Changelog - FireWatch AI
+
+**Créé par Marino ATOHOUN**
+
+Toutes les modifications notables de ce projet seront documentées dans ce fichier.
+
+Le format est basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.0.0/),
+et ce projet adhère au [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2024-12-26
+
+### 🎉 Version initiale - Créée par Marino ATOHOUN
+
+#### Ajouté
+- **Système de détection IA complet**
+  - Intégration YOLOv8 pour la détection d'incendie et d'intrusion
+  - Support des modèles personnalisés (`incendies.pt`, `intrusion.pt`)
+  - Analyse en temps réel d'images, vidéos et flux caméra
+
+- **Interface web moderne**
+  - Frontend responsive avec Tailwind CSS
+  - Interface utilisateur intuitive et accessible
+  - Support du drag & drop pour les fichiers
+  - Prévisualisation en temps réel des uploads
+
+- **Backend Django robuste**
+  - Architecture MVC bien structurée
+  - API REST complète pour l'intégration
+  - Gestion sécurisée des uploads de fichiers
+  - Système de sessions de détection
+
+- **Base de données et modèles**
+  - Modèles Django pour contacts, sessions et détections
+  - Support SQLite (développement) et PostgreSQL (production)
+  - Interface d'administration Django complète
+  - Historique complet des analyses
+
+- **Fonctionnalités de détection**
+  - Analyse d'images avec boîtes englobantes
+  - Traitement vidéo frame par frame
+  - Capture et analyse depuis webcam
+  - Scores de confiance et métadonnées
+
+- **Système de contact**
+  - Formulaire de contact intégré
+  - Stockage en base de données
+  - Interface d'administration pour la gestion
+
+- **Configuration et déploiement**
+  - Support Docker et Docker Compose
+  - Scripts d'installation automatisés
+  - Configuration pour production et développement
+  - Documentation complète
+
+- **Sécurité**
+  - Protection CSRF activée
+  - Validation des types de fichiers
+  - Limitation de taille des uploads
+  - Gestion sécurisée des sessions
+
+- **Performance et monitoring**
+  - Cache Redis intégré
+  - Logs structurés
+  - Métriques de performance
+  - Support GPU pour l'IA
+
+#### Fonctionnalités techniques
+- **Framework**: Django 4.2+
+- **IA/ML**: YOLOv8, OpenCV, PyTorch
+- **Frontend**: HTML5, CSS3, JavaScript, Tailwind CSS
+- **Base de données**: SQLite/PostgreSQL
+- **Cache**: Redis
+- **Serveur**: Gunicorn + Nginx
+- **Conteneurisation**: Docker
+
+#### Structure du projet
+```
+firewatch_project/
+├── firewatch_project/     # Configuration Django
+├── detection/             # Application principale
+├── models/               # Modèles YOLOv8
+├── media/                # Fichiers uploadés
+├── static/               # Fichiers statiques
+├── scripts/              # Scripts utilitaires
+├── requirements.txt      # Dépendances
+├── Dockerfile           # Configuration Docker
+├── docker-compose.yml   # Orchestration
+└── README.md           # Documentation
+```
+
+#### API Endpoints
+- `GET /` - Page principale
+- `POST /contact/` - Formulaire de contact
+- `POST /analyze/image/` - Analyse d'image
+- `POST /analyze/video/` - Analyse de vidéo
+- `GET /api/results/<session_id>/` - Récupération des résultats
+- `GET /api/models/status/` - Statut des modèles IA
+
+#### Configuration
+- Variables d'environnement via `.env`
+- Support multi-environnement (dev/prod)
+- Configuration des seuils de détection
+- Paramètres de performance ajustables
+
+#### Tests
+- Tests unitaires complets
+- Tests d'intégration
+- Tests de sécurité
+- Tests de performance
+- Couverture de code
+
+#### Documentation
+- README.md complet
+- Guide d'installation détaillé
+- Documentation API
+- Exemples d'utilisation
+- Guide de déploiement
+
+### 🔧 Configuration requise
+- Python 3.11+
+- Django 4.2+
+- YOLOv8 (Ultralytics)
+- OpenCV
+- PostgreSQL (production)
+- Redis (cache)
+- Docker (optionnel)
+
+### 🚀 Installation rapide
+```bash
+# Cloner le projet
+git clone <repo-url>
+cd firewatch_project
+
+# Configuration automatique
+chmod +x scripts/setup.sh
+./scripts/setup.sh
+
+# Lancer le serveur
+source venv/bin/activate
+python manage.py runserver
+```
+
+### 📝 Notes de version
+Cette version initiale fournit une base solide pour un système de détection d'incendie et d'intrusion. Le code est conçu pour être facilement extensible et maintenir une haute performance.
+
+**Points forts:**
+- Architecture modulaire et scalable
+- Interface utilisateur moderne et responsive
+- Intégration IA prête pour la production
+- Documentation complète
+- Tests exhaustifs
+- Support multi-plateforme
+
+**Prochaines améliorations prévues:**
+- Notifications en temps réel (WebSockets)
+- Tableau de bord analytique
+- API mobile
+- Intégration cloud (AWS, Azure)
+- Modèles IA pré-entraînés
+- Support multi-langues
+
+---
+
+## Format des versions futures
+
+### [X.Y.Z] - YYYY-MM-DD
+
+#### Ajouté
+- Nouvelles fonctionnalités
+
+#### Modifié
+- Changements dans les fonctionnalités existantes
+
+#### Déprécié
+- Fonctionnalités bientôt supprimées
+
+#### Supprimé
+- Fonctionnalités supprimées
+
+#### Corrigé
+- Corrections de bugs
+
+#### Sécurité
+- Corrections de vulnérabilités
+
+---
+
+**FireWatch AI** - Créé avec passion par Marino ATOHOUN
+*Solution intelligente de détection d'incendie et d'intrusion*
+

Dockerfile

@@ -0,0 +1,70 @@
+# Dockerfile pour FireWatch AI
+# Créé par Marino ATOHOUN
+
+FROM python:3.11-slim
+
+# Métadonnées
+LABEL maintainer="Marino ATOHOUN"
+LABEL description="FireWatch AI - Système de détection d'incendie et d'intrusion"
+LABEL version="1.0"
+
+# Variables d'environnement
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Répertoire de travail
+WORKDIR /app
+
+# Installation des dépendances système
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libpq-dev \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgthread-2.0-0 \
+    libgtk-3-0 \
+    python3-opencv \
+    ffmpeg \
+    wget \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copier les requirements et installer les dépendances Python
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copier le code de l'application
+COPY . .
+
+# Créer les répertoires nécessaires
+RUN mkdir -p media/uploads/images media/uploads/videos media/results models logs staticfiles
+
+# Collecter les fichiers statiques
+RUN python manage.py collectstatic --noinput
+
+# Créer un utilisateur non-root pour la sécurité
+RUN adduser --disabled-password --gecos '' appuser
+RUN chown -R appuser:appuser /app
+USER appuser
+
+# Exposer le port
+EXPOSE 8000
+
+# Commande de santé
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/ || exit 1
+
+# Script de démarrage
+COPY docker-entrypoint.sh /app/
+RUN chmod +x /app/docker-entrypoint.sh
+
+# Commande par défaut
+ENTRYPOINT ["/app/docker-entrypoint.sh"]
+CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "--timeout", "120", "firewatch_project.wsgi:application"]
+

INSTALLATION.md

@@ -0,0 +1,419 @@
+# 📖 Guide d'Installation - FireWatch AI
+
+**Créé par Marino ATOHOUN**
+
+Ce guide vous accompagne pas à pas dans l'installation et la configuration de FireWatch AI.
+
+## 🎯 Prérequis Système
+
+### Minimum requis
+- **OS** : Ubuntu 20.04+, Windows 10+, macOS 10.15+
+- **Python** : 3.11 ou supérieur
+- **RAM** : 8 GB minimum (16 GB recommandé)
+- **Stockage** : 10 GB d'espace libre
+- **GPU** : Optionnel mais recommandé (NVIDIA avec CUDA)
+
+### Logiciels requis
+- Git
+- Python 3.11+
+- pip (gestionnaire de packages Python)
+- Node.js 16+ (pour les outils de développement frontend)
+
+## 🔧 Installation Étape par Étape
+
+### Étape 1 : Préparation de l'environnement
+
+#### Sur Ubuntu/Debian
+```bash
+# Mise à jour du système
+sudo apt update && sudo apt upgrade -y
+
+# Installation des dépendances système
+sudo apt install -y python3.11 python3.11-venv python3-pip git curl
+sudo apt install -y libgl1-mesa-glx libglib2.0-0 libsm6 libxext6 libxrender-dev
+sudo apt install -y libgomp1 libgthread-2.0-0 libgtk-3-0 python3-opencv ffmpeg
+
+# Installation de PostgreSQL (optionnel, pour la production)
+sudo apt install -y postgresql postgresql-contrib
+
+# Installation de Redis (optionnel, pour le cache)
+sudo apt install -y redis-server
+```
+
+#### Sur Windows
+```powershell
+# Installer Python depuis python.org ou via Microsoft Store
+# Installer Git depuis git-scm.com
+# Installer Visual Studio Build Tools pour les packages natifs
+
+# Via Chocolatey (optionnel)
+choco install python git nodejs postgresql redis-64
+```
+
+#### Sur macOS
+```bash
+# Via Homebrew
+brew install python@3.11 git node postgresql redis opencv ffmpeg
+
+# Ou via MacPorts
+sudo port install python311 git nodejs postgresql redis opencv4
+```
+
+### Étape 2 : Clonage et Configuration du Projet
+
+```bash
+# Cloner le projet
+git clone https://github.com/votre-username/firewatch-ai.git
+cd firewatch-ai
+
+# Créer un environnement virtuel
+python3.11 -m venv venv
+
+# Activer l'environnement virtuel
+# Sur Linux/macOS :
+source venv/bin/activate
+# Sur Windows :
+venv\Scripts\activate
+
+# Vérifier la version de Python
+python --version  # Doit afficher Python 3.11.x
+```
+
+### Étape 3 : Installation des Dépendances Python
+
+```bash
+# Mettre à jour pip
+pip install --upgrade pip
+
+# Installer les dépendances de base
+pip install -r requirements.txt
+
+# Pour le développement (optionnel)
+pip install -r requirements-dev.txt
+```
+
+**Note** : L'installation peut prendre 10-15 minutes selon votre connexion internet.
+
+### Étape 4 : Configuration des Variables d'Environnement
+
+```bash
+# Copier le fichier d'exemple
+cp .env.example .env
+
+# Éditer le fichier .env
+nano .env  # ou votre éditeur préféré
+```
+
+**Configuration minimale pour commencer :**
+```bash
+DEBUG=True
+SECRET_KEY=votre-cle-secrete-django-changez-moi
+ALLOWED_HOSTS=localhost,127.0.0.1,0.0.0.0
+DATABASE_URL=sqlite:///db.sqlite3
+```
+
+### Étape 5 : Préparation des Modèles YOLOv8
+
+```bash
+# Créer le répertoire des modèles
+mkdir -p models
+
+# Copier vos modèles YOLOv8 (vous devez les avoir entraînés)
+cp /chemin/vers/vos/modeles/incendies.pt models/
+cp /chemin/vers/vos/modeles/intrusion.pt models/
+
+# Vérifier que les modèles sont présents
+ls -la models/
+# Doit afficher : incendies.pt et intrusion.pt
+```
+
+**Si vous n'avez pas encore de modèles :**
+```bash
+# L'application fonctionnera en mode simulation
+# Vous pourrez tester l'interface et intégrer vos modèles plus tard
+echo "Les modèles seront chargés quand vous les placerez dans models/"
+```
+
+### Étape 6 : Configuration de la Base de Données
+
+#### Option A : SQLite (Développement)
+```bash
+# Créer et appliquer les migrations
+python manage.py makemigrations
+python manage.py migrate
+
+# Créer un superutilisateur
+python manage.py createsuperuser
+# Suivre les instructions à l'écran
+```
+
+#### Option B : PostgreSQL (Production)
+```bash
+# Se connecter à PostgreSQL
+sudo -u postgres psql
+
+# Créer la base de données et l'utilisateur
+CREATE DATABASE firewatch_db;
+CREATE USER firewatch WITH PASSWORD 'votre_mot_de_passe';
+GRANT ALL PRIVILEGES ON DATABASE firewatch_db TO firewatch;
+\q
+
+# Modifier .env
+DATABASE_URL=postgresql://firewatch:votre_mot_de_passe@localhost:5432/firewatch_db
+
+# Appliquer les migrations
+python manage.py migrate
+python manage.py createsuperuser
+```
+
+### Étape 7 : Collecte des Fichiers Statiques
+
+```bash
+# Collecter les fichiers statiques
+python manage.py collectstatic --noinput
+
+# Créer les répertoires media
+mkdir -p media/uploads/images media/uploads/videos media/results
+```
+
+### Étape 8 : Test de l'Installation
+
+```bash
+# Lancer le serveur de développement
+python manage.py runserver 0.0.0.0:8000
+
+# Dans un autre terminal, tester l'API
+curl http://localhost:8000/
+```
+
+**Ouvrir votre navigateur** : http://localhost:8000
+
+Vous devriez voir la page d'accueil de FireWatch AI.
+
+## 🐳 Installation avec Docker (Recommandée)
+
+### Prérequis Docker
+```bash
+# Installer Docker
+curl -fsSL https://get.docker.com -o get-docker.sh
+sudo sh get-docker.sh
+
+# Installer Docker Compose
+sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+sudo chmod +x /usr/local/bin/docker-compose
+
+# Ajouter votre utilisateur au groupe docker
+sudo usermod -aG docker $USER
+# Redémarrer votre session
+```
+
+### Installation Docker
+```bash
+# Cloner le projet
+git clone https://github.com/votre-username/firewatch-ai.git
+cd firewatch-ai
+
+# Placer vos modèles
+mkdir models
+cp /chemin/vers/incendies.pt models/
+cp /chemin/vers/intrusion.pt models/
+
+# Lancer avec Docker Compose
+docker-compose up -d
+
+# Vérifier que tout fonctionne
+docker-compose ps
+docker-compose logs web
+```
+
+**Accéder à l'application** : http://localhost:8000
+
+## ⚙️ Configuration Avancée
+
+### Configuration GPU (NVIDIA)
+
+```bash
+# Installer NVIDIA Docker
+distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
+curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
+curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+
+sudo apt-get update && sudo apt-get install -y nvidia-docker2
+sudo systemctl restart docker
+
+# Modifier docker-compose.yml pour utiliser le GPU
+# Ajouter sous le service web :
+#   deploy:
+#     resources:
+#       reservations:
+#         devices:
+#           - driver: nvidia
+#             count: 1
+#             capabilities: [gpu]
+```
+
+### Configuration Redis (Cache)
+
+```bash
+# Installer Redis
+sudo apt install redis-server
+
+# Configurer Redis
+sudo nano /etc/redis/redis.conf
+# Modifier : bind 127.0.0.1
+# Modifier : maxmemory 256mb
+# Modifier : maxmemory-policy allkeys-lru
+
+# Redémarrer Redis
+sudo systemctl restart redis-server
+
+# Tester Redis
+redis-cli ping  # Doit retourner PONG
+```
+
+### Configuration Nginx (Production)
+
+```bash
+# Installer Nginx
+sudo apt install nginx
+
+# Créer la configuration
+sudo nano /etc/nginx/sites-available/firewatch
+
+# Contenu de la configuration :
+server {
+    listen 80;
+    server_name votre-domaine.com;
+    
+    client_max_body_size 50M;
+    
+    location /static/ {
+        alias /path/to/firewatch/staticfiles/;
+    }
+    
+    location /media/ {
+        alias /path/to/firewatch/media/;
+    }
+    
+    location / {
+        proxy_pass http://127.0.0.1:8000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+
+# Activer le site
+sudo ln -s /etc/nginx/sites-available/firewatch /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl restart nginx
+```
+
+## 🔍 Vérification de l'Installation
+
+### Tests de Base
+```bash
+# Activer l'environnement virtuel
+source venv/bin/activate
+
+# Lancer les tests
+python manage.py test
+
+# Vérifier les modèles
+python manage.py shell
+>>> from detection.models import AIModelStatus
+>>> AIModelStatus.objects.all()
+```
+
+### Tests Fonctionnels
+1. **Interface Web** : http://localhost:8000
+2. **Administration** : http://localhost:8000/admin/
+3. **API Status** : http://localhost:8000/api/models/status/
+4. **Upload d'image** : Tester via l'interface web
+
+### Logs et Débogage
+```bash
+# Voir les logs Django
+tail -f logs/firewatch.log
+
+# Logs Docker
+docker-compose logs -f web
+
+# Déboguer les erreurs
+python manage.py check
+python manage.py check --deploy
+```
+
+## 🚨 Résolution des Problèmes Courants
+
+### Erreur : "No module named 'cv2'"
+```bash
+pip install opencv-python
+# Ou sur Ubuntu :
+sudo apt install python3-opencv
+```
+
+### Erreur : "CUDA out of memory"
+```bash
+# Réduire la taille des batches dans settings.py
+# Ou utiliser CPU uniquement :
+export CUDA_VISIBLE_DEVICES=""
+```
+
+### Erreur : "Permission denied" sur media/
+```bash
+sudo chown -R $USER:$USER media/
+chmod -R 755 media/
+```
+
+### Erreur de base de données
+```bash
+# Réinitialiser la base de données
+rm db.sqlite3
+python manage.py migrate
+python manage.py createsuperuser
+```
+
+### Port 8000 déjà utilisé
+```bash
+# Utiliser un autre port
+python manage.py runserver 0.0.0.0:8080
+
+# Ou tuer le processus
+sudo lsof -t -i tcp:8000 | xargs kill -9
+```
+
+## 📋 Checklist Post-Installation
+
+- [ ] ✅ Python 3.11+ installé
+- [ ] ✅ Environnement virtuel créé et activé
+- [ ] ✅ Dépendances installées sans erreur
+- [ ] ✅ Variables d'environnement configurées
+- [ ] ✅ Base de données migrée
+- [ ] ✅ Superutilisateur créé
+- [ ] ✅ Modèles YOLOv8 placés (ou mode simulation)
+- [ ] ✅ Serveur démarre sans erreur
+- [ ] ✅ Interface web accessible
+- [ ] ✅ Upload d'image fonctionne
+- [ ] ✅ Administration accessible
+
+## 🎉 Félicitations !
+
+Votre installation de FireWatch AI est maintenant terminée !
+
+### Prochaines étapes :
+1. **Tester l'application** avec vos propres images/vidéos
+2. **Intégrer vos modèles YOLOv8** personnalisés
+3. **Configurer la production** si nécessaire
+4. **Personnaliser l'interface** selon vos besoins
+
+### Ressources utiles :
+- 📖 [Documentation complète](README.md)
+- 🐛 [Signaler un bug](lien-vers-issues)
+- 💬 [Support communautaire](lien-vers-forum)
+
+---
+
+**Besoin d'aide ?** Contactez Marino ATOHOUN, créateur de FireWatch AI.
+

LICENSE

@@ -0,0 +1,32 @@
+MIT License
+
+Copyright (c) 2024 Marino ATOHOUN - FireWatch AI Project
+
+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.
+
+---
+
+FireWatch AI - Système de Détection d'Incendie et d'Intrusion
+Créé par Marino ATOHOUN
+
+Ce projet utilise des technologies open source et des modèles d'intelligence 
+artificielle pour la détection d'incendie et d'intrusion en temps réel.
+
+Pour plus d'informations, consultez le fichier README.md
+

README.md

@@ -0,0 +1,322 @@
+# 🔥 FireWatch AI - Système de Détection d'Incendie et d'Intrusion
+
+**Créé par Marino ATOHOUN**
+
+FireWatch AI est une solution intelligente de détection d'incendie et d'intrusion utilisant des modèles YOLOv8 pour analyser des images, vidéos et flux de caméra en temps réel.
+
+## 🚀 Fonctionnalités
+
+- **Détection d'incendie** : Identification précise des flammes et de la fumée
+- **Détection d'intrusion** : Reconnaissance de personnes et mouvements suspects
+- **Analyse multi-format** : Support des images, vidéos et flux caméra
+- **Interface web moderne** : Interface utilisateur intuitive et responsive
+- **API REST** : Intégration facile avec d'autres systèmes
+- **Temps réel** : Analyse instantanée avec alertes
+- **Administration** : Interface d'administration Django complète
+
+## 🛠️ Technologies Utilisées
+
+- **Backend** : Django 4.2+, Python 3.11+
+- **IA/ML** : YOLOv8 (Ultralytics), OpenCV, PyTorch
+- **Frontend** : HTML5, CSS3, JavaScript, Tailwind CSS
+- **Base de données** : SQLite (dev), PostgreSQL (prod)
+- **Cache** : Redis
+- **Déploiement** : Docker, Docker Compose
+- **Serveur web** : Gunicorn, Nginx
+
+## 📋 Prérequis
+
+- Python 3.11+
+- pip
+- Git
+- Docker et Docker Compose (pour le déploiement)
+- Modèles YOLOv8 entraînés (`incendies.pt`, `intrusion.pt`)
+
+## 🔧 Installation
+
+### Installation locale
+
+1. **Cloner le projet**
+   ```bash
+   git clone <url-du-repo>
+   cd firewatch_project
+   ```
+
+2. **Créer un environnement virtuel**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # Linux/Mac
+   # ou
+   venv\Scripts\activate  # Windows
+   ```
+
+3. **Installer les dépendances**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Configurer les variables d'environnement**
+   ```bash
+   cp .env.example .env
+   # Éditer .env avec vos configurations
+   ```
+
+5. **Placer les modèles YOLOv8**
+   ```bash
+   # Copier vos modèles dans le répertoire models/
+   cp /chemin/vers/incendies.pt models/
+   cp /chemin/vers/intrusion.pt models/
+   ```
+
+6. **Effectuer les migrations**
+   ```bash
+   python manage.py migrate
+   ```
+
+7. **Créer un superutilisateur**
+   ```bash
+   python manage.py createsuperuser
+   ```
+
+8. **Lancer le serveur de développement**
+   ```bash
+   python manage.py runserver
+   ```
+
+L'application sera accessible à l'adresse : http://127.0.0.1:8000
+
+### Installation avec Docker
+
+1. **Cloner le projet**
+   ```bash
+   git clone <url-du-repo>
+   cd firewatch_project
+   ```
+
+2. **Placer les modèles YOLOv8**
+   ```bash
+   mkdir models
+   cp /chemin/vers/incendies.pt models/
+   cp /chemin/vers/intrusion.pt models/
+   ```
+
+3. **Lancer avec Docker Compose**
+   ```bash
+   # Production
+   docker-compose up -d
+   
+   # Développement
+   docker-compose -f docker-compose.yml -f docker-compose.dev.yml up
+   ```
+
+L'application sera accessible à l'adresse : http://localhost:8000
+
+## 📁 Structure du Projet
+
+```
+firewatch_project/
+├── firewatch_project/          # Configuration Django
+│   ├── settings.py
+│   ├── urls.py
+│   └── wsgi.py
+├── detection/                  # Application principale
+│   ├── models.py              # Modèles de données
+│   ├── views.py               # Logique métier
+│   ├── urls.py                # Routes
+│   ├── admin.py               # Interface d'administration
+│   └── templates/             # Templates HTML
+├── models/                    # Modèles YOLOv8
+│   ├── incendies.pt          # Modèle de détection d'incendie
+│   └── intrusion.pt          # Modèle de détection d'intrusion
+├── media/                     # Fichiers uploadés
+│   ├── uploads/               # Images/vidéos uploadées
+│   └── results/               # Résultats avec détections
+├── static/                    # Fichiers statiques
+│   ├── css/
+│   ├── js/
+│   └── images/
+├── requirements.txt           # Dépendances Python
+├── Dockerfile                # Configuration Docker
+├── docker-compose.yml        # Orchestration Docker
+└── README.md                 # Documentation
+```
+
+## 🎯 Utilisation
+
+### Interface Web
+
+1. **Accéder à l'application** : http://localhost:8000
+2. **Choisir le type d'analyse** :
+   - **Image** : Upload d'une image pour analyse
+   - **Vidéo** : Upload d'une vidéo pour analyse frame par frame
+   - **Caméra** : Analyse en temps réel depuis la webcam
+3. **Visualiser les résultats** : Détections avec boîtes englobantes et scores de confiance
+4. **Télécharger les résultats** : Images annotées et données JSON
+
+### API REST
+
+#### Analyser une image
+```bash
+curl -X POST http://localhost:8000/analyze/image/ \
+  -F "image=@/chemin/vers/image.jpg" \
+  -H "X-CSRFToken: <token>"
+```
+
+#### Analyser une vidéo
+```bash
+curl -X POST http://localhost:8000/analyze/video/ \
+  -F "video=@/chemin/vers/video.mp4" \
+  -H "X-CSRFToken: <token>"
+```
+
+#### Obtenir les résultats
+```bash
+curl http://localhost:8000/api/results/<session_id>/
+```
+
+### Administration
+
+Accéder à l'interface d'administration : http://localhost:8000/admin/
+
+- Gérer les contacts
+- Visualiser les sessions de détection
+- Consulter les statistiques
+- Configurer les modèles IA
+
+## 🔧 Configuration
+
+### Variables d'environnement importantes
+
+```bash
+# Modèles IA
+FIRE_MODEL_PATH=models/incendies.pt
+INTRUSION_MODEL_PATH=models/intrusion.pt
+
+# Seuils de détection
+MIN_CONFIDENCE_THRESHOLD=0.5
+MAX_DETECTIONS_PER_ANALYSIS=100
+
+# Limites de fichiers
+FILE_UPLOAD_MAX_MEMORY_SIZE=52428800  # 50MB
+MAX_VIDEO_DURATION=300  # 5 minutes
+
+# Base de données
+DATABASE_URL=postgresql://user:pass@localhost:5432/firewatch_db
+```
+
+### Personnalisation des modèles
+
+Pour utiliser vos propres modèles YOLOv8 :
+
+1. **Placer les fichiers `.pt`** dans le répertoire `models/`
+2. **Modifier les chemins** dans `.env` ou `settings.py`
+3. **Adapter les classes** dans `detection/views.py` si nécessaire
+4. **Redémarrer l'application**
+
+## 🧪 Tests
+
+```bash
+# Installer les dépendances de test
+pip install -r requirements-dev.txt
+
+# Lancer les tests
+python manage.py test
+
+# Avec coverage
+coverage run --source='.' manage.py test
+coverage report
+```
+
+## 📊 Monitoring et Logs
+
+### Logs de l'application
+```bash
+# Voir les logs en temps réel
+tail -f logs/firewatch.log
+
+# Logs Docker
+docker-compose logs -f web
+```
+
+### Métriques
+- Temps de traitement des analyses
+- Nombre de détections par session
+- Utilisation des ressources
+- Erreurs et exceptions
+
+## 🚀 Déploiement en Production
+
+### Avec Docker (Recommandé)
+
+1. **Configurer les variables d'environnement**
+   ```bash
+   export SECRET_KEY="votre-cle-secrete-production"
+   export DEBUG=False
+   export ALLOWED_HOSTS="votre-domaine.com"
+   ```
+
+2. **Lancer en production**
+   ```bash
+   docker-compose up -d
+   ```
+
+3. **Configurer Nginx** (optionnel)
+   - Modifier `nginx.conf` selon vos besoins
+   - Ajouter les certificats SSL dans `ssl/`
+
+### Déploiement manuel
+
+1. **Serveur web** : Gunicorn + Nginx
+2. **Base de données** : PostgreSQL
+3. **Cache** : Redis
+4. **Stockage** : AWS S3 ou stockage local
+5. **Monitoring** : Sentry, Prometheus
+
+## 🔒 Sécurité
+
+- **CSRF Protection** : Activé par défaut
+- **Rate Limiting** : Limitation des requêtes par IP
+- **File Validation** : Vérification des types et tailles de fichiers
+- **SQL Injection** : Protection via l'ORM Django
+- **XSS Protection** : Échappement automatique des templates
+
+## 🤝 Contribution
+
+1. Fork le projet
+2. Créer une branche feature (`git checkout -b feature/nouvelle-fonctionnalite`)
+3. Commit les changements (`git commit -am 'Ajouter nouvelle fonctionnalité'`)
+4. Push vers la branche (`git push origin feature/nouvelle-fonctionnalite`)
+5. Créer une Pull Request
+
+## 📝 Changelog
+
+### Version 1.0.0 (2024)
+- ✅ Détection d'incendie et d'intrusion
+- ✅ Interface web responsive
+- ✅ API REST complète
+- ✅ Support multi-format (image/vidéo/caméra)
+- ✅ Administration Django
+- ✅ Déploiement Docker
+
+## 📄 Licence
+
+Ce projet est sous licence MIT. Voir le fichier `LICENSE` pour plus de détails.
+
+## 👨‍💻 Auteur
+
+**Marino ATOHOUN**
+- Data Scientist & Développeur Backend
+- Expert en Intelligence Artificielle et Computer Vision
+
+## 📞 Support
+
+Pour toute question ou support :
+- 📧 Email : contact@firewatch.ai
+- 🐛 Issues : [GitHub Issues](lien-vers-issues)
+- 📖 Documentation : [Wiki du projet](lien-vers-wiki)
+
+---
+
+**FireWatch AI** - Solution intelligente de détection d'incendie et d'intrusion
+*Créé avec ❤️ par Marino ATOHOUN*
+

detection/__init__.py

@@ -0,0 +1,2 @@
+# Detection App - Créé par Marino ATOHOUN - FireWatch AI Project
+

detection/admin.py

@@ -0,0 +1,132 @@
+"""
+Configuration de l'interface d'administration Django
+Créé par Marino ATOHOUN - FireWatch AI Project
+"""
+from django.contrib import admin
+from django.utils.html import format_html
+from .models import Contact, DetectionSession, Detection, AIModelStatus
+
+
+@admin.register(Contact)
+class ContactAdmin(admin.ModelAdmin):
+    """Administration des contacts - Par Marino ATOHOUN"""
+    list_display = ('name', 'email', 'created_at', 'is_read', 'message_preview')
+    list_filter = ('is_read', 'created_at')
+    search_fields = ('name', 'email', 'message')
+    readonly_fields = ('created_at',)
+    list_editable = ('is_read',)
+    ordering = ('-created_at',)
+
+    def message_preview(self, obj):
+        """Aperçu du message"""
+        return obj.message[:50] + "..." if len(obj.message) > 50 else obj.message
+    message_preview.short_description = "Aperçu du message"
+
+    fieldsets = (
+        ('Informations de contact', {
+            'fields': ('name', 'email')
+        }),
+        ('Message', {
+            'fields': ('message',)
+        }),
+        ('Statut', {
+            'fields': ('is_read', 'created_at')
+        }),
+    )
+
+
+class DetectionInline(admin.TabularInline):
+    """Inline pour afficher les détections dans une session"""
+    model = Detection
+    extra = 0
+    readonly_fields = ('class_name', 'confidence', 'bbox_x', 'bbox_y', 'bbox_width', 'bbox_height')
+
+
+@admin.register(DetectionSession)
+class DetectionSessionAdmin(admin.ModelAdmin):
+    """Administration des sessions de détection - Par Marino ATOHOUN"""
+    list_display = ('session_id', 'detection_type', 'created_at', 'is_processed', 'processing_time', 'detections_count')
+    list_filter = ('detection_type', 'is_processed', 'created_at')
+    search_fields = ('session_id',)
+    readonly_fields = ('session_id', 'created_at', 'processing_time')
+    inlines = [DetectionInline]
+    ordering = ('-created_at',)
+
+    def detections_count(self, obj):
+        """Nombre de détections dans la session"""
+        return obj.detections.count()
+    detections_count.short_description = "Nombre de détections"
+
+    fieldsets = (
+        ('Informations de session', {
+            'fields': ('session_id', 'detection_type', 'created_at')
+        }),
+        ('Fichiers', {
+            'fields': ('original_file', 'result_file')
+        }),
+        ('Traitement', {
+            'fields': ('is_processed', 'processing_time')
+        }),
+    )
+
+
+@admin.register(Detection)
+class DetectionAdmin(admin.ModelAdmin):
+    """Administration des détections - Par Marino ATOHOUN"""
+    list_display = ('session', 'class_name', 'confidence_percent', 'frame_number', 'bbox_preview')
+    list_filter = ('class_name', 'session__detection_type', 'session__created_at')
+    search_fields = ('session__session_id', 'class_name')
+    readonly_fields = ('session', 'class_name', 'confidence', 'bbox_x', 'bbox_y', 'bbox_width', 'bbox_height')
+    ordering = ('-session__created_at', 'frame_number')
+
+    def confidence_percent(self, obj):
+        """Affichage de la confiance en pourcentage"""
+        return f"{obj.confidence:.1%}"
+    confidence_percent.short_description = "Confiance"
+
+    def bbox_preview(self, obj):
+        """Aperçu de la bounding box"""
+        return f"({obj.bbox_x:.0f}, {obj.bbox_y:.0f}) {obj.bbox_width:.0f}x{obj.bbox_height:.0f}"
+    bbox_preview.short_description = "Boîte englobante"
+
+
+@admin.register(AIModelStatus)
+class AIModelStatusAdmin(admin.ModelAdmin):
+    """Administration du statut des modèles IA - Par Marino ATOHOUN"""
+    list_display = ('model_type', 'is_loaded_display', 'model_version', 'accuracy_percent', 'last_loaded')
+    list_filter = ('model_type', 'is_loaded')
+    readonly_fields = ('created_at', 'updated_at', 'last_loaded')
+    ordering = ('model_type',)
+
+    def is_loaded_display(self, obj):
+        """Affichage coloré du statut de chargement"""
+        if obj.is_loaded:
+            return format_html('<span style="color: green;">✓ Chargé</span>')
+        else:
+            return format_html('<span style="color: red;">✗ Non chargé</span>')
+    is_loaded_display.short_description = "Statut"
+
+    def accuracy_percent(self, obj):
+        """Affichage de la précision en pourcentage"""
+        return f"{obj.accuracy:.1%}" if obj.accuracy else "N/A"
+    accuracy_percent.short_description = "Précision"
+
+    fieldsets = (
+        ('Configuration du modèle', {
+            'fields': ('model_type', 'model_path', 'model_version')
+        }),
+        ('Statut', {
+            'fields': ('is_loaded', 'last_loaded', 'accuracy')
+        }),
+        ('Dates', {
+            'fields': ('created_at', 'updated_at'),
+            'classes': ('collapse',)
+        }),
+    )
+
+
+# Par Marino ATOHOUN: Personnalisation de l'interface d'administration
+admin.site.site_header = "FireWatch AI - Administration"
+admin.site.site_title = "FireWatch AI Admin"
+admin.site.index_title = "Panneau d'administration - Créé par Marino ATOHOUN"
+

detection/apps.py

@@ -0,0 +1,12 @@
+"""
+Configuration de l'application Detection
+Créé par Marino ATOHOUN - FireWatch AI Project
+"""
+from django.apps import AppConfig
+
+
+class DetectionConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'detection'
+    verbose_name = 'Détection IA - FireWatch'
+

detection/migrations/0001_initial.py

@@ -0,0 +1,252 @@
+# Generated by Django 4.2.23 on 2025-08-26 00:58
+
+import detection.models
+from django.db import migrations, models
+import django.db.models.deletion
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="AIModelStatus",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "model_type",
+                    models.CharField(
+                        choices=[
+                            ("fire", "Modèle Incendie"),
+                            ("intrusion", "Modèle Intrusion"),
+                        ],
+                        max_length=20,
+                        unique=True,
+                        verbose_name="Type de modèle",
+                    ),
+                ),
+                (
+                    "model_path",
+                    models.CharField(max_length=500, verbose_name="Chemin du modèle"),
+                ),
+                (
+                    "is_loaded",
+                    models.BooleanField(default=False, verbose_name="Modèle chargé"),
+                ),
+                (
+                    "last_loaded",
+                    models.DateTimeField(
+                        blank=True, null=True, verbose_name="Dernière fois chargé"
+                    ),
+                ),
+                (
+                    "model_version",
+                    models.CharField(
+                        blank=True,
+                        max_length=50,
+                        null=True,
+                        verbose_name="Version du modèle",
+                    ),
+                ),
+                (
+                    "accuracy",
+                    models.FloatField(
+                        blank=True, null=True, verbose_name="Précision du modèle"
+                    ),
+                ),
+                (
+                    "created_at",
+                    models.DateTimeField(
+                        auto_now_add=True, verbose_name="Date de création"
+                    ),
+                ),
+                (
+                    "updated_at",
+                    models.DateTimeField(
+                        auto_now=True, verbose_name="Date de mise à jour"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Statut du modèle IA",
+                "verbose_name_plural": "Statuts des modèles IA",
+            },
+        ),
+        migrations.CreateModel(
+            name="Contact",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=100, verbose_name="Nom")),
+                ("email", models.EmailField(max_length=254, verbose_name="Email")),
+                ("message", models.TextField(verbose_name="Message")),
+                (
+                    "created_at",
+                    models.DateTimeField(
+                        auto_now_add=True, verbose_name="Date de création"
+                    ),
+                ),
+                ("is_read", models.BooleanField(default=False, verbose_name="Lu")),
+            ],
+            options={
+                "verbose_name": "Contact",
+                "verbose_name_plural": "Contacts",
+                "ordering": ["-created_at"],
+            },
+        ),
+        migrations.CreateModel(
+            name="DetectionSession",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "session_id",
+                    models.UUIDField(default=uuid.uuid4, editable=False, unique=True),
+                ),
+                (
+                    "detection_type",
+                    models.CharField(
+                        choices=[
+                            ("image", "Image"),
+                            ("video", "Vidéo"),
+                            ("camera", "Caméra"),
+                        ],
+                        max_length=10,
+                        verbose_name="Type de détection",
+                    ),
+                ),
+                (
+                    "original_file",
+                    models.FileField(
+                        blank=True,
+                        null=True,
+                        upload_to=detection.models.upload_to_images,
+                        verbose_name="Fichier original",
+                    ),
+                ),
+                (
+                    "result_file",
+                    models.FileField(
+                        blank=True,
+                        null=True,
+                        upload_to=detection.models.upload_to_results,
+                        verbose_name="Fichier résultat",
+                    ),
+                ),
+                (
+                    "created_at",
+                    models.DateTimeField(
+                        auto_now_add=True, verbose_name="Date de création"
+                    ),
+                ),
+                (
+                    "processing_time",
+                    models.FloatField(
+                        blank=True,
+                        null=True,
+                        verbose_name="Temps de traitement (secondes)",
+                    ),
+                ),
+                (
+                    "is_processed",
+                    models.BooleanField(default=False, verbose_name="Traité"),
+                ),
+            ],
+            options={
+                "verbose_name": "Session de détection",
+                "verbose_name_plural": "Sessions de détection",
+                "ordering": ["-created_at"],
+            },
+        ),
+        migrations.CreateModel(
+            name="Detection",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "class_name",
+                    models.CharField(
+                        choices=[
+                            ("fire", "Incendie"),
+                            ("smoke", "Fumée"),
+                            ("person", "Personne"),
+                            ("intrusion", "Intrusion"),
+                            ("vehicle", "Véhicule"),
+                            ("other", "Autre"),
+                        ],
+                        max_length=20,
+                        verbose_name="Classe détectée",
+                    ),
+                ),
+                ("confidence", models.FloatField(verbose_name="Confiance")),
+                ("bbox_x", models.FloatField(verbose_name="Boîte englobante X")),
+                ("bbox_y", models.FloatField(verbose_name="Boîte englobante Y")),
+                (
+                    "bbox_width",
+                    models.FloatField(verbose_name="Largeur boîte englobante"),
+                ),
+                (
+                    "bbox_height",
+                    models.FloatField(verbose_name="Hauteur boîte englobante"),
+                ),
+                (
+                    "frame_number",
+                    models.IntegerField(
+                        default=0, verbose_name="Numéro de frame (pour vidéo)"
+                    ),
+                ),
+                (
+                    "timestamp",
+                    models.FloatField(
+                        blank=True, null=True, verbose_name="Timestamp (pour vidéo)"
+                    ),
+                ),
+                (
+                    "session",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="detections",
+                        to="detection.detectionsession",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Détection",
+                "verbose_name_plural": "Détections",
+                "ordering": ["-session__created_at", "frame_number"],
+            },
+        ),
+    ]

detection/migrations/__init__.py

@@ -0,0 +1,2 @@
+# Migrations - Créé par Marino ATOHOUN - FireWatch AI Project
+

detection/models.py

@@ -0,0 +1,149 @@
+"""
+Modèles de données pour l'application Detection
+Créé par Marino ATOHOUN - FireWatch AI Project
+"""
+from django.db import models
+from django.utils import timezone
+import uuid
+import os
+
+
+def upload_to_images(instance, filename):
+    """Fonction pour définir le chemin d'upload des images"""
+    ext = filename.split('.')[-1]
+    filename = f"{uuid.uuid4()}.{ext}"
+    return os.path.join('uploads/images/', filename)
+
+
+def upload_to_videos(instance, filename):
+    """Fonction pour définir le chemin d'upload des vidéos"""
+    ext = filename.split('.')[-1]
+    filename = f"{uuid.uuid4()}.{ext}"
+    return os.path.join('uploads/videos/', filename)
+
+
+def upload_to_results(instance, filename):
+    """Fonction pour définir le chemin d'upload des résultats"""
+    ext = filename.split('.')[-1]
+    filename = f"result_{uuid.uuid4()}.{ext}"
+    return os.path.join('results/', filename)
+
+
+class Contact(models.Model):
+    """
+    Modèle pour stocker les messages de contact
+    Par Marino ATOHOUN
+    """
+    name = models.CharField(max_length=100, verbose_name="Nom")
+    email = models.EmailField(verbose_name="Email")
+    message = models.TextField(verbose_name="Message")
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name="Date de création")
+    is_read = models.BooleanField(default=False, verbose_name="Lu")
+
+    class Meta:
+        verbose_name = "Contact"
+        verbose_name_plural = "Contacts"
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f"Message de {self.name} ({self.email}) - {self.created_at.strftime('%d/%m/%Y %H:%M')}"
+
+
+class DetectionSession(models.Model):
+    """
+    Modèle pour stocker les sessions de détection
+    Par Marino ATOHOUN
+    """
+    DETECTION_TYPES = [
+        ('image', 'Image'),
+        ('video', 'Vidéo'),
+        ('camera', 'Caméra'),
+    ]
+
+    session_id = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
+    detection_type = models.CharField(max_length=10, choices=DETECTION_TYPES, verbose_name="Type de détection")
+    original_file = models.FileField(upload_to=upload_to_images, null=True, blank=True, verbose_name="Fichier original")
+    result_file = models.FileField(upload_to=upload_to_results, null=True, blank=True, verbose_name="Fichier résultat")
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name="Date de création")
+    processing_time = models.FloatField(null=True, blank=True, verbose_name="Temps de traitement (secondes)")
+    is_processed = models.BooleanField(default=False, verbose_name="Traité")
+
+    class Meta:
+        verbose_name = "Session de détection"
+        verbose_name_plural = "Sessions de détection"
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f"Session {self.session_id} - {self.get_detection_type_display()} - {self.created_at.strftime('%d/%m/%Y %H:%M')}"
+
+
+class Detection(models.Model):
+    """
+    Modèle pour stocker les résultats de détection individuels
+    Par Marino ATOHOUN
+    """
+    DETECTION_CLASSES = [
+        ('fire', 'Incendie'),
+        ('smoke', 'Fumée'),
+        ('person', 'Personne'),
+        ('intrusion', 'Intrusion'),
+        ('vehicle', 'Véhicule'),
+        ('other', 'Autre'),
+    ]
+
+    session = models.ForeignKey(DetectionSession, on_delete=models.CASCADE, related_name='detections')
+    class_name = models.CharField(max_length=20, choices=DETECTION_CLASSES, verbose_name="Classe détectée")
+    confidence = models.FloatField(verbose_name="Confiance")
+    bbox_x = models.FloatField(verbose_name="Boîte englobante X")
+    bbox_y = models.FloatField(verbose_name="Boîte englobante Y")
+    bbox_width = models.FloatField(verbose_name="Largeur boîte englobante")
+    bbox_height = models.FloatField(verbose_name="Hauteur boîte englobante")
+    frame_number = models.IntegerField(default=0, verbose_name="Numéro de frame (pour vidéo)")
+    timestamp = models.FloatField(null=True, blank=True, verbose_name="Timestamp (pour vidéo)")
+
+    class Meta:
+        verbose_name = "Détection"
+        verbose_name_plural = "Détections"
+        ordering = ['-session__created_at', 'frame_number']
+
+    def __str__(self):
+        return f"{self.get_class_name_display()} - {self.confidence:.2%} - Session {self.session.session_id}"
+
+    @property
+    def bbox_dict(self):
+        """Retourne la bounding box sous forme de dictionnaire"""
+        return {
+            'x': self.bbox_x,
+            'y': self.bbox_y,
+            'width': self.bbox_width,
+            'height': self.bbox_height
+        }
+
+
+class AIModelStatus(models.Model):
+    """
+    Modèle pour suivre le statut des modèles IA
+    Par Marino ATOHOUN
+    """
+    MODEL_TYPES = [
+        ('fire', 'Modèle Incendie'),
+        ('intrusion', 'Modèle Intrusion'),
+    ]
+
+    model_type = models.CharField(max_length=20, choices=MODEL_TYPES, unique=True, verbose_name="Type de modèle")
+    model_path = models.CharField(max_length=500, verbose_name="Chemin du modèle")
+    is_loaded = models.BooleanField(default=False, verbose_name="Modèle chargé")
+    last_loaded = models.DateTimeField(null=True, blank=True, verbose_name="Dernière fois chargé")
+    model_version = models.CharField(max_length=50, null=True, blank=True, verbose_name="Version du modèle")
+    accuracy = models.FloatField(null=True, blank=True, verbose_name="Précision du modèle")
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name="Date de création")
+    updated_at = models.DateTimeField(auto_now=True, verbose_name="Date de mise à jour")
+
+    class Meta:
+        verbose_name = "Statut du modèle IA"
+        verbose_name_plural = "Statuts des modèles IA"
+
+    def __str__(self):
+        status = "Chargé" if self.is_loaded else "Non chargé"
+        return f"{self.get_model_type_display()} - {status}"
+

detection/templates/detection/index.html

@@ -0,0 +1,718 @@
+{% load static %}
+<!DOCTYPE html>
+<!-- Fichier adapté pour Django par Marino ATOHOUN - FireWatch AI Project -->
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FireWatch AI - Détection d'incendie et d'intrusion</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <style>
+        :root {
+            --primary-dark: #0f172a;
+            --primary-blue: #1e40af;
+            --accent-violet: #7c3aed;
+            --accent-pink: #ec4899;
+            --light-gray: #f1f5f9;
+        }
+        
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background-color: var(--light-gray);
+        }
+        
+        .gradient-bg {
+            background: linear-gradient(135deg, var(--primary-blue) 0%, var(--accent-violet) 100%);
+        }
+        
+        .card-glass {
+            background: rgba(255, 255, 255, 0.1);
+            backdrop-filter: blur(10px);
+            -webkit-backdrop-filter: blur(10px);
+            border-radius: 1rem;
+            border: 1px solid rgba(255, 255, 255, 0.2);
+        }
+        
+        .pulse-animation {
+            animation: pulse 2s infinite;
+        }
+        
+        @keyframes pulse {
+            0% { box-shadow: 0 0 0 0 rgba(236, 72, 153, 0.4); }
+            70% { box-shadow: 0 0 0 10px rgba(236, 72, 153, 0); }
+            100% { box-shadow: 0 0 0 0 rgba(236, 72, 153, 0); }
+        }
+        
+        .tab-active {
+            border-bottom: 3px solid var(--accent-pink);
+            color: var(--accent-pink);
+        }
+
+        .loading {
+            display: none;
+        }
+
+        .loading.show {
+            display: block;
+        }
+
+        .alert {
+            padding: 1rem;
+            margin: 1rem 0;
+            border-radius: 0.5rem;
+            display: none;
+        }
+
+        .alert.show {
+            display: block;
+        }
+
+        .alert-success {
+            background-color: #d1fae5;
+            color: #065f46;
+            border: 1px solid #a7f3d0;
+        }
+
+        .alert-error {
+            background-color: #fee2e2;
+            color: #991b1b;
+            border: 1px solid #fca5a5;
+        }
+    </style>
+</head>
+<body class="min-h-screen">
+    <!-- Header -->
+    <header class="gradient-bg text-white shadow-xl">
+        <div class="container mx-auto px-4 py-6">
+            <div class="flex justify-between items-center">
+                <div class="flex items-center space-x-2">
+                    <i class="fas fa-fire text-2xl text-pink-500"></i>
+                    <h1 class="text-2xl font-bold">FireWatch <span class="text-pink-400">AI</span></h1>
+                </div>
+                <nav class="hidden md:flex space-x-6">
+                    <a href="#about" class="hover:text-pink-300 transition">À propos</a>
+                    <a href="#demo" class="hover:text-pink-300 transition">Démonstration</a>
+                    <a href="#creator" class="hover:text-pink-300 transition">Créateur</a>
+                    <a href="#contact" class="hover:text-pink-300 transition">Contact</a>
+                </nav>
+                <button class="md:hidden text-xl">
+                    <i class="fas fa-bars"></i>
+                </button>
+            </div>
+        </div>
+    </header>
+
+    <!-- Hero Section -->
+    <section class="gradient-bg text-white py-20">
+        <div class="container mx-auto px-4 flex flex-col md:flex-row items-center">
+            <div class="md:w-1/2 mb-10 md:mb-0">
+                <h2 class="text-4xl md:text-5xl font-bold mb-6">Détection intelligente d'incendie et d'intrusion</h2>
+                <p class="text-xl mb-8 text-gray-200">Notre solution IA avancée utilise YOLOv8 pour identifier les risques en temps réel à partir d'images, de vidéos ou de flux caméra.</p>
+                <a href="#demo" class="bg-pink-500 hover:bg-pink-600 text-white font-bold py-3 px-6 rounded-full transition duration-300 inline-flex items-center">
+                    Essayer maintenant <i class="fas fa-arrow-right ml-2"></i>
+                </a>
+            </div>
+            <div class="md:w-1/2 flex justify-center">
+                <div class="card-glass p-6 w-full max-w-md">
+                    <div class="bg-black rounded-lg overflow-hidden aspect-video flex items-center justify-center">
+                        <i class="fas fa-play text-pink-500 text-4xl"></i>
+                    </div>
+                    <p class="text-center mt-4 text-gray-300">Démonstration en direct de la détection</p>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- About Section -->
+    <section id="about" class="py-16 bg-white">
+        <div class="container mx-auto px-4">
+            <h2 class="text-3xl font-bold text-center mb-12 text-gray-800">À propos du projet</h2>
+            <div class="grid md:grid-cols-3 gap-8">
+                <div class="bg-gray-50 p-6 rounded-xl shadow-md hover:shadow-lg transition">
+                    <div class="text-indigo-600 text-3xl mb-4">
+                        <i class="fas fa-fire-extinguisher"></i>
+                    </div>
+                    <h3 class="text-xl font-semibold mb-3 text-gray-800">Détection d'incendie</h3>
+                    <p class="text-gray-600">Notre modèle identifie avec précision les débuts d'incendie, même dans des conditions de faible visibilité.</p>
+                </div>
+                <div class="bg-gray-50 p-6 rounded-xl shadow-md hover:shadow-lg transition">
+                    <div class="text-violet-600 text-3xl mb-4">
+                        <i class="fas fa-user-secret"></i>
+                    </div>
+                    <h3 class="text-xl font-semibold mb-3 text-gray-800">Détection d'intrusion</h3>
+                    <p class="text-gray-600">Système de surveillance intelligent qui repère les intrusions et mouvements suspects en temps réel.</p>
+                </div>
+                <div class="bg-gray-50 p-6 rounded-xl shadow-md hover:shadow-lg transition">
+                    <div class="text-pink-600 text-3xl mb-4">
+                        <i class="fas fa-bolt"></i>
+                    </div>
+                    <h3 class="text-xl font-semibold mb-3 text-gray-800">Temps réel</h3>
+                    <p class="text-gray-600">Analyse instantanée des flux vidéo avec alertes en temps réel pour une intervention rapide.</p>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- Demo Section -->
+    <section id="demo" class="py-16 bg-gray-50">
+        <div class="container mx-auto px-4">
+            <h2 class="text-3xl font-bold text-center mb-12 text-gray-800">Essayer la démonstration</h2>
+            
+            <div class="max-w-4xl mx-auto bg-white rounded-xl shadow-lg overflow-hidden">
+                <!-- Tabs -->
+                <div class="flex border-b">
+                    <button onclick="switchTab('image')" class="tab-button py-4 px-6 font-medium text-gray-500 hover:text-pink-500 transition tab-active" id="image-tab">
+                        <i class="fas fa-image mr-2"></i> Image
+                    </button>
+                    <button onclick="switchTab('video')" class="tab-button py-4 px-6 font-medium text-gray-500 hover:text-pink-500 transition" id="video-tab">
+                        <i class="fas fa-video mr-2"></i> Vidéo
+                    </button>
+                    <button onclick="switchTab('camera')" class="tab-button py-4 px-6 font-medium text-gray-500 hover:text-pink-500 transition" id="camera-tab">
+                        <i class="fas fa-camera mr-2"></i> Caméra
+                    </button>
+                </div>
+                
+                <!-- Tab Content -->
+                <div class="p-6">
+                    <!-- Image Tab Content -->
+                    <div id="image-content" class="tab-content">
+                        <form id="image-form" method="post" enctype="multipart/form-data">
+                            {% csrf_token %}
+                            <div class="border-2 border-dashed border-gray-300 rounded-lg p-8 text-center">
+                                <i class="fas fa-cloud-upload-alt text-4xl text-indigo-500 mb-4"></i>
+                                <h3 class="text-xl font-semibold mb-2">Uploader une image</h3>
+                                <p class="text-gray-500 mb-4">Glissez-déposez une image ou cliquez pour sélectionner</p>
+                                <input type="file" name="image" id="image-upload" accept="image/*" class="hidden" required>
+                                <label for="image-upload" class="bg-indigo-500 hover:bg-indigo-600 text-white font-medium py-2 px-4 rounded cursor-pointer transition">
+                                    Sélectionner une image
+                                </label>
+                                <div id="image-preview" class="mt-4 hidden">
+                                    <img id="preview-img" src="" alt="Aperçu" class="max-w-full h-48 mx-auto rounded">
+                                </div>
+                            </div>
+                            <div class="mt-6 flex justify-between">
+                                <button type="button" onclick="resetImageForm()" class="bg-gray-200 hover:bg-gray-300 text-gray-800 font-medium py-2 px-4 rounded transition">
+                                    <i class="fas fa-redo mr-2"></i> Réinitialiser
+                                </button>
+                                <button type="submit" class="bg-pink-500 hover:bg-pink-600 text-white font-medium py-2 px-4 rounded transition">
+                                    <i class="fas fa-search mr-2"></i> Analyser
+                                </button>
+                            </div>
+                            <div class="loading mt-4 text-center">
+                                <i class="fas fa-spinner fa-spin text-2xl text-indigo-500"></i>
+                                <p class="mt-2 text-gray-600">Analyse en cours...</p>
+                            </div>
+                        </form>
+                    </div>
+                    
+                    <!-- Video Tab Content -->
+                    <div id="video-content" class="tab-content hidden">
+                        <form id="video-form" method="post" enctype="multipart/form-data">
+                            {% csrf_token %}
+                            <div class="border-2 border-dashed border-gray-300 rounded-lg p-8 text-center">
+                                <i class="fas fa-film text-4xl text-violet-500 mb-4"></i>
+                                <h3 class="text-xl font-semibold mb-2">Uploader une vidéo</h3>
+                                <p class="text-gray-500 mb-4">Glissez-déposez une vidéo ou cliquez pour sélectionner</p>
+                                <input type="file" name="video" id="video-upload" accept="video/*" class="hidden" required>
+                                <label for="video-upload" class="bg-violet-500 hover:bg-violet-600 text-white font-medium py-2 px-4 rounded cursor-pointer transition">
+                                    Sélectionner une vidéo
+                                </label>
+                                <div id="video-preview" class="mt-4 hidden">
+                                    <video id="preview-video" controls class="max-w-full h-48 mx-auto rounded">
+                                        <source src="" type="video/mp4">
+                                        Votre navigateur ne supporte pas la lecture vidéo.
+                                    </video>
+                                </div>
+                            </div>
+                            <div class="mt-6 flex justify-between">
+                                <button type="button" onclick="resetVideoForm()" class="bg-gray-200 hover:bg-gray-300 text-gray-800 font-medium py-2 px-4 rounded transition">
+                                    <i class="fas fa-redo mr-2"></i> Réinitialiser
+                                </button>
+                                <button type="submit" class="bg-pink-500 hover:bg-pink-600 text-white font-medium py-2 px-4 rounded transition">
+                                    <i class="fas fa-play mr-2"></i> Démarrer l'analyse
+                                </button>
+                            </div>
+                            <div class="loading mt-4 text-center">
+                                <i class="fas fa-spinner fa-spin text-2xl text-violet-500"></i>
+                                <p class="mt-2 text-gray-600">Analyse vidéo en cours...</p>
+                            </div>
+                        </form>
+                    </div>
+                    
+                    <!-- Camera Tab Content -->
+                    <div id="camera-content" class="tab-content hidden">
+                        <div class="border-2 border-dashed border-gray-300 rounded-lg p-8 text-center">
+                            <i class="fas fa-camera text-4xl text-pink-500 mb-4"></i>
+                            <h3 class="text-xl font-semibold mb-2">Accéder à votre caméra</h3>
+                            <p class="text-gray-500 mb-4">Autorisez l'accès à votre caméra pour une analyse en temps réel</p>
+                            <button id="start-camera" class="bg-pink-500 hover:bg-pink-600 text-white font-medium py-2 px-4 rounded cursor-pointer transition pulse-animation">
+                                <i class="fas fa-video mr-2"></i> Activer la caméra
+                            </button>
+                            <div id="camera-stream" class="mt-4 hidden">
+                                <video id="camera-video" autoplay muted class="max-w-full h-64 mx-auto rounded bg-black"></video>
+                                <canvas id="camera-canvas" class="hidden"></canvas>
+                            </div>
+                        </div>
+                        <div class="mt-6 flex justify-center">
+                            <button id="stop-camera" class="bg-gray-200 hover:bg-gray-300 text-gray-800 font-medium py-2 px-4 rounded transition hidden">
+                                <i class="fas fa-stop mr-2"></i> Arrêter
+                            </button>
+                            <button id="capture-frame" class="bg-indigo-500 hover:bg-indigo-600 text-white font-medium py-2 px-4 rounded transition ml-4 hidden">
+                                <i class="fas fa-camera mr-2"></i> Capturer et analyser
+                            </button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Results Section -->
+            <div id="results" class="max-w-4xl mx-auto mt-12 bg-white rounded-xl shadow-lg overflow-hidden hidden">
+                <div class="p-6">
+                    <h3 class="text-xl font-semibold mb-4 text-gray-800">Résultats de l'analyse</h3>
+                    <div class="flex flex-col md:flex-row gap-6">
+                        <div class="md:w-1/2">
+                            <div id="result-image-container" class="bg-black rounded-lg overflow-hidden aspect-video flex items-center justify-center">
+                                <img id="result-image" src="" alt="Résultat de l'analyse" class="w-full h-full object-contain">
+                            </div>
+                        </div>
+                        <div class="md:w-1/2">
+                            <div class="bg-gray-50 p-4 rounded-lg">
+                                <h4 class="font-medium text-gray-800 mb-3">Détections:</h4>
+                                <ul id="detection-list" class="space-y-2">
+                                    <!-- Les détections seront insérées ici par JavaScript -->
+                                </ul>
+                            </div>
+                            <div class="mt-4">
+                                <button id="download-results" class="bg-indigo-500 hover:bg-indigo-600 text-white font-medium py-2 px-4 rounded transition">
+                                    <i class="fas fa-download mr-2"></i> Télécharger les résultats
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Alert Messages -->
+            <div id="alert-container" class="max-w-4xl mx-auto mt-4">
+                <div id="success-alert" class="alert alert-success">
+                    <i class="fas fa-check-circle mr-2"></i>
+                    <span id="success-message"></span>
+                </div>
+                <div id="error-alert" class="alert alert-error">
+                    <i class="fas fa-exclamation-circle mr-2"></i>
+                    <span id="error-message"></span>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- Creator Section -->
+    <section id="creator" class="py-16 bg-gradient-to-r from-indigo-900 to-violet-900 text-white">
+        <div class="container mx-auto px-4">
+            <h2 class="text-3xl font-bold text-center mb-12">À propos du créateur</h2>
+            <div class="max-w-4xl mx-auto flex flex-col md:flex-row items-center gap-8">
+                <div class="md:w-1/3 flex justify-center">
+                    <div class="w-48 h-48 rounded-full bg-gray-300 overflow-hidden border-4 border-pink-400 shadow-lg">
+                        <img src="https://via.placeholder.com/200" alt="Marino ATOHOUN" class="w-full h-full object-cover">
+                    </div>
+                </div>
+                <div class="md:w-2/3">
+                    <h3 class="text-2xl font-bold mb-2">Marino ATOHOUN</h3>
+                    <p class="text-pink-300 font-medium mb-4">Data Scientist & Développeur Backend</p>
+                    <p class="mb-4 text-gray-300">Expert en intelligence artificielle et développement logiciel, Marino ATOHOUN a conçu cette solution innovante pour répondre aux besoins croissants de sécurité et de prévention des risques.</p>
+                    <p class="mb-4 text-gray-300">Avec une solide expérience dans le traitement d'images et l'analyse de données, il a développé ce système de détection basé sur YOLOv8 pour offrir une solution performante et accessible.</p>
+                    <div class="flex space-x-4">
+                        <a href="#" class="text-gray-300 hover:text-pink-300 transition">
+                            <i class="fab fa-github text-xl"></i>
+                        </a>
+                        <a href="#" class="text-gray-300 hover:text-pink-300 transition">
+                            <i class="fab fa-linkedin text-xl"></i>
+                        </a>
+                        <a href="#" class="text-gray-300 hover:text-pink-300 transition">
+                            <i class="fas fa-envelope text-xl"></i>
+                        </a>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- Contact Section -->
+    <section id="contact" class="py-16 bg-white">
+        <div class="container mx-auto px-4">
+            <h2 class="text-3xl font-bold text-center mb-12 text-gray-800">Contactez-nous</h2>
+            <div class="max-w-2xl mx-auto bg-gray-50 rounded-xl shadow-md p-8">
+                <form id="contact-form" method="post">
+                    {% csrf_token %}
+                    <div id="contact-alert" class="alert">
+                        <span id="contact-message"></span>
+                    </div>
+                    <div class="mb-6">
+                        <label for="name" class="block text-gray-700 font-medium mb-2">Nom</label>
+                        <input type="text" id="name" name="name" class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-indigo-500" required>
+                    </div>
+                    <div class="mb-6">
+                        <label for="email" class="block text-gray-700 font-medium mb-2">Email</label>
+                        <input type="email" id="email" name="email" class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-indigo-500" required>
+                    </div>
+                    <div class="mb-6">
+                        <label for="message" class="block text-gray-700 font-medium mb-2">Message</label>
+                        <textarea id="message" name="message" rows="4" class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-indigo-500" required></textarea>
+                    </div>
+                    <button type="submit" class="bg-indigo-500 hover:bg-indigo-600 text-white font-medium py-2 px-6 rounded-lg transition w-full">
+                        <i class="fas fa-paper-plane mr-2"></i> Envoyer le message
+                    </button>
+                </form>
+            </div>
+        </div>
+    </section>
+
+    <!-- Footer -->
+    <footer class="bg-gray-900 text-white py-8">
+        <div class="container mx-auto px-4">
+            <div class="flex flex-col md:flex-row justify-between items-center">
+                <div class="mb-4 md:mb-0">
+                    <div class="flex items-center space-x-2">
+                        <i class="fas fa-fire text-xl text-pink-500"></i>
+                        <span class="text-xl font-bold">FireWatch <span class="text-pink-400">AI</span></span>
+                    </div>
+                    <p class="text-gray-400 mt-2">Solution intelligente de détection d'incendie et d'intrusion</p>
+                </div>
+                <div class="flex space-x-6">
+                    <a href="#" class="text-gray-400 hover:text-pink-400 transition">
+                        <i class="fab fa-facebook-f"></i>
+                    </a>
+                    <a href="#" class="text-gray-400 hover:text-pink-400 transition">
+                        <i class="fab fa-twitter"></i>
+                    </a>
+                    <a href="#" class="text-gray-400 hover:text-pink-400 transition">
+                        <i class="fab fa-instagram"></i>
+                    </a>
+                    <a href="#" class="text-gray-400 hover:text-pink-400 transition">
+                        <i class="fab fa-github"></i>
+                    </a>
+                </div>
+            </div>
+            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-gray-400">
+                <p>&copy; 2024 FireWatch AI. Tous droits réservés. Conçu avec passion par Marino ATOHOUN.</p>
+            </div>
+        </div>
+    </footer>
+
+    <script>
+        // Par Marino ATOHOUN: JavaScript pour l'interaction avec le backend Django
+        
+        // Obtenir le token CSRF
+        function getCSRFToken() {
+            return document.querySelector('[name=csrfmiddlewaretoken]').value;
+        }
+
+        // Fonctions utilitaires pour les alertes
+        function showAlert(type, message) {
+            const alertContainer = document.getElementById('alert-container');
+            const alert = document.getElementById(type + '-alert');
+            const messageSpan = document.getElementById(type + '-message');
+            
+            messageSpan.textContent = message;
+            alert.classList.add('show');
+            
+            setTimeout(() => {
+                alert.classList.remove('show');
+            }, 5000);
+        }
+
+        function showContactAlert(type, message) {
+            const alert = document.getElementById('contact-alert');
+            const messageSpan = document.getElementById('contact-message');
+            
+            alert.className = 'alert show alert-' + type;
+            messageSpan.textContent = message;
+            
+            setTimeout(() => {
+                alert.classList.remove('show');
+            }, 5000);
+        }
+
+        // Tab switching functionality
+        function switchTab(tabName) {
+            // Hide all tab contents
+            document.querySelectorAll('.tab-content').forEach(content => {
+                content.classList.add('hidden');
+            });
+            
+            // Remove active class from all tabs
+            document.querySelectorAll('.tab-button').forEach(button => {
+                button.classList.remove('tab-active');
+            });
+            
+            // Show selected tab content
+            document.getElementById(tabName + '-content').classList.remove('hidden');
+            
+            // Add active class to selected tab
+            document.getElementById(tabName + '-tab').classList.add('tab-active');
+        }
+
+        // Fonctions de réinitialisation des formulaires
+        function resetImageForm() {
+            document.getElementById('image-form').reset();
+            document.getElementById('image-preview').classList.add('hidden');
+            document.getElementById('results').classList.add('hidden');
+        }
+
+        function resetVideoForm() {
+            document.getElementById('video-form').reset();
+            document.getElementById('video-preview').classList.add('hidden');
+            document.getElementById('results').classList.add('hidden');
+        }
+
+        // Aperçu des fichiers
+        document.getElementById('image-upload').addEventListener('change', function(e) {
+            const file = e.target.files[0];
+            if (file) {
+                const reader = new FileReader();
+                reader.onload = function(e) {
+                    document.getElementById('preview-img').src = e.target.result;
+                    document.getElementById('image-preview').classList.remove('hidden');
+                };
+                reader.readAsDataURL(file);
+            }
+        });
+
+        document.getElementById('video-upload').addEventListener('change', function(e) {
+            const file = e.target.files[0];
+            if (file) {
+                const url = URL.createObjectURL(file);
+                document.getElementById('preview-video').src = url;
+                document.getElementById('video-preview').classList.remove('hidden');
+            }
+        });
+
+        // Gestion du formulaire d'image
+        document.getElementById('image-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            
+            const formData = new FormData(this);
+            const loadingDiv = this.querySelector('.loading');
+            
+            loadingDiv.classList.add('show');
+            
+            fetch("{% url 'detection:analyze_image' %}", {
+                method: 'POST',
+                body: formData,
+                headers: {
+                    'X-CSRFToken': getCSRFToken()
+                }
+            })
+            .then(response => response.json())
+            .then(data => {
+                loadingDiv.classList.remove('show');
+                
+                if (data.success) {
+                    displayResults(data);
+                    showAlert('success', 'Analyse terminée avec succès!');
+                } else {
+                    showAlert('error', data.error || 'Erreur lors de l\'analyse');
+                }
+            })
+            .catch(error => {
+                loadingDiv.classList.remove('show');
+                showAlert('error', 'Erreur de connexion au serveur');
+                console.error('Error:', error);
+            });
+        });
+
+        // Gestion du formulaire de vidéo
+        document.getElementById('video-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            
+            const formData = new FormData(this);
+            const loadingDiv = this.querySelector('.loading');
+            
+            loadingDiv.classList.add('show');
+            
+            fetch("{% url 'detection:analyze_video' %}", {
+                method: 'POST',
+                body: formData,
+                headers: {
+                    'X-CSRFToken': getCSRFToken()
+                }
+            })
+            .then(response => response.json())
+            .then(data => {
+                loadingDiv.classList.remove('show');
+                
+                if (data.success) {
+                    displayResults(data);
+                    showAlert('success', 'Analyse vidéo terminée avec succès!');
+                } else {
+                    showAlert('error', data.error || 'Erreur lors de l\'analyse vidéo');
+                }
+            })
+            .catch(error => {
+                loadingDiv.classList.remove('show');
+                showAlert('error', 'Erreur de connexion au serveur');
+                console.error('Error:', error);
+            });
+        });
+
+        // Gestion du formulaire de contact
+        document.getElementById('contact-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            
+            const formData = new FormData(this);
+            
+            fetch("{% url 'detection:contact' %}", {
+                method: 'POST',
+                body: formData,
+                headers: {
+                    'X-CSRFToken': getCSRFToken()
+                }
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    showContactAlert('success', data.message);
+                    this.reset();
+                } else {
+                    showContactAlert('error', data.error || 'Erreur lors de l\'envoi du message');
+                }
+            })
+            .catch(error => {
+                showContactAlert('error', 'Erreur de connexion au serveur');
+                console.error('Error:', error);
+            });
+        });
+
+        // Affichage des résultats
+        function displayResults(data) {
+            const resultsSection = document.getElementById('results');
+            const resultImage = document.getElementById('result-image');
+            const detectionList = document.getElementById('detection-list');
+            
+            // Afficher l'image de résultat
+            if (data.result_image_url) {
+                resultImage.src = data.result_image_url;
+            }
+            
+            // Afficher les détections
+            detectionList.innerHTML = '';
+            if (data.detections && data.detections.length > 0) {
+                data.detections.forEach(detection => {
+                    const li = document.createElement('li');
+                    li.className = 'flex items-center';
+                    
+                    // Couleur selon le type de détection
+                    let colorClass = 'bg-blue-500';
+                    if (detection.class_name === 'fire' || detection.class_name === 'smoke') {
+                        colorClass = 'bg-red-500';
+                    } else if (detection.class_name === 'person' || detection.class_name === 'intrusion') {
+                        colorClass = 'bg-orange-500';
+                    }
+                    
+                    li.innerHTML = `
+                        <span class="w-3 h-3 ${colorClass} rounded-full mr-2"></span>
+                        <span>${detection.label || detection.class_name}: 
+                        <span class="font-medium">${(detection.confidence * 100).toFixed(1)}% de confiance</span></span>
+                    `;
+                    detectionList.appendChild(li);
+                });
+            } else {
+                detectionList.innerHTML = '<li class="text-gray-500">Aucune détection trouvée</li>';
+            }
+            
+            // Afficher la section des résultats
+            resultsSection.classList.remove('hidden');
+            resultsSection.scrollIntoView({ behavior: 'smooth' });
+        }
+
+        // Gestion de la caméra
+        let cameraStream = null;
+        let cameraVideo = document.getElementById('camera-video');
+        let cameraCanvas = document.getElementById('camera-canvas');
+
+        document.getElementById('start-camera').addEventListener('click', function() {
+            navigator.mediaDevices.getUserMedia({ video: true })
+                .then(function(stream) {
+                    cameraStream = stream;
+                    cameraVideo.srcObject = stream;
+                    
+                    document.getElementById('camera-stream').classList.remove('hidden');
+                    document.getElementById('stop-camera').classList.remove('hidden');
+                    document.getElementById('capture-frame').classList.remove('hidden');
+                    this.classList.remove('pulse-animation');
+                })
+                .catch(function(error) {
+                    showAlert('error', 'Impossible d\'accéder à la caméra: ' + error.message);
+                });
+        });
+
+        document.getElementById('stop-camera').addEventListener('click', function() {
+            if (cameraStream) {
+                cameraStream.getTracks().forEach(track => track.stop());
+                cameraStream = null;
+            }
+            
+            document.getElementById('camera-stream').classList.add('hidden');
+            document.getElementById('stop-camera').classList.add('hidden');
+            document.getElementById('capture-frame').classList.add('hidden');
+            document.getElementById('start-camera').classList.add('pulse-animation');
+        });
+
+        document.getElementById('capture-frame').addEventListener('click', function() {
+            if (cameraVideo.videoWidth > 0) {
+                // Capturer une frame de la vidéo
+                cameraCanvas.width = cameraVideo.videoWidth;
+                cameraCanvas.height = cameraVideo.videoHeight;
+                
+                const ctx = cameraCanvas.getContext('2d');
+                ctx.drawImage(cameraVideo, 0, 0);
+                
+                // Convertir en blob et envoyer pour analyse
+                cameraCanvas.toBlob(function(blob) {
+                    const formData = new FormData();
+                    formData.append('image', blob, 'camera_capture.jpg');
+                    
+                    fetch("{% url 'detection:analyze_image' %}", {
+                        method: 'POST',
+                        body: formData,
+                        headers: {
+                            'X-CSRFToken': getCSRFToken()
+                        }
+                    })
+                    .then(response => response.json())
+                    .then(data => {
+                        if (data.success) {
+                            displayResults(data);
+                            showAlert('success', 'Capture analysée avec succès!');
+                        } else {
+                            showAlert('error', data.error || 'Erreur lors de l\'analyse');
+                        }
+                    })
+                    .catch(error => {
+                        showAlert('error', 'Erreur de connexion au serveur');
+                        console.error('Error:', error);
+                    });
+                }, 'image/jpeg', 0.8);
+            }
+        });
+
+        // Smooth scrolling for navigation links
+        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
+            anchor.addEventListener('click', function(e) {
+                e.preventDefault();
+                const target = document.querySelector(this.getAttribute('href'));
+                if (target) {
+                    target.scrollIntoView({
+                        behavior: 'smooth'
+                    });
+                }
+            });
+        });
+    </script>
+    
+    <!-- Signature Marino ATOHOUN -->
+    <div style="display: none;">Code signé par Marino ATOHOUN - FireWatch AI Project</div>
+</body>
+</html>
+

detection/tests.py

@@ -0,0 +1,405 @@
+"""
+Tests pour l'application Detection
+Créé par Marino ATOHOUN - FireWatch AI Project
+"""
+import os
+import tempfile
+from django.test import TestCase, Client
+from django.urls import reverse
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.contrib.auth.models import User
+from PIL import Image
+import io
+from .models import Contact, DetectionSession, Detection, AIModelStatus
+
+
+class ContactModelTest(TestCase):
+    """Tests pour le modèle Contact - Par Marino ATOHOUN"""
+    
+    def setUp(self):
+        self.contact = Contact.objects.create(
+            name="Test User",
+            email="test@example.com",
+            message="Message de test"
+        )
+    
+    def test_contact_creation(self):
+        """Test de création d'un contact"""
+        self.assertEqual(self.contact.name, "Test User")
+        self.assertEqual(self.contact.email, "test@example.com")
+        self.assertFalse(self.contact.is_read)
+    
+    def test_contact_str_method(self):
+        """Test de la méthode __str__ du contact"""
+        expected = f"Message de {self.contact.name} ({self.contact.email}) - {self.contact.created_at.strftime('%d/%m/%Y %H:%M')}"
+        self.assertEqual(str(self.contact), expected)
+
+
+class DetectionSessionModelTest(TestCase):
+    """Tests pour le modèle DetectionSession - Par Marino ATOHOUN"""
+    
+    def setUp(self):
+        self.session = DetectionSession.objects.create(
+            detection_type='image'
+        )
+    
+    def test_session_creation(self):
+        """Test de création d'une session"""
+        self.assertEqual(self.session.detection_type, 'image')
+        self.assertFalse(self.session.is_processed)
+        self.assertIsNotNone(self.session.session_id)
+    
+    def test_session_str_method(self):
+        """Test de la méthode __str__ de la session"""
+        expected = f"Session {self.session.session_id} - Image - {self.session.created_at.strftime('%d/%m/%Y %H:%M')}"
+        self.assertEqual(str(self.session), expected)
+
+
+class DetectionModelTest(TestCase):
+    """Tests pour le modèle Detection - Par Marino ATOHOUN"""
+    
+    def setUp(self):
+        self.session = DetectionSession.objects.create(detection_type='image')
+        self.detection = Detection.objects.create(
+            session=self.session,
+            class_name='fire',
+            confidence=0.92,
+            bbox_x=100,
+            bbox_y=100,
+            bbox_width=150,
+            bbox_height=150
+        )
+    
+    def test_detection_creation(self):
+        """Test de création d'une détection"""
+        self.assertEqual(self.detection.class_name, 'fire')
+        self.assertEqual(self.detection.confidence, 0.92)
+    
+    def test_bbox_dict_property(self):
+        """Test de la propriété bbox_dict"""
+        expected = {
+            'x': 100,
+            'y': 100,
+            'width': 150,
+            'height': 150
+        }
+        self.assertEqual(self.detection.bbox_dict, expected)
+
+
+class ViewsTest(TestCase):
+    """Tests pour les vues - Par Marino ATOHOUN"""
+    
+    def setUp(self):
+        self.client = Client()
+    
+    def test_index_view(self):
+        """Test de la vue principale"""
+        response = self.client.get(reverse('detection:index'))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, 'FireWatch AI')
+    
+    def test_contact_view_post(self):
+        """Test de soumission du formulaire de contact"""
+        data = {
+            'name': 'Test User',
+            'email': 'test@example.com',
+            'message': 'Message de test'
+        }
+        response = self.client.post(reverse('detection:contact'), data)
+        self.assertEqual(response.status_code, 200)
+        
+        # Vérifier que le contact a été créé
+        contact = Contact.objects.get(email='test@example.com')
+        self.assertEqual(contact.name, 'Test User')
+    
+    def test_contact_view_invalid_data(self):
+        """Test avec des données invalides"""
+        data = {
+            'name': '',
+            'email': 'invalid-email',
+            'message': ''
+        }
+        response = self.client.post(reverse('detection:contact'), data)
+        self.assertEqual(response.status_code, 400)
+    
+    def create_test_image(self):
+        """Crée une image de test"""
+        image = Image.new('RGB', (100, 100), color='red')
+        image_io = io.BytesIO()
+        image.save(image_io, format='JPEG')
+        image_io.seek(0)
+        return SimpleUploadedFile(
+            "test_image.jpg",
+            image_io.getvalue(),
+            content_type="image/jpeg"
+        )
+    
+    def test_analyze_image_view(self):
+        """Test d'analyse d'image"""
+        test_image = self.create_test_image()
+        
+        response = self.client.post(
+            reverse('detection:analyze_image'),
+            {'image': test_image}
+        )
+        
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertTrue(data['success'])
+        self.assertIn('session_id', data)
+        self.assertIn('detections', data)
+    
+    def test_analyze_image_no_file(self):
+        """Test d'analyse sans fichier"""
+        response = self.client.post(reverse('detection:analyze_image'))
+        self.assertEqual(response.status_code, 400)
+        data = response.json()
+        self.assertFalse(data['success'])
+    
+    def test_models_status_api(self):
+        """Test de l'API de statut des modèles"""
+        # Créer un statut de modèle de test
+        AIModelStatus.objects.create(
+            model_type='fire',
+            model_path='models/incendies.pt',
+            is_loaded=True
+        )
+        
+        response = self.client.get(reverse('detection:models_status'))
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertTrue(data['success'])
+        self.assertIn('models', data)
+
+
+class AdminTest(TestCase):
+    """Tests pour l'interface d'administration - Par Marino ATOHOUN"""
+    
+    def setUp(self):
+        self.admin_user = User.objects.create_superuser(
+            username='admin',
+            email='admin@test.com',
+            password='admin123'
+        )
+        self.client = Client()
+        self.client.login(username='admin', password='admin123')
+    
+    def test_admin_contact_list(self):
+        """Test de la liste des contacts dans l'admin"""
+        Contact.objects.create(
+            name="Test User",
+            email="test@example.com",
+            message="Message de test"
+        )
+        
+        response = self.client.get('/admin/detection/contact/')
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, 'Test User')
+    
+    def test_admin_detection_session_list(self):
+        """Test de la liste des sessions dans l'admin"""
+        session = DetectionSession.objects.create(detection_type='image')
+        
+        response = self.client.get('/admin/detection/detectionsession/')
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, str(session.session_id))
+
+
+class UtilityTest(TestCase):
+    """Tests pour les fonctions utilitaires - Par Marino ATOHOUN"""
+    
+    def test_file_upload_paths(self):
+        """Test des chemins d'upload"""
+        from .models import upload_to_images, upload_to_videos, upload_to_results
+        
+        # Mock instance
+        class MockInstance:
+            pass
+        
+        instance = MockInstance()
+        
+        # Test des chemins
+        image_path = upload_to_images(instance, 'test.jpg')
+        self.assertTrue(image_path.startswith('uploads/images/'))
+        self.assertTrue(image_path.endswith('.jpg'))
+        
+        video_path = upload_to_videos(instance, 'test.mp4')
+        self.assertTrue(video_path.startswith('uploads/videos/'))
+        self.assertTrue(video_path.endswith('.mp4'))
+        
+        result_path = upload_to_results(instance, 'result.jpg')
+        self.assertTrue(result_path.startswith('results/'))
+        self.assertTrue(result_path.endswith('.jpg'))
+
+
+class IntegrationTest(TestCase):
+    """Tests d'intégration - Par Marino ATOHOUN"""
+    
+    def setUp(self):
+        self.client = Client()
+    
+    def test_full_image_analysis_workflow(self):
+        """Test du workflow complet d'analyse d'image"""
+        # 1. Créer une image de test
+        image = Image.new('RGB', (640, 480), color='red')
+        image_io = io.BytesIO()
+        image.save(image_io, format='JPEG')
+        image_io.seek(0)
+        test_image = SimpleUploadedFile(
+            "test_fire.jpg",
+            image_io.getvalue(),
+            content_type="image/jpeg"
+        )
+        
+        # 2. Analyser l'image
+        response = self.client.post(
+            reverse('detection:analyze_image'),
+            {'image': test_image}
+        )
+        
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertTrue(data['success'])
+        
+        session_id = data['session_id']
+        
+        # 3. Vérifier que la session a été créée
+        session = DetectionSession.objects.get(session_id=session_id)
+        self.assertEqual(session.detection_type, 'image')
+        self.assertTrue(session.is_processed)
+        
+        # 4. Récupérer les résultats via l'API
+        response = self.client.get(
+            reverse('detection:get_results', kwargs={'session_id': session_id})
+        )
+        
+        self.assertEqual(response.status_code, 200)
+        results_data = response.json()
+        self.assertTrue(results_data['success'])
+        self.assertEqual(results_data['session_id'], session_id)
+    
+    def test_contact_and_admin_workflow(self):
+        """Test du workflow contact et administration"""
+        # 1. Envoyer un message de contact
+        contact_data = {
+            'name': 'John Doe',
+            'email': 'john@example.com',
+            'message': 'Question sur FireWatch AI'
+        }
+        
+        response = self.client.post(reverse('detection:contact'), contact_data)
+        self.assertEqual(response.status_code, 200)
+        
+        # 2. Vérifier que le contact existe
+        contact = Contact.objects.get(email='john@example.com')
+        self.assertEqual(contact.name, 'John Doe')
+        self.assertFalse(contact.is_read)
+        
+        # 3. Marquer comme lu (simulation admin)
+        contact.is_read = True
+        contact.save()
+        
+        # 4. Vérifier la mise à jour
+        updated_contact = Contact.objects.get(email='john@example.com')
+        self.assertTrue(updated_contact.is_read)
+
+
+class PerformanceTest(TestCase):
+    """Tests de performance - Par Marino ATOHOUN"""
+    
+    def test_multiple_detections_creation(self):
+        """Test de création de multiples détections"""
+        import time
+        
+        session = DetectionSession.objects.create(detection_type='video')
+        
+        start_time = time.time()
+        
+        # Créer 100 détections
+        detections = []
+        for i in range(100):
+            detection = Detection(
+                session=session,
+                class_name='fire',
+                confidence=0.8 + (i % 20) * 0.01,
+                bbox_x=i * 10,
+                bbox_y=i * 10,
+                bbox_width=100,
+                bbox_height=100,
+                frame_number=i
+            )
+            detections.append(detection)
+        
+        Detection.objects.bulk_create(detections)
+        
+        end_time = time.time()
+        creation_time = end_time - start_time
+        
+        # Vérifier que la création est rapide (moins de 1 seconde)
+        self.assertLess(creation_time, 1.0)
+        
+        # Vérifier que toutes les détections ont été créées
+        self.assertEqual(Detection.objects.filter(session=session).count(), 100)
+
+
+class SecurityTest(TestCase):
+    """Tests de sécurité - Par Marino ATOHOUN"""
+    
+    def test_csrf_protection(self):
+        """Test de protection CSRF"""
+        # Tentative de POST sans token CSRF
+        response = self.client.post(reverse('detection:contact'), {
+            'name': 'Test',
+            'email': 'test@example.com',
+            'message': 'Test'
+        })
+        
+        # Django doit rejeter la requête sans CSRF token
+        self.assertEqual(response.status_code, 403)
+    
+    def test_file_type_validation(self):
+        """Test de validation des types de fichiers"""
+        # Créer un fichier texte déguisé en image
+        fake_image = SimpleUploadedFile(
+            "fake.jpg",
+            b"This is not an image",
+            content_type="text/plain"
+        )
+        
+        response = self.client.post(
+            reverse('detection:analyze_image'),
+            {'image': fake_image}
+        )
+        
+        # La requête doit être rejetée
+        self.assertEqual(response.status_code, 400)
+    
+    def test_large_file_rejection(self):
+        """Test de rejet des fichiers trop volumineux"""
+        # Créer un fichier de 100MB (simulé)
+        large_content = b"x" * (100 * 1024 * 1024)  # 100MB
+        large_file = SimpleUploadedFile(
+            "large.jpg",
+            large_content,
+            content_type="image/jpeg"
+        )
+        
+        # Note: Ce test peut ne pas fonctionner en environnement de test
+        # car Django limite la taille en mémoire
+        try:
+            response = self.client.post(
+                reverse('detection:analyze_image'),
+                {'image': large_file}
+            )
+            # Si la requête passe, elle doit être rejetée par notre validation
+            if response.status_code == 200:
+                data = response.json()
+                self.assertFalse(data.get('success', True))
+        except Exception:
+            # Exception attendue pour un fichier trop volumineux
+            pass
+
+
+# Par Marino ATOHOUN: Commande pour lancer tous les tests
+# python manage.py test detection.tests
+

detection/urls.py

@@ -0,0 +1,35 @@
+"""
+URLs pour l'application Detection
+Créé par Marino ATOHOUN - FireWatch AI Project
+"""
+from django.urls import path
+from . import views
+
+app_name = 'detection'
+
+urlpatterns = [
+    # Page principale
+    path('', views.index_view, name='index'),
+    
+    # Formulaire de contact
+    path('contact/', views.contact_view, name='contact'),
+    
+    # Analyse d'images
+    path('analyze/image/', views.analyze_image_view, name='analyze_image'),
+    
+    # Analyse de vidéos
+    path('analyze/video/', views.analyze_video_view, name='analyze_video'),
+    
+    # Analyse en temps réel (caméra)
+    path('analyze/camera/', views.analyze_camera_view, name='analyze_camera'),
+    
+    # API pour obtenir les résultats
+    path('api/results/<uuid:session_id>/', views.get_results_api, name='get_results'),
+    
+    # Téléchargement des résultats
+    path('download/results/<uuid:session_id>/', views.download_results, name='download_results'),
+    
+    # Statut des modèles IA
+    path('api/models/status/', views.models_status_api, name='models_status'),
+]
+

detection/views.py

@@ -0,0 +1,630 @@
+"""
+Vues pour l'application Detection
+Créé par Marino ATOHOUN - FireWatch AI Project
+"""
+import os
+import json
+import time
+import uuid
+import cv2
+import numpy as np
+from PIL import Image
+from django.shortcuts import render
+from django.http import JsonResponse, HttpResponse, Http404
+from django.views.decorators.http import require_POST, require_GET
+from django.views.decorators.csrf import csrf_exempt
+from django.conf import settings
+from django.core.files.storage import default_storage
+from django.core.files.base import ContentFile
+from django.utils import timezone
+from .models import Contact, DetectionSession, Detection, AIModelStatus
+import logging
+
+# Par Marino ATOHOUN: Configuration du logging
+logger = logging.getLogger(__name__)
+
+# Par Marino ATOHOUN: Variables globales pour les modèles YOLOv8
+# Ces variables seront initialisées au démarrage du serveur
+fire_model = None
+intrusion_model = None
+
+# Par Marino ATOHOUN: Fonction pour charger les modèles YOLOv8
+def load_yolo_models():
+    """
+    Charge les modèles YOLOv8 pour la détection d'incendie et d'intrusion
+    À appeler au démarrage du serveur Django
+    """
+    global fire_model, intrusion_model
+    
+    try:
+        # Par Marino ATOHOUN: Importez YOLO ici quand vous avez ultralytics installé
+        # from ultralytics import YOLO
+        
+        # Vérifier si les fichiers de modèles existent
+        fire_model_path = settings.FIRE_MODEL_PATH
+        intrusion_model_path = settings.INTRUSION_MODEL_PATH
+        
+        # Par Marino ATOHOUN: Décommentez ces lignes quand vous avez vos modèles
+        # if os.path.exists(fire_model_path):
+        #     fire_model = YOLO(fire_model_path)
+        #     logger.info("Modèle d'incendie chargé avec succès")
+        #     
+        #     # Mettre à jour le statut dans la base de données
+        #     AIModelStatus.objects.update_or_create(
+        #         model_type='fire',
+        #         defaults={
+        #             'model_path': str(fire_model_path),
+        #             'is_loaded': True,
+        #             'last_loaded': timezone.now(),
+        #             'model_version': '1.0'
+        #         }
+        #     )
+        # else:
+        #     logger.warning(f"Modèle d'incendie non trouvé: {fire_model_path}")
+        
+        # if os.path.exists(intrusion_model_path):
+        #     intrusion_model = YOLO(intrusion_model_path)
+        #     logger.info("Modèle d'intrusion chargé avec succès")
+        #     
+        #     # Mettre à jour le statut dans la base de données
+        #     AIModelStatus.objects.update_or_create(
+        #         model_type='intrusion',
+        #         defaults={
+        #             'model_path': str(intrusion_model_path),
+        #             'is_loaded': True,
+        #             'last_loaded': timezone.now(),
+        #             'model_version': '1.0'
+        #         }
+        #     )
+        # else:
+        #     logger.warning(f"Modèle d'intrusion non trouvé: {intrusion_model_path}")
+        
+        # Par Marino ATOHOUN: Pour l'instant, on simule le chargement
+        logger.info("Simulation du chargement des modèles - Remplacez par le vrai code")
+        
+        # Créer les entrées de statut pour la simulation
+        AIModelStatus.objects.update_or_create(
+            model_type='fire',
+            defaults={
+                'model_path': str(fire_model_path),
+                'is_loaded': False,  # Sera True quand vous aurez les vrais modèles
+                'last_loaded': None,
+                'model_version': '1.0'
+            }
+        )
+        
+        AIModelStatus.objects.update_or_create(
+            model_type='intrusion',
+            defaults={
+                'model_path': str(intrusion_model_path),
+                'is_loaded': False,  # Sera True quand vous aurez les vrais modèles
+                'last_loaded': None,
+                'model_version': '1.0'
+            }
+        )
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement des modèles: {e}")
+
+
+# Par Marino ATOHOUN: Fonction pour effectuer la détection sur une image
+def detect_objects_in_image(image_path, session):
+    """
+    Effectue la détection d'objets sur une image
+    Retourne une liste de détections
+    """
+    detections = []
+    
+    try:
+        # Par Marino ATOHOUN: Ici vous intégrerez votre code de détection YOLOv8
+        # Exemple de ce que vous devrez faire:
+        
+        # # Charger l'image
+        # image = cv2.imread(image_path)
+        # 
+        # # Détection avec le modèle d'incendie
+        # if fire_model:
+        #     fire_results = fire_model(image)
+        #     for result in fire_results:
+        #         boxes = result.boxes
+        #         if boxes is not None:
+        #             for box in boxes:
+        #                 x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+        #                 confidence = box.conf[0].cpu().numpy()
+        #                 class_id = int(box.cls[0].cpu().numpy())
+        #                 
+        #                 # Mapper les classes selon votre modèle
+        #                 class_name = 'fire' if class_id == 0 else 'smoke'
+        #                 
+        #                 detection = Detection.objects.create(
+        #                     session=session,
+        #                     class_name=class_name,
+        #                     confidence=float(confidence),
+        #                     bbox_x=float(x1),
+        #                     bbox_y=float(y1),
+        #                     bbox_width=float(x2 - x1),
+        #                     bbox_height=float(y2 - y1)
+        #                 )
+        #                 detections.append(detection)
+        # 
+        # # Détection avec le modèle d'intrusion
+        # if intrusion_model:
+        #     intrusion_results = intrusion_model(image)
+        #     # Traitement similaire...
+        
+        # Par Marino ATOHOUN: Pour l'instant, on simule des détections
+        # Remplacez cette section par votre vraie logique de détection
+        
+        # Simulation de détections aléatoires pour la démonstration
+        import random
+        
+        simulation_detections = [
+            {'class_name': 'fire', 'confidence': 0.92, 'bbox': [100, 100, 150, 150]},
+            {'class_name': 'person', 'confidence': 0.87, 'bbox': [200, 150, 100, 200]},
+            {'class_name': 'smoke', 'confidence': 0.78, 'bbox': [50, 50, 80, 100]},
+        ]
+        
+        for sim_det in simulation_detections:
+            if random.random() > 0.3:  # 70% de chance d'apparaître
+                detection = Detection.objects.create(
+                    session=session,
+                    class_name=sim_det['class_name'],
+                    confidence=sim_det['confidence'],
+                    bbox_x=sim_det['bbox'][0],
+                    bbox_y=sim_det['bbox'][1],
+                    bbox_width=sim_det['bbox'][2],
+                    bbox_height=sim_det['bbox'][3]
+                )
+                detections.append(detection)
+        
+        logger.info(f"Détections simulées créées: {len(detections)}")
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la détection: {e}")
+    
+    return detections
+
+
+# Par Marino ATOHOUN: Fonction pour dessiner les boîtes de détection
+def draw_detections_on_image(image_path, detections, output_path):
+    """
+    Dessine les boîtes de détection sur l'image et sauvegarde le résultat
+    """
+    try:
+        # Par Marino ATOHOUN: Ici vous dessinerez les vraies boîtes de détection
+        # Exemple de ce que vous devrez faire:
+        
+        # image = cv2.imread(image_path)
+        # 
+        # for detection in detections:
+        #     x1 = int(detection.bbox_x)
+        #     y1 = int(detection.bbox_y)
+        #     x2 = int(detection.bbox_x + detection.bbox_width)
+        #     y2 = int(detection.bbox_y + detection.bbox_height)
+        #     
+        #     # Couleur selon le type de détection
+        #     if detection.class_name in ['fire', 'smoke']:
+        #         color = (0, 0, 255)  # Rouge
+        #     else:
+        #         color = (255, 0, 0)  # Bleu
+        #     
+        #     # Dessiner la boîte
+        #     cv2.rectangle(image, (x1, y1), (x2, y2), color, 2)
+        #     
+        #     # Ajouter le label
+        #     label = f"{detection.class_name}: {detection.confidence:.2f}"
+        #     cv2.putText(image, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        # 
+        # # Sauvegarder l'image avec les détections
+        # cv2.imwrite(output_path, image)
+        
+        # Par Marino ATOHOUN: Pour l'instant, on copie juste l'image originale
+        # Remplacez par votre vraie logique de dessin
+        import shutil
+        shutil.copy2(image_path, output_path)
+        logger.info(f"Image de résultat créée (simulation): {output_path}")
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du dessin des détections: {e}")
+
+
+def index_view(request):
+    """
+    Vue principale - Affiche la page d'accueil
+    Par Marino ATOHOUN
+    """
+    return render(request, 'detection/index.html')
+
+
+@require_POST
+def contact_view(request):
+    """
+    Gère la soumission du formulaire de contact
+    Par Marino ATOHOUN
+    """
+    try:
+        name = request.POST.get('name', '').strip()
+        email = request.POST.get('email', '').strip()
+        message = request.POST.get('message', '').strip()
+        
+        if not all([name, email, message]):
+            return JsonResponse({
+                'success': False,
+                'error': 'Tous les champs sont requis.'
+            }, status=400)
+        
+        # Créer le contact dans la base de données
+        contact = Contact.objects.create(
+            name=name,
+            email=email,
+            message=message
+        )
+        
+        logger.info(f"Nouveau contact créé: {contact.id} - {name} ({email})")
+        
+        return JsonResponse({
+            'success': True,
+            'message': 'Votre message a été envoyé avec succès! Nous vous répondrons bientôt.'
+        })
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la création du contact: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Une erreur est survenue lors de l\'envoi du message.'
+        }, status=500)
+
+
+@require_POST
+def analyze_image_view(request):
+    """
+    Gère l'upload et l'analyse d'une image
+    Par Marino ATOHOUN
+    """
+    try:
+        if 'image' not in request.FILES:
+            return JsonResponse({
+                'success': False,
+                'error': 'Aucune image fournie.'
+            }, status=400)
+        
+        image_file = request.FILES['image']
+        
+        # Vérifier le type de fichier
+        allowed_types = ['image/jpeg', 'image/jpg', 'image/png', 'image/bmp']
+        if image_file.content_type not in allowed_types:
+            return JsonResponse({
+                'success': False,
+                'error': 'Type de fichier non supporté. Utilisez JPG, PNG ou BMP.'
+            }, status=400)
+        
+        # Créer une session de détection
+        session = DetectionSession.objects.create(
+            detection_type='image'
+        )
+        
+        # Sauvegarder l'image uploadée
+        image_path = default_storage.save(
+            f'uploads/images/{session.session_id}_{image_file.name}',
+            ContentFile(image_file.read())
+        )
+        session.original_file = image_path
+        session.save()
+        
+        # Obtenir le chemin complet
+        full_image_path = os.path.join(settings.MEDIA_ROOT, image_path)
+        
+        # Mesurer le temps de traitement
+        start_time = time.time()
+        
+        # Par Marino ATOHOUN: Effectuer la détection
+        detections = detect_objects_in_image(full_image_path, session)
+        
+        # Créer l'image de résultat avec les détections
+        result_filename = f'results/result_{session.session_id}.jpg'
+        result_path = os.path.join(settings.MEDIA_ROOT, result_filename)
+        os.makedirs(os.path.dirname(result_path), exist_ok=True)
+        
+        draw_detections_on_image(full_image_path, detections, result_path)
+        
+        # Sauvegarder le chemin du résultat
+        session.result_file = result_filename
+        session.processing_time = time.time() - start_time
+        session.is_processed = True
+        session.save()
+        
+        # Préparer la réponse
+        detections_data = []
+        for detection in detections:
+            detections_data.append({
+                'class_name': detection.class_name,
+                'label': detection.get_class_name_display(),
+                'confidence': detection.confidence,
+                'bbox': detection.bbox_dict
+            })
+        
+        result_image_url = request.build_absolute_uri(settings.MEDIA_URL + result_filename)
+        
+        logger.info(f"Analyse d'image terminée: Session {session.session_id}, {len(detections)} détections")
+        
+        return JsonResponse({
+            'success': True,
+            'session_id': str(session.session_id),
+            'detections': detections_data,
+            'result_image_url': result_image_url,
+            'processing_time': session.processing_time
+        })
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de l'analyse d'image: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Une erreur est survenue lors de l\'analyse de l\'image.'
+        }, status=500)
+
+
+@require_POST
+def analyze_video_view(request):
+    """
+    Gère l'upload et l'analyse d'une vidéo
+    Par Marino ATOHOUN
+    """
+    try:
+        if 'video' not in request.FILES:
+            return JsonResponse({
+                'success': False,
+                'error': 'Aucune vidéo fournie.'
+            }, status=400)
+        
+        video_file = request.FILES['video']
+        
+        # Vérifier le type de fichier
+        allowed_types = ['video/mp4', 'video/avi', 'video/mov', 'video/mkv']
+        if video_file.content_type not in allowed_types:
+            return JsonResponse({
+                'success': False,
+                'error': 'Type de fichier non supporté. Utilisez MP4, AVI, MOV ou MKV.'
+            }, status=400)
+        
+        # Créer une session de détection
+        session = DetectionSession.objects.create(
+            detection_type='video'
+        )
+        
+        # Sauvegarder la vidéo uploadée
+        video_path = default_storage.save(
+            f'uploads/videos/{session.session_id}_{video_file.name}',
+            ContentFile(video_file.read())
+        )
+        session.original_file = video_path
+        session.save()
+        
+        # Par Marino ATOHOUN: Ici vous intégrerez votre logique d'analyse vidéo
+        # Exemple de ce que vous devrez faire:
+        
+        # full_video_path = os.path.join(settings.MEDIA_ROOT, video_path)
+        # cap = cv2.VideoCapture(full_video_path)
+        # 
+        # frame_count = 0
+        # detections = []
+        # 
+        # while True:
+        #     ret, frame = cap.read()
+        #     if not ret:
+        #         break
+        #     
+        #     # Analyser chaque frame (ou une frame sur N pour optimiser)
+        #     if frame_count % 30 == 0:  # Analyser une frame toutes les 30
+        #         # Sauvegarder temporairement la frame
+        #         temp_frame_path = f'/tmp/frame_{frame_count}.jpg'
+        #         cv2.imwrite(temp_frame_path, frame)
+        #         
+        #         # Analyser la frame
+        #         frame_detections = detect_objects_in_image(temp_frame_path, session)
+        #         
+        #         # Ajouter le numéro de frame et timestamp
+        #         for detection in frame_detections:
+        #             detection.frame_number = frame_count
+        #             detection.timestamp = frame_count / cap.get(cv2.CAP_PROP_FPS)
+        #             detection.save()
+        #         
+        #         detections.extend(frame_detections)
+        #     
+        #     frame_count += 1
+        # 
+        # cap.release()
+        
+        # Par Marino ATOHOUN: Pour l'instant, simulation de l'analyse vidéo
+        start_time = time.time()
+        
+        # Simuler quelques détections sur différentes frames
+        import random
+        simulation_detections = []
+        
+        for frame_num in [0, 30, 60, 90]:
+            if random.random() > 0.5:
+                detection = Detection.objects.create(
+                    session=session,
+                    class_name=random.choice(['fire', 'person', 'smoke']),
+                    confidence=random.uniform(0.7, 0.95),
+                    bbox_x=random.uniform(50, 200),
+                    bbox_y=random.uniform(50, 200),
+                    bbox_width=random.uniform(80, 150),
+                    bbox_height=random.uniform(80, 150),
+                    frame_number=frame_num,
+                    timestamp=frame_num / 30.0  # Supposer 30 FPS
+                )
+                simulation_detections.append(detection)
+        
+        session.processing_time = time.time() - start_time
+        session.is_processed = True
+        session.save()
+        
+        # Préparer la réponse
+        detections_data = []
+        for detection in simulation_detections:
+            detections_data.append({
+                'class_name': detection.class_name,
+                'label': detection.get_class_name_display(),
+                'confidence': detection.confidence,
+                'bbox': detection.bbox_dict,
+                'frame_number': detection.frame_number,
+                'timestamp': detection.timestamp
+            })
+        
+        logger.info(f"Analyse vidéo terminée: Session {session.session_id}, {len(simulation_detections)} détections")
+        
+        return JsonResponse({
+            'success': True,
+            'session_id': str(session.session_id),
+            'detections': detections_data,
+            'processing_time': session.processing_time,
+            'message': 'Analyse vidéo terminée. Fonctionnalité complète disponible avec vos modèles YOLOv8.'
+        })
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de l'analyse vidéo: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Une erreur est survenue lors de l\'analyse de la vidéo.'
+        }, status=500)
+
+
+@require_POST
+def analyze_camera_view(request):
+    """
+    Gère l'analyse en temps réel depuis la caméra
+    Par Marino ATOHOUN
+    """
+    # Cette vue est appelée quand l'utilisateur capture une frame depuis la caméra
+    # Le frontend envoie l'image capturée comme un blob
+    return analyze_image_view(request)  # Réutiliser la logique d'analyse d'image
+
+
+@require_GET
+def get_results_api(request, session_id):
+    """
+    API pour récupérer les résultats d'une session de détection
+    Par Marino ATOHOUN
+    """
+    try:
+        session = DetectionSession.objects.get(session_id=session_id)
+        detections = session.detections.all()
+        
+        detections_data = []
+        for detection in detections:
+            detections_data.append({
+                'class_name': detection.class_name,
+                'label': detection.get_class_name_display(),
+                'confidence': detection.confidence,
+                'bbox': detection.bbox_dict,
+                'frame_number': detection.frame_number,
+                'timestamp': detection.timestamp
+            })
+        
+        result_image_url = None
+        if session.result_file:
+            result_image_url = request.build_absolute_uri(settings.MEDIA_URL + session.result_file.name)
+        
+        return JsonResponse({
+            'success': True,
+            'session_id': str(session.session_id),
+            'detection_type': session.detection_type,
+            'detections': detections_data,
+            'result_image_url': result_image_url,
+            'processing_time': session.processing_time,
+            'is_processed': session.is_processed,
+            'created_at': session.created_at.isoformat()
+        })
+        
+    except DetectionSession.DoesNotExist:
+        return JsonResponse({
+            'success': False,
+            'error': 'Session de détection non trouvée.'
+        }, status=404)
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des résultats: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Une erreur est survenue.'
+        }, status=500)
+
+
+def download_results(request, session_id):
+    """
+    Permet de télécharger les résultats d'une session
+    Par Marino ATOHOUN
+    """
+    try:
+        session = DetectionSession.objects.get(session_id=session_id)
+        
+        if not session.result_file:
+            raise Http404("Aucun fichier de résultat disponible")
+        
+        # Préparer le fichier pour téléchargement
+        file_path = session.result_file.path
+        
+        if not os.path.exists(file_path):
+            raise Http404("Fichier de résultat non trouvé")
+        
+        with open(file_path, 'rb') as f:
+            response = HttpResponse(f.read(), content_type='image/jpeg')
+            response['Content-Disposition'] = f'attachment; filename="firewatch_result_{session_id}.jpg"'
+            return response
+            
+    except DetectionSession.DoesNotExist:
+        raise Http404("Session de détection non trouvée")
+    except Exception as e:
+        logger.error(f"Erreur lors du téléchargement: {e}")
+        raise Http404("Erreur lors du téléchargement")
+
+
+@require_GET
+def models_status_api(request):
+    """
+    API pour obtenir le statut des modèles IA
+    Par Marino ATOHOUN
+    """
+    try:
+        models_status = AIModelStatus.objects.all()
+        
+        status_data = []
+        for model in models_status:
+            status_data.append({
+                'model_type': model.model_type,
+                'model_name': model.get_model_type_display(),
+                'is_loaded': model.is_loaded,
+                'last_loaded': model.last_loaded.isoformat() if model.last_loaded else None,
+                'model_version': model.model_version,
+                'accuracy': model.accuracy
+            })
+        
+        return JsonResponse({
+            'success': True,
+            'models': status_data
+        })
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération du statut des modèles: {e}")
+        return JsonResponse({
+            'success': False,
+            'error': 'Une erreur est survenue.'
+        }, status=500)
+
+
+# Par Marino ATOHOUN: Initialiser les modèles au démarrage
+# Cette fonction sera appelée quand Django démarre
+def initialize_models():
+    """
+    Initialise les modèles YOLOv8 au démarrage de Django
+    """
+    try:
+        load_yolo_models()
+    except Exception as e:
+        logger.error(f"Erreur lors de l'initialisation des modèles: {e}")
+
+
+# Par Marino ATOHOUN: Appeler l'initialisation
+# Décommentez cette ligne quand vous aurez vos modèles
+initialize_models()
+

docker-compose.yml

@@ -0,0 +1,134 @@
+# Docker Compose pour FireWatch AI
+# Créé par Marino ATOHOUN
+
+version: '3.8'
+
+services:
+  # Application Django
+  web:
+    build: .
+    container_name: firewatch_web
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./media:/app/media
+      - ./models:/app/models
+      - ./logs:/app/logs
+    environment:
+      - DEBUG=False
+      - SECRET_KEY=${SECRET_KEY:-django-insecure-change-me-in-production}
+      - DATABASE_URL=postgresql://firewatch:firewatch123@db:5432/firewatch_db
+      - REDIS_URL=redis://redis:6379/0
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - DJANGO_SUPERUSER_USERNAME=admin
+      - DJANGO_SUPERUSER_EMAIL=admin@firewatch.ai
+      - DJANGO_SUPERUSER_PASSWORD=admin123
+    depends_on:
+      - db
+      - redis
+    restart: unless-stopped
+    networks:
+      - firewatch_network
+
+  # Base de données PostgreSQL
+  db:
+    image: postgres:15
+    container_name: firewatch_db
+    environment:
+      - POSTGRES_DB=firewatch_db
+      - POSTGRES_USER=firewatch
+      - POSTGRES_PASSWORD=firewatch123
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+    restart: unless-stopped
+    networks:
+      - firewatch_network
+
+  # Redis pour le cache et Celery
+  redis:
+    image: redis:7-alpine
+    container_name: firewatch_redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+    networks:
+      - firewatch_network
+
+  # Celery Worker pour les tâches asynchrones
+  celery:
+    build: .
+    container_name: firewatch_celery
+    command: celery -A firewatch_project worker --loglevel=info
+    volumes:
+      - ./media:/app/media
+      - ./models:/app/models
+      - ./logs:/app/logs
+    environment:
+      - DEBUG=False
+      - SECRET_KEY=${SECRET_KEY:-django-insecure-change-me-in-production}
+      - DATABASE_URL=postgresql://firewatch:firewatch123@db:5432/firewatch_db
+      - REDIS_URL=redis://redis:6379/0
+      - CELERY_BROKER_URL=redis://redis:6379/0
+    depends_on:
+      - db
+      - redis
+    restart: unless-stopped
+    networks:
+      - firewatch_network
+
+  # Nginx (optionnel, pour la production)
+  nginx:
+    image: nginx:alpine
+    container_name: firewatch_nginx
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+      - ./media:/app/media
+      - ./staticfiles:/app/staticfiles
+      - ./ssl:/etc/nginx/ssl  # Pour les certificats SSL
+    depends_on:
+      - web
+    restart: unless-stopped
+    networks:
+      - firewatch_network
+
+volumes:
+  postgres_data:
+    driver: local
+  redis_data:
+    driver: local
+
+networks:
+  firewatch_network:
+    driver: bridge
+
+# Configuration pour le développement
+# Utilisez: docker-compose -f docker-compose.yml -f docker-compose.dev.yml up
+---
+# docker-compose.dev.yml
+version: '3.8'
+
+services:
+  web:
+    environment:
+      - DEBUG=True
+      - DJANGO_SUPERUSER_USERNAME=dev
+      - DJANGO_SUPERUSER_EMAIL=dev@firewatch.local
+      - DJANGO_SUPERUSER_PASSWORD=dev123
+    volumes:
+      - .:/app  # Mount du code source pour le développement
+    ports:
+      - "8000:8000"
+    command: python manage.py runserver 0.0.0.0:8000
+
+  # Désactiver Nginx en développement
+  nginx:
+    profiles:
+      - production
+

docker-entrypoint.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+# Script d'entrée Docker pour FireWatch AI
+# Créé par Marino ATOHOUN
+
+set -e
+
+# Couleurs pour les logs
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}🔥 FireWatch AI - Démarrage du conteneur${NC}"
+echo -e "${BLUE}Créé par Marino ATOHOUN${NC}"
+
+# Fonction de logging
+log() {
+    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
+}
+
+warning() {
+    echo -e "${YELLOW}[$(date +'%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}"
+}
+
+# Attendre que la base de données soit prête (si PostgreSQL)
+if [ "$DATABASE_URL" ]; then
+    log "Attente de la base de données..."
+    
+    # Extraire l'host et le port de DATABASE_URL
+    if [[ $DATABASE_URL == postgresql* ]]; then
+        DB_HOST=$(echo $DATABASE_URL | sed -n 's/.*@\([^:]*\):.*/\1/p')
+        DB_PORT=$(echo $DATABASE_URL | sed -n 's/.*:\([0-9]*\)\/.*/\1/p')
+        
+        if [ "$DB_HOST" ] && [ "$DB_PORT" ]; then
+            log "Vérification de la connexion à PostgreSQL ($DB_HOST:$DB_PORT)..."
+            
+            # Attendre que PostgreSQL soit prêt
+            until nc -z $DB_HOST $DB_PORT; do
+                warning "PostgreSQL n'est pas encore prêt - attente..."
+                sleep 2
+            done
+            
+            log "PostgreSQL est prêt!"
+        fi
+    fi
+fi
+
+# Exécuter les migrations
+log "Exécution des migrations de base de données..."
+python manage.py migrate --noinput
+
+# Créer un superutilisateur si les variables d'environnement sont définies
+if [ "$DJANGO_SUPERUSER_USERNAME" ] && [ "$DJANGO_SUPERUSER_EMAIL" ] && [ "$DJANGO_SUPERUSER_PASSWORD" ]; then
+    log "Création du superutilisateur..."
+    python manage.py shell << EOF
+from django.contrib.auth import get_user_model
+User = get_user_model()
+if not User.objects.filter(username='$DJANGO_SUPERUSER_USERNAME').exists():
+    User.objects.create_superuser('$DJANGO_SUPERUSER_USERNAME', '$DJANGO_SUPERUSER_EMAIL', '$DJANGO_SUPERUSER_PASSWORD')
+    print('Superutilisateur créé avec succès')
+else:
+    print('Superutilisateur existe déjà')
+EOF
+fi
+
+# Collecter les fichiers statiques
+log "Collecte des fichiers statiques..."
+python manage.py collectstatic --noinput
+
+# Vérifier la présence des modèles YOLOv8
+log "Vérification des modèles YOLOv8..."
+if [ -f "models/incendies.pt" ]; then
+    log "✓ Modèle d'incendie trouvé"
+else
+    warning "✗ Modèle d'incendie non trouvé (models/incendies.pt)"
+fi
+
+if [ -f "models/intrusion.pt" ]; then
+    log "✓ Modèle d'intrusion trouvé"
+else
+    warning "✗ Modèle d'intrusion non trouvé (models/intrusion.pt)"
+fi
+
+# Créer les répertoires nécessaires
+log "Création des répertoires nécessaires..."
+mkdir -p media/uploads/images media/uploads/videos media/results logs
+
+# Vérifier les permissions
+log "Vérification des permissions..."
+if [ ! -w "media" ]; then
+    error "Pas de permission d'écriture sur le répertoire media"
+    exit 1
+fi
+
+# Afficher les informations de configuration
+log "Configuration:"
+echo "  - DEBUG: ${DEBUG:-False}"
+echo "  - ALLOWED_HOSTS: ${ALLOWED_HOSTS:-localhost}"
+echo "  - DATABASE_URL: ${DATABASE_URL:-sqlite:///db.sqlite3}"
+
+# Démarrer Celery en arrière-plan si Redis est configuré
+if [ "$CELERY_BROKER_URL" ]; then
+    log "Démarrage de Celery worker..."
+    celery -A firewatch_project worker --loglevel=info --detach
+fi
+
+log "🚀 Démarrage de l'application FireWatch AI..."
+
+# Exécuter la commande passée en argument
+exec "$@"
+

firewatch_project/__init__.py

@@ -0,0 +1,2 @@
+# FireWatch AI Project - Créé par Marino ATOHOUN
+

firewatch_project/asgi.py

@@ -0,0 +1,18 @@
+"""
+ASGI config for firewatch_project project.
+Créé par Marino ATOHOUN - FireWatch AI Project
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/4.2/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'firewatch_project.settings')
+
+application = get_asgi_application()
+

firewatch_project/settings.py

@@ -0,0 +1,149 @@
+"""
+Django settings for firewatch_project project.
+Créé par Marino ATOHOUN - FireWatch AI Project
+
+Generated by 'django-admin startproject' using Django 4.2.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/4.2/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/4.2/ref/settings/
+"""
+
+from pathlib import Path
+import os
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = 'django-insecure-firewatch-ai-marino-atohoun-2024-secret-key-change-in-production'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = ['*']  # Par Marino ATOHOUN: Permettre tous les hosts pour le développement
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'detection',  # Par Marino ATOHOUN: Notre application de détection
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'firewatch_project.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [BASE_DIR / 'templates'],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'firewatch_project.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/4.2/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/4.2/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/4.2/topics/i18n/
+
+LANGUAGE_CODE = 'fr-fr'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/4.2/howto/static-files/
+
+STATIC_URL = '/static/'
+STATIC_ROOT = BASE_DIR / 'staticfiles'
+
+STATICFILES_DIRS = [
+    BASE_DIR / 'static',
+]
+
+# Par Marino ATOHOUN: Configuration pour les fichiers uploadés
+MEDIA_URL = '/media/'
+MEDIA_ROOT = BASE_DIR / 'media'
+
+# Default primary key field type
+# https://docs.djangoproject.com/en/4.2/ref/settings/#default-auto-field
+
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+# Par Marino ATOHOUN: Configuration pour les uploads de fichiers
+FILE_UPLOAD_MAX_MEMORY_SIZE = 50 * 1024 * 1024  # 50MB
+DATA_UPLOAD_MAX_MEMORY_SIZE = 50 * 1024 * 1024  # 50MB
+
+# Par Marino ATOHOUN: Configuration CORS pour permettre les requêtes depuis le frontend
+CORS_ALLOW_ALL_ORIGINS = True
+CORS_ALLOW_CREDENTIALS = True
+
+# Par Marino ATOHOUN: Configuration pour les modèles YOLOv8
+YOLO_MODELS_PATH = BASE_DIR / 'models'
+FIRE_MODEL_PATH = YOLO_MODELS_PATH / 'incendies.pt'
+INTRUSION_MODEL_PATH = YOLO_MODELS_PATH / 'intrusion.pt'
+

firewatch_project/urls.py

@@ -0,0 +1,31 @@
+"""firewatch_project URL Configuration
+Créé par Marino ATOHOUN - FireWatch AI Project
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/4.2/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+from django.contrib import admin
+from django.urls import path, include
+from django.conf import settings
+from django.conf.urls.static import static
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('', include('detection.urls')),  # Par Marino ATOHOUN: Inclure les URLs de l'app detection
+]
+
+# Par Marino ATOHOUN: Servir les fichiers media en mode développement
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
+    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
+

firewatch_project/wsgi.py

@@ -0,0 +1,18 @@
+"""
+WSGI config for firewatch_project project.
+Créé par Marino ATOHOUN - FireWatch AI Project
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'firewatch_project.settings')
+
+application = get_wsgi_application()
+

manage.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks.
+Créé par Marino ATOHOUN - FireWatch AI Project
+"""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'firewatch_project.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()
+

media/README.md

@@ -0,0 +1,32 @@
+# Répertoire Media - FireWatch AI
+
+**Créé par Marino ATOHOUN**
+
+Ce répertoire contient tous les fichiers uploadés par les utilisateurs et les résultats de détection.
+
+## Structure
+
+```
+media/
+├── uploads/
+│   ├── images/          # Images uploadées par les utilisateurs
+│   └── videos/          # Vidéos uploadées par les utilisateurs
+└── results/             # Images avec détections dessinées
+```
+
+## Sécurité
+
+- Les fichiers sont automatiquement renommés avec des UUID pour éviter les conflits
+- Seuls certains types de fichiers sont acceptés (voir `views.py`)
+- Taille maximale configurée dans `settings.py`
+
+## Nettoyage
+
+Il est recommandé de nettoyer périodiquement ce répertoire pour éviter l'accumulation de fichiers.
+
+Vous pouvez créer une tâche cron pour supprimer les fichiers anciens :
+```bash
+# Supprimer les fichiers de plus de 7 jours
+find /path/to/media -type f -mtime +7 -delete
+```
+

models/README.md

@@ -0,0 +1,38 @@
+# Modèles YOLOv8 - FireWatch AI
+
+**Créé par Marino ATOHOUN**
+
+Ce répertoire doit contenir vos modèles YOLOv8 entraînés :
+
+## Fichiers requis
+
+1. **incendies.pt** - Modèle pour la détection d'incendie et de fumée
+2. **intrusion.pt** - Modèle pour la détection d'intrusion et de personnes
+
+## Instructions d'installation
+
+1. Placez vos fichiers de modèles `.pt` dans ce répertoire
+2. Assurez-vous que les noms correspondent exactement à ceux attendus
+3. Vérifiez que les modèles sont compatibles avec la version d'ultralytics installée
+
+## Configuration
+
+Les chemins des modèles sont configurés dans `settings.py` :
+- `FIRE_MODEL_PATH` : Chemin vers le modèle d'incendie
+- `INTRUSION_MODEL_PATH` : Chemin vers le modèle d'intrusion
+
+## Utilisation
+
+Les modèles sont chargés automatiquement au démarrage du serveur Django dans `detection/views.py`.
+
+Pour activer le chargement des modèles :
+1. Installez ultralytics : `pip install ultralytics`
+2. Décommentez les lignes de chargement dans `load_yolo_models()`
+3. Décommentez l'appel à `initialize_models()` à la fin de `views.py`
+
+## Statut des modèles
+
+Vous pouvez vérifier le statut des modèles via :
+- Interface d'administration Django : `/admin/`
+- API : `/api/models/status/`
+

requirements-dev.txt

@@ -0,0 +1,36 @@
+# Requirements de développement pour FireWatch AI - Créé par Marino ATOHOUN
+
+# Inclure les requirements de base
+-r requirements.txt
+
+# Outils de développement
+django-debug-toolbar>=4.1.0
+django-extensions>=3.2.0
+ipython>=8.14.0
+jupyter>=1.0.0
+
+# Tests et qualité de code
+pytest>=7.4.0
+pytest-django>=4.5.0
+pytest-cov>=4.1.0
+factory-boy>=3.3.0  # Pour créer des données de test
+faker>=19.0.0  # Génération de données factices
+
+# Linting et formatage
+black>=23.0.0
+isort>=5.12.0
+flake8>=6.0.0
+mypy>=1.5.0
+pre-commit>=3.3.0
+
+# Documentation
+sphinx>=7.1.0
+sphinx-rtd-theme>=1.3.0
+
+# Profiling et performance
+django-silk>=5.0.0  # Profiling des requêtes
+memory-profiler>=0.61.0
+
+# Base de données de développement
+sqlite3  # Inclus avec Python
+

requirements.txt

@@ -0,0 +1,53 @@
+# Requirements pour FireWatch AI - Créé par Marino ATOHOUN
+# Version Django et dépendances de base
+Django>=4.2.0,<5.0.0
+Pillow>=10.0.0
+
+# Computer Vision et IA
+opencv-python>=4.8.0
+numpy>=1.24.0
+ultralytics>=8.0.0
+torch>=2.0.0
+torchvision>=0.15.0
+
+# Traitement d'images et vidéos
+imageio>=2.31.0
+scikit-image>=0.21.0
+
+# Base de données et ORM
+psycopg2-binary>=2.9.0  # Pour PostgreSQL en production
+
+# API et sérialisation
+djangorestframework>=3.14.0
+django-cors-headers>=4.0.0
+
+# Gestion des fichiers et stockage
+django-storages>=1.13.0  # Pour le stockage cloud (AWS S3, etc.)
+boto3>=1.26.0  # Pour AWS S3
+
+# Monitoring et logging
+django-extensions>=3.2.0
+python-decouple>=3.8  # Pour la gestion des variables d'environnement
+
+# Sécurité
+django-ratelimit>=4.0.0  # Limitation du taux de requêtes
+django-csp>=3.7  # Content Security Policy
+
+# Développement et tests
+pytest>=7.4.0
+pytest-django>=4.5.0
+coverage>=7.2.0
+black>=23.0.0  # Formatage du code
+flake8>=6.0.0  # Linting
+
+# Production
+gunicorn>=21.0.0  # Serveur WSGI pour production
+whitenoise>=6.5.0  # Gestion des fichiers statiques
+redis>=4.6.0  # Cache et sessions
+celery>=5.3.0  # Tâches asynchrones
+
+# Utilitaires
+python-magic>=0.4.27  # Détection du type MIME
+requests>=2.31.0
+python-dateutil>=2.8.0
+

scripts/deploy.sh

@@ -0,0 +1,428 @@
+#!/bin/bash
+# Script de déploiement pour FireWatch AI
+# Créé par Marino ATOHOUN
+
+set -e
+
+# Couleurs
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+NC='\033[0m'
+
+# Configuration
+PROJECT_NAME="firewatch_project"
+DEPLOY_USER="firewatch"
+DEPLOY_PATH="/opt/firewatch"
+SERVICE_NAME="firewatch"
+NGINX_SITE="firewatch"
+
+log() {
+    echo -e "${GREEN}[$(date +'%H:%M:%S')] $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[$(date +'%H:%M:%S')] ERROR: $1${NC}"
+    exit 1
+}
+
+warning() {
+    echo -e "${YELLOW}[$(date +'%H:%M:%S')] WARNING: $1${NC}"
+}
+
+info() {
+    echo -e "${BLUE}[$(date +'%H:%M:%S')] INFO: $1${NC}"
+}
+
+# Banner
+echo -e "${PURPLE}"
+echo "🚀 ========================================= 🚀"
+echo "    FireWatch AI - Déploiement Production"
+echo "         Créé par Marino ATOHOUN"
+echo "🚀 ========================================= 🚀"
+echo -e "${NC}"
+
+# Vérification des droits root
+if [[ $EUID -ne 0 ]]; then
+   error "Ce script doit être exécuté en tant que root (sudo)"
+fi
+
+# Mode de déploiement
+echo "Modes de déploiement disponibles :"
+echo "1. Docker (Recommandé)"
+echo "2. Installation manuelle"
+echo "3. Mise à jour"
+read -p "Choisissez un mode (1-3): " deploy_mode
+
+case $deploy_mode in
+    1)
+        log "Déploiement avec Docker..."
+        deploy_docker
+        ;;
+    2)
+        log "Installation manuelle..."
+        deploy_manual
+        ;;
+    3)
+        log "Mise à jour..."
+        update_deployment
+        ;;
+    *)
+        error "Mode invalide"
+        ;;
+esac
+
+deploy_docker() {
+    log "Installation de Docker et Docker Compose..."
+    
+    # Installation de Docker
+    if ! command -v docker &> /dev/null; then
+        curl -fsSL https://get.docker.com -o get-docker.sh
+        sh get-docker.sh
+        rm get-docker.sh
+    fi
+    
+    # Installation de Docker Compose
+    if ! command -v docker-compose &> /dev/null; then
+        curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+        chmod +x /usr/local/bin/docker-compose
+    fi
+    
+    # Création du répertoire de déploiement
+    mkdir -p $DEPLOY_PATH
+    cd $DEPLOY_PATH
+    
+    # Copie des fichiers
+    if [ -f "/tmp/firewatch-deploy.tar.gz" ]; then
+        tar -xzf /tmp/firewatch-deploy.tar.gz
+    else
+        error "Archive de déploiement non trouvée"
+    fi
+    
+    # Configuration des variables d'environnement
+    if [ ! -f ".env" ]; then
+        cp .env.example .env
+        
+        # Génération des mots de passe
+        DB_PASSWORD=$(openssl rand -base64 32)
+        SECRET_KEY=$(python3 -c "import secrets; print(secrets.token_urlsafe(50))")
+        
+        sed -i "s/SECRET_KEY=.*/SECRET_KEY=$SECRET_KEY/" .env
+        sed -i "s/firewatch123/$DB_PASSWORD/g" .env
+        
+        warning "Veuillez éditer .env avec vos configurations spécifiques"
+    fi
+    
+    # Démarrage des services
+    log "Démarrage des services Docker..."
+    docker-compose up -d
+    
+    # Attendre que les services soient prêts
+    sleep 30
+    
+    # Vérification
+    if docker-compose ps | grep -q "Up"; then
+        log "✓ Services Docker démarrés avec succès"
+    else
+        error "Échec du démarrage des services"
+    fi
+    
+    # Configuration Nginx (optionnel)
+    setup_nginx_docker
+}
+
+deploy_manual() {
+    log "Installation manuelle..."
+    
+    # Installation des dépendances système
+    apt update
+    apt install -y python3.11 python3.11-venv python3-pip nginx postgresql redis-server
+    apt install -y libgl1-mesa-glx libglib2.0-0 libsm6 libxext6 libxrender-dev
+    
+    # Création de l'utilisateur de déploiement
+    if ! id "$DEPLOY_USER" &>/dev/null; then
+        useradd -m -s /bin/bash $DEPLOY_USER
+        log "Utilisateur $DEPLOY_USER créé"
+    fi
+    
+    # Création du répertoire de déploiement
+    mkdir -p $DEPLOY_PATH
+    chown $DEPLOY_USER:$DEPLOY_USER $DEPLOY_PATH
+    
+    # Copie et extraction du code
+    if [ -f "/tmp/firewatch-deploy.tar.gz" ]; then
+        cd $DEPLOY_PATH
+        tar -xzf /tmp/firewatch-deploy.tar.gz
+        chown -R $DEPLOY_USER:$DEPLOY_USER .
+    else
+        error "Archive de déploiement non trouvée"
+    fi
+    
+    # Configuration de l'environnement virtuel
+    sudo -u $DEPLOY_USER python3.11 -m venv $DEPLOY_PATH/venv
+    sudo -u $DEPLOY_USER $DEPLOY_PATH/venv/bin/pip install -r $DEPLOY_PATH/requirements.txt
+    
+    # Configuration de PostgreSQL
+    setup_postgresql
+    
+    # Configuration de Redis
+    systemctl enable redis-server
+    systemctl start redis-server
+    
+    # Configuration de l'application
+    setup_application
+    
+    # Configuration du service systemd
+    setup_systemd_service
+    
+    # Configuration Nginx
+    setup_nginx_manual
+    
+    log "Installation manuelle terminée"
+}
+
+setup_postgresql() {
+    log "Configuration de PostgreSQL..."
+    
+    # Démarrage de PostgreSQL
+    systemctl enable postgresql
+    systemctl start postgresql
+    
+    # Création de la base de données et de l'utilisateur
+    sudo -u postgres psql << EOF
+CREATE DATABASE firewatch_db;
+CREATE USER firewatch WITH PASSWORD 'firewatch_secure_password_2024';
+GRANT ALL PRIVILEGES ON DATABASE firewatch_db TO firewatch;
+\q
+EOF
+    
+    log "✓ PostgreSQL configuré"
+}
+
+setup_application() {
+    log "Configuration de l'application..."
+    
+    cd $DEPLOY_PATH
+    
+    # Configuration des variables d'environnement
+    if [ ! -f ".env" ]; then
+        cp .env.example .env
+        
+        SECRET_KEY=$(python3 -c "import secrets; print(secrets.token_urlsafe(50))")
+        sed -i "s/SECRET_KEY=.*/SECRET_KEY=$SECRET_KEY/" .env
+        sed -i "s/DEBUG=True/DEBUG=False/" .env
+        sed -i "s/DATABASE_URL=.*/DATABASE_URL=postgresql:\/\/firewatch:firewatch_secure_password_2024@localhost:5432\/firewatch_db/" .env
+    fi
+    
+    # Migrations et collecte des fichiers statiques
+    sudo -u $DEPLOY_USER $DEPLOY_PATH/venv/bin/python manage.py migrate
+    sudo -u $DEPLOY_USER $DEPLOY_PATH/venv/bin/python manage.py collectstatic --noinput
+    
+    # Création des répertoires
+    mkdir -p $DEPLOY_PATH/media $DEPLOY_PATH/logs
+    chown -R $DEPLOY_USER:$DEPLOY_USER $DEPLOY_PATH/media $DEPLOY_PATH/logs
+    
+    log "✓ Application configurée"
+}
+
+setup_systemd_service() {
+    log "Configuration du service systemd..."
+    
+    cat > /etc/systemd/system/$SERVICE_NAME.service << EOF
+[Unit]
+Description=FireWatch AI Django Application
+After=network.target postgresql.service redis.service
+
+[Service]
+Type=exec
+User=$DEPLOY_USER
+Group=$DEPLOY_USER
+WorkingDirectory=$DEPLOY_PATH
+Environment=PATH=$DEPLOY_PATH/venv/bin
+ExecStart=$DEPLOY_PATH/venv/bin/gunicorn --bind 127.0.0.1:8000 --workers 4 --timeout 120 $PROJECT_NAME.wsgi:application
+ExecReload=/bin/kill -s HUP \$MAINPID
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+EOF
+    
+    systemctl daemon-reload
+    systemctl enable $SERVICE_NAME
+    systemctl start $SERVICE_NAME
+    
+    log "✓ Service systemd configuré et démarré"
+}
+
+setup_nginx_manual() {
+    log "Configuration de Nginx..."
+    
+    cat > /etc/nginx/sites-available/$NGINX_SITE << EOF
+server {
+    listen 80;
+    server_name _;
+    
+    client_max_body_size 50M;
+    
+    location /static/ {
+        alias $DEPLOY_PATH/staticfiles/;
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+    
+    location /media/ {
+        alias $DEPLOY_PATH/media/;
+        expires 1y;
+        add_header Cache-Control "public";
+    }
+    
+    location / {
+        proxy_pass http://127.0.0.1:8000;
+        proxy_set_header Host \$host;
+        proxy_set_header X-Real-IP \$remote_addr;
+        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto \$scheme;
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+    }
+}
+EOF
+    
+    # Activation du site
+    ln -sf /etc/nginx/sites-available/$NGINX_SITE /etc/nginx/sites-enabled/
+    rm -f /etc/nginx/sites-enabled/default
+    
+    # Test et redémarrage
+    nginx -t
+    systemctl enable nginx
+    systemctl restart nginx
+    
+    log "✓ Nginx configuré"
+}
+
+setup_nginx_docker() {
+    log "Configuration de Nginx pour Docker..."
+    
+    cat > nginx.conf << EOF
+events {
+    worker_connections 1024;
+}
+
+http {
+    upstream firewatch_app {
+        server web:8000;
+    }
+    
+    server {
+        listen 80;
+        server_name _;
+        
+        client_max_body_size 50M;
+        
+        location /static/ {
+            alias /app/staticfiles/;
+        }
+        
+        location /media/ {
+            alias /app/media/;
+        }
+        
+        location / {
+            proxy_pass http://firewatch_app;
+            proxy_set_header Host \$host;
+            proxy_set_header X-Real-IP \$remote_addr;
+            proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto \$scheme;
+        }
+    }
+}
+EOF
+    
+    log "✓ Configuration Nginx pour Docker créée"
+}
+
+update_deployment() {
+    log "Mise à jour du déploiement..."
+    
+    if [ -f "$DEPLOY_PATH/docker-compose.yml" ]; then
+        # Mise à jour Docker
+        cd $DEPLOY_PATH
+        docker-compose down
+        
+        # Sauvegarde
+        backup_dir="/tmp/firewatch-backup-$(date +%Y%m%d-%H%M%S)"
+        mkdir -p $backup_dir
+        cp -r media models .env $backup_dir/
+        
+        # Extraction de la nouvelle version
+        if [ -f "/tmp/firewatch-deploy.tar.gz" ]; then
+            tar -xzf /tmp/firewatch-deploy.tar.gz
+        fi
+        
+        # Restauration des données
+        cp -r $backup_dir/* .
+        
+        # Redémarrage
+        docker-compose up -d
+        
+    else
+        # Mise à jour manuelle
+        systemctl stop $SERVICE_NAME
+        
+        cd $DEPLOY_PATH
+        
+        # Sauvegarde
+        backup_dir="/tmp/firewatch-backup-$(date +%Y%m%d-%H%M%S)"
+        mkdir -p $backup_dir
+        cp -r media models .env $backup_dir/
+        
+        # Extraction de la nouvelle version
+        if [ -f "/tmp/firewatch-deploy.tar.gz" ]; then
+            tar -xzf /tmp/firewatch-deploy.tar.gz
+        fi
+        
+        # Restauration des données
+        cp -r $backup_dir/* .
+        chown -R $DEPLOY_USER:$DEPLOY_USER .
+        
+        # Mise à jour des dépendances
+        sudo -u $DEPLOY_USER $DEPLOY_PATH/venv/bin/pip install -r requirements.txt
+        
+        # Migrations
+        sudo -u $DEPLOY_USER $DEPLOY_PATH/venv/bin/python manage.py migrate
+        sudo -u $DEPLOY_USER $DEPLOY_PATH/venv/bin/python manage.py collectstatic --noinput
+        
+        # Redémarrage
+        systemctl start $SERVICE_NAME
+        systemctl restart nginx
+    fi
+    
+    log "✓ Mise à jour terminée"
+}
+
+# Vérification finale
+log "Vérification du déploiement..."
+sleep 10
+
+if curl -f http://localhost/ > /dev/null 2>&1; then
+    log "✅ Déploiement réussi ! FireWatch AI est accessible"
+    echo ""
+    echo -e "${GREEN}🎉 FireWatch AI est maintenant en production ! 🎉${NC}"
+    echo -e "${BLUE}URL: http://votre-serveur/${NC}"
+    echo -e "${BLUE}Admin: http://votre-serveur/admin/${NC}"
+    echo ""
+    echo -e "${YELLOW}N'oubliez pas de :${NC}"
+    echo "1. Configurer un nom de domaine"
+    echo "2. Installer un certificat SSL"
+    echo "3. Configurer les sauvegardes"
+    echo "4. Placer vos modèles YOLOv8 dans models/"
+    echo ""
+    echo -e "${PURPLE}Créé par Marino ATOHOUN${NC}"
+else
+    error "Échec du déploiement - L'application n'est pas accessible"
+fi
+

scripts/setup.sh

@@ -0,0 +1,178 @@
+#!/bin/bash
+# Script de configuration automatique pour FireWatch AI
+# Créé par Marino ATOHOUN
+
+set -e
+
+# Couleurs pour les messages
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+NC='\033[0m' # No Color
+
+# Fonction de logging
+log() {
+    echo -e "${GREEN}[$(date +'%H:%M:%S')] $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[$(date +'%H:%M:%S')] ERROR: $1${NC}"
+    exit 1
+}
+
+warning() {
+    echo -e "${YELLOW}[$(date +'%H:%M:%S')] WARNING: $1${NC}"
+}
+
+info() {
+    echo -e "${BLUE}[$(date +'%H:%M:%S')] INFO: $1${NC}"
+}
+
+# Banner
+echo -e "${PURPLE}"
+echo "🔥 ========================================= 🔥"
+echo "    FireWatch AI - Configuration Setup"
+echo "         Créé par Marino ATOHOUN"
+echo "🔥 ========================================= 🔥"
+echo -e "${NC}"
+
+# Vérification des prérequis
+log "Vérification des prérequis..."
+
+# Vérifier Python
+if ! command -v python3.11 &> /dev/null; then
+    if ! command -v python3 &> /dev/null; then
+        error "Python 3.11+ requis. Veuillez l'installer d'abord."
+    else
+        PYTHON_VERSION=$(python3 --version | cut -d' ' -f2 | cut -d'.' -f1,2)
+        if [[ $(echo "$PYTHON_VERSION < 3.11" | bc -l) -eq 1 ]]; then
+            error "Python 3.11+ requis. Version actuelle: $PYTHON_VERSION"
+        fi
+        PYTHON_CMD="python3"
+    fi
+else
+    PYTHON_CMD="python3.11"
+fi
+
+log "✓ Python trouvé: $($PYTHON_CMD --version)"
+
+# Vérifier pip
+if ! command -v pip3 &> /dev/null; then
+    error "pip3 requis. Veuillez l'installer d'abord."
+fi
+
+log "✓ pip trouvé: $(pip3 --version)"
+
+# Vérifier git
+if ! command -v git &> /dev/null; then
+    error "git requis. Veuillez l'installer d'abord."
+fi
+
+log "✓ git trouvé: $(git --version)"
+
+# Configuration de l'environnement virtuel
+log "Configuration de l'environnement virtuel..."
+
+if [ ! -d "venv" ]; then
+    info "Création de l'environnement virtuel..."
+    $PYTHON_CMD -m venv venv
+else
+    info "Environnement virtuel existant trouvé"
+fi
+
+# Activation de l'environnement virtuel
+log "Activation de l'environnement virtuel..."
+source venv/bin/activate
+
+# Mise à jour de pip
+log "Mise à jour de pip..."
+pip install --upgrade pip
+
+# Installation des dépendances
+log "Installation des dépendances Python..."
+if [ -f "requirements.txt" ]; then
+    pip install -r requirements.txt
+else
+    error "Fichier requirements.txt non trouvé"
+fi
+
+# Configuration des variables d'environnement
+log "Configuration des variables d'environnement..."
+if [ ! -f ".env" ]; then
+    if [ -f ".env.example" ]; then
+        cp .env.example .env
+        info "Fichier .env créé à partir de .env.example"
+        warning "Veuillez éditer .env avec vos configurations"
+    else
+        error "Fichier .env.example non trouvé"
+    fi
+else
+    info "Fichier .env existant trouvé"
+fi
+
+# Génération d'une clé secrète Django
+log "Génération d'une clé secrète Django..."
+SECRET_KEY=$(python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())")
+sed -i "s/SECRET_KEY=.*/SECRET_KEY=$SECRET_KEY/" .env
+info "Clé secrète générée et configurée"
+
+# Création des répertoires nécessaires
+log "Création des répertoires nécessaires..."
+mkdir -p media/uploads/images media/uploads/videos media/results models logs static/css static/js static/images
+
+# Configuration de la base de données
+log "Configuration de la base de données..."
+python manage.py makemigrations
+python manage.py migrate
+
+# Collecte des fichiers statiques
+log "Collecte des fichiers statiques..."
+python manage.py collectstatic --noinput
+
+# Vérification des modèles YOLOv8
+log "Vérification des modèles YOLOv8..."
+if [ -f "models/incendies.pt" ]; then
+    log "✓ Modèle d'incendie trouvé"
+else
+    warning "✗ Modèle d'incendie non trouvé (models/incendies.pt)"
+    info "L'application fonctionnera en mode simulation"
+fi
+
+if [ -f "models/intrusion.pt" ]; then
+    log "✓ Modèle d'intrusion trouvé"
+else
+    warning "✗ Modèle d'intrusion non trouvé (models/intrusion.pt)"
+    info "L'application fonctionnera en mode simulation"
+fi
+
+# Création d'un superutilisateur (optionnel)
+echo ""
+read -p "Voulez-vous créer un superutilisateur maintenant ? (y/N): " create_superuser
+if [[ $create_superuser =~ ^[Yy]$ ]]; then
+    log "Création du superutilisateur..."
+    python manage.py createsuperuser
+fi
+
+# Tests de base
+log "Exécution des tests de base..."
+python manage.py check
+
+# Résumé de l'installation
+echo ""
+echo -e "${GREEN}🎉 Configuration terminée avec succès ! 🎉${NC}"
+echo ""
+echo -e "${BLUE}Prochaines étapes :${NC}"
+echo "1. Activez l'environnement virtuel : source venv/bin/activate"
+echo "2. Lancez le serveur : python manage.py runserver"
+echo "3. Ouvrez votre navigateur : http://127.0.0.1:8000"
+echo "4. Accédez à l'admin : http://127.0.0.1:8000/admin/"
+echo ""
+echo -e "${YELLOW}Pour utiliser vos modèles YOLOv8 :${NC}"
+echo "1. Placez incendies.pt et intrusion.pt dans le dossier models/"
+echo "2. Décommentez les lignes de chargement dans detection/views.py"
+echo "3. Redémarrez le serveur"
+echo ""
+echo -e "${PURPLE}FireWatch AI est prêt ! Créé par Marino ATOHOUN${NC}"
+

static/css/custom.css

@@ -0,0 +1,236 @@
+/* 
+ * Styles personnalisés pour FireWatch AI
+ * Créé par Marino ATOHOUN
+ */
+
+/* Variables CSS personnalisées */
+:root {
+    --firewatch-primary: #1e40af;
+    --firewatch-secondary: #7c3aed;
+    --firewatch-accent: #ec4899;
+    --firewatch-dark: #0f172a;
+    --firewatch-light: #f1f5f9;
+}
+
+/* Styles pour les alertes personnalisées */
+.firewatch-alert {
+    border-radius: 0.5rem;
+    padding: 1rem;
+    margin: 1rem 0;
+    border-left: 4px solid;
+    animation: slideIn 0.3s ease-out;
+}
+
+.firewatch-alert-success {
+    background-color: #d1fae5;
+    color: #065f46;
+    border-left-color: #10b981;
+}
+
+.firewatch-alert-error {
+    background-color: #fee2e2;
+    color: #991b1b;
+    border-left-color: #ef4444;
+}
+
+.firewatch-alert-info {
+    background-color: #dbeafe;
+    color: #1e40af;
+    border-left-color: #3b82f6;
+}
+
+/* Animation pour les alertes */
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* Styles pour les boutons de chargement */
+.firewatch-loading {
+    position: relative;
+    overflow: hidden;
+}
+
+.firewatch-loading::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(90deg, transparent, rgba(255,255,255,0.3), transparent);
+    animation: loading 1.5s infinite;
+}
+
+@keyframes loading {
+    0% { left: -100%; }
+    100% { left: 100%; }
+}
+
+/* Styles pour les résultats de détection */
+.detection-item {
+    transition: all 0.3s ease;
+    border-radius: 0.5rem;
+    padding: 0.75rem;
+    margin: 0.5rem 0;
+    background: rgba(255, 255, 255, 0.8);
+    backdrop-filter: blur(10px);
+}
+
+.detection-item:hover {
+    transform: translateX(5px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+}
+
+/* Indicateurs de confiance */
+.confidence-bar {
+    height: 4px;
+    border-radius: 2px;
+    background: linear-gradient(90deg, #ef4444, #f59e0b, #10b981);
+    margin-top: 0.25rem;
+}
+
+/* Styles pour la prévisualisation des fichiers */
+.file-preview {
+    border: 2px dashed #d1d5db;
+    border-radius: 0.5rem;
+    padding: 2rem;
+    text-align: center;
+    transition: all 0.3s ease;
+}
+
+.file-preview.dragover {
+    border-color: var(--firewatch-accent);
+    background-color: rgba(236, 72, 153, 0.1);
+}
+
+.file-preview img,
+.file-preview video {
+    max-width: 100%;
+    max-height: 200px;
+    border-radius: 0.5rem;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+
+/* Styles pour les onglets */
+.firewatch-tab {
+    position: relative;
+    transition: all 0.3s ease;
+}
+
+.firewatch-tab.active::after {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    height: 3px;
+    background: linear-gradient(90deg, var(--firewatch-primary), var(--firewatch-accent));
+    border-radius: 2px 2px 0 0;
+}
+
+/* Styles pour les statistiques */
+.stat-card {
+    background: linear-gradient(135deg, rgba(255,255,255,0.1), rgba(255,255,255,0.05));
+    backdrop-filter: blur(10px);
+    border: 1px solid rgba(255,255,255,0.2);
+    border-radius: 1rem;
+    padding: 1.5rem;
+    transition: all 0.3s ease;
+}
+
+.stat-card:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.1);
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .firewatch-alert {
+        margin: 0.5rem;
+        padding: 0.75rem;
+    }
+    
+    .detection-item {
+        padding: 0.5rem;
+    }
+    
+    .file-preview {
+        padding: 1rem;
+    }
+}
+
+/* Styles pour l'accessibilité */
+.sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+}
+
+/* Focus styles pour l'accessibilité */
+button:focus,
+input:focus,
+textarea:focus,
+select:focus {
+    outline: 2px solid var(--firewatch-accent);
+    outline-offset: 2px;
+}
+
+/* Styles pour les tooltips */
+.firewatch-tooltip {
+    position: relative;
+    display: inline-block;
+}
+
+.firewatch-tooltip .tooltip-text {
+    visibility: hidden;
+    width: 200px;
+    background-color: var(--firewatch-dark);
+    color: white;
+    text-align: center;
+    border-radius: 6px;
+    padding: 8px;
+    position: absolute;
+    z-index: 1;
+    bottom: 125%;
+    left: 50%;
+    margin-left: -100px;
+    opacity: 0;
+    transition: opacity 0.3s;
+    font-size: 0.875rem;
+}
+
+.firewatch-tooltip:hover .tooltip-text {
+    visibility: visible;
+    opacity: 1;
+}
+
+/* Signature Marino ATOHOUN */
+.marino-signature {
+    font-family: 'Courier New', monospace;
+    font-size: 0.75rem;
+    color: #6b7280;
+    text-align: center;
+    margin-top: 2rem;
+}
+
+.marino-signature::before {
+    content: "/* ";
+}
+
+.marino-signature::after {
+    content: " */";
+}
+

static/js/firewatch.js

@@ -0,0 +1,401 @@
+/**
+ * JavaScript personnalisé pour FireWatch AI
+ * Créé par Marino ATOHOUN
+ */
+
+// Namespace pour éviter les conflits
+const FireWatch = {
+    // Configuration
+    config: {
+        maxFileSize: 50 * 1024 * 1024, // 50MB
+        allowedImageTypes: ['image/jpeg', 'image/jpg', 'image/png', 'image/bmp'],
+        allowedVideoTypes: ['video/mp4', 'video/avi', 'video/mov', 'video/mkv'],
+        apiEndpoints: {
+            analyzeImage: '/analyze/image/',
+            analyzeVideo: '/analyze/video/',
+            contact: '/contact/',
+            modelsStatus: '/api/models/status/'
+        }
+    },
+
+    // Utilitaires
+    utils: {
+        /**
+         * Obtient le token CSRF pour les requêtes AJAX
+         */
+        getCSRFToken: function() {
+            const token = document.querySelector('[name=csrfmiddlewaretoken]');
+            return token ? token.value : '';
+        },
+
+        /**
+         * Formate la taille d'un fichier en format lisible
+         */
+        formatFileSize: function(bytes) {
+            if (bytes === 0) return '0 Bytes';
+            const k = 1024;
+            const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+        },
+
+        /**
+         * Valide un fichier selon les critères définis
+         */
+        validateFile: function(file, allowedTypes) {
+            if (!file) {
+                return { valid: false, error: 'Aucun fichier sélectionné' };
+            }
+
+            if (file.size > FireWatch.config.maxFileSize) {
+                return { 
+                    valid: false, 
+                    error: `Fichier trop volumineux. Taille maximale: ${FireWatch.utils.formatFileSize(FireWatch.config.maxFileSize)}` 
+                };
+            }
+
+            if (!allowedTypes.includes(file.type)) {
+                return { 
+                    valid: false, 
+                    error: `Type de fichier non supporté: ${file.type}` 
+                };
+            }
+
+            return { valid: true };
+        },
+
+        /**
+         * Affiche une notification toast
+         */
+        showToast: function(message, type = 'info', duration = 5000) {
+            const toast = document.createElement('div');
+            toast.className = `firewatch-toast firewatch-toast-${type}`;
+            toast.innerHTML = `
+                <div class="flex items-center">
+                    <i class="fas fa-${type === 'success' ? 'check-circle' : type === 'error' ? 'exclamation-circle' : 'info-circle'} mr-2"></i>
+                    <span>${message}</span>
+                    <button class="ml-auto text-lg" onclick="this.parentElement.parentElement.remove()">×</button>
+                </div>
+            `;
+
+            // Styles inline pour le toast
+            Object.assign(toast.style, {
+                position: 'fixed',
+                top: '20px',
+                right: '20px',
+                zIndex: '9999',
+                padding: '1rem',
+                borderRadius: '0.5rem',
+                boxShadow: '0 4px 12px rgba(0,0,0,0.15)',
+                maxWidth: '400px',
+                animation: 'slideInRight 0.3s ease-out'
+            });
+
+            // Couleurs selon le type
+            const colors = {
+                success: { bg: '#d1fae5', text: '#065f46', border: '#10b981' },
+                error: { bg: '#fee2e2', text: '#991b1b', border: '#ef4444' },
+                info: { bg: '#dbeafe', text: '#1e40af', border: '#3b82f6' }
+            };
+
+            const color = colors[type] || colors.info;
+            Object.assign(toast.style, {
+                backgroundColor: color.bg,
+                color: color.text,
+                borderLeft: `4px solid ${color.border}`
+            });
+
+            document.body.appendChild(toast);
+
+            // Auto-suppression
+            setTimeout(() => {
+                if (toast.parentElement) {
+                    toast.remove();
+                }
+            }, duration);
+        }
+    },
+
+    // Gestion des fichiers
+    fileHandler: {
+        /**
+         * Configure le drag & drop pour un élément
+         */
+        setupDragDrop: function(element, callback) {
+            ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+                element.addEventListener(eventName, preventDefaults, false);
+            });
+
+            function preventDefaults(e) {
+                e.preventDefault();
+                e.stopPropagation();
+            }
+
+            ['dragenter', 'dragover'].forEach(eventName => {
+                element.addEventListener(eventName, () => element.classList.add('dragover'), false);
+            });
+
+            ['dragleave', 'drop'].forEach(eventName => {
+                element.addEventListener(eventName, () => element.classList.remove('dragover'), false);
+            });
+
+            element.addEventListener('drop', function(e) {
+                const files = e.dataTransfer.files;
+                if (files.length > 0) {
+                    callback(files[0]);
+                }
+            }, false);
+        },
+
+        /**
+         * Crée un aperçu pour un fichier image
+         */
+        createImagePreview: function(file, container) {
+            const reader = new FileReader();
+            reader.onload = function(e) {
+                container.innerHTML = `
+                    <img src="${e.target.result}" alt="Aperçu" class="file-preview-image">
+                    <p class="mt-2 text-sm text-gray-600">${file.name} (${FireWatch.utils.formatFileSize(file.size)})</p>
+                `;
+                container.classList.remove('hidden');
+            };
+            reader.readAsDataURL(file);
+        },
+
+        /**
+         * Crée un aperçu pour un fichier vidéo
+         */
+        createVideoPreview: function(file, container) {
+            const url = URL.createObjectURL(file);
+            container.innerHTML = `
+                <video controls class="file-preview-video">
+                    <source src="${url}" type="${file.type}">
+                    Votre navigateur ne supporte pas la lecture vidéo.
+                </video>
+                <p class="mt-2 text-sm text-gray-600">${file.name} (${FireWatch.utils.formatFileSize(file.size)})</p>
+            `;
+            container.classList.remove('hidden');
+        }
+    },
+
+    // Gestion de la caméra
+    camera: {
+        stream: null,
+        video: null,
+        canvas: null,
+
+        /**
+         * Initialise l'accès à la caméra
+         */
+        init: function(videoElement, canvasElement) {
+            this.video = videoElement;
+            this.canvas = canvasElement;
+        },
+
+        /**
+         * Démarre le flux de la caméra
+         */
+        start: function() {
+            return navigator.mediaDevices.getUserMedia({ 
+                video: { 
+                    width: { ideal: 1280 },
+                    height: { ideal: 720 }
+                } 
+            })
+            .then(stream => {
+                this.stream = stream;
+                this.video.srcObject = stream;
+                return stream;
+            });
+        },
+
+        /**
+         * Arrête le flux de la caméra
+         */
+        stop: function() {
+            if (this.stream) {
+                this.stream.getTracks().forEach(track => track.stop());
+                this.stream = null;
+                this.video.srcObject = null;
+            }
+        },
+
+        /**
+         * Capture une frame de la caméra
+         */
+        captureFrame: function() {
+            if (!this.video || this.video.videoWidth === 0) {
+                throw new Error('Caméra non initialisée ou pas de signal vidéo');
+            }
+
+            this.canvas.width = this.video.videoWidth;
+            this.canvas.height = this.video.videoHeight;
+
+            const ctx = this.canvas.getContext('2d');
+            ctx.drawImage(this.video, 0, 0);
+
+            return new Promise(resolve => {
+                this.canvas.toBlob(resolve, 'image/jpeg', 0.8);
+            });
+        }
+    },
+
+    // Gestion des résultats
+    results: {
+        /**
+         * Affiche les résultats de détection
+         */
+        display: function(data) {
+            const resultsSection = document.getElementById('results');
+            const resultImage = document.getElementById('result-image');
+            const detectionList = document.getElementById('detection-list');
+
+            // Afficher l'image de résultat
+            if (data.result_image_url) {
+                resultImage.src = data.result_image_url;
+                resultImage.onerror = function() {
+                    this.src = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNjQwIiBoZWlnaHQ9IjQ4MCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBmaWxsPSIjZGRkIi8+PHRleHQgeD0iNTAlIiB5PSI1MCUiIGZvbnQtZmFtaWx5PSJBcmlhbCIgZm9udC1zaXplPSIxOCIgZmlsbD0iIzk5OSIgdGV4dC1hbmNob3I9Im1pZGRsZSIgZHk9Ii4zZW0iPkltYWdlIG5vbiBkaXNwb25pYmxlPC90ZXh0Pjwvc3ZnPg==';
+                };
+            }
+
+            // Afficher les détections
+            detectionList.innerHTML = '';
+            if (data.detections && data.detections.length > 0) {
+                data.detections.forEach((detection, index) => {
+                    const li = document.createElement('li');
+                    li.className = 'detection-item flex items-center justify-between';
+
+                    // Couleur selon le type de détection
+                    const colorMap = {
+                        'fire': 'bg-red-500',
+                        'smoke': 'bg-orange-500',
+                        'person': 'bg-blue-500',
+                        'intrusion': 'bg-purple-500',
+                        'vehicle': 'bg-green-500'
+                    };
+
+                    const colorClass = colorMap[detection.class_name] || 'bg-gray-500';
+                    const confidence = (detection.confidence * 100).toFixed(1);
+
+                    li.innerHTML = `
+                        <div class="flex items-center">
+                            <span class="w-3 h-3 ${colorClass} rounded-full mr-3"></span>
+                            <div>
+                                <span class="font-medium">${detection.label || detection.class_name}</span>
+                                <div class="text-sm text-gray-600">
+                                    Confiance: ${confidence}%
+                                    ${detection.frame_number !== undefined ? ` | Frame: ${detection.frame_number}` : ''}
+                                </div>
+                            </div>
+                        </div>
+                        <div class="text-right">
+                            <div class="confidence-bar" style="width: ${confidence}%; background: linear-gradient(90deg, #ef4444, #f59e0b, #10b981);"></div>
+                        </div>
+                    `;
+
+                    detectionList.appendChild(li);
+                });
+            } else {
+                detectionList.innerHTML = '<li class="text-gray-500 text-center py-4">Aucune détection trouvée</li>';
+            }
+
+            // Afficher la section des résultats avec animation
+            resultsSection.classList.remove('hidden');
+            resultsSection.scrollIntoView({ behavior: 'smooth' });
+
+            // Ajouter les statistiques si disponibles
+            if (data.processing_time) {
+                const statsHtml = `
+                    <div class="mt-4 p-3 bg-gray-100 rounded-lg">
+                        <div class="text-sm text-gray-600">
+                            <i class="fas fa-clock mr-1"></i>
+                            Temps de traitement: ${data.processing_time.toFixed(2)}s
+                        </div>
+                    </div>
+                `;
+                detectionList.insertAdjacentHTML('afterend', statsHtml);
+            }
+        }
+    },
+
+    // API
+    api: {
+        /**
+         * Envoie une requête POST avec gestion d'erreurs
+         */
+        post: function(url, formData, options = {}) {
+            const defaultOptions = {
+                method: 'POST',
+                headers: {
+                    'X-CSRFToken': FireWatch.utils.getCSRFToken()
+                },
+                body: formData
+            };
+
+            return fetch(url, { ...defaultOptions, ...options })
+                .then(response => {
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                    }
+                    return response.json();
+                })
+                .catch(error => {
+                    console.error('Erreur API:', error);
+                    throw error;
+                });
+        },
+
+        /**
+         * Vérifie le statut des modèles IA
+         */
+        checkModelsStatus: function() {
+            return fetch(FireWatch.config.apiEndpoints.modelsStatus)
+                .then(response => response.json())
+                .catch(error => {
+                    console.error('Erreur lors de la vérification du statut des modèles:', error);
+                    return { success: false, error: error.message };
+                });
+        }
+    },
+
+    // Initialisation
+    init: function() {
+        console.log('FireWatch AI - Initialisation par Marino ATOHOUN');
+        
+        // Vérifier le statut des modèles au chargement
+        this.api.checkModelsStatus().then(data => {
+            if (data.success && data.models) {
+                console.log('Statut des modèles:', data.models);
+            }
+        });
+
+        // Ajouter les styles CSS dynamiquement si nécessaire
+        if (!document.querySelector('#firewatch-styles')) {
+            const style = document.createElement('style');
+            style.id = 'firewatch-styles';
+            style.textContent = `
+                @keyframes slideInRight {
+                    from { transform: translateX(100%); opacity: 0; }
+                    to { transform: translateX(0); opacity: 1; }
+                }
+                .firewatch-toast { font-family: system-ui, -apple-system, sans-serif; }
+            `;
+            document.head.appendChild(style);
+        }
+
+        // Message de bienvenue en mode développement
+        if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
+            console.log('%cFireWatch AI - Mode Développement', 'color: #ec4899; font-size: 16px; font-weight: bold;');
+            console.log('%cCréé par Marino ATOHOUN', 'color: #7c3aed; font-size: 12px;');
+        }
+    }
+};
+
+// Initialisation automatique quand le DOM est prêt
+document.addEventListener('DOMContentLoaded', function() {
+    FireWatch.init();
+});
+
+// Export pour utilisation globale
+window.FireWatch = FireWatch;
+