parking-land/README.md

# 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.