Upload files to "/"

Dockerfile.builder

@@ -0,0 +1,66 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt update && apt install -y --no-install-suggests --no-install-recommends \
+    libjpeg-dev \
+    zlib1g-dev \
+    build-essential \
+    ca-certificates \
+    curl \
+    gnupg \
+    cmake \
+    ninja-build \
+    git
+
+RUN apt install -y libjpeg62 libpng-dev libtiff-dev libz-dev libproj-dev liblzma-dev libjbig-dev libzstd-dev libgeotiff-dev libwebp-dev liblzma-dev nlohmann-json3-dev   
+
+ENV GDAL_VERSION 3.12.2
+
+ADD http://download.osgeo.org/gdal/${GDAL_VERSION}/gdal-${GDAL_VERSION}.tar.gz /usr/local/src/
+
+RUN cd /usr/local/src && tar -xvf gdal-${GDAL_VERSION}.tar.gz && cd gdal-${GDAL_VERSION} \
+    && cmake -S . -B build \ 
+    -G Ninja \
+    -DCMAKE_INSTALL_PREFIX=/usr/local \
+    -DBUILD_SHARED_LIBS=ON \
+    && cmake --build build --config Release \
+    && cmake --install build \
+    && ldconfig
+    #&& rm -Rf /usr/local/src/*
+
+RUN git clone https://github.com/LASzip/LASzip.git && cd LASzip \
+    && cmake -S . -B build \
+    -G Ninja \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_INSTALL_PREFIX=/usr/local \
+    -DBUILD_SHARED_LIBS=ON \
+    && cmake --build build \
+    && cmake --install build --config Release \
+    && ldconfig
+
+RUN git clone https://github.com/PDAL/PDAL.git && cd PDAL \
+    && cmake -S . -B build \
+    -G Ninja \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_INSTALL_PREFIX=/usr/local \
+    -DCMAKE_PREFIX_PATH=/usr/local \
+    -DBUILD_PLUGIN_LASZIP=ON \
+    -DGDAL_DIR=/usr/local/lib/cmake/gdal \
+    && cmake --build build \
+    && cmake --install build --config Release \
+    && ldconfig
+
+RUN git clone https://github.com/connormanning/entwine.git && cd entwine \
+    && cmake -S . -B build \
+    -G Ninja \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_INSTALL_PREFIX=/usr/local \
+    -DCMAKE_PREFIX_PATH=/usr/local \
+    && cmake --build build \
+    && cmake --install build --config Release \
+    && ldconfig
+
+RUN apt remove -y libgeotiff-dev libpng-dev libtiff-dev libjpeg-dev libz-dev libproj-dev liblzma-dev libjbig-dev libzstd-dev libgeotiff-dev libwebp-dev liblzma-dev nlohmann-json3-dev ninja-build cmake build-essential zlib1g-dev \
+    && apt autoremove -y \
+    && rm -rf /usr/local/src/* /var/lib/apt/lists/* /tmp/* /var/tmp/*

agents.md

@@ -0,0 +1,145 @@
+# 🤖 Configuration des Agents Cline - Analyse & Débogage
+
+## 📋 Contexte du Projet
+**Nom du projet :** PointCloud Classifier
+**Objectif :** Développer une application web pour l'upload, la manipulation, le traitement et l'affichage de nuages de points 3D.
+**Utilisation principale :** Visualisation technique, gestion de données géospatiales, administration.
+
+## 📋 Vue d'ensemble
+Ce fichier définit les agents IA utilisés pour analyser, comprendre, déboguer et faire évoluer le repository de l'application **point-cloud-classifier**.
+- **Objectif principal :** Identifier les bugs, optimiser le code et comprendre l'architecture.
+- **Environnement :** VS Code avec Cline.
+- **Langage principal :** Python, JavaScript, TypeScript
+- **Framework :** FastAPI, HTMX, Django, Svelte, AlpineJS, DaisyUi, jinja2
+
+---
+
+### Backend (Serveur & Traitement)
+- **Langage :** Python 3.12+
+- **Framework Web :** FastAPI (API REST, Serveur)
+- **Traitement Nuages :** PDAL (Point Data Abstraction Library) pour le filtrage/rééchantillonnage.
+- **Stockage Nuages :** Entwine (Format de stockage optimisé pour les nuages de points): format EPT.
+- **Base de Données :** SQLite avec Spatialite pour les métadonnées.
+- **Sécurité :** Gestion sécurisée des uploads (taille, type MIME, virus scan).
+
+### Frontend (Interface Utilisateur)
+- **Templates :** Jinja2 (Intégration avec FastAPI).
+- **Interactivité :** HTMX (Chargement dynamique sans rechargement complet).
+- **Composants UI :** DaisyUI (Thèmes Tailwind CSS).
+- **Logique Client :** AlpineJS (Gestion d'état légère).
+- **Visualisation :** Potree Viewer (Bibliothèque WebGL pour l'affichage 3D).
+
+---
+
+## 👥 Définition des Agents
+
+### 1. Agent: Architecte Système
+- **Rôle :** Analyseur de structure et de dépendances.
+- **Description :** Il examine le code global, les fichiers de configuration et les imports pour comprendre comment les modules interagissent.
+- **Objectif :** Produire une carte mentale de l'architecture et identifier les points de rupture potentiels.
+- **Outils :**
+  - Lecture de fichiers (`tree`, `ls`, `find`)
+  - Analyse de dépendances (`uv pip list`, `npm list`)
+  - Recherche de patterns de code
+- **Contraintes :**
+  - Ne pas modifier le code sans validation.
+  - Identifier les fichiers critiques avant toute suggestion.
+- **Entrées attendues :** Structure du repository, logs d'erreur.
+- **Sorties attendues :** Résumé de l'architecture, liste des fichiers suspects.
+
+### 2. Agent: Développeur de Debugging
+- **Rôle :** Expert en résolution de problèmes et d'erreurs.
+- **Description :** Il analyse les logs, les erreurs de compilation et les comportements inattendus pour trouver la cause racine.
+- **Objectif :** Proposer des corrections de code précises et tester les hypothèses.
+- **Outils :**
+  - Lecture de logs (`tail -f`, `grep`)
+  - Exécution de commandes de test
+  - Modification de code (avec validation)
+- **Contraintes :**
+  - Toujours expliquer la cause du bug avant de proposer une solution.
+  - Ne jamais supprimer des lignes de code sans justification.
+- **Entrées attendues :** Erreurs, logs, messages d'exception.
+- **Sorties attendues :** Code corrigé, explication du bug, tests de validation.
+
+### 3. Agent: Backend Python & Traitement
+- **Rôle :** Développeur API et Pipeline de données.
+- **Responsabilités :**
+  - Créer les endpoints FastAPI (Upload, Traitement, Récupération).
+  - Intégrer PDAL pour les traitements (filtrage, densification).
+  - Gérer le stockage Entwine.
+  - Gérer les métadonnées dans la DB.
+- **Contraintes :**
+  - Utiliser des types de données Python stricts (Pydantic).
+  - Gérer les erreurs de traitement PDAL (ex: fichiers corrompus).
+  - Optimiser la mémoire pour les gros fichiers.
+
+### 4. Agent: Frontend UI/UX
+- **Rôle :** Développeur Interface et Visualisation.
+- **Responsabilités :**
+  - Créer les templates Jinja2 avec DaisyUI.
+  - Implémenter l'intégration Potree Viewer.
+  - Gérer les interactions HTMX (formulaires, notifications).
+  - Utiliser AlpineJS pour la gestion des States Management, des menus et modales.
+- **Contraintes :**
+  - Le code doit être responsive.
+  - Utiliser les composants DaisyUI existants (boutons, cartes, tableaux).
+  - S'assurer que Potree est chargé correctement.
+
+### 5. Agent: Intégration & Qualité
+- **Rôle :** Vérificateur de compatibilité.
+- **Responsabilités :**
+  - Vérifier que les templates Jinja2 sont bien rendus par FastAPI.
+  - S'assurer que les assets (JS/CSS) sont bien servis.
+  - Valider les permissions de fichiers.
+- **Contraintes :**
+  - Ne jamais modifier le code Potree sans vérifier la compatibilité.
+  - Respecter les conventions de nommage FastAPI.
+
+### 6. Agent: Vérificateur de Qualité
+- **Rôle :** Revueur de code et garant de la sécurité.
+- **Description :** Il vérifie que les modifications respectent les standards de l'équipe et ne créent pas de nouvelles vulnérabilités.
+- **Objectif :** S'assurer que le code est propre, sécurisé et maintenable.
+- **Outils :**
+  - Linters (`flake8`, `eslint`, `prettier`)
+  - Analyseurs de sécurité (`bandit`, `snyk`)
+  - Tests unitaires
+- **Contraintes :**
+  - Signaler toute régression potentielle.
+  - Suggérer des améliorations de performance.
+- **Entrées attendues :** Code modifié, résultats de tests.
+- **Sorties attendues :** Rapport de qualité, suggestions d'amélioration.
+
+---
+
+## 🔄 Flux de travail (Workflow)
+
+1. **Analyse initiale :** L'Agent Architecte scanne le repository et identifie les fichiers clés.
+2. **Détection du problème :** L'Agent Debugging analyse les erreurs et propose des hypothèses.
+3. **Isolation :** L'agent détermine si le problème vient du Backend (Python/PDAL) ou du Frontend (HTMX/Potree).
+4. **Correction :** L'Agent Debugging modifie le code en proposant une solution de code respectant la stack.
+5. **Validation :** L'Agent vérifie la syntaxe et les imports.
+6. **Rapport :** Un résumé des actions est généré pour l'utilisateur.
+
+---
+
+## 🚨 Règles de Sécurité & Bonnes Pratiques
+
+1. **Uploads :**
+   - Ne jamais exécuter le code uploadé directement.
+   - Limiter la taille des fichiers uploadés (ex: max 10GB par défaut).
+   - Vérifier l'extension des fichiers (`.las`, `.laz`, `.ply`, `.pcd`).
+
+2. **Potree :**
+   - Utiliser la version stable de Potree.
+   - Ne pas exposer les clés API de visualisation.
+
+3. **Code :**
+   - Utiliser `async/await` pour FastAPI.
+   - Utiliser `@app.get`, `@app.post` pour les routes.
+   - Utiliser `x-data` pour AlpineJS.
+   - Utiliser `hx-get`, `hx-post` pour HTMX.
+
+4. **Fichiers :**
+   - Ne pas modifier les fichiers système (`/etc`, `/usr`).
+   - Ne pas exécuter de commandes shell dangereuses sans confirmation.
+

architecture.md

@@ -0,0 +1,321 @@
+# 🏗️ Architecture PointCloud Viewer - Diagramme Mermaid
+
+## Vue d'ensemble de l'architecture
+
+```mermaid
+flowchart TB
+    subgraph "Infrastructure Docker"
+        subgraph "Frontend Service:8091"
+            FE[FastAPI Frontend]
+            FE -- HTMX --> UI[Interface UI]
+            UI -- AlpineJS --> FE
+        end
+        
+        subgraph "Backend Service:8000"
+            BE[FastAPI Backend]
+            BE -- API --> FE
+        end
+        
+        subgraph "External Services"
+            POT[Potree Viewer:8090]
+            PDAL[PDAL Tool]
+            ENT[Entwine Tool]
+        end
+    end
+    
+    subgraph "Data Storage"
+        UPLOADS[./backend/data/uploads/]
+        EPT_DIR[./backend/data/ept/]
+        CONFIG[./frontend/config/]
+    end
+    
+    subgraph "Templates & Static"
+        TEMPLATES[./frontend/templates/]
+        COMPONENTS[./frontend/components/]
+        STATIC[./backend/static/potree/]
+    end
+```
+
+## Flux principal d'upload et conversion
+
+```mermaid
+sequenceDiagram
+    participant User as Utilisateur
+    participant FE as Frontend (8091)
+    participant BE as Backend (8000)
+    participant ENT as Entwine
+    participant FS as Système de Fichiers
+
+    User->>FE: 1. Télécharge fichier LAS/LAZ/PLY
+    FE->>FE: 2. Vérifie format supporté
+    FE->>BE: 3. POST /upload avec fichier
+    BE->>BE: 4. Génère UUID (pc_id)
+    BE->>FS: 5. Écrit fichier dans uploads/
+    BE->>ENT: 6. LANCE entwine build
+    ENT->>FS: 7. Convertit vers format EPT
+    ENT->>FS: 8. Crée dossier ept/{pc_id}/
+    ENT-->>BE: 9. Retourne résultat
+    BE->>BE: 10. Sauvegarde manifest.json
+    BE-->>FE: 11. Retourne JSON avec pc_id
+    FE->>FE: 12. Affiche résultat HTMX
+    FE->>POT: 13. Génère page viewer
+    FE-->>User: 14. Affiche visualisation Potree
+```
+
+## Flux de visualisation
+
+```mermaid
+flowchart LR
+    subgraph Frontend
+        A[Page /viewer/list] --> B[HTMX Fetch /viewer/list]
+        B --> C[cloud_list.html]
+    end
+    
+    subgraph Backend
+        D[API /viewer/list] --> E[Lecture EPT_DIR]
+        E --> F[manifest.json]
+        F --> G[Statistiques]
+    end
+    
+    C -->|Affichage| H[Tableau Nuages]
+    
+    H -->|Click| I[Page /viewer/{pc_id}]
+    I -->|HTMX| J[viewer.html partial]
+    J -->|Embed| K[Potree Viewer]
+    
+    K -->|Chargement| L[/ept_data/{pc_id}/ept.json]
+    L --> M[Visualisation 3D]
+```
+
+## Flux de crop (réduction du nuage)
+
+```mermaid
+sequenceDiagram
+    participant User as Utilisateur
+    participant FE as Frontend
+    participant BE as Backend
+    participant PDAL as PDAL
+    participant FS as Système Fichiers
+
+    User->>FE: 1. Sélectionne nuage + box 3D
+    FE->>BE: 2. POST /admin/crop/{pc_id} avec box
+    BE->>PDAL: 3. LANCE pdal filter
+    PDAL->>FS: 4. Lit fichier source LAS
+    PDAL->>FS: 5. Applique box de filtrage
+    PDAL->>FS: 6. Écrit fichier LAS cropped
+    PDAL-->>BE: 7. Retourne fichier cropped
+    BE->>FS: 8. Lance entwine sur fichier cropped
+    ENT->>FS: 9. Convertit vers EPT
+    BE->>FS: 10. Sauvegarde nouveau nuage
+    BE-->>FE: 11. Retourne nouveau pc_id
+    FE->>FE: 12. Affiche nouveau nuage
+```
+
+## Architecture des routes
+
+```mermaid
+mindmap
+  root((Architecture))
+    Frontend
+      /upload
+        GET / - Redirection
+        GET /upload - Page upload
+        POST /upload - Upload fichier
+        GET /health-check - Vérification
+      /viewer
+        GET /viewer/list - Liste nuages
+        GET /viewer/{pc_id} - Visualisation
+      /admin
+        GET /admin/backend-config
+        POST /admin/backend-config
+        GET /admin/list
+        GET /admin/debug/{pc_id}
+        DELETE /admin/delete/{pc_id}
+        POST /admin/crop/{pc_id}
+    Backend
+      /upload
+        POST /upload - Conversion entwine
+      /viewer
+        GET /viewer/list - Liste EPT
+        GET /viewer/{pc_id} - Page viewer
+        GET /viewer-embed/{pc_id} - Embed
+      /admin
+        GET /debug/{pc_id} - Debug info
+        DELETE /delete/{pc_id} - Suppression
+        POST /admin/crop/{pc_id} - Crop PDAL
+      /health - Health check
+      / - Page HTML
+      /ept_data - Serveur statique
+      /static - Assets
+```
+
+## Structure des dossiers EPT
+
+```mermaid
+graph TD
+    EPT[EPT Directory]
+    EPT --> MANIFEST[manifest.json]
+    EPT --> EPT_JSON[ept.json]
+    EPT --> EPT_BUILD[ept-build.json]
+    EPT --> EPT_DATA[ept-data/]
+    EPT_DATA --> TUILES[.las.tileset]
+    EPT_DATA --> META[meta.json]
+    EPT --> EPT_HIERARCHY[ept-hierarchy/]
+    EPT_HIERARCHY --> NOEUDS[.node]
+    EPT --> EPT_SOURCES[ept-sources/]
+    EPT_SOURCES --> SOURCES[.las]
+```
+
+## Diagramme complet des interactions
+
+```mermaid
+flowchart TB
+    subgraph "Utilisateur"
+        U[Utilisateur]
+    end
+    
+    subgraph "Frontend Service [8091]"
+        direction TB
+        FE[FastAPI<br/>Jinja2 + HTMX + AlpineJS]
+        UI[Interface<br/>DaisyUI + Tailwind]
+        API_CLIENT[api_client.py<br/>httpx Async]
+        CONFIG[config.py<br/>BACKEND_URL + POTREE_URL]
+        
+        U -->|Navigate| UI
+        UI -->|HTMX| FE
+        FE -->|Templates| UI
+        FE -->|Routes| API_CLIENT
+        API_CLIENT -->|HTTP| BE
+        FE -->|Config| CONFIG
+    end
+    
+    subgraph "Backend Service [8000]"
+        direction TB
+        BE[FastAPI<br/>PDAL + Entwine]
+        ROUTES[Routes<br/>upload.py<br/>viewer.py<br/>admin.py]
+        SERVICES[Services<br/>converter.py<br/>manifest.py<br/>html_generator.py]
+        UTILS[Utils<br/>disk.py]
+        STATIC[Static Files<br/>Potree Viewer]
+        
+        BE -->|Include| ROUTES
+        ROUTES -->|Call| SERVICES
+        SERVICES -->|Read| UTILS
+        BE -->|Serve| STATIC
+        BE -->|Mount| EPT_DIR[/ept_data/]
+    end
+    
+    subgraph "Outils Externes"
+        ENT[Entwine<br/>build EPT]
+        PDAL[PDAL<br/>filter/crop LAS]
+    end
+    
+    subgraph "Stockage"
+        UPLOADS[uploads/<br/>fichiers LAS/LAZ]
+        EPT[ept/<br/>nuages convertis]
+        CONFIG_FILE[config/<br/>backend.json]
+    end
+    
+    subgraph "External"
+        POT[Potree Viewer<br/>WebGL 3D]
+    end
+    
+    %% Flux Upload
+    UI -->|1. Choix fichier| U
+    U -->|2. POST /upload| API_CLIENT
+    API_CLIENT -->|3. POST /upload| BE
+    BE -->|4. Enregistrer| UPLOADS
+    BE -->|5. Lancer| ENT
+    ENT -->|6. Convertir| EPT
+    BE -->|7. Sauvegarder| SERVICES
+    SERVICES -->|8. manifest.json| EPT
+    
+    %% Flux Liste
+    UI -->|9. /viewer/list| API_CLIENT
+    API_CLIENT -->|10. GET /viewer/list| BE
+    BE -->|11. Lire| EPT
+    BE -->|12. Retourne| API_CLIENT
+    API_CLIENT -->|13. Affiche| UI
+    
+    %% Flux Visualisation
+    UI -->|14. /viewer/{pc_id}| FE
+    FE -->|15. Embed| POT
+    POT -->|16. Charger| EPT_DIR
+    EPT_DIR -->|17. ept.json| POT
+    POT -->|18. Visualiser| U
+    
+    %% Flux Crop
+    UI -->|19. /admin/crop| API_CLIENT
+    API_CLIENT -->|20. POST /admin/crop| BE
+    BE -->|21. Lancer| PDAL
+    PDAL -->|22. Filtre| UPLOADS
+    BE -->|23. Convertir| ENT
+    ENT -->|24. Nouveau EPT| EPT
+    BE -->|25. Retourne| API_CLIENT
+    API_CLIENT -->|26. Affiche| UI
+    
+    %% Styles
+    classDef user fill:#e1f5ff,stroke:#1890ff,stroke-width:2px
+    classDef frontend fill:#fff7e6,stroke:#fa8c16,stroke-width:2px
+    classDef backend fill:#f6ffed,stroke:#52c41a,stroke-width:2px
+    classDef tools fill:#f0f5ff,stroke:#2f54eb,stroke-width:2px
+    classDef storage fill:#fff0f6,stroke:#eb2f96,stroke-width:2px
+    classDef external fill:#f9f0ff,stroke:#722ed1,stroke-width:2px
+    
+    class U user
+    class FE,UI,API_CLIENT,CONFIG frontend
+    class BE,ROUTES,SERVICES,UTILS,STATIC backend
+    class ENT,PDAL tools
+    class UPLOADS,EPT,CONFIG_FILE storage
+    class POT external
+```
+
+## Fonctionnalités de l'application
+
+### 1. Upload et Conversion
+- Téléchargement de fichiers LAS, LAZ, PLY, XYZ, PTS
+- Conversion automatique vers format EPT (Entwine Point Tile)
+- Génération de manifeste pour chaque nuage
+- Suivi du temps de conversion
+
+### 2. Visualisation 3D
+- Intégration Potree Viewer (WebGL)
+- Chargement direct des tuiles EPT
+- Configuration de la taille de point et forme
+- Support des modes embed et standalone
+
+### 3. Administration
+- Liste de tous les nuages de points
+- Informations détaillées (taille, nombre de fichiers, date)
+- Debug panel pour inspection
+- Suppression de nuages
+
+### 4. Traitement PDAL
+- Crop 3D des nuages de points
+- Définition de box de sélection
+- Conversion du résultat en EPT
+
+### 5. Configuration Dynamique
+- URL du backend configurable
+- URL de Potree configurable
+- Sauvegarde dans fichier JSON
+- Variables d'environnement
+
+### 6. Monitoring
+- Endpoint /health pour vérification
+- Indicateur de disponibilité Entwine
+- Affichage de l'espace disque libre
+- Version de PDAL
+
+### 7. Relevant Files and Code:
+
+- __backend/main.py__: Point d'entrée backend, mounting de /ept_data, /static, /potree
+- __backend/routes/upload.py__: POST /upload - conversion entwine avec UUID
+- __backend/routes/viewer.py__: GET /viewer/list, /viewer/{pc_id}, /viewer-embed/{pc_id}
+- __backend/services/converter.py__: run_entwine() - commande entwine build
+- __backend/services/manifest.py__: save_manifest(), read_manifest()
+- __backend/services/html_generator.py__: generate_viewer_html() - template Potree
+- __frontend/api_client.py__: check_health(), upload_file(), get_debug(), delete_pointcloud(), crop_pointcloud()
+- __frontend/routes/upload.py__: POST /upload → api_client.upload_file()
+- __frontend/routes/crop.py__: POST /admin/crop/{pc_id} → api_client.crop_pointcloud()
+- __frontend/templates/index.html__: Interface principale avec HTMX tabs (Upload, Admin)
+- __docker-compose.yml__: 2 services, volumes mount, environment variables

architecture_readme.md

@@ -0,0 +1,91 @@
+# 📄 Structure du Projet et Diagrammes Mermaid
+
+Fichier `architecture.md` contenant une description complète de l'application avec **6 diagrammes Mermaid** :
+
+## 📁 Structure du Dossier
+
+```
+Point-Cloud-Classifier-HTMX/
+├── agents.md
+├── docker-compose.yml          # Configuration Docker (2 services)
+├── Dockerfile.builder
+├── Dockerfile.entwine          # Backend avec Entwine
+├── Dockerfile.frontend         # Frontend avec HTMX
+├── pyproject.toml
+├── requirements.txt
+├── Roo.md                      # Contexte du projet
+├── architecture.md             # 📄 NOUVEAU - Documentation complète
+├── backend/
+│   ├── __init__.py
+│   ├── config.py               # Configuration backend
+│   ├── main.py                 # FastAPI backend
+│   ├── data/
+│   │   ├── uploads/            # Fichiers LAS bruts
+│   │   └── ept/                # Nuages convertis
+│   ├── routes/
+│   │   ├── upload.py           # Routes upload
+│   │   ├── viewer.py           # Routes visualisation
+│   │   └── admin.py            # Routes admin
+│   ├── services/
+│   │   ├── converter.py        # Conversion Entwine
+│   │   ├── manifest.py         # Gestion manifest.json
+│   │   └── html_generator.py   # Génération HTML Potree
+│   └── static/
+│       └── potree/             # Assets Potree
+└── frontend/
+    ├── api_client.py           # Client HTTP async
+    ├── config.py               # Configuration frontend
+    ├── main.py                 # FastAPI frontend
+    ├── components/             # Composants HTMX
+    ├── routes/
+    │   ├── upload.py
+    │   ├── viewer.py
+    │   ├── admin.py
+    │   └── crop.py
+    ├── static/
+    │   └── potree/
+    └── templates/
+        ├── index.html
+        └── partials/
+            ├── cloud_list.html
+            ├── viewer.html
+            ├── crop.html
+            ├── backend_config.html
+            ├── debug_panel.html
+            ├── health_status.html
+            └── upload_result.html
+```
+
+## 🔄 Diagrammes Mermaid
+
+### 1. Vue d'ensemble de l'architecture
+Architecture globale avec Frontend (8091), Backend (8000), Outils externes (Potree, PDAL, Entwine) et Stockage.
+
+### 2. Flux principal d'upload et conversion
+SequenceDiagram montrant les 14 étapes : Upload → Vérification → Conversion Entwine → Manifeste → Visualisation.
+
+### 3. Flux de visualisation
+Flowchart LR de la liste des nuages → sélection → embed Potree → chargement EPT → visualisation 3D.
+
+### 4. Flux de crop (réduction du nuage)
+SequenceDiagram du traitement PDAL : Sélection box 3D → Filtre LAS → Conversion EPT → Nouveau nuage.
+
+### 5. Architecture des routes
+Mindmap détaillant toutes les routes Frontend et Backend avec leurs endpoints.
+
+### 6. Diagramme complet des interactions
+Flowchart TB complet avec 26 étapes numérotées, classes colorées par type (utilisateur, frontend, backend, outils, stockage, externe).
+
+### 7. Structure des dossiers EPT
+Graph TD montrant la structure interne d'un dossier EPT (manifest, ept.json, tuiles, hiérarchie, sources).
+
+## 🎯 Fonctionnalités Documentées
+
+1. **Upload et Conversion** - LAS/LAZ/PLY → EPT
+2. **Visualisation 3D** - Potree Viewer WebGL
+3. **Administration** - Liste, Debug, Suppression
+4. **Traitement PDAL** - Crop 3D
+5. **Configuration Dynamique** - URLs configurables
+6. **Monitoring** - Health check, espace disque
+
+Le fichier `architecture.md` est prêt à être utilisé comme contexte pour un agent AI et pour la revue des fonctionnalités.

docker-compose.yml

@@ -0,0 +1,30 @@
+services:
+
+  backend_entwine:
+    build:
+      context: .
+      dockerfile: Dockerfile.entwine
+    container_name: pointcloud-backend-htmx
+    ports:
+      - "8090:8000"
+    volumes:
+      - ./backend:/app/backend
+    environment:
+      - HOST_DATA_DIR=/app/backend/data
+    restart: unless-stopped
+
+  frontend_htmx:
+    build:
+      context: .
+      dockerfile: Dockerfile.frontend
+    container_name: pointcloud-frontend-htmx
+    ports:
+      - "8091:8080"
+    volumes:
+      - ./frontend:/app/frontend
+    environment:
+      - MAX_UPLOAD_SIZE_GB=10
+      - BACKEND_URL=http://backend_entwine:8000
+    depends_on:
+      - backend_entwine
+    restart: unless-stopped