Update pages/12_🌲_VertXtractor.py

pages/12_🌲_VertXtractor.py

@@ -2,99 +2,114 @@ import streamlit as st
 import geopandas as gpd
 import folium
 from streamlit_folium import folium_static
+from shapely.geometry import box
 import requests
+import json
 from io import BytesIO
+import zipfile
 from PIL import Image
-import tempfile
+import numpy as np
 
-st.set_page_config(layout="wide", page_title="GeoJSON Orthophoto Downloader")
+# Liste des couches de données Swisstopo
+LAYERS = {
+    "Bâtiments": "ch.swisstopo.vec25-gebaeude",
+    "Réseau hydrographique": "ch.swisstopo.vec25-gewaessernetz",
+    "Réseau routier": "ch.swisstopo.vec25-strassen",
+    "Couverture du sol": "ch.swisstopo.vec25-landesbedeckung",
+    "Limites administratives": "ch.swisstopo.swissboundaries3d",
+    "Modèle numérique de terrain": "ch.swisstopo.swissalti3d",
+    "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",
+    "Orthophoto SWISSIMAGE": "ch.swisstopo.swissimage-product",
+    "Noms géographiques": "ch.swisstopo.swissnames3d",
+}
 
-st.title("GeoJSON Orthophoto Downloader")
-
-@st.cache_data
-def get_swisstopo_layers():
-    url = "https://api3.geo.admin.ch/rest/services/api/MapServer"
-    response = requests.get(url)
-    if response.status_code == 200:
-        layers = response.json()
-        return {layer['layerBodId']: layer['layerName'] for layer in layers['layers']}
-    return {}
-
-swisstopo_layers = get_swisstopo_layers()
-
-# File uploader for GeoJSON
-uploaded_file = st.file_uploader("Choose a GeoJSON file", type="geojson")
-
-if uploaded_file is not None:
-    # Read the GeoJSON file
-    gdf = gpd.read_file(uploaded_file)
-    
-    # Get the bounding box
-    minx, miny, maxx, maxy = gdf.total_bounds
+# Fonction pour extraire les données Swisstopo
+def extract_swisstopo_data(min_x, min_y, max_x, max_y, layer):
+    bbox = box(min_x, min_y, max_x, max_y)
+    api_url = "https://api3.geo.admin.ch/rest/services/api/MapServer/identify"
     
-    # Create a map centered on the GeoJSON data
-    m = folium.Map(location=[(miny+maxy)/2, (minx+maxx)/2], zoom_start=10)
+    params = {
+        "geometry": f"{bbox.bounds[0]},{bbox.bounds[1]},{bbox.bounds[2]},{bbox.bounds[3]}",
+        "geometryType": "esriGeometryEnvelope",
+        "layers": f"all:{layer}",
+        "mapExtent": f"{bbox.bounds[0]},{bbox.bounds[1]},{bbox.bounds[2]},{bbox.bounds[3]}",
+        "imageDisplay": "1000,1000,96",
+        "tolerance": "0",
+        "lang": "fr",
+        "sr": "2056"
+    }
     
-    # Add GeoJSON to the map
-    folium.GeoJson(gdf).add_to(m)
+    response = requests.get(api_url, params=params)
+    response.raise_for_status()
     
-    # Fit the map to the GeoJSON bounds
-    m.fit_bounds([[miny, minx], [maxy, maxx]])
+    data = response.json()
+    features = [feature["geometry"] for feature in data["results"]]
     
-    # Display the map
-    folium_static(m)
-    
-    # Choose the map provider
-    provider = st.selectbox("Choose map provider", ["ESRI World Imagery", "Swisstopo"])
-    
-    if provider == "Swisstopo":
-        selected_layer = st.selectbox("Choose Swisstopo layer", list(swisstopo_layers.keys()), format_func=lambda x: swisstopo_layers[x])
-    
-    if st.button("Download Orthophoto"):
-        if provider == "ESRI World Imagery":
-            # ESRI World Imagery WMS URL
-            wms_url = "https://services.arcgisonline.com/arcgis/rest/services/World_Imagery/MapServer/export"
-            
-            # Parameters for the WMS request
-            params = {
-                'bbox': f"{minx},{miny},{maxx},{maxy}",
-                'bboxSR': 4326,
-                'imageSR': 4326,
-                'size': '1000,1000',
-                'format': 'png',
-                'f': 'image'
-            }
-            
-            # Make the request
-            response = requests.get(wms_url, params=params)
-            
-        elif provider == "Swisstopo":
-            # Swisstopo MapServer URL
-            mapserver_url = f"https://api3.geo.admin.ch/rest/services/api/MapServer/{selected_layer}/image"
-            
-            # Parameters for the MapServer request
-            params = {
-                'bbox': f"{minx},{miny},{maxx},{maxy}",
-                'imageSize': '1000,1000',
-                'format': 'png'
-            }
-            
-            # Make the request
-            response = requests.get(mapserver_url, params=params)
-        
-        if response.status_code == 200:
-            # Save the image
-            image = Image.open(BytesIO(response.content))
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_file:
-                image.save(tmp_file.name)
-                st.success(f"Image saved as {tmp_file.name}")
-            
-            # Display the downloaded image
-            st.image(image, caption=f"Downloaded {provider} Orthophoto", use_column_width=True)
-        else:
-            st.error(f"Failed to download the image. Status code: {response.status_code}")
+    gdf = gpd.GeoDataFrame.from_features(features, crs="EPSG:2056")
+    return gdf
 
-    st.write("Note: This is a demo application. For production use, please ensure you comply with the usage terms of the chosen map provider.")
+# Fonction pour télécharger l'image SWISSIMAGE (inchangée)
+def download_swissimage(min_x, min_y, max_x, max_y):
+    # ... (le code reste le même)
+
+# Interface utilisateur Streamlit
+st.title("Extracteur de données Swisstopo")
+
+# Sélection de la couche
+selected_layer_name = st.selectbox(
+    "Sélectionnez la couche de données",
+    list(LAYERS.keys())
+)
+layer = LAYERS[selected_layer_name]
+
+# Entrée des coordonnées
+col1, col2 = st.columns(2)
+with col1:
+    min_x = st.number_input("Coordonnée X minimale", value=2600000)
+    min_y = st.number_input("Coordonnée Y minimale", value=1200000)
+with col2:
+    max_x = st.number_input("Coordonnée X maximale", value=2601000)
+    max_y = st.number_input("Coordonnée Y maximale", value=1201000)
+
+if st.button("Extraire les données"):
+    try:
+        # Extraction des données Swisstopo
+        gdf = extract_swisstopo_data(min_x, min_y, max_x, max_y, layer)
+        
+        # Affichage des données
+        st.subheader("Aperçu des données")
+        st.write(gdf.head())
+        
+        # Visualisation sur une carte
+        st.subheader("Visualisation des données")
+        m = folium.Map(location=[gdf.geometry.centroid.y.mean(), gdf.geometry.centroid.x.mean()], zoom_start=14)
+        folium.GeoJson(gdf).add_to(m)
+        folium_static(m)
+        
+        # Téléchargement des données
+        st.download_button(
+            label="Télécharger les données (GeoJSON)",
+            data=gdf.to_json(),
+            file_name=f"{selected_layer_name.lower().replace(' ', '_')}.geojson",
+            mime="application/json"
+        )
+        
+        # Téléchargement et affichage de l'image SWISSIMAGE
+        if layer == "ch.swisstopo.swissimage-product":
+            st.subheader("Image SWISSIMAGE")
+            image = download_swissimage(min_x, min_y, max_x, max_y)
+            if image is not None:
+                st.image(image, caption="Image SWISSIMAGE", use_column_width=True)
+            else:
+                st.warning("Aucune image SWISSIMAGE disponible pour cette zone.")
+        
+    except Exception as e:
+        st.error(f"Une erreur s'est produite : {str(e)}")
 
-else:
-    st.write("Please upload a GeoJSON file to start.")
+# Informations supplémentaires
+st.sidebar.markdown("## À propos")
+st.sidebar.markdown("Cet outil permet d'extraire des données géospatiales de Swisstopo.")
+st.sidebar.markdown("Développé par Vertdure")
+st.sidebar.markdown("[Code source](https://huggingface.co/spaces/Vertdure/Streamlit/tree/main)")