Update pages/5_📍_VertXtractor.py

pages/5_📍_VertXtractor.py

@@ -1,179 +1,198 @@
 import streamlit as st
+import geopandas as gpd
+import rasterio
+import numpy as np
+from pyproj import Transformer
+import trimesh
+import logging
+from io import BytesIO
 import folium
 from streamlit_folium import folium_static
-from folium.plugins import Draw
-import requests
-import json
-import os
-import urllib.request
-import csv
-from osgeo import gdal
-import numpy as np
-import math
-import shutil
-import sys
-import glob
 
-# Configuration de la page Streamlit
-st.set_page_config(page_title="SwissTopo Downloader", layout="wide")
+# Configuration du logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# Constantes
-PRODUCTS = {
-    'Luftbild 10cm': 'ch.swisstopo.swissimage-dop10',
-    'Landeskarte 1:10': 'ch.swisstopo.landeskarte-farbe-10',
-    'Landeskarte 1:25': 'ch.swisstopo.pixelkarte-farbe-pk25.noscale',
-    'Landeskarte 1:50': 'ch.swisstopo.pixelkarte-farbe-pk50.noscale',
-    'Landeskarte 1:100': 'ch.swisstopo.pixelkarte-farbe-pk100.noscale',
-    'Landeskarte 1:200': 'ch.swisstopo.pixelkarte-farbe-pk200.noscale',
-    'Höhenmodell': 'ch.swisstopo.swissalti3d',
-}
+# Fonction pour charger le MNT de la Suisse (à implémenter)
+def load_swiss_dem():
+    """
+    Charge le MNT de la Suisse. Cette fonction devrait être implémentée pour charger
+    le MNT complet de la Suisse à partir d'une source de données appropriée.
+    """
+    # Placeholder - à remplacer par le chargement réel du MNT suisse
+    return None, None
 
-# Fonctions utilitaires
-def osm_to_decimal(tile_x, tile_y, zoom):
-    """Convertit les coordonnées OSM en coordonnées décimales."""
-    n = 2.0 ** zoom
-    lon_deg = tile_x / n * 360.0 - 180.0
-    lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * tile_y / n)))
-    lat_deg = math.degrees(lat_rad)
-    return lat_deg, lon_deg
+# Fonction pour extraire une partie du MNT
+def extract_dem_region(dem, transform, bbox):
+    """
+    Extrait une région spécifique du MNT basée sur une boîte englobante.
 
-def get_items(productname, LLlon, LLlat, URlon, URlat, first100=False):
-    """Récupère les éléments pour une zone d'intérêt donnée."""
-    url = f"https://data.geo.admin.ch/api/stac/v0.9/collections/{productname}/items?bbox={LLlon},{LLlat},{URlon},{URlat}"
-    response = requests.get(url)
-    items_result = json.loads(response.content)
-    assets = items_result.get('features', [])
-    
-    items_files = []
-    for asset in assets:
-        asset_url = asset.get('assets', {}).get('data', {}).get('href')
-        if asset_url:
-            items_files.append(asset_url)
-    
-    # Filtrage des fichiers selon les cas spécifiques
-    if "_krel_" in productname:
-        items_files = [i for i in items_files if "_krel_" in i]
-    
-    if "0.1" in productname:
-        items_files = [i for i in items_files if "_0.1_" in i]
-    
-    if productname == 'ch.swisstopo.swissalti3d':
-        items_files = [i for i in items_files if i.endswith(".tif")]
-        items_files = [i for i in items_files if "_0.5_" in i]
-    
-    return items_files
+    Args:
+        dem (numpy.array): Données du MNT complet
+        transform (affine.Affine): Transformation géospatiale
+        bbox (tuple): Boîte englobante (minx, miny, maxx, maxy)
 
-def create_csv(productname, LLlon, LLlat, URlon, URlat):
-    """Crée un fichier CSV contenant les URLs des données à télécharger."""
-    coords = f"{LLlon}_{LLlat}_{URlon}_{URlat}"
-    csv_filepath = os.path.join(os.getcwd(), f"{productname}{coords}.csv")
-    
-    items_files = get_items(productname, LLlon, LLlat, URlon, URlat)
-    
-    with open(csv_filepath, 'w', newline='') as f:
-        writer = csv.writer(f)
-        for item in items_files:
-            writer.writerow([item])
-    
-    return csv_filepath
+    Returns:
+        tuple: (données du MNT extraites, nouvelle transformation)
+    """
+    # Conversion des coordonnées de la bbox en indices de pixels
+    minx, miny, maxx, maxy = bbox
+    rows, cols = rasterio.transform.rowcol(transform, [minx, maxx], [miny, maxy])
+    
+    # Extraction de la région
+    window = ((rows[0], rows[1]), (cols[0], cols[1]))
+    dem_region = dem[window[0][0]:window[0][1], window[1][0]:window[1][1]]
+    
+    # Calcul de la nouvelle transformation
+    new_transform = rasterio.transform.from_bounds(minx, miny, maxx, maxy, 
+                                                   dem_region.shape[1], dem_region.shape[0])
+    
+    return dem_region, new_transform
 
-def merge_rasters(input_files, output_file, compress_method='JPEG'):
-    """Fusionne plusieurs rasters en un seul."""
-    gdal.UseExceptions()
-    
-    # Ouvrir le premier fichier pour obtenir les métadonnées
-    src_ds = gdal.Open(input_files[0])
-    driver = gdal.GetDriverByName("GTiff")
-    
-    # Créer le fichier de sortie
-    dst_ds = driver.CreateCopy(output_file, src_ds, 0,
-                               options=[f"COMPRESS={compress_method}",
-                                        "TILED=YES",
-                                        "BIGTIFF=YES"])
-    
-    # Fermer le premier fichier
-    src_ds = None
-    
-    # Fusionner les autres fichiers
-    for file in input_files[1:]:
-        gdal.Warp(output_file, file, format="GTiff", options=[f"COMPRESS={compress_method}"])
-    
-    # Fermer le fichier de sortie
-    dst_ds = None
-
-def process_csv(csv_filepath, no_merge=False):
-    """Traite le fichier CSV pour télécharger et fusionner les données."""
-    download_dir = os.path.dirname(csv_filepath)
-    order_name = os.path.basename(csv_filepath).split('.')[0]
-    
-    with open(csv_filepath, 'r') as file:
-        urls = file.readlines()
-    
-    downloaded_files = []
-    for i, url in enumerate(urls):
-        url = url.strip()
-        filename = os.path.join(download_dir, url.split('/')[-1])
+def create_mesh(dem, transform, resolution):
+    """
+    Crée un maillage 3D à partir des données du MNT.
+    
+    Args:
+        dem (numpy.array): Données du MNT
+        transform (affine.Affine): Transformation géospatiale
+        resolution (int): Résolution du maillage
+    
+    Returns:
+        trimesh.Trimesh: Maillage 3D
+    """
+    try:
+        height, width = dem.shape
+        x, y = np.meshgrid(np.arange(width), np.arange(height))
+        lon, lat = rasterio.transform.xy(transform, y, x)
         
-        if not os.path.isfile(filename):
-            st.text(f"Téléchargement du fichier : {i+1} sur {len(urls)}")
-            urllib.request.urlretrieve(url, filename)
+        vertices = np.column_stack((lon.flatten(), lat.flatten(), dem.flatten()))
+        faces = []
+        for i in range(height - 1):
+            for j in range(width - 1):
+                idx = i * width + j
+                faces.append([idx, idx + 1, idx + width])
+                faces.append([idx + 1, idx + width + 1, idx + width])
         
-        downloaded_files.append(filename)
-    
-    if not no_merge:
-        output_file = os.path.join(download_dir, f"{order_name}_merged.tif")
-        st.text("Fusion des fichiers téléchargés...")
-        merge_rasters(downloaded_files, output_file)
-        st.text(f"Résultat fusionné dans : {output_file}")
-    else:
-        st.text(f"Fichiers téléchargés dans : {download_dir}")
-    
-    return output_file if not no_merge else download_dir
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+        
+        target_faces = (height * width) // (resolution ** 2)
+        mesh = mesh.simplify_quadric_decimation(target_faces)
+        
+        return mesh
+    except Exception as e:
+        logger.error(f"Erreur lors de la création du maillage: {str(e)}")
+        st.error("Erreur lors de la création du maillage. Veuillez vérifier les paramètres.")
+        return None
 
-# Interface utilisateur Streamlit
-def main():
-    st.title("SwissTopo Downloader")
-    
-    # Sélection du produit
-    selected_product = st.selectbox("Sélectionnez un produit", list(PRODUCTS.keys()))
-    
-    # Carte interactive pour dessiner la bbox
-    st.subheader("Dessinez une boîte englobante sur la carte")
+def visualize_mesh(mesh):
+    """
+    Crée une visualisation du maillage.
+    
+    Args:
+        mesh (trimesh.Trimesh): Maillage 3D à visualiser
+    
+    Returns:
+        matplotlib.figure.Figure: Figure contenant la visualisation du maillage
+    """
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.mplot3d import Axes3D
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot_trisurf(mesh.vertices[:, 0], mesh.vertices[:, 1], mesh.vertices[:, 2], 
+                    triangles=mesh.faces, cmap='viridis')
+    ax.set_xlabel('X')
+    ax.set_ylabel('Y')
+    ax.set_zlabel('Z')
+    return fig
+
+def export_for_blender(mesh):
+    """
+    Exporte le maillage dans un format compatible avec Blender.
+    
+    Args:
+        mesh (trimesh.Trimesh): Maillage 3D à exporter
+    
+    Returns:
+        bytes: Contenu du fichier d'export
+    """
+    try:
+        obj_file = BytesIO()
+        mesh.export(obj_file, file_type='obj')
+        return obj_file.getvalue()
+    except Exception as e:
+        logger.error(f"Erreur lors de l'export pour Blender: {str(e)}")
+        st.error("Erreur lors de l'export pour Blender. Veuillez réessayer.")
+        return None
+
+# Interface Streamlit
+st.title("Mesh Tiler CH - Streamlit Edition")
+st.write("Sélectionnez une zone en Suisse pour créer un maillage 3D.")
+
+# Chargement du MNT complet de la Suisse
+swiss_dem, swiss_transform = load_swiss_dem()
+
+# Sélection de la méthode d'entrée
+input_method = st.radio("Choisissez la méthode de sélection de la zone :", 
+                        ("Dessiner sur la carte", "Entrer les coordonnées"))
+
+if input_method == "Dessiner sur la carte":
+    # Créer une carte centrée sur la Suisse
     m = folium.Map(location=[46.8182, 8.2275], zoom_start=8)
-    draw = Draw(
-        draw_options={
-            'rectangle': True,
-            'polygon': False,
-            'polyline': False,
-            'circle': False,
-            'marker': False,
-            'circlemarker': False,
-        },
-        edit_options={'edit': False}
-    )
-    draw.add_to(m)
-    
-    output = folium_static(m)
     
-    # Récupération des coordonnées de la bbox
-    bbox_coords = None
-    if 'last_active_drawing' in st.session_state:
-        bbox = st.session_state.last_active_drawing['geometry']['coordinates'][0]
-        lons = [coord[0] for coord in bbox]
-        lats = [coord[1] for coord in bbox]
-        bbox_coords = [min(lons), min(lats), max(lons), max(lats)]
-        st.write(f"Coordonnées de la bbox : {bbox_coords}")
+    # Ajouter un outil de dessin de rectangle
+    draw = folium.plugins.Draw(export=True)
+    draw.add_to(m)
     
-    # Options
-    no_merge = st.checkbox("Ne pas fusionner les fichiers téléchargés")
+    # Afficher la carte
+    folium_static(m)
     
-    if st.button("Télécharger") and bbox_coords:
-        product = PRODUCTS[selected_product]
-        csv_filepath = create_csv(product, *bbox_coords)
-        result = process_csv(csv_filepath, no_merge)
-        st.success(f"Téléchargement terminé ! Résultat : {result}")
-    elif st.button("Télécharger") and not bbox_coords:
-        st.error("Veuillez dessiner une boîte englobante sur la carte avant de télécharger.")
+    # Récupérer les coordonnées du rectangle dessiné
+    if st.button("Créer le maillage à partir de la sélection"):
+        # Ici, vous devriez récupérer les coordonnées du rectangle dessiné
+        # Cette partie nécessite une implémentation plus avancée avec JavaScript
+        st.write("Fonctionnalité en cours de développement.")
+        
+else:
+    # Entrer les coordonnées manuellement
+    col1, col2 = st.columns(2)
+    with col1:
+        minx = st.number_input("Min X", value=7.0)
+        miny = st.number_input("Min Y", value=46.0)
+    with col2:
+        maxx = st.number_input("Max X", value=8.0)
+        maxy = st.number_input("Max Y", value=47.0)
+    
+    if st.button("Créer le maillage"):
+        bbox = (minx, miny, maxx, maxy)
+        dem_region, region_transform = extract_dem_region(swiss_dem, swiss_transform, bbox)
+        
+        resolution = st.slider("Résolution du maillage", min_value=1, max_value=100, value=10)
+        mesh = create_mesh(dem_region, region_transform, resolution)
+        
+        if mesh is not None:
+            fig = visualize_mesh(mesh)
+            st.pyplot(fig)
+            
+            if st.button("Exporter pour Blender"):
+                blender_file = export_for_blender(mesh)
+                if blender_file is not None:
+                    st.download_button("Télécharger le fichier Blender (.obj)", 
+                                       blender_file, 
+                                       file_name="mesh_export.obj", 
+                                       mime="application/octet-stream")
+
+# Guide d'utilisation simplifié
+st.markdown("""
+## Guide d'utilisation
+
+1. Choisissez entre dessiner sur la carte ou entrer les coordonnées manuellement.
+2. Sélectionnez la zone d'intérêt en Suisse.
+3. Cliquez sur "Créer le maillage" pour générer le modèle 3D.
+4. Ajustez la résolution du maillage si nécessaire.
+5. Visualisez le maillage 3D généré.
+6. Exportez le maillage au format OBJ pour Blender si souhaité.
 
-if __name__ == "__main__":
-    main()
+Pour toute question ou problème, n'hésitez pas à contacter le support technique.
+""")