mirror of
https://forge.chapril.org/tykayn/parking-land
synced 2025-06-20 01:44:42 +02:00
add makefile
This commit is contained in:
Tykayn
tykayn
parent
eb8fafdd49
commit
44f85a8ae9
9 changed files with 525 additions and 186164 deletions
8
.gitignore
vendored
Normal file
8
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
*.json
|
||||
*.html
|
||||
*.jpg
|
||||
*.png
|
||||
*.pdf
|
||||
*.csv
|
||||
*.xlsx
|
||||
__pycache__
|
||||
|
|
@ -7,8 +7,10 @@ Ce guide détaille l'utilisation des différents scripts disponibles dans ce pro
|
|||
1. [Génération de rapports HTML](#génération-de-rapports-html)
|
||||
2. [Génération de cartes](#génération-de-cartes)
|
||||
3. [Conversion HTML vers JPG](#conversion-html-vers-jpg)
|
||||
4. [Workflow recommandé](#workflow-recommandé)
|
||||
5. [Dépannage](#dépannage)
|
||||
4. [Récupération et analyse des données](#récupération-et-analyse-des-données)
|
||||
5. [Workflow recommandé](#workflow-recommandé)
|
||||
6. [Dépannage](#dépannage)
|
||||
7. [Utilisation simplifiée avec Make](#utilisation-simplifiée-avec-make)
|
||||
|
||||
## Génération de rapports HTML
|
||||
|
||||
|
|
@ -186,21 +188,103 @@ python html_to_jpg.py <fichier_html> [-o output.jpg] [-m méthode]
|
|||
python html_to_jpg.py carte_ville.html -o carte_ville.jpg -m selenium
|
||||
```
|
||||
|
||||
## Récupération et analyse des données
|
||||
|
||||
### Script fetch.py
|
||||
|
||||
Le script `fetch.py` permet de récupérer les données OpenStreetMap pour une ville et d'exécuter automatiquement l'analyse avec `compute.py`.
|
||||
|
||||
#### Syntaxe
|
||||
|
||||
```bash
|
||||
python fetch.py <id_ou_nom_ville> [options]
|
||||
```
|
||||
|
||||
#### Arguments
|
||||
|
||||
- `<id_ou_nom_ville>` : Identifiant OpenStreetMap de la ville ou nom de la ville (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 de compute.py (défaut: summary_results.json)
|
||||
- `--verbose`, `-v` : Afficher plus d'informations pendant l'exécution
|
||||
|
||||
#### Exemples
|
||||
|
||||
```bash
|
||||
# Utilisation avec un ID OpenStreetMap
|
||||
python fetch.py 1209165
|
||||
|
||||
# Utilisation avec un nom de ville
|
||||
python fetch.py "Briis-sous-Forges"
|
||||
|
||||
# Spécifier le fichier de sortie
|
||||
python fetch.py "Paris" -o paris_results.json
|
||||
|
||||
# Récupérer les données sans exécuter l'analyse
|
||||
python fetch.py "Lyon" --no-compute
|
||||
```
|
||||
|
||||
#### Fonctionnement
|
||||
|
||||
Le script effectue les opérations suivantes :
|
||||
|
||||
1. Si un nom de ville est fourni, il utilise `find_city_osm_id.py` pour rechercher l'ID OpenStreetMap correspondant
|
||||
2. Il récupère les données OpenStreetMap pour la ville et les sauvegarde dans `overpass_data.json`
|
||||
3. Par défaut, il exécute automatiquement `compute.py` pour analyser les données
|
||||
4. Les résultats de l'analyse sont sauvegardés dans le fichier spécifié (par défaut: `summary_results.json`)
|
||||
5. Un résumé des résultats est affiché à l'écran
|
||||
|
||||
### Script compute.py
|
||||
|
||||
Le script `compute.py` analyse les données OpenStreetMap récupérées par `fetch.py` et génère des statistiques.
|
||||
|
||||
#### Syntaxe
|
||||
|
||||
```bash
|
||||
python compute.py [options]
|
||||
```
|
||||
|
||||
#### Fonctionnement
|
||||
|
||||
Le script lit le fichier `overpass_data.json` généré par `fetch.py` et calcule diverses statistiques :
|
||||
- Longueur totale des routes
|
||||
- Surface des routes
|
||||
- Nombre et surface des bâtiments
|
||||
- Nombre et capacité des parkings
|
||||
- Longueur des pistes cyclables
|
||||
- Nombre de stations de recharge
|
||||
|
||||
Les résultats sont sauvegardés dans le fichier `summary_results.json` qui peut ensuite être utilisé par `present.py` pour générer un rapport HTML.
|
||||
|
||||
## Workflow recommandé
|
||||
|
||||
Pour obtenir les meilleurs résultats, suivez ce workflow en deux étapes :
|
||||
Pour une analyse complète d'une ville, suivez ce workflow :
|
||||
|
||||
1. **Générer une carte HTML avec Folium** :
|
||||
1. **Récupérer les données et effectuer l'analyse** :
|
||||
```bash
|
||||
python generate_city_map.py 1209165 -o carte_ville.html --folium
|
||||
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
|
||||
|
||||
2. **Générer un rapport HTML** :
|
||||
```bash
|
||||
python present.py resultats_ville.json rapport_ville.html
|
||||
```
|
||||
|
||||
2. **Convertir la carte HTML en image JPG** :
|
||||
3. **Générer une carte de la ville** :
|
||||
```bash
|
||||
python find_city_osm_id.py "Nom de la ville" -o carte_ville.html
|
||||
```
|
||||
|
||||
4. **Convertir la carte HTML en image JPG** (si nécessaire) :
|
||||
```bash
|
||||
python html2jpg.py carte_ville.html -o carte_ville.jpg
|
||||
```
|
||||
|
||||
Cette approche en deux étapes est plus robuste que la génération directe en JPG.
|
||||
Cette approche en quatre étapes permet d'obtenir à la fois un rapport détaillé et une carte visuelle de la ville analysée.
|
||||
|
||||
## Dépannage
|
||||
|
||||
|
|
@ -311,4 +395,87 @@ Ce script simplifie considérablement le workflow en permettant de passer direct
|
|||
python find_city_osm_id.py "Briis-sous-Forges" -c fr -o briis.html && python html2jpg.py briis.html -o briis.jpg
|
||||
```
|
||||
|
||||
Cette approche est beaucoup plus simple que de rechercher manuellement l'ID OpenStreetMap de la ville, puis d'exécuter séparément les scripts de génération de carte.
|
||||
Cette approche est beaucoup plus simple que de rechercher manuellement l'ID OpenStreetMap de la ville, puis d'exécuter séparément les scripts de génération de carte.
|
||||
|
||||
## Utilisation simplifiée avec Make
|
||||
|
||||
Un Makefile est disponible pour simplifier l'installation et l'utilisation du projet. Cette approche est recommandée pour les utilisateurs qui souhaitent une solution clé en main.
|
||||
|
||||
### Installation avec Make
|
||||
|
||||
Pour installer l'environnement virtuel et toutes les dépendances nécessaires :
|
||||
|
||||
```bash
|
||||
make setup
|
||||
```
|
||||
|
||||
Cette commande va :
|
||||
- Créer un environnement virtuel Python
|
||||
- Installer toutes les dépendances requises depuis requirements.txt
|
||||
- Installer et configurer Playwright pour la conversion HTML vers JPG
|
||||
|
||||
Après l'installation, activez l'environnement virtuel :
|
||||
|
||||
```bash
|
||||
source venv/bin/activate
|
||||
```
|
||||
|
||||
### Commandes disponibles
|
||||
|
||||
#### Analyse d'une ville
|
||||
|
||||
Pour récupérer les données, effectuer l'analyse et générer une carte pour une ville :
|
||||
|
||||
```bash
|
||||
make city CITY="Nom de la ville"
|
||||
```
|
||||
|
||||
Exemple :
|
||||
```bash
|
||||
make city CITY="Paris"
|
||||
```
|
||||
|
||||
Cette commande exécute automatiquement :
|
||||
1. `fetch.py` pour récupérer les données OpenStreetMap
|
||||
2. `find_city_osm_id.py` pour générer une carte HTML
|
||||
3. `html2jpg.py` pour convertir la carte en image JPG
|
||||
|
||||
Les fichiers générés seront :
|
||||
- `Paris_results.json` : Résultats de l'analyse
|
||||
- `Paris_carte.html` : Carte HTML interactive
|
||||
- `Paris_carte.jpg` : Image de la carte
|
||||
|
||||
#### Génération d'un rapport HTML
|
||||
|
||||
Pour générer un rapport HTML à partir des résultats d'analyse :
|
||||
|
||||
```bash
|
||||
make report CITY="Paris"
|
||||
```
|
||||
|
||||
Cette commande utilise `present.py` pour générer un rapport HTML à partir du fichier `Paris_results.json`.
|
||||
|
||||
#### Analyse complète
|
||||
|
||||
Pour effectuer l'analyse complète (données, carte et rapport) en une seule commande :
|
||||
|
||||
```bash
|
||||
make all CITY="Paris"
|
||||
```
|
||||
|
||||
#### Nettoyage
|
||||
|
||||
Pour supprimer tous les fichiers temporaires et l'environnement virtuel :
|
||||
|
||||
```bash
|
||||
make clean
|
||||
```
|
||||
|
||||
### Avantages de l'utilisation de Make
|
||||
|
||||
- **Simplicité** : Une seule commande pour effectuer plusieurs opérations
|
||||
- **Cohérence** : Nommage cohérent des fichiers de sortie
|
||||
- **Environnement isolé** : Utilisation d'un environnement virtuel pour éviter les conflits de dépendances
|
||||
- **Automatisation** : Enchaînement automatique des différentes étapes du workflow
|
||||
|
||||
Cette approche est particulièrement recommandée pour les utilisateurs qui souhaitent analyser plusieurs villes ou qui utilisent régulièrement le projet.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB After Width: | Height: | Size: 20 KiB |
69
Makefile
Normal file
69
Makefile
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
# Makefile pour l'analyse urbaine
|
||||
# Usage:
|
||||
# make setup - Installer l'environnement virtuel et les dépendances
|
||||
# make city CITY=Paris - Récupérer les données et générer une carte pour Paris
|
||||
|
||||
# Variables
|
||||
PYTHON = python3
|
||||
VENV = venv
|
||||
PIP = $(VENV)/bin/pip
|
||||
PYTHON_VENV = $(VENV)/bin/python
|
||||
CITY ?= Paris
|
||||
|
||||
.PHONY: setup city clean help
|
||||
|
||||
# Cible par défaut
|
||||
help:
|
||||
@echo "Utilisation du Makefile pour l'analyse urbaine:"
|
||||
@echo " make setup - Installer l'environnement virtuel et les dépendances"
|
||||
@echo " make city CITY=Paris - Récupérer les données et générer une carte pour Paris"
|
||||
@echo " make report CITY=Paris - Générer un rapport HTML pour Paris"
|
||||
@echo " make all CITY=Paris - Récupérer les données, générer une carte et un rapport pour Paris"
|
||||
@echo " make clean - Supprimer les fichiers temporaires et l'environnement virtuel"
|
||||
|
||||
# Installer l'environnement virtuel et les dépendances
|
||||
setup:
|
||||
@echo "Création de l'environnement virtuel..."
|
||||
$(PYTHON) -m venv $(VENV)
|
||||
@echo "Installation des dépendances..."
|
||||
$(PIP) install --upgrade pip
|
||||
$(PIP) install -r requirements.txt
|
||||
@echo "Installation de Playwright pour la conversion HTML vers JPG..."
|
||||
$(PIP) install playwright
|
||||
$(VENV)/bin/playwright install
|
||||
@echo "Installation terminée. Utilisez 'source venv/bin/activate' pour activer l'environnement."
|
||||
|
||||
# Récupérer les données et générer une carte pour une ville
|
||||
city: check-venv
|
||||
@echo "Récupération des données pour $(CITY)..."
|
||||
$(PYTHON_VENV) fetch.py "$(CITY)" -o "$(CITY)_results.json"
|
||||
@echo "Génération de la carte pour $(CITY)..."
|
||||
$(PYTHON_VENV) find_city_osm_id.py "$(CITY)" -c fr -o "$(CITY)_carte.html"
|
||||
@echo "Conversion de la carte HTML en JPG..."
|
||||
$(PYTHON_VENV) html2jpg.py "$(CITY)_carte.html" -o "$(CITY)_carte.jpg"
|
||||
@echo "Traitement terminé. Résultats disponibles dans $(CITY)_results.json, $(CITY)_carte.html et $(CITY)_carte.jpg"
|
||||
|
||||
# Générer un rapport HTML pour une ville
|
||||
report: check-venv
|
||||
@echo "Génération du rapport HTML pour $(CITY)..."
|
||||
$(PYTHON_VENV) present.py "$(CITY)_results.json" "$(CITY)_rapport.html"
|
||||
@echo "Rapport généré dans $(CITY)_rapport.html"
|
||||
|
||||
# Récupérer les données, générer une carte et un rapport pour une ville
|
||||
all: city report
|
||||
@echo "Traitement complet terminé pour $(CITY)"
|
||||
|
||||
# Vérifier si l'environnement virtuel existe
|
||||
check-venv:
|
||||
@if [ ! -d "$(VENV)" ]; then \
|
||||
echo "L'environnement virtuel n'existe pas. Exécutez 'make setup' d'abord."; \
|
||||
exit 1; \
|
||||
fi
|
||||
|
||||
# Nettoyer les fichiers temporaires et l'environnement virtuel
|
||||
clean:
|
||||
@echo "Suppression des fichiers temporaires..."
|
||||
rm -f *.jpg *.html *.json
|
||||
@echo "Suppression de l'environnement virtuel..."
|
||||
rm -rf $(VENV)
|
||||
@echo "Nettoyage terminé."
|
||||
124
README.md
124
README.md
|
|
@ -14,6 +14,7 @@ Ce projet permet de générer des rapports HTML et des cartes visuelles présent
|
|||
- 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
|
||||
|
||||
|
|
@ -43,8 +44,76 @@ Ce projet permet de générer des rapports HTML et des cartes visuelles présent
|
|||
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
|
||||
|
|
@ -56,8 +125,7 @@ Arguments :
|
|||
- `[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
|
||||
|
||||
Exemple :
|
||||
```bash
|
||||
python present.py summary_results.json rapport_ville.html template_ameliore.html
|
||||
```
|
||||
|
|
@ -74,8 +142,7 @@ Arguments :
|
|||
- `--folium` : Utiliser Folium au lieu d'OSMnx (plus léger mais moins détaillé)
|
||||
- `-v, --verbose` : Afficher les messages de débogage
|
||||
|
||||
### Exemple
|
||||
|
||||
Exemple :
|
||||
```bash
|
||||
python generate_city_map.py 123456 -o carte_ville.jpg
|
||||
```
|
||||
|
|
@ -241,4 +308,51 @@ Pour les utilisateurs avancés, voici comment combiner toutes les étapes en une
|
|||
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.
|
||||
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.
|
||||
|
|
@ -12,12 +12,12 @@ OVERPASS_API = "https://overpass-api.de/api/interpreter"
|
|||
# Configuration des arguments de ligne de commande
|
||||
parser = argparse.ArgumentParser(description="Calculer les parkings et la surface d'une ville.")
|
||||
parser.add_argument("--city", type=str, default="Limours", help="Nom de la ville (défaut: Limours)")
|
||||
parser.add_argument("--osm-id", type=str, default="3601176343", help="Identifiant OpenStreetMap de la ville (défaut: 3601176343 pour Limours)")
|
||||
args = parser.parse_args()
|
||||
|
||||
CITY_NAME = args.city
|
||||
# limours: 3601176343
|
||||
# briis-sous-forges: 3601209165
|
||||
parser.add_argument("--osm-id", type=str, default="3601209165", help="Identifiant OpenStreetMap de la ville (défaut: 3601209165 pour Briis-sous-Forges)")
|
||||
|
||||
city_overpass_id = args.osm_id
|
||||
|
||||
|
|
@ -157,7 +157,7 @@ def estimate_road_length_and_surface(city_name):
|
|||
if "capacity" in element["tags"]:
|
||||
charging_stations_with_capacity_count += 1
|
||||
charging_stations_capacity_provided += int(element["tags"]["capacity"])
|
||||
elif "tags" in element and "man_mande" in element["tags"] and ["tags"]["man_mande"] == "charge_point":
|
||||
elif "tags" in element and "man_made" in element["tags"] and element["tags"]["man_made"] == "charge_point":
|
||||
charging_points += 1
|
||||
# points de charge
|
||||
road_length += element_road_length
|
||||
|
|
|
|||
138
fetch.py
138
fetch.py
|
|
@ -1,5 +1,8 @@
|
|||
import requests
|
||||
import json
|
||||
import sys
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
# Configuration
|
||||
OVERPASS_API = "https://overpass-api.de/api/interpreter"
|
||||
|
|
@ -8,12 +11,57 @@ import argparse
|
|||
|
||||
def parse_arguments():
|
||||
parser = argparse.ArgumentParser(description="Récupère les données OpenStreetMap pour une ville")
|
||||
parser.add_argument("city_id", help="Identifiant OpenStreetMap de la ville")
|
||||
parser.add_argument("city_id", type=str, help="Identifiant OpenStreetMap de la ville ou nom de la ville", nargs="+")
|
||||
parser.add_argument("--no-compute", action="store_true", help="Ne pas exécuter compute.py après la récupération des données")
|
||||
parser.add_argument("--output", "-o", type=str, default="summary_results.json", help="Fichier de sortie pour les résultats de compute.py (défaut: summary_results.json)")
|
||||
parser.add_argument("--verbose", "-v", action="store_true", help="Afficher plus d'informations pendant l'exécution")
|
||||
return parser.parse_args()
|
||||
|
||||
args = parse_arguments()
|
||||
|
||||
|
||||
city_overpass_id = args.city_id # ID de la ville
|
||||
from find_city_osm_id import search_city, get_relation_id
|
||||
|
||||
# Vérifier si l'argument est un nombre ou un nom de ville
|
||||
if len(city_overpass_id) == 1 and city_overpass_id[0].isdigit():
|
||||
# Si c'est un nombre, l'utiliser directement comme ID
|
||||
city_overpass_id = int(city_overpass_id[0])
|
||||
if args.verbose:
|
||||
print(f"Utilisation de l'ID OpenStreetMap: {city_overpass_id}")
|
||||
else:
|
||||
# Si c'est un nom de ville, faire une recherche
|
||||
city_name = " ".join(city_overpass_id)
|
||||
print(f"Recherche de la ville: {city_name}")
|
||||
|
||||
# Effectuer la recherche
|
||||
results = search_city(city_name)
|
||||
|
||||
if not results:
|
||||
print("Aucune ville trouvée")
|
||||
sys.exit(1)
|
||||
|
||||
# Prendre le premier résultat
|
||||
first_result = results[0]
|
||||
osm_type = first_result.get('osm_type', '').capitalize()
|
||||
osm_id = first_result.get('osm_id', '')
|
||||
|
||||
# Obtenir l'ID de relation si nécessaire
|
||||
if osm_type != 'Relation':
|
||||
print(f"L'élément trouvé est de type {osm_type}, recherche de l'ID de relation associé...")
|
||||
relation_id = get_relation_id(osm_type, osm_id)
|
||||
if relation_id:
|
||||
osm_id = relation_id
|
||||
print(f"ID de relation trouvé: {osm_id}")
|
||||
else:
|
||||
print("Aucune relation trouvée pour ce résultat. Utilisation de l'ID original.")
|
||||
|
||||
city_overpass_id = osm_id
|
||||
print(f"ID OpenStreetMap utilisé: {city_overpass_id}")
|
||||
|
||||
|
||||
# Convertir l'ID en format Overpass (ajouter 3600000000 pour les relations)
|
||||
city_overpass_id = 3600000000 + city_overpass_id
|
||||
|
||||
def fetch_overpass_data():
|
||||
# Requête Overpass pour obtenir les routes et bâtiments de la ville
|
||||
|
|
@ -21,6 +69,7 @@ def fetch_overpass_data():
|
|||
[out:json][timeout:25];area(id:{city_overpass_id})->.searchArea;(way["building"](area.searchArea);nwr["amenity"="bicycle_parking"](area.searchArea);nwr["amenity"="charging_station"](area.searchArea);nwr["man_made"="charge_point"](area.searchArea);nwr["amenity"="parking"](area.searchArea);way["highway"]["highway"~"residential|primary|secondary|tertiary|service|footway|unclassified|cycleway|roundabout|mini_roundabout"](area.searchArea););out geom;
|
||||
'''
|
||||
|
||||
print("Récupération des données OpenStreetMap...")
|
||||
response = requests.post(OVERPASS_API, data={"data": overpass_query}, headers={"X-Requested-With": "overpass-turbo"})
|
||||
|
||||
if response.status_code == 200:
|
||||
|
|
@ -28,8 +77,91 @@ def fetch_overpass_data():
|
|||
with open('overpass_data.json', 'w') as file:
|
||||
json.dump(data, file, ensure_ascii=False, indent=4)
|
||||
print("Données Overpass récupérées et sauvegardées dans overpass_data.json")
|
||||
return True
|
||||
else:
|
||||
print(f"Échec de la requête Overpass. Code d'erreur: {response.status_code}")
|
||||
print(f"Échec de la requête Overpass. Code d'erreur: {response.status_code}", response.text)
|
||||
return False
|
||||
|
||||
def run_compute():
|
||||
"""
|
||||
Exécute le script compute.py pour analyser les données récupérées
|
||||
et générer les statistiques.
|
||||
|
||||
Returns:
|
||||
bool: True si l'exécution a réussi, False sinon
|
||||
"""
|
||||
try:
|
||||
print("\n--- Exécution de compute.py pour analyser les données ---")
|
||||
|
||||
# Vérifier si compute.py existe
|
||||
if not os.path.exists("compute.py"):
|
||||
print("Erreur: Le script compute.py n'a pas été trouvé.")
|
||||
return False
|
||||
|
||||
# Exécuter compute.py avec l'ID OpenStreetMap
|
||||
cmd = ["python", "compute.py", "--osm-id", str(city_overpass_id)]
|
||||
|
||||
# Ajouter les options si nécessaire
|
||||
if args.verbose:
|
||||
print(f"Commande: {' '.join(cmd)}")
|
||||
|
||||
result = subprocess.run(cmd, capture_output=True, text=True)
|
||||
|
||||
# Vérifier si la commande a réussi
|
||||
if result.returncode == 0:
|
||||
print("Analyse des données terminée avec succès.")
|
||||
|
||||
# Vérifier si le fichier de résultats a été généré
|
||||
if os.path.exists("summary_results.json"):
|
||||
# Copier le fichier vers le chemin spécifié par l'utilisateur
|
||||
if args.output != "summary_results.json":
|
||||
with open("summary_results.json", "r") as src_file:
|
||||
with open(args.output, "w") as dest_file:
|
||||
dest_file.write(src_file.read())
|
||||
print(f"Résultats sauvegardés dans {args.output}")
|
||||
else:
|
||||
print("Résultats sauvegardés dans summary_results.json")
|
||||
|
||||
# Afficher un résumé des résultats
|
||||
with open("summary_results.json", "r") as file:
|
||||
results = json.load(file)
|
||||
print("\n--- Résumé des résultats ---")
|
||||
print(f"Ville: {results.get('city_name', 'Non spécifié')}")
|
||||
print(f"Nombre de bâtiments: {results.get('building_count', 0)}")
|
||||
print(f"Longueur totale des routes: {results.get('longueur_route_km', 0):.2f} km")
|
||||
print(f"Longueur des pistes cyclables: {results.get('road_cycleway_km', 0):.2f} km")
|
||||
print(f"Nombre de places de parking: {results.get('car_parking_capacity_provided', 0)}")
|
||||
print(f"Nombre de stations de recharge: {results.get('charging_stations', 0)}")
|
||||
|
||||
return True
|
||||
else:
|
||||
print("Avertissement: Le fichier summary_results.json n'a pas été généré.")
|
||||
return False
|
||||
else:
|
||||
print(f"Erreur lors de l'exécution de compute.py (code {result.returncode}):")
|
||||
print(result.stderr)
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print(f"Erreur lors de l'exécution de compute.py: {str(e)}")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
fetch_overpass_data()
|
||||
# Récupérer les données OpenStreetMap
|
||||
success = fetch_overpass_data()
|
||||
|
||||
# Exécuter compute.py si la récupération a réussi et que l'option --no-compute n'est pas activée
|
||||
if success and not args.no_compute:
|
||||
run_compute()
|
||||
print("\nPour générer un rapport HTML à partir des résultats, exécutez:")
|
||||
print(f"python present.py {args.output}")
|
||||
|
||||
print("\nPour générer une carte de la ville, exécutez:")
|
||||
print(f"python generate_city_map.py {city_overpass_id - 3600000000} -o carte_ville.html --folium")
|
||||
elif not success:
|
||||
print("Impossible d'exécuter compute.py car la récupération des données a échoué.")
|
||||
elif args.no_compute:
|
||||
print("\nL'option --no-compute est activée, compute.py n'a pas été exécuté.")
|
||||
print("Pour exécuter compute.py manuellement, utilisez la commande:")
|
||||
print("python compute.py")
|
||||
|
||||
|
|
|
|||
186129
overpass_data.json
186129
overpass_data.json
File diff suppressed because it is too large
Load diff
|
|
@ -1,10 +1,10 @@
|
|||
{
|
||||
"longueur_route_km": 228.33392384008508,
|
||||
"road_cycleway_km": 0.027059960352724084,
|
||||
"compte_highways": 3530,
|
||||
"surface_route_km2": 1.5983374668805956,
|
||||
"building_count": 2516,
|
||||
"building_area": 2.6538178289989005e-08,
|
||||
"longueur_route_km": 1074.260839985517,
|
||||
"road_cycleway_km": 0.198057781137736,
|
||||
"compte_highways": 17198,
|
||||
"surface_route_km2": 7.519825879898618,
|
||||
"building_count": 14256,
|
||||
"building_area": 1.9447133403000965e-07,
|
||||
"building_sizes": [
|
||||
0,
|
||||
10,
|
||||
|
|
@ -16,24 +16,24 @@
|
|||
],
|
||||
"building_size_counts": [
|
||||
0,
|
||||
2516,
|
||||
14256,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
],
|
||||
"compte_piste_cyclable": 4,
|
||||
"car_parking_capacity_provided": 491,
|
||||
"compte_piste_cyclable": 14,
|
||||
"car_parking_capacity_provided": 1030,
|
||||
"roundabout_count": 0,
|
||||
"mini_roundabout_count": 0,
|
||||
"surface_parking_km2": 9820.0,
|
||||
"surface_bicycle_parking_km2": 4.2e-05,
|
||||
"parking_with_capacity_count": 43,
|
||||
"capacity_bicycle_parking_provided": 125,
|
||||
"bicycle_parking_surface_from_capacity_provided_in_m2": 250,
|
||||
"charging_stations": 4,
|
||||
"charging_stations_with_capacity_count": 4,
|
||||
"charging_stations_capacity_provided": 7,
|
||||
"surface_parking_km2": 20600.000000000015,
|
||||
"surface_bicycle_parking_km2": 5.8e-05,
|
||||
"parking_with_capacity_count": 44,
|
||||
"capacity_bicycle_parking_provided": 190,
|
||||
"bicycle_parking_surface_from_capacity_provided_in_m2": 380,
|
||||
"charging_stations": 11,
|
||||
"charging_stations_with_capacity_count": 10,
|
||||
"charging_stations_capacity_provided": 46,
|
||||
"charging_points": 0
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue