Update pages/5_📍_VertXtractor.py

pages/5_📍_VertXtractor.py

@@ -1,110 +1,172 @@
 import streamlit as st
-import requests
 import folium
 from streamlit_folium import folium_static
-import geopandas as gpd
+from folium.plugins import Draw
+import requests
 import rasterio
 from rasterio.merge import merge
-import os
 import tempfile
-import zipfile
+import os
 from io import BytesIO
+import json
+from shapely.geometry import box
+import geopandas as gpd
 
-# Configurations et constantes
-STAC_API_URL = "https://data.geo.admin.ch/api/stac/v0.9/collections/"
-PRODUCTS = {
-    'Photo aérienne 10cm': 'ch.swisstopo.swissimage-dop10',
-    'Carte nationale 1:10 000': 'ch.swisstopo.landeskarte-farbe-10',
-    'Carte nationale 1:25 000': 'ch.swisstopo.pixelkarte-farbe-pk25.noscale',
-    'Carte nationale 1:50 000': 'ch.swisstopo.pixelkarte-farbe-pk50.noscale',
-    'Carte nationale 1:100 000': 'ch.swisstopo.pixelkarte-farbe-pk100.noscale',
-    'Carte nationale 1:200 000': 'ch.swisstopo.pixelkarte-farbe-pk200.noscale',
-    'Modèle numérique de terrain': 'ch.swisstopo.swissalti3d',
-}
+# Configuration de la page Streamlit
+st.set_page_config(layout="wide", page_title="SwissTopoBatchNMerge")
+st.title("SwissTopoBatchNMerge Streamlit")
 
-@st.cache_data
-def get_items(product_name, bbox):
-    """Récupère les éléments pour une zone d'intérêt (AOI)."""
-    url = f"{STAC_API_URL}{product_name}/items?bbox={bbox}"
+# Fonction pour télécharger les données depuis une URL
+def download_data(url):
     response = requests.get(url)
     if response.status_code == 200:
-        items = response.json().get('features', [])
-        return [item['assets']['data']['href'] for item in items if 'data' in item['assets']]
+        return BytesIO(response.content)
+    else:
+        st.error(f"Erreur lors du téléchargement: {response.status_code}")
+        return None
+
+# Fonction pour fusionner les tuiles raster
+def merge_tiles(files):
+    src_files_to_mosaic = []
+    for file in files:
+        src = rasterio.open(file)
+        src_files_to_mosaic.append(src)
+    mosaic, out_trans = merge(src_files_to_mosaic)
+    return mosaic, out_trans
+
+# Fonction pour obtenir les liens de téléchargement des tuiles de l'API swisstopo
+def get_swisstopo_tiles(bbox, product):
+    # URL de l'API d'identification de swisstopo
+    api_url = "https://api3.geo.admin.ch/rest/services/api/MapServer/identify"
+    
+    # Paramètres de la requête
+    params = {
+        'geometry': f"{bbox[0]},{bbox[1]},{bbox[2]},{bbox[3]}",
+        'geometryType': 'esriGeometryEnvelope',
+        'imageDisplay': '1000,1000,96',
+        'mapExtent': f"{bbox[0]},{bbox[1]},{bbox[2]},{bbox[3]}",
+        'tolerance': '0',
+        'layers': 'all:' + product,
+        'sr': '4326'
+    }
+    
+    # Envoi de la requête à l'API
+    response = requests.get(api_url, params=params)
+    
+    if response.status_code == 200:
+        data = response.json()
+        # Extraction des liens de téléchargement des résultats
+        return [result['attributes']['download'] for result in data['results'] if 'download' in result['attributes']]
     else:
-        st.error(f"Erreur lors de la récupération des éléments: {response.status_code}")
+        st.error(f"Erreur lors de la requête à l'API: {response.status_code}")
         return []
 
-def download_and_merge(urls):
-    """Télécharge et fusionne les tuiles raster."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        files = []
-        for url in urls:
-            response = requests.get(url)
-            if response.status_code == 200:
-                file_path = os.path.join(tmpdir, os.path.basename(url))
-                with open(file_path, 'wb') as f:
-                    f.write(response.content)
-                files.append(file_path)
-        
-        if files:
-            src_files_to_mosaic = [rasterio.open(fp) for fp in files]
-            mosaic, out_trans = merge(src_files_to_mosaic)
-            
-            out_meta = src_files_to_mosaic[0].meta.copy()
-            out_meta.update({
-                "driver": "GTiff",
-                "height": mosaic.shape[1],
-                "width": mosaic.shape[2],
-                "transform": out_trans
-            })
-            
-            merged_file = BytesIO()
-            with rasterio.MemoryFile(merged_file) as memfile:
-                with memfile.open(**out_meta) as dest:
-                    dest.write(mosaic)
-            
-            merged_file.seek(0)
-            return merged_file
-    return None
+# Création de la carte Folium centrée sur la Suisse
+m = folium.Map(location=[46.8182, 8.2275], zoom_start=8)
 
-def main():
-    st.title("Téléchargeur de cartes SwissTopo")
+# Ajout d'un contrôle de dessin à la carte
+draw = Draw(
+    draw_options={
+        'rectangle': True,
+        'polygon': False,
+        'polyline': False,
+        'circle': False,
+        'marker': False,
+        'circlemarker': False,
+    },
+    edit_options={'edit': False}
+)
+m.add_child(draw)
 
-    # Sélection du produit
-    product = st.selectbox("Choisissez un produit", list(PRODUCTS.keys()))
+# Affichage de la carte dans Streamlit
+map_data = folium_static(m, width=700, height=500)
 
-    # Carte pour sélectionner la bbox
-    m = folium.Map(location=[46.8182, 8.2275], zoom_start=8)
-    draw = folium.plugins.Draw(export=True)
-    draw.add_to(m)
-    folium_static(m)
+# Sélection du produit swisstopo
+product = st.selectbox(
+    "Choisissez un produit",
+    ["ch.swisstopo.swissimage-dop10", "ch.swisstopo.swissalti3d"],
+    help="Sélectionnez le type de données que vous souhaitez télécharger"
+)
 
-    # Récupération de la bbox dessinée
-    bbox = None
-    if 'last_active_drawing' in st.session_state:
-        bbox_coords = st.session_state.last_active_drawing['geometry']['coordinates'][0]
-        bbox = f"{bbox_coords[0][0]},{bbox_coords[0][1]},{bbox_coords[2][0]},{bbox_coords[2][1]}"
-        st.write(f"Zone sélectionnée : {bbox}")
+# Vérification si une boîte de sélection a été dessinée
+if 'last_active_drawing' in st.session_state:
+    # Extraction des coordonnées de la boîte de sélection
+    bbox = st.session_state.last_active_drawing['geometry']['coordinates'][0]
+    bbox = [coord for sublist in bbox[:-1] for coord in sublist]
+    st.write(f"Boîte de sélection : {bbox}")
 
-    if st.button("Télécharger") and bbox:
-        with st.spinner("Téléchargement en cours..."):
-            urls = get_items(PRODUCTS[product], bbox)
-            if urls:
-                merged_file = download_and_merge(urls)
-                if merged_file:
-                    st.success("Fusion des fichiers réussie !")
-                    st.download_button(
-                        label="Télécharger la carte fusionnée",
-                        data=merged_file,
-                        file_name="carte_fusionnee.tif",
+    if st.button("Télécharger et fusionner"):
+        with st.spinner("Récupération des liens de téléchargement..."):
+            urls = get_swisstopo_tiles(bbox, product)
+        
+        if urls:
+            with st.spinner("Téléchargement des tuiles..."):
+                temp_dir = tempfile.mkdtemp()
+                files = []
+                for i, url in enumerate(urls):
+                    file = download_data(url)
+                    if file:
+                        file_path = os.path.join(temp_dir, f"tile_{i}.tif")
+                        with open(file_path, "wb") as f:
+                            f.write(file.getvalue())
+                        files.append(file_path)
+            
+            if files:
+                with st.spinner("Fusion des tuiles..."):
+                    mosaic, out_trans = merge_tiles(files)
+                
+                st.success("Traitement terminé !")
+                
+                # Sauvegarde du résultat fusionné
+                output_path = os.path.join(temp_dir, "result.tif")
+                with rasterio.open(output_path, 'w', **mosaic.profile) as dst:
+                    dst.write(mosaic)
+                
+                # Proposition de téléchargement du résultat
+                with open(output_path, "rb") as file:
+                    btn = st.download_button(
+                        label="Télécharger le résultat",
+                        data=file,
+                        file_name="merged_result.tif",
                         mime="image/tiff"
                     )
-                else:
-                    st.error("Erreur lors de la fusion des fichiers.")
             else:
-                st.warning("Aucune donnée trouvée pour cette zone.")
-    elif not bbox:
-        st.info("Veuillez dessiner une zone sur la carte avant de télécharger.")
+                st.error("Échec du téléchargement des tuiles.")
+        else:
+            st.error("Aucune tuile trouvée pour la zone sélectionnée.")
+else:
+    st.write("Veuillez dessiner une boîte de sélection sur la carte.")
+
+# JavaScript pour récupérer les coordonnées de la boîte dessinée
+st.components.v1.html(
+    """
+    <script>
+    const map = document.getElementsByClassName('folium-map')[0];
+    map.addEventListener('draw:created', function(e) {
+        const type = e.layerType;
+        const layer = e.layer;
+        if (type === 'rectangle') {
+            const bounds = layer.getBounds();
+            const coordinates = [
+                bounds.getSouthWest().lng, bounds.getSouthWest().lat,
+                bounds.getNorthEast().lng, bounds.getNorthEast().lat
+            ];
+            window.parent.postMessage({
+                type: 'drawing',
+                coordinates: coordinates
+            }, '*');
+        }
+    });
+    </script>
+    """,
+    height=0,
+)
+
+# Gestion des événements de dessin
+if 'last_active_drawing' not in st.session_state:
+    st.session_state.last_active_drawing = None
 
-if __name__ == "__main__":
-    main()
+for event in st.session_state.get("events", []):
+    if event.type == 'drawing':
+        st.session_state.last_active_drawing = event.data
+        st.experimental_rerun()