Update pages/12_🌲_VertXtractor.py

pages/12_🌲_VertXtractor.py

@@ -3,56 +3,117 @@ import geopandas as gpd
 import folium
 from streamlit_folium import folium_static, st_folium
 from folium.plugins import Draw
-from shapely.geometry import box, shape
 import requests
 from io import BytesIO
 from PIL import Image
-import pyproj
+from shapely.geometry import box
 
-# ... (le reste du code reste inchangé)
+# Liste des couches disponibles
+LAYERS = {
+    "Swisstopo - SWISSIMAGE 10 cm": {"id": "ch.swisstopo.swissimage-dop10", "source": "swisstopo"},
+    "Swisstopo - Carte nationale 1:25'000": {"id": "ch.swisstopo.pixelkarte-farbe-pk25.noscale", "source": "swisstopo"},
+    "Swisstopo - Modèle numérique de terrain": {"id": "ch.swisstopo.swissalti3d", "source": "swisstopo"},
+    "ESRI - World Imagery": {"id": "esri_world_imagery", "source": "esri"},
+    "ESRI - World Elevation": {"id": "esri_world_elevation", "source": "esri"}
+}
+
+def draw_box_on_map():
+    m = folium.Map(location=[46.8, 8.2], zoom_start=8)
+    draw = Draw(
+        draw_options={
+            'polyline': False,
+            'polygon': False,
+            'circle': False,
+            'marker': False,
+            'circlemarker': False,
+        },
+        edit_options={'edit': False}
+    )
+    draw.add_to(m)
+
+    output = st_folium(m, width=700, height=500)
+
+    if output['last_active_drawing']:
+        coords = output['last_active_drawing']['geometry']['coordinates'][0]
+        return box(min(c[0] for c in coords), min(c[1] for c in coords),
+                   max(c[0] for c in coords), max(c[1] for c in coords))
+    return None
+
+def create_geojson_from_box(bbox):
+    gdf = gpd.GeoDataFrame({'geometry': [bbox]}, crs="EPSG:4326")
+    gdf_swiss = gdf.to_crs("EPSG:2056")
+    gdf['geometry_swiss'] = gdf_swiss['geometry']
+    return gdf
+
+def extract_swisstopo_data(bbox, layer_id):
+    api_url = f"https://data.geo.admin.ch/api/stac/v0.9/collections/{layer_id}/items"
+    params = {"bbox": ",".join(map(str, bbox)), "limit": 100}
+    
+    response = requests.get(api_url, params=params)
+    response.raise_for_status()
+    
+    data = response.json()
+    if data['features']:
+        return gpd.GeoDataFrame.from_features(data['features'])
+    return None
+
+def extract_esri_data(bbox, layer_id):
+    # Placeholder pour l'extraction des données ESRI
+    st.warning("L'extraction des données ESRI n'est pas implémentée dans cet exemple")
+    return None
 
 def main():
-    # ... (le reste du code reste inchangé jusqu'à la partie de visualisation)
+    st.title("Extracteur de données Swisstopo et ESRI")
 
-    if st.button("Extraire les données"):
-        with st.spinner("Extraction des données en cours..."):
-            try:
-                gdf = extract_stac_data(min_x, min_y, max_x, max_y, collection, input_crs)
+    # Étape 1: Dessiner la boîte de sélection
+    st.subheader("Étape 1: Dessiner la zone d'intérêt")
+    bbox = draw_box_on_map()
+
+    if bbox:
+        st.success("Zone sélectionnée avec succès!")
+        gdf = create_geojson_from_box(bbox)
+
+        # Affichage de la carte avec la boîte dessinée
+        m = folium.Map()
+        folium.GeoJson(gdf).add_to(m)
+        m.fit_bounds(m.get_bounds())
+        folium_static(m)
+
+        # Étape 2: Sélection des couches
+        st.subheader("Étape 2: Sélection des couches")
+        selected_layers = st.multiselect("Sélectionnez les couches à extraire", list(LAYERS.keys()))
+
+        if st.button("Extraire les données"):
+            for layer_name in selected_layers:
+                layer_info = LAYERS[layer_name]
                 
-                if gdf is not None:
-                    st.subheader("Aperçu des données")
-                    st.write(gdf.head())
-                    
-                    st.subheader("Visualisation des données")
-                    gdf_wgs84 = gdf.to_crs(epsg=4326)
-                    
-                    # Calcul du centre de la carte en utilisant total_bounds
-                    bounds = gdf_wgs84.total_bounds
-                    center_lat = (bounds[1] + bounds[3]) / 2
-                    center_lon = (bounds[0] + bounds[2]) / 2
-                    
-                    m = folium.Map(location=[center_lat, center_lon], zoom_start=12)
-                    folium.GeoJson(gdf_wgs84).add_to(m)
-                    folium_static(m)
-                    
-                    # Téléchargement des données
-                    if "swissimage" in collection:
-                        if 'assets' in gdf.iloc[0] and 'rgb' in gdf.iloc[0]['assets']:
-                            image_url = gdf.iloc[0]['assets']['rgb']['href']
-                            st.markdown(f"[Télécharger l'image]({image_url})")
-                    else:
-                        st.download_button(
-                            label="Télécharger les données (GeoJSON)",
-                            data=gdf.to_json(),
-                            file_name=f"{selected_collection.lower().replace(' ', '_')}.geojson",
-                            mime="application/json"
-                        )
+                # Choix des coordonnées en fonction de la source
+                if layer_info["source"] == "swisstopo":
+                    bbox = gdf['geometry_swiss'].total_bounds
+                else:  # ESRI
+                    bbox = gdf['geometry'].total_bounds
+
+                st.write(f"Extraction de {layer_name}...")
                 
-                st.success("Extraction terminée avec succès!")
-            except Exception as e:
-                st.error(f"Une erreur s'est produite : {str(e)}")
+                if layer_info["source"] == "swisstopo":
+                    data = extract_swisstopo_data(bbox, layer_info["id"])
+                else:
+                    data = extract_esri_data(bbox, layer_info["id"])
+
+                if data is not None:
+                    st.write(data.head())
+                    st.download_button(
+                        label=f"Télécharger {layer_name} (GeoJSON)",
+                        data=data.to_json(),
+                        file_name=f"{layer_name.lower().replace(' ', '_')}.geojson",
+                        mime="application/json"
+                    )
+                else:
+                    st.warning(f"Aucune donnée trouvée pour {layer_name}")
 
-    # ... (le reste du code reste inchangé)
+    st.sidebar.markdown("## À propos")
+    st.sidebar.markdown("Cet outil permet d'extraire des données géospatiales de Swisstopo et ESRI.")
+    st.sidebar.markdown("Développé par Vertdure")
 
 if __name__ == "__main__":
     main()