mirror of
https://forge.chapril.org/tykayn/parking-land
synced 2025-06-20 01:44:42 +02:00
358 lines
No EOL
9.8 KiB
Markdown
358 lines
No EOL
9.8 KiB
Markdown
# Analyse Urbaine - Générateur de Rapports et Cartes
|
|
|
|
Ce projet permet de générer des rapports HTML et des cartes visuelles présentant les résultats d'analyse urbaine pour une ville donnée, à partir de données JSON et OpenStreetMap.
|
|
|
|
> **Note :** Pour des instructions détaillées, consultez le [Guide d'Utilisation Détaillé](GUIDE_UTILISATION.md).
|
|
|
|
## Fonctionnalités
|
|
|
|
- Génération de rapports HTML à partir de données JSON
|
|
- Visualisation des statistiques urbaines (routes, pistes cyclables, parkings, bâtiments, etc.)
|
|
- Génération de cartes visuelles des villes à partir de leur ID OpenStreetMap
|
|
- Utilisation du fond de carte Stamen Terrain pour une meilleure lisibilité
|
|
- Sélecteur de fonds de carte (Stamen Terrain, Stamen Toner, Stamen Watercolor, OpenStreetMap)
|
|
- Calcul automatique de ratios et d'indicateurs
|
|
- Templates personnalisables
|
|
- Interface responsive adaptée aux mobiles et ordinateurs
|
|
- Récupération et analyse automatique des données OpenStreetMap
|
|
|
|
## Prérequis
|
|
|
|
- Python 3.6 ou supérieur
|
|
- Jinja2 (`pip install jinja2`)
|
|
- Pour les cartes : OSMnx ou Folium (voir requirements.txt)
|
|
|
|
## Installation
|
|
|
|
1. Clonez ce dépôt :
|
|
```
|
|
git clone https://github.com/votre-utilisateur/analyse-urbaine.git
|
|
cd analyse-urbaine
|
|
```
|
|
|
|
2. Installez les dépendances :
|
|
```
|
|
pip install -r requirements.txt
|
|
```
|
|
|
|
3. Pour la conversion HTML vers JPG, installez l'un des outils suivants :
|
|
- wkhtmltopdf/wkhtmltoimage : https://wkhtmltopdf.org/downloads.html
|
|
- CutyCapt (pour Linux) : `sudo apt-get install cutycapt`
|
|
- Playwright (recommandé) :
|
|
```bash
|
|
pip install playwright
|
|
playwright install
|
|
```
|
|
|
|
## Installation simplifiée avec Make
|
|
|
|
Un Makefile est disponible pour simplifier l'installation et l'utilisation du projet.
|
|
|
|
### Installation de l'environnement virtuel et des dépendances
|
|
|
|
```bash
|
|
make setup
|
|
```
|
|
|
|
Cette commande va :
|
|
- Créer un environnement virtuel Python
|
|
- Installer toutes les dépendances requises
|
|
- Installer et configurer Playwright pour la conversion HTML vers JPG
|
|
|
|
Après l'installation, activez l'environnement virtuel :
|
|
|
|
```bash
|
|
source venv/bin/activate
|
|
```
|
|
|
|
### Analyse complète d'une ville
|
|
|
|
```bash
|
|
make city CITY="Paris"
|
|
```
|
|
|
|
Cette commande va :
|
|
- Récupérer les données OpenStreetMap pour Paris
|
|
- Analyser les données avec compute.py
|
|
- Générer une carte HTML avec Folium
|
|
- Convertir la carte HTML en image JPG
|
|
|
|
### Génération d'un rapport HTML
|
|
|
|
```bash
|
|
make report CITY="Paris"
|
|
```
|
|
|
|
### Analyse complète et génération de rapport
|
|
|
|
```bash
|
|
make all CITY="Paris"
|
|
```
|
|
|
|
### Nettoyage des fichiers temporaires
|
|
|
|
```bash
|
|
make clean
|
|
```
|
|
|
|
## Utilisation
|
|
|
|
### Récupération et analyse des données
|
|
|
|
```bash
|
|
python fetch.py <nom_ville_ou_id> [options]
|
|
```
|
|
|
|
Arguments :
|
|
- `<nom_ville_ou_id>` : Nom de la ville ou identifiant OpenStreetMap (obligatoire)
|
|
- `--no-compute` : Ne pas exécuter compute.py après la récupération des données
|
|
- `--output`, `-o` : Fichier de sortie pour les résultats (défaut: summary_results.json)
|
|
- `--verbose`, `-v` : Afficher plus d'informations pendant l'exécution
|
|
|
|
Exemple :
|
|
```bash
|
|
python fetch.py "Paris" -o paris_results.json
|
|
```
|
|
|
|
### Génération d'un rapport HTML
|
|
|
|
```bash
|
|
python present.py <fichier_json> [fichier_html_sortie] [fichier_template]
|
|
```
|
|
|
|
Arguments :
|
|
- `<fichier_json>` : Chemin vers le fichier JSON contenant les données (obligatoire)
|
|
- `[fichier_html_sortie]` : Chemin où sauvegarder le fichier HTML (par défaut: resultat.html)
|
|
- `[fichier_template]` : Nom du fichier template à utiliser (par défaut: template.html)
|
|
|
|
Exemple :
|
|
```bash
|
|
python present.py summary_results.json rapport_ville.html template_ameliore.html
|
|
```
|
|
|
|
### Génération d'une carte de ville
|
|
|
|
```bash
|
|
python generate_city_map.py <osm_id> [options]
|
|
```
|
|
|
|
Arguments :
|
|
- `<osm_id>` : ID OpenStreetMap de la ville (obligatoire)
|
|
- `-o, --output` : Chemin où sauvegarder l'image
|
|
- `--folium` : Utiliser Folium au lieu d'OSMnx (plus léger mais moins détaillé)
|
|
- `-v, --verbose` : Afficher les messages de débogage
|
|
|
|
Exemple :
|
|
```bash
|
|
python generate_city_map.py 123456 -o carte_ville.jpg
|
|
```
|
|
|
|
### Utilisation avancée
|
|
|
|
Pour plus de contrôle, vous pouvez utiliser les scripts individuels :
|
|
|
|
1. Génération de carte avec OSMnx (haute qualité) :
|
|
```bash
|
|
python map.py <osm_id> [-o output.jpg]
|
|
```
|
|
|
|
2. Génération de carte avec Folium (plus léger) :
|
|
```bash
|
|
python map_simple.py <osm_id> [-o output.html]
|
|
```
|
|
|
|
3. Conversion d'une carte HTML en JPG :
|
|
```bash
|
|
python html_to_jpg.py <fichier_html> [-o output.jpg] [-m méthode]
|
|
```
|
|
|
|
Ou avec le nouveau script simplifié (recommandé) :
|
|
```bash
|
|
python html2jpg.py <fichier_html> [-o output.jpg]
|
|
```
|
|
|
|
### Test de la solution
|
|
|
|
Pour tester la solution avec des données fictives :
|
|
|
|
```bash
|
|
python test_present.py
|
|
```
|
|
|
|
## Structure des données JSON
|
|
|
|
Le fichier JSON doit contenir les clés suivantes :
|
|
|
|
```json
|
|
{
|
|
"city_name": "Nom de la ville",
|
|
"longueur_route_km": 228.33,
|
|
"road_cycleway_km": 12.5,
|
|
"compte_highways": 3530,
|
|
"surface_route_km2": 1.59,
|
|
"building_count": 2516,
|
|
"building_area": 2.65,
|
|
"building_sizes": [0, 10, 50, 100, 200, 500, "Infinity"],
|
|
"building_size_counts": [120, 450, 780, 650, 400, 116],
|
|
"compte_piste_cyclable": 42,
|
|
"car_parking_capacity_provided": 491,
|
|
"roundabout_count": 12,
|
|
"mini_roundabout_count": 5,
|
|
"surface_parking_km2": 0.35,
|
|
"surface_bicycle_parking_km2": 0.042,
|
|
"charging_stations": 14,
|
|
"charging_stations_with_capacity_count": 12,
|
|
"charging_stations_capacity_provided": 28,
|
|
"charging_points": 32
|
|
}
|
|
```
|
|
|
|
## Templates disponibles
|
|
|
|
- `template.html` : Template de base avec tableau simple
|
|
- `template_ameliore.html` : Template amélioré avec design moderne, cartes et visualisations
|
|
|
|
## Personnalisation
|
|
|
|
Vous pouvez créer vos propres templates en vous basant sur les templates existants. Utilisez la syntaxe Jinja2 pour accéder aux données.
|
|
|
|
## Trouver l'ID OpenStreetMap d'une ville
|
|
|
|
### Méthode manuelle
|
|
|
|
1. Allez sur [OpenStreetMap](https://www.openstreetmap.org/)
|
|
2. Recherchez la ville souhaitée
|
|
3. Cliquez sur la ville dans les résultats
|
|
4. L'URL contiendra l'ID de la relation, par exemple : `https://www.openstreetmap.org/relation/123456`
|
|
5. L'ID est le nombre après "relation/" (ici, 123456)
|
|
|
|
### Méthode automatique (recommandée)
|
|
|
|
Utilisez le script `find_city_osm_id.py` pour rechercher une ville par son nom et obtenir son ID de relation :
|
|
|
|
```bash
|
|
python find_city_osm_id.py "Nom de la ville"
|
|
```
|
|
|
|
Options disponibles :
|
|
- `-c, --country` : Filtrer par code pays (ex: fr, be, ch)
|
|
- `-l, --limit` : Nombre maximum de résultats (défaut: 5)
|
|
- `-r, --relation-only` : Afficher uniquement les IDs de relation
|
|
- `-j, --json` : Afficher les résultats au format JSON
|
|
|
|
Exemple :
|
|
```bash
|
|
python find_city_osm_id.py "Paris"
|
|
```
|
|
|
|
## Licence
|
|
|
|
Ce projet est sous licence AGPLv3+.
|
|
|
|
## Workflow recommandé pour générer une carte
|
|
|
|
### Méthode simplifiée (recommandée)
|
|
|
|
Utilisez le script `find_city_osm_id.py` qui recherche et génère automatiquement la carte en une seule commande :
|
|
|
|
```bash
|
|
python find_city_osm_id.py "Nom de la ville" -c fr -o carte_ville.html
|
|
```
|
|
|
|
Pour convertir ensuite la carte HTML en image JPG :
|
|
|
|
```bash
|
|
python html2jpg.py carte_ville.html -o carte_ville.jpg
|
|
```
|
|
|
|
Cette méthode est la plus simple car elle :
|
|
- Recherche automatiquement l'ID OpenStreetMap de la ville
|
|
- Génère directement la carte HTML avec Folium
|
|
- Suggère la commande pour convertir en JPG
|
|
|
|
### Méthode manuelle (étape par étape)
|
|
|
|
Si vous préférez contrôler chaque étape du processus :
|
|
|
|
#### Étape 1 : Trouver l'ID OpenStreetMap de la ville
|
|
|
|
Utilisez le script `find_city_osm_id.py` pour trouver l'ID de la ville par son nom, mais désactivez la génération automatique de carte :
|
|
|
|
```bash
|
|
python find_city_osm_id.py "Nom de la ville" -c fr -ng
|
|
```
|
|
|
|
Ou en ligne de commande pour obtenir directement l'ID :
|
|
|
|
```bash
|
|
ID=$(python find_city_osm_id.py "Nom de la ville" -c fr -r | head -n 1)
|
|
```
|
|
|
|
#### Étape 2 : Générer la carte HTML avec Folium
|
|
|
|
```bash
|
|
python generate_city_map.py <osm_id> -o carte_ville.html --folium
|
|
```
|
|
|
|
#### Étape 3 : Convertir la carte HTML en image JPG
|
|
|
|
```bash
|
|
python html2jpg.py carte_ville.html -o carte_ville.jpg
|
|
```
|
|
|
|
### Workflow complet en une seule commande
|
|
|
|
Pour les utilisateurs avancés, voici comment combiner toutes les étapes en une seule commande :
|
|
|
|
```bash
|
|
python find_city_osm_id.py "Briis-sous-Forges" -c fr -o carte_ville.html && python html2jpg.py carte_ville.html -o carte_ville.jpg
|
|
```
|
|
|
|
Cette approche en une ou deux étapes est robuste et permet de générer des cartes pour n'importe quelle ville en connaissant simplement son nom.
|
|
|
|
## Workflow complet d'analyse urbaine
|
|
|
|
Pour une analyse complète d'une ville, suivez ce workflow :
|
|
|
|
### Étape 1 : Récupérer les données et effectuer l'analyse
|
|
|
|
```bash
|
|
python fetch.py "Nom de la ville" -o resultats_ville.json
|
|
```
|
|
|
|
Cette commande va :
|
|
- Rechercher l'ID OpenStreetMap de la ville
|
|
- Récupérer les données OpenStreetMap
|
|
- Exécuter l'analyse avec compute.py
|
|
- Sauvegarder les résultats dans resultats_ville.json
|
|
|
|
### Étape 2 : Générer un rapport HTML
|
|
|
|
```bash
|
|
python present.py resultats_ville.json rapport_ville.html
|
|
```
|
|
|
|
### Étape 3 : Générer une carte de la ville
|
|
|
|
```bash
|
|
python find_city_osm_id.py "Nom de la ville" -o carte_ville.html
|
|
```
|
|
|
|
### Étape 4 : Convertir la carte HTML en image JPG (si nécessaire)
|
|
|
|
```bash
|
|
python html2jpg.py carte_ville.html -o carte_ville.jpg
|
|
```
|
|
|
|
### Workflow complet en une seule commande
|
|
|
|
Pour les utilisateurs avancés, voici comment combiner toutes les étapes en une seule commande :
|
|
|
|
```bash
|
|
python fetch.py "Nom de la ville" -o resultats_ville.json && \
|
|
python present.py resultats_ville.json rapport_ville.html && \
|
|
python find_city_osm_id.py "Nom de la ville" -o carte_ville.html && \
|
|
python html2jpg.py carte_ville.html -o carte_ville.jpg
|
|
```
|
|
|
|
Cette approche permet d'obtenir à la fois un rapport détaillé et une carte visuelle de la ville analysée en une seule commande. |