Update pages/12_🌲_VertXtractor.py

pages/12_🌲_VertXtractor.py

@@ -6,10 +6,6 @@ from folium.plugins import Draw
 import requests
 from shapely.geometry import box
 import json
-import io
-import rasterio
-from rasterio.io import MemoryFile
-import numpy as np
 
 st.set_page_config(layout="wide", page_title="Extracteur de données géospatiales")
 
@@ -42,76 +38,34 @@ def create_geojson_from_box(bbox):
     return json.loads(gdf.to_json()), json.loads(gdf.to_crs("EPSG:2056").to_json())
 
 @st.cache_data
-def extract_swisstopo_data(bbox, layer_id, layer_type):
-    api_url = f"https://data.geo.admin.ch/api/stac/v0.9/collections/{layer_id}/items"
-    params = {"bbox": ",".join(map(str, bbox)), "limit": 1}
-    try:
+def get_download_url(bbox, layer_info):
+    if layer_info["source"] == "swisstopo":
+        api_url = f"https://data.geo.admin.ch/api/stac/v0.9/collections/{layer_info['id']}/items"
+        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']:
             feature = data['features'][0]
             asset_keys = feature['assets'].keys()
             data_key = 'rgb' if 'rgb' in asset_keys else 'data' if 'data' in asset_keys else next(iter(asset_keys))
-            data_url = feature['assets'][data_key]['href']
-            return requests.get(data_url).content
-    except requests.RequestException as e:
-        st.error(f"Erreur Swisstopo: {str(e)}")
+            return feature['assets'][data_key]['href']
+    else:  # ESRI
+        service_url = f"https://services.arcgisonline.com/arcgis/rest/services/{layer_info['id']}/MapServer/export"
+        params = {
+            "bbox": f"{bbox[0]},{bbox[1]},{bbox[2]},{bbox[3]}",
+            "bboxSR": 4326,
+            "size": "1000,1000",
+            "format": "png",
+            "f": "html",
+            "imageSR": 4326,
+            "transparent": "true"
+        }
+        return f"{service_url}?{'&'.join([f'{k}={v}' for k, v in params.items()])}"
     return None
 
-@st.cache_data
-def extract_esri_data(bbox, layer_id, layer_type):
-    service_url = f"https://services.arcgisonline.com/arcgis/rest/services/{layer_id}/MapServer/export"
-    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 ESRI: {str(e)}")
-    return None
-
-def process_and_display_data(data, layer_name, layer_type):
-    if data is None:
-        st.warning(f"Pas de données pour {layer_name}")
-        return
-    try:
-        with MemoryFile(data) as memfile:
-            with memfile.open() as src:
-                image = src.read()
-                if image.shape[0] == 3:
-                    image = np.transpose(image, (1, 2, 0))
-                elif image.shape[0] == 1:
-                    image = image[0]
-                
-                st.image(image, caption=layer_name, use_column_width=True)
-                
-                output = io.BytesIO()
-                with MemoryFile(output) as memfile:
-                    with memfile.open(**src.profile) as dst:
-                        dst.write(src.read())
-                
-                st.download_button(
-                    label=f"Télécharger {layer_name} (GeoTIFF)",
-                    data=output.getvalue(),
-                    file_name=f"{layer_name.lower().replace(' ', '_')}.tif",
-                    mime="image/tiff"
-                )
-    except Exception as e:
-        st.error(f"Erreur de traitement pour {layer_name}: {str(e)}")
-
 def main():
     st.title("Extracteur de données Swisstopo et ESRI")
 
-    if 'selected_layers' not in st.session_state:
-        st.session_state.selected_layers = set()
-
     col1, col2 = st.columns([1, 3])
 
     with col1:
@@ -120,11 +74,7 @@ def main():
         
         layers = SWISSTOPO_LAYERS if source == "Swisstopo" else ESRI_LAYERS
         
-        for layer_name in layers:
-            if st.checkbox(layer_name, value=layer_name in st.session_state.selected_layers):
-                st.session_state.selected_layers.add(layer_name)
-            else:
-                st.session_state.selected_layers.discard(layer_name)
+        selected_layers = st.multiselect("Couches à extraire", list(layers.keys()))
         
         st.markdown("---")
         st.markdown("## À propos\nExtracteur de données géospatiales Swisstopo et ESRI.\nDéveloppé par Vertdure")
@@ -157,20 +107,22 @@ def main():
                 st.session_state['geojson_swiss'] = json.loads(gdf.to_crs(2056).to_json())
                 st.success("GeoJSON chargé!")
 
-        if st.button("Extraire les données"):
+        if st.button("Obtenir les liens de téléchargement"):
             if 'geojson_wgs84' not in st.session_state or 'geojson_swiss' not in st.session_state:
                 st.error("Définissez d'abord une zone d'intérêt.")
-            elif not st.session_state.selected_layers:
+            elif not selected_layers:
                 st.error("Sélectionnez au moins une couche à extraire.")
             else:
-                with st.spinner("Extraction des données en cours..."):
-                    for layer_name in st.session_state.selected_layers:
-                        layer_info = SWISSTOPO_LAYERS.get(layer_name) or ESRI_LAYERS.get(layer_name)
-                        bbox = gpd.GeoDataFrame.from_features(st.session_state['geojson_swiss' if layer_info["source"] == "swisstopo" else 'geojson_wgs84']).total_bounds
-                        st.info(f"Traitement de la couche : {layer_name}")
-                        data = extract_swisstopo_data(bbox, layer_info["id"], layer_info["type"]) if layer_info["source"] == "swisstopo" else extract_esri_data(bbox, layer_info["id"], layer_info["type"])
-                        process_and_display_data(data, layer_name, layer_info["type"])
-                st.success("Extraction terminée !")
+                for layer_name in selected_layers:
+                    layer_info = layers[layer_name]
+                    bbox = gpd.GeoDataFrame.from_features(st.session_state['geojson_swiss' if layer_info["source"] == "swisstopo" else 'geojson_wgs84']).total_bounds
+                    st.write(f"Traitement de la couche : {layer_name}")
+                    st.write(f"Bbox : {bbox}")
+                    download_url = get_download_url(bbox, layer_info)
+                    if download_url:
+                        st.markdown(f"[Télécharger {layer_name}]({download_url})")
+                    else:
+                        st.error(f"Impossible d'obtenir le lien pour {layer_name}")
 
 if __name__ == "__main__":
     main()