Update pages/12_🌲_VertXtractor.py

pages/12_🌲_VertXtractor.py

@@ -6,17 +6,23 @@ from folium.plugins import Draw
 import requests
 from shapely.geometry import box
 import json
+import io
+import rasterio
+from rasterio.io import MemoryFile
+from PIL import Image
+import numpy as np
 
 # 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"}
+    "Swisstopo - SWISSIMAGE 10 cm": {"id": "ch.swisstopo.swissimage-dop10", "source": "swisstopo", "type": "image"},
+    "Swisstopo - Carte nationale 1:25'000": {"id": "ch.swisstopo.pixelkarte-farbe-pk25.noscale", "source": "swisstopo", "type": "image"},
+    "Swisstopo - Modèle numérique de terrain": {"id": "ch.swisstopo.swissalti3d", "source": "swisstopo", "type": "raster"},
+    "ESRI - World Imagery": {"id": "WorldImagery", "source": "esri", "type": "image"},
+    "ESRI - World Elevation": {"id": "WorldElevation", "source": "esri", "type": "raster"}
 }
 
 def draw_box_on_map():
+    """Permet à l'utilisateur de dessiner une boîte sur une carte Folium."""
     m = folium.Map(location=[46.8, 8.2], zoom_start=8)
     draw = Draw(
         draw_options={
@@ -32,27 +38,89 @@ def draw_box_on_map():
     return st_folium(m, width=700, height=500)
 
 def create_geojson_from_box(bbox):
+    """Crée des GeoJSON en WGS84 et LV95 à partir d'une boîte englobante."""
     gdf = gpd.GeoDataFrame({'geometry': [bbox]}, crs="EPSG:4326")
     gdf_swiss = gdf.to_crs("EPSG:2056")
     return json.loads(gdf.to_json()), json.loads(gdf_swiss.to_json())
 
-def extract_swisstopo_data(bbox, layer_id):
+def extract_swisstopo_data(bbox, layer_id, layer_type):
+    """Extrait les données Swisstopo en utilisant l'API STAC."""
     api_url = f"https://data.geo.admin.ch/api/stac/v0.9/collections/{layer_id}/items"
-    params = {"bbox": ",".join(map(str, bbox)), "limit": 100}
+    params = {"bbox": ",".join(map(str, bbox)), "limit": 1}
     
-    response = requests.get(api_url, params=params)
-    response.raise_for_status()
-    
-    data = response.json()
-    if data['features']:
-        return gpd.GeoDataFrame.from_features(data['features'])
+    try:
+        response = requests.get(api_url, params=params)
+        response.raise_for_status()
+        
+        data = response.json()
+        if data['features']:
+            feature = data['features'][0]
+            if layer_type == "image":
+                return feature['assets']['rgb']['href']
+            elif layer_type == "raster":
+                raster_url = feature['assets']['data']['href']
+                raster_response = requests.get(raster_url)
+                raster_response.raise_for_status()
+                return raster_response.content
+    except requests.RequestException as e:
+        st.error(f"Erreur lors de l'extraction des données Swisstopo: {str(e)}")
     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")
+def extract_esri_data(bbox, layer_id, layer_type):
+    """Extrait les données ESRI en utilisant les services ArcGIS REST."""
+    if layer_type == "image":
+        service_url = "https://services.arcgisonline.com/arcgis/rest/services/World_Imagery/MapServer/export"
+    elif layer_type == "raster":
+        service_url = "https://elevation.arcgis.com/arcgis/rest/services/WorldElevation/Terrain/ImageServer/exportImage"
+    
+    params = {
+        "bbox": f"{bbox[0]},{bbox[1]},{bbox[2]},{bbox[3]}",
+        "bboxSR": 4326,
+        "size": "1000,1000",
+        "format": "tiff",
+        "f": "image"
+    }
+    
+    try:
+        response = requests.get(service_url, params=params)
+        response.raise_for_status()
+        return response.content
+    except requests.RequestException as e:
+        st.error(f"Erreur lors de l'extraction des données ESRI: {str(e)}")
     return None
 
+def process_and_display_data(data, layer_name, layer_type):
+    """Traite et affiche les données extraites."""
+    if data is None:
+        st.warning(f"Aucune donnée trouvée pour {layer_name}")
+        return
+
+    if layer_type == "image":
+        try:
+            with MemoryFile(data) as memfile:
+                with memfile.open() as dataset:
+                    image_array = dataset.read()
+                    image = Image.fromarray(np.transpose(image_array, (1, 2, 0)))
+                    st.image(image, caption=layer_name, use_column_width=True)
+        except Exception as e:
+            st.error(f"Erreur lors du traitement de l'image pour {layer_name}: {str(e)}")
+    elif layer_type == "raster":
+        try:
+            with MemoryFile(data) as memfile:
+                with memfile.open() as dataset:
+                    raster_array = dataset.read(1)  # Lire le premier canal
+                    st.image(raster_array, caption=f"{layer_name} (première bande)", use_column_width=True)
+        except Exception as e:
+            st.error(f"Erreur lors du traitement du raster pour {layer_name}: {str(e)}")
+
+    # Bouton de téléchargement
+    st.download_button(
+        label=f"Télécharger {layer_name}",
+        data=data,
+        file_name=f"{layer_name.lower().replace(' ', '_')}.tif",
+        mime="application/octet-stream"
+    )
+
 def main():
     st.title("Extracteur de données Swisstopo et ESRI")
 
@@ -94,22 +162,12 @@ def main():
                     
                     if layer_info["source"] == "swisstopo":
                         bbox = gpd.GeoDataFrame.from_features(st.session_state['geojson_swiss']).total_bounds
-                        data = extract_swisstopo_data(bbox, layer_info["id"])
+                        data = extract_swisstopo_data(bbox, layer_info["id"], layer_info["type"])
                     else:  # ESRI
                         bbox = gpd.GeoDataFrame.from_features(st.session_state['geojson_wgs84']).total_bounds
-                        data = extract_esri_data(bbox, layer_info["id"])
-
-                    if data is not None:
-                        st.write(f"Données extraites pour {layer_name}:")
-                        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}")
+                        data = extract_esri_data(bbox, layer_info["id"], layer_info["type"])
+
+                    process_and_display_data(data, layer_name, layer_info["type"])
 
     st.sidebar.markdown("## À propos")
     st.sidebar.markdown("Cet outil permet d'extraire des données géospatiales de Swisstopo et ESRI.")