Update pages/12_🌲_VertXtractor.py

pages/12_🌲_VertXtractor.py

@@ -10,49 +10,39 @@ import io
 import rasterio
 from rasterio.io import MemoryFile
 import numpy as np
+import os
 
-# Configuration de la page
-st.set_page_config(layout="wide", page_title="Extracteur de données géospatiales")
+# ... (le reste des imports et la définition de LAYERS restent inchangés)
 
-# Définition des couches disponibles
-LAYERS = {
-    "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 - MNT": {"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():
-    """Crée une carte interactive pour dessiner une zone d'intérêt."""
-    m = folium.Map(location=[46.8, 8.2], zoom_start=8)
-    Draw(draw_options={'polyline': False, 'polygon': False, 'circle': False, 'marker': False, 'circlemarker': False},
-         edit_options={'edit': False}).add_to(m)
-    return st_folium(m, width=700, height=500)
-
-def create_geojson_from_box(bbox):
-    """Crée un GeoJSON à partir d'une boîte englobante."""
-    gdf = gpd.GeoDataFrame({'geometry': [bbox]}, crs="EPSG:4326")
-    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):
-    """Extrait les données de Swisstopo."""
-    api_url = f"https://data.geo.admin.ch/api/stac/v0.9/collections/{layer_id}/items"
-    params = {"bbox": ",".join(map(str, bbox)), "limit": 1}
+def process_and_save_data(data, layer_name, layer_type):
+    """Traite et sauvegarde les données extraites."""
+    if data is None:
+        st.warning(f"Pas de données pour {layer_name}")
+        return
     try:
-        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 None
+        with MemoryFile(data) as memfile:
+            with memfile.open() as src:
+                # Créer un dossier pour sauvegarder les fichiers
+                output_folder = "extracted_data"
+                os.makedirs(output_folder, exist_ok=True)
+                
+                # Nom du fichier de sortie
+                output_filename = os.path.join(output_folder, f"{layer_name.lower().replace(' ', '_')}.tif")
+                
+                # Écrire les données dans un nouveau fichier GeoTIFF
+                profile = src.profile
+                if layer_type == "image" and src.count == 4:  # Pour les images RGBA
+                    profile.update(count=3)  # On ne garde que les 3 premières bandes (RGB)
+                
+                with rasterio.open(output_filename, 'w', **profile) as dst:
+                    if layer_type == "image" and src.count == 4:
+                        dst.write(src.read()[0:3, :, :])  # Écrire seulement les bandes RGB
+                    else:
+                        dst.write(src.read())
+                
+                st.success(f"Données sauvegardées : {output_filename}")
+    except Exception as e:
+        st.error(f"Erreur de traitement pour {layer_name}: {str(e)}")
 
 @st.cache_data
 def extract_esri_data(bbox, layer_id, layer_type):
@@ -63,7 +53,8 @@ def extract_esri_data(bbox, layer_id, layer_type):
         "bboxSR": 4326,
         "size": "1000,1000",
         "format": "tiff",
-        "f": "image"
+        "f": "image",
+        "imageSR": 4326  # Ajout de cette ligne pour spécifier le système de coordonnées de l'image
     }
     try:
         response = requests.get(service_url, params=params)
@@ -73,47 +64,19 @@ def extract_esri_data(bbox, layer_id, layer_type):
         st.error(f"Erreur 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"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)}")
+# ... (le reste du code reste inchangé jusqu'à la fonction main())
 
 def main():
     st.title("Extracteur de données Swisstopo et ESRI")
 
+    # Sélecteur de couches
+    selected_layers = st.multiselect("Couches à extraire", list(LAYERS.keys()))
+
     # Création de deux colonnes
     col1, col2 = st.columns([1, 3])
 
-    # Colonne de gauche pour le sélecteur de couches
+    # Colonne de gauche pour les informations
     with col1:
-        st.subheader("Sélection des couches")
-        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")
 
@@ -149,7 +112,7 @@ def main():
                         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"])
+                        process_and_save_data(data, layer_name, layer_info["type"])
                 st.success("Extraction terminée !")
 
 if __name__ == "__main__":