Update pages/5_📍_VertXtractor.py

pages/5_📍_VertXtractor.py

@@ -8,58 +8,40 @@ import logging
 from io import BytesIO
 import folium
 from streamlit_folium import folium_static
+from folium.plugins import Draw
+import json
 
 # Configuration du logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Fonction pour charger le MNT de la Suisse (à implémenter)
+@st.cache_data
 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
+    # Pour l'exemple, on crée un MNT fictif
+    dem = np.random.rand(1000, 1000) * 1000  # MNT fictif de 1000x1000 pixels
+    transform = rasterio.transform.from_bounds(5.9, 45.8, 10.5, 47.8, 1000, 1000)
+    return dem, transform
 
-# 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.
-
-    Args:
-        dem (numpy.array): Données du MNT complet
-        transform (affine.Affine): Transformation géospatiale
-        bbox (tuple): Boîte englobante (minx, miny, maxx, maxy)
-
-    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]))
+    window = ((min(rows), max(rows)), (min(cols), max(cols)))
     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 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
@@ -88,12 +70,6 @@ def create_mesh(dem, transform, resolution):
 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
@@ -110,12 +86,6 @@ def visualize_mesh(mesh):
 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()
@@ -126,47 +96,68 @@ def export_for_blender(mesh):
         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.")
+def main():
+    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()
+    # 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"))
+    # 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)
-    
-    # Ajouter un outil de dessin de rectangle
-    draw = folium.plugins.Draw(export=True)
-    draw.add_to(m)
-    
-    # Afficher la carte
-    folium_static(m)
-    
-    # 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.")
+    bbox_coords = None
+
+    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)
         
-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)
+        # Ajouter un outil de dessin de rectangle
+        draw = Draw(
+            draw_options={
+                'rectangle': True,
+                'polyline': False,
+                'polygon': False,
+                'circle': False,
+                'marker': False,
+                'circlemarker': False},
+            edit_options={'edit': False}
+        )
+        draw.add_to(m)
+        
+        # Afficher la carte
+        map_data = folium_static(m, width=700, height=500)
+        
+        # Récupérer les coordonnées du rectangle dessiné
+        if st.button("Créer le maillage à partir de la sélection", key="create_mesh_map"):
+            draw_data = st.session_state.get('last_active_drawing', None)
+            if draw_data:
+                bbox = draw_data['geometry']['coordinates'][0]
+                bbox_coords = (
+                    min(coord[0] for coord in bbox),
+                    min(coord[1] for coord in bbox),
+                    max(coord[0] for coord in bbox),
+                    max(coord[1] for coord in bbox)
+                )
+            else:
+                st.warning("Veuillez dessiner un rectangle sur la carte.")
+            
+    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", key="create_mesh_coords"):
+            bbox_coords = (minx, miny, maxx, maxy)
+
+    if bbox_coords:
+        dem_region, region_transform = extract_dem_region(swiss_dem, swiss_transform, bbox_coords)
         
         resolution = st.slider("Résolution du maillage", min_value=1, max_value=100, value=10)
         mesh = create_mesh(dem_region, region_transform, resolution)
@@ -175,24 +166,28 @@ else:
             fig = visualize_mesh(mesh)
             st.pyplot(fig)
             
-            if st.button("Exporter pour Blender"):
+            if st.button("Exporter pour Blender", key="export_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")
+                                       mime="application/octet-stream",
+                                       key="download_blender")
+
+    # Guide d'utilisation simplifié
+    st.markdown("""
+    ## Guide d'utilisation
 
-# 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é.
 
-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é.
+    Pour toute question ou problème, n'hésitez pas à contacter le support technique.
+    """)
 
-Pour toute question ou problème, n'hésitez pas à contacter le support technique.
-""")
+if __name__ == "__main__":
+    main()