generate map with folium

generate_city_map.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Script principal qui génère une carte d'une ville à partir de son ID OpenStreetMap
+et la convertit en image JPG en une seule commande.
+"""
+
+import os
+import sys
+import argparse
+import logging
+import importlib.util
+from datetime import datetime
+
+# Configuration de la journalisation
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def check_module_available(module_name):
+    """Vérifie si un module Python est disponible."""
+    return importlib.util.find_spec(module_name) is not None
+
+def generate_map(osm_id, output_path=None, use_osmnx=True, verbose=False):
+    """
+    Génère une carte d'une ville à partir de son ID OpenStreetMap.
+    
+    Args:
+        osm_id (int): L'identifiant OpenStreetMap de la ville
+        output_path (str, optional): Chemin où sauvegarder l'image
+        use_osmnx (bool): Utiliser OSMnx (True) ou Folium (False)
+        verbose (bool): Afficher les messages de débogage
+        
+    Returns:
+        str: Chemin vers l'image générée ou None en cas d'erreur
+    """
+    try:
+        # Configurer le niveau de journalisation
+        if verbose:
+            logger.setLevel(logging.DEBUG)
+        
+        # Vérifier si l'ID OSM est valide
+        if osm_id <= 0:
+            logger.error(f"ID OpenStreetMap invalide: {osm_id}")
+            return None
+        
+        # Déterminer quelle méthode utiliser
+        osmnx_available = check_module_available('osmnx')
+        
+        if use_osmnx and osmnx_available:
+            try:
+                logger.info("Utilisation d'OSMnx pour générer la carte...")
+                
+                # Importer map.py
+                import map
+                
+                # Vérifier si la fonction config existe dans osmnx
+                if not hasattr(map.ox, 'config'):
+                    logger.warning("La fonction 'config' n'existe pas dans OSMnx. Utilisation de Folium à la place.")
+                    raise AttributeError("Module 'osmnx' has no attribute 'config'")
+                
+                # Générer la carte avec OSMnx
+                city_data = map.get_city_by_osm_id(osm_id)
+                
+                if not city_data:
+                    logger.warning(f"Impossible de récupérer les données pour l'ID OSM: {osm_id} avec OSMnx. Essai avec Folium...")
+                    raise ValueError("Aucune donnée trouvée")
+                
+                return map.generate_city_map(city_data, output_path)
+            
+            except Exception as e:
+                logger.warning(f"Erreur avec OSMnx: {str(e)}. Utilisation de Folium à la place.")
+                use_osmnx = False
+        
+        if not use_osmnx or not osmnx_available:
+            if use_osmnx and not osmnx_available:
+                logger.warning("OSMnx n'est pas disponible. Utilisation de Folium à la place.")
+            
+            logger.info("Utilisation de Folium pour générer la carte...")
+            
+            # Importer map_simple.py
+            import map_simple
+            
+            # Générer la carte avec Folium
+            city_data = map_simple.get_city_data_from_osm(osm_id)
+            
+            if not city_data:
+                logger.error(f"Impossible de récupérer les données pour l'ID OSM: {osm_id}")
+                return None
+            
+            html_path = map_simple.create_folium_map(city_data, output_path)
+            
+            if not html_path:
+                logger.error("Échec de la génération de la carte HTML")
+                return None
+            
+            # Si un chemin de sortie spécifique est demandé avec une extension .jpg ou .png
+            if output_path and (output_path.lower().endswith('.jpg') or output_path.lower().endswith('.png')):
+                # Essayer de convertir en image
+                try:
+                    # Importer html_to_jpg.py
+                    import html_to_jpg
+                    
+                    # Convertir en image
+                    logger.info(f"Conversion de la carte HTML en {os.path.splitext(output_path)[1][1:].upper()}...")
+                    
+                    # Essayer différentes méthodes de conversion
+                    for method in ['imgkit','wkhtmltoimage',  'cutycapt']:
+                        try:
+                            result = html_to_jpg.convert_html_to_jpg(html_path, output_path, method)
+                            if result:
+                                return result
+                        except Exception as e:
+                            logger.debug(f"Échec de la méthode {method}: {str(e)}")
+                    
+                    logger.warning(f"Impossible de convertir en {os.path.splitext(output_path)[1][1:].upper()}. Utilisation du fichier HTML à la place.")
+                    return html_path
+                
+                except ImportError:
+                    logger.warning("Module html_to_jpg non disponible. Utilisation du fichier HTML à la place.")
+                    return html_path
+            else:
+                # Si aucune conversion n'est demandée, retourner le chemin HTML
+                return html_path
+    
+    except Exception as e:
+        logger.error(f"Erreur lors de la génération de la carte: {str(e)}")
+        return None
+
+def main():
+    """
+    Fonction principale qui traite les arguments de ligne de commande
+    et génère la carte de la ville.
+    """
+    parser = argparse.ArgumentParser(description='Génère une carte d\'une ville à partir de son ID OpenStreetMap.')
+    parser.add_argument('osm_id', type=int, help='ID OpenStreetMap de la ville')
+    parser.add_argument('-o', '--output', type=str, help='Chemin où sauvegarder l\'image')
+    parser.add_argument('--folium', action='store_true', help='Utiliser Folium au lieu d\'OSMnx')
+    parser.add_argument('-v', '--verbose', action='store_true', help='Afficher les messages de débogage')
+    
+    args = parser.parse_args()
+    
+    # Générer la carte
+    output_path = generate_map(args.osm_id, args.output, not args.folium, args.verbose)
+    
+    if output_path:
+        logger.info(f"Carte générée avec succès: {output_path}")
+        
+        # Afficher des instructions pour visualiser la carte
+        if output_path.lower().endswith('.html'):
+            logger.info(f"Pour visualiser la carte, ouvrez le fichier HTML dans un navigateur web:")
+            logger.info(f"  file://{os.path.abspath(output_path)}")
+    else:
+        logger.error("Échec de la génération de la carte")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()