Update pages/Ter.py

pages/Ter.py

@@ -1,140 +1,49 @@
-import streamlit as st
-import geopandas as gpd
-import folium
-from folium import plugins
-import requests
+import leafmap
 import numpy as np
-import plotly.graph_objects as go
-from streamlit_folium import folium_static
-import tempfile
-import os
-import uuid
-from concurrent.futures import ThreadPoolExecutor
-import time
 
-st.set_page_config(layout="wide")
-
-def uploaded_file_to_gdf(data):
-    _, file_extension = os.path.splitext(data.name)
-    file_id = str(uuid.uuid4())
-    file_path = os.path.join(tempfile.gettempdir(), f"{file_id}{file_extension}")
-    with open(file_path, "wb") as file:
-        file.write(data.getbuffer())
-    if file_path.lower().endswith(".kml"):
-        gdf = gpd.read_file(file_path, driver="KML")
-    else:
-        gdf = gpd.read_file(file_path)
-    return gdf
-
-def get_elevation(x, y):
-    url = "https://api3.geo.admin.ch/rest/services/height"
-    params = {
-        "easting": x,
-        "northing": y,
-        "sr": "2056"
+# Fonction pour calculer les coordonnées de la bbox
+def calculate_bbox(center_lat, center_lon, format, scale):
+    paper_sizes = {
+        'A4': (210, 297),
+        'A3': (297, 420),
+        'A2': (420, 594),
+        'A1': (594, 841),
+        'A0': (841, 1189)
     }
-    response = requests.get(url, params=params)
-    if response.status_code == 200:
-        data = response.json()
-        return data['height']
-    else:
+
+    size = paper_sizes.get(format)
+    if not size:
         return None
 
-def get_elevation_data(bbox, resolution=0.5):
-    x_min, y_min, x_max, y_max = bbox
-    width = int((x_max - x_min) / resolution)
-    height = int((y_max - y_min) / resolution)
-    x_coords = np.linspace(x_min, x_max, width)
-    y_coords = np.linspace(y_min, y_max, height)
-    
-    elevation_data = np.zeros((height, width))
-    
-    total_points = width * height
-    points_processed = 0
-    
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-    
-    with ThreadPoolExecutor(max_workers=20) as executor:
-        futures = []
-        for i, y in enumerate(y_coords):
-            for j, x in enumerate(x_coords):
-                futures.append(executor.submit(get_elevation, x, y))
-        
-        start_time = time.time()
-        for i, future in enumerate(futures):
-            row = i // width
-            col = i % width
-            elevation_data[row, col] = future.result() if future.result() is not None else 0
-            
-            points_processed += 1
-            if points_processed % 100 == 0:
-                progress = points_processed / total_points
-                progress_bar.progress(progress)
-                elapsed_time = time.time() - start_time
-                estimated_total_time = elapsed_time / progress
-                remaining_time = estimated_total_time - elapsed_time
-                status_text.text(f"Traitement : {points_processed}/{total_points} points. Temps restant estimé : {remaining_time:.2f} secondes")
+    width_mm, height_mm = size
+    width_m = (width_mm / 1000) * scale
+    height_m = (height_mm / 1000) * scale
+
+    bounds = [
+        [center_lat - (height_m / 2) / 111320, center_lon - (width_m / 2) / (111320 * np.cos(center_lat * np.pi / 180))],
+        [center_lat + (height_m / 2) / 111320, center_lon + (width_m / 2) / (111320 * np.cos(center_lat * np.pi / 180))]
+    ]
+
+    return bounds
 
-    return elevation_data
+# Créer une carte centrée sur la Suisse
+m = leafmap.Map(center=[46.8182, 8.2275], zoom=8)
 
-def create_3d_terrain(elevation_data, bbox):
-    x_min, y_min, x_max, y_max = bbox
-    x = np.linspace(x_min, x_max, elevation_data.shape[1])
-    y = np.linspace(y_max, y_min, elevation_data.shape[0])
-    x, y = np.meshgrid(x, y)
-    fig = go.Figure(data=[go.Surface(z=elevation_data, x=x, y=y)])
-    fig.update_layout(title='Visualisation 3D du Terrain', autosize=True,
-                      scene=dict(
-                          aspectmode='manual',
-                          aspectratio=dict(x=1, y=1, z=0.1)
-                      ))
-    return fig
+# Ajouter un outil pour dessiner des formes
+m.add_draw_control()
+
+# Fonction pour ajuster la carte à la bbox calculée
+def draw_bbox():
+    center_lat, center_lon = m.center
+    format = 'A4'  # Exemple de format
+    scale = 1000   # Exemple d'échelle
+    bbox = calculate_bbox(center_lat, center_lon, format, scale)
+    
+    if bbox:
+        m.fit_bounds(bbox)
 
-def app():
-    st.title("Visualisation 3D du Terrain Suisse (Échelle 1:1)")
-    st.markdown(
-        """
-        Une application web interactive pour visualiser le terrain suisse en 3D à l'échelle 1:1.
-        """
-    )
-    col1, col2 = st.columns([2, 1])
-    with col1:
-        m = folium.Map(location=[46.8182, 8.2275], zoom_start=8)
-        folium.TileLayer(
-            tiles="https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.pixelkarte-farbe/default/current/3857/{z}/{x}/{y}.jpeg",
-            attr="© swisstopo",
-            name="swisstopo",
-            overlay=False,
-            control=True
-        ).add_to(m)
-        draw = plugins.Draw(export=True)
-        draw.add_to(m)
-        folium.LayerControl().add_to(m)
-        folium_static(m, height=400)
-    with col2:
-        data = st.file_uploader(
-            "Téléchargez un fichier GeoJSON à utiliser comme ROI.",
-            type=["geojson", "kml", "zip"],
-        )
-        resolution = st.slider("Résolution (en mètres)", min_value=0.1, max_value=5.0, value=0.5, step=0.1)
-        if st.button("Générer la visualisation 3D"):
-            if data is None:
-                st.warning("Veuillez télécharger un fichier GeoJSON.")
-            else:
-                gdf = uploaded_file_to_gdf(data)
-                gdf_2056 = gdf.to_crs(epsg=2056)
-                bbox = gdf_2056.total_bounds
-                st.subheader("Visualisation 3D du terrain")
-                with st.spinner('Génération de la visualisation 3D en cours... Cela peut prendre plusieurs minutes.'):
-                    elevation_data = get_elevation_data(bbox, resolution)
-                    if elevation_data is not None:
-                        fig = create_3d_terrain(elevation_data, bbox)
-                        st.plotly_chart(fig, use_container_width=True)
-                        
-                        # Sauvegarde des données pour l'impression 3D
-                        np.savetxt("elevation_data.csv", elevation_data, delimiter=",")
-                        st.success("Les données d'élévation ont été sauvegardées dans 'elevation_data.csv' pour l'impression 3D.")
+# Ajouter un bouton pour dessiner la bbox
+m.add_button(label="Dessiner BBox", on_click=draw_bbox)
 
-if __name__ == "__main__":
-    app()
+# Afficher la carte dans Streamlit
+m.to_streamlit()