Update pages/12_🌲_VertXtractor.py

pages/12_🌲_VertXtractor.py

@@ -1,15 +1,15 @@
 import streamlit as st
-import folium
-from streamlit_folium import folium_static
 import geopandas as gpd
 import tempfile
 import os
-import urllib
+import urllib.request
 import json
 from pathlib import Path
 import datetime
 from osgeo import gdal
-from PIL import Image
+import io
+import zipfile
+import base64
 
 # Constants
 CATEGORIES = {
@@ -33,16 +33,15 @@ DIC_LAYERS = {
 # Helper functions
 def wgs84_to_lv95(lat, lon):
     url = f'http://geodesy.geo.admin.ch/reframe/wgs84tolv95?easting={lat}&northing={lon}&format=json'
-    site = urllib.request.urlopen(url)
-    data = json.load(site)
+    with urllib.request.urlopen(url) as response:
+        data = json.load(response)
     return data['easting'], data['northing']
 
 def lv95_to_wgs84(x, y):
     url = f'http://geodesy.geo.admin.ch/reframe/lv95towgs84?easting={x}&northing={y}&format=json'
-    f = urllib.request.urlopen(url)
-    txt = f.read().decode('utf-8')
-    json_res = json.loads(txt)
-    return json_res
+    with urllib.request.urlopen(url) as response:
+        data = json.load(response)
+    return data['easting'], data['northing']
 
 def detect_and_convert_bbox(bbox):
     xmin, ymin, xmax, ymax = bbox
@@ -82,7 +81,7 @@ def detect_and_convert_bbox(bbox):
         wgs84_min = lv95_to_wgs84(xmin, ymin)
         wgs84_max = lv95_to_wgs84(xmax, ymax)
         
-        bbox_wgs84 = (wgs84_min['easting'], wgs84_min['northing'], wgs84_max['easting'], wgs84_max['northing'])
+        bbox_wgs84 = (wgs84_min, wgs84_max[0], wgs84_max[1], wgs84_min[1])
         return (bbox_wgs84, bbox)
     
     return None
@@ -98,9 +97,8 @@ def get_list_from_STAC_swisstopo(url, est, sud, ouest, nord, gdb=False):
     res = []
 
     while url:
-        f = urllib.request.urlopen(url)
-        txt = f.read().decode('utf-8')
-        json_res = json.loads(txt)
+        with urllib.request.urlopen(url) as response:
+            json_res = json.load(response)
         url = None
         links = json_res.get('links', None)
         if links:
@@ -164,26 +162,31 @@ def suppr_doublons_list_mnt(lst):
         res.append(url)
     return res
 
-def get_trees_points_from_bbox(bbox, fn_geojson):
-    xmin, ymin, xmax, ymax = bbox
-    url_base = 'https://hepiadata.hesge.ch/arcgis/rest/services/suisse/TLM_C4D_couverture_sol/FeatureServer/0/query?'
-    params = {
-        "geometry": f"{xmin},{ymin},{xmax},{ymax}",
-        "geometryType": "esriGeometryEnvelope",
-        "returnGeometry": "true",
-        "returnZ": "true",
-        "spatialRel": "esriSpatialRelIntersects",
-        "f": "json"
-    }
-    query_string = urllib.parse.urlencode(params)
-    url = url_base + query_string
-
-    with urllib.request.urlopen(url) as response:
-        response_data = response.read()
-        data = json.loads(response_data)
-
-        with open(fn_geojson, 'w') as f:
-            json.dump(data, f)
+@st.cache_data
+def get_urls(bbox_wgs84, data_types, resolutions):
+    urls = []
+    for data_type, enabled in data_types.items():
+        if enabled:
+            url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS[data_type]
+            if data_type in ['mnt', 'ortho']:
+                resolution = resolutions[data_type]
+                tri = f'_{resolution}_'
+                lst = [v for v in get_list_from_STAC_swisstopo(url, *bbox_wgs84) if tri in v]
+                if data_type == 'mnt':
+                    lst = suppr_doublons_list_mnt(lst)
+                else:
+                    lst = suppr_doublons_list_ortho(lst)
+            elif data_type == 'mns':
+                lst = [v for v in get_list_from_STAC_swisstopo(url, *bbox_wgs84) if 'raster' in v]
+                lst = suppr_doublons_list_mnt(lst)
+            elif data_type == 'bati3D_v2':
+                lst = get_list_from_STAC_swisstopo(url, *bbox_wgs84)
+                lst = suppr_doublons_bati3D_v2(lst)
+            elif data_type == 'bati3D_v3':
+                lst = get_list_from_STAC_swisstopo(url, *bbox_wgs84, gdb=True)
+                lst = suppr_doublons_bati3D_v3(lst)
+            urls.extend(lst)
+    return urls
 
 def geojson_forest(bbox, fn_geojson):
     xmin, ymin, xmax, ymax = bbox
@@ -207,137 +210,12 @@ def geojson_forest(bbox, fn_geojson):
     url = url_base + query_string
     
     with urllib.request.urlopen(url) as response:
-        response_data = response.read()
-        data = json.loads(response_data)
-        
-        with open(fn_geojson, 'w') as f:
-            json.dump(data, f)
-
-def get_urls(bbox_wgs84, mnt=True, mns=True, bati3D_v2=True, bati3D_v3=True, ortho=True, mnt_resol=0.5, ortho_resol=0.1):
-    est, sud, ouest, nord = bbox_wgs84
-    urls = []
-
-    if mnt:
-        mnt_resol = 0.5 if mnt_resol < 2 else 2
-        tri = f'_{mnt_resol}_'
-        url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS['mnt']
-        lst = [v for v in get_list_from_STAC_swisstopo(url, est, sud, ouest, nord) if tri in v]
-        lst = suppr_doublons_list_mnt(lst)
-        urls += lst
-
-    if mns:
-        url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS['mns']
-        lst = [v for v in get_list_from_STAC_swisstopo(url, est, sud, ouest, nord) if 'raster' in v]
-        lst = suppr_doublons_list_mnt(lst)
-        urls += lst
-
-    if bati3D_v2:
-        url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS['bati3D_v2']
-        lst = get_list_from_STAC_swisstopo(url, est, sud, ouest, nord)
-        lst = suppr_doublons_bati3D_v2(lst)
-        urls += lst
-
-    if bati3D_v3:
-        url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS['bati3D_v3']
-        lst = get_list_from_STAC_swisstopo(url, est, sud, ouest, nord, gdb=True)
-        lst = suppr_doublons_bati3D_v3(lst)
-        urls += lst
-
-    if ortho:
-        ortho_resol = 0.1 if ortho_resol < 2 else 2
-        tri = f'_{ortho_resol}_'
-        url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS['ortho']
-        lst = [v for v in get_list_from_STAC_swisstopo(url, est, sud, ouest, nord) if tri in v]
-        lst = suppr_doublons_list_ortho(lst)
-        urls += lst
-
-    return urls
-
-def classification_urls(urls):
-    dic = {}
-    for url in urls:
-        fn = url.split('/')[-1]
-        dirname = fn.split('_')[0]
-        
-        if dirname == 'swissbuildings3d':
-            name, version, *a = fn.split('_')
-            if version == '2':
-                an = fn.split('_')[2].split('-')[0]
-            elif version == '3':
-                an = fn.split('_')[3]
-            dirname = f'{name}_v{version}_{an}'
-        
-        elif dirname == 'swissalti3d':
-            name, an, no_flle, resol, *a = fn.split('_')
-            if resol == '0.5':
-                resol = '50cm'
-                fn = fn.replace('0.5', '50cm')
-            elif resol == '2':
-                resol = '2m'
-                fn = fn.replace('2', '2m')
-            dirname = f'{name}_{an}_{resol}'
-        elif dirname == 'swisssurface3d-raster':
-            name, an, no_flle, resol, *a = fn.split('_')
-            if resol == '0.5':
-                resol = '50cm'
-                fn = fn.replace('0.5', '50cm')
-            dirname = f'{name}_{an}_{resol}'
-        elif dirname == 'swissimage-dop10':
-            name, an, no_flle, resol, *a = fn.split('_')
-            if resol == '0.1':
-                resol = '10cm'
-                fn = fn.replace('0.1', '10cm')
-            elif resol == '2':
-                resol = '2m'
-                fn = fn.replace('2', '2m')
-            dirname = f'{name}_{an}_{resol}'
-        
-        dic.setdefault(dirname, []).append((url, fn))
-    return dic
-
-def download_files(urls, path):
-    now = datetime.datetime.now()
-    path = Path(path) / f'swisstopo_extraction_{now.strftime("%Y%m%d_%H%M")}'
-    path.mkdir(exist_ok=True)
-
-    for k, v in classification_urls(urls).items():
-        p = path / k
-        p.mkdir(exist_ok=True)
-        for url, fn in v:
-            urllib.request.urlretrieve(url, p / fn)
-    return path
-
-def download_and_merge_ortho(urls, output_path):
-    """
-    Download ortho images from URLs and merge them into a single GeoTIFF.
-    
-    :param urls: List of URLs to download ortho images from
-    :param output_path: Path to save the merged image
-    :return: Path to the merged image
-    """
-    # Create a temporary directory to store downloaded files
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Download all files
-        local_files = []
-        for i, url in enumerate(urls):
-            local_filename = os.path.join(temp_dir, f"ortho_{i}.tif")
-            urllib.request.urlretrieve(url, local_filename)
-            local_files.append(local_filename)
-        
-        # Merge downloaded files
-        vrt_options = gdal.BuildVRTOptions(resampleAlg='nearest', addAlpha=False)
-        vrt_path = os.path.join(temp_dir, "merged.vrt")
-        vrt = gdal.BuildVRT(vrt_path, local_files, options=vrt_options)
-        vrt = None  # Close the dataset
+        data = json.load(response)
         
-        # Translate VRT to GeoTIFF
-        translate_options = gdal.TranslateOptions(format="GTiff", creationOptions=["COMPRESS=LZW", "TILED=YES"])
-        gdal.Translate(output_path, vrt_path, options=translate_options)
-    
-    return output_path
+    with open(fn_geojson, 'w') as f:
+        json.dump(data, f)
 
 def create_geojson_with_links(urls, bbox):
-    """Create a GeoJSON file with download links"""
     features = []
     for url in urls:
         feature = {
@@ -348,7 +226,7 @@ def create_geojson_with_links(urls, bbox):
             },
             "properties": {
                 "url": url,
-                "type": url.split('/')[-2].split('_')[0]  # Assuming type is in the URL
+                "type": url.split('/')[-2].split('_')[0]
             }
         }
         features.append(feature)
@@ -360,7 +238,6 @@ def create_geojson_with_links(urls, bbox):
     return json.dumps(geojson)
 
 def merge_ortho_images(urls, output_format='GTiff'):
-    """Merge ortho images and return the result as bytes"""
     with tempfile.TemporaryDirectory() as temp_dir:
         local_files = []
         for i, url in enumerate(urls):
@@ -387,7 +264,6 @@ def merge_ortho_images(urls, output_format='GTiff'):
             return f.read()
 
 def prepare_download_package(urls, bbox, ortho_format):
-    """Prepare a zip file containing all data"""
     geojson_data = create_geojson_with_links(urls, bbox)
     ortho_urls = [url for url in urls if 'swissimage-dop10' in url]
     ortho_data = merge_ortho_images(ortho_urls, ortho_format) if ortho_urls else None
@@ -405,7 +281,40 @@ st.set_page_config(page_title="Swiss Geospatial Data Downloader", layout="wide")
 
 st.title("Swiss Geospatial Data Downloader")
 
-# (Include the sidebar and main content area from the previous version)
+# Sidebar for data selection
+st.sidebar.header("Data Selection")
+data_types = {
+    'mnt': st.sidebar.checkbox("Digital Terrain Model (MNT)", value=True),
+    'mns': st.sidebar.checkbox("Digital Surface Model (MNS)", value=True),
+    'bati3D_v2': st.sidebar.checkbox("3D Buildings v2", value=True),
+    'bati3D_v3': st.sidebar.checkbox("3D Buildings v3", value=True),
+    'ortho': st.sidebar.checkbox("Orthophotos", value=True),
+}
+
+resolutions = {
+    'mnt': st.sidebar.selectbox("MNT Resolution", [0.5, 2.0], index=0),
+    'ortho': st.sidebar.selectbox("Orthophoto Resolution", [0.1, 2.0], index=0),
+}
+
+ortho_format = st.sidebar.selectbox("Ortho Output Format", ['GTiff', 'JPEG', 'PNG'], index=0)
+
+# Main content area
+st.subheader("Enter Bounding Box Coordinates")
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    xmin = st.number_input("Min Longitude", value=6.0500, step=0.0001, format="%.4f")
+with col2:
+    ymin = st.number_input("Min Latitude", value=46.1800, step=0.0001, format="%.4f")
+with col3:
+    xmax = st.number_input("Max Longitude", value=6.2200, step=0.0001, format="%.4f")
+with col4:
+    ymax = st.number_input("Max Latitude", value=46.2500, step=0.0001, format="%.4f")
+
+if 'bbox' not in st.session_state:
+    st.session_state.bbox = None
+
+if st.button("Set Bounding Box"):
+    st.session_state.bbox = [xmin, ymin, xmax, ymax]
 
 if st.session_state.bbox:
     st.write(f"Selected bounding box (WGS84): {st.session_state.bbox}")