Upload 31 files

Home.py

@@ -0,0 +1,58 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+st.set_page_config(layout="wide")
+
+st.sidebar.title("About")
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Picenni Kenzo [wetlands.io]() | [GitHub]() | [Twitter]() | [YouTube]() | [LinkedIn]()
+    """
+)
+
+st.sidebar.title("Support")
+st.sidebar.info(
+    """
+    If you want to reward my work, I'd love a cup of coffee from you. Thanks!
+    
+    """
+)
+
+
+st.title("VertGIS")
+
+st.markdown(
+    """
+    This multi-page web app demonstrates various interactive web apps created using [streamlit](https://streamlit.io) and open-source mapping libraries, 
+    such as [leafmap](https://leafmap.org), [geemap](https://geemap.org), [pydeck](https://deckgl.readthedocs.io), and [kepler.gl](https://docs.kepler.gl/docs/keplergl-jupyter).
+    This is an open-source project and you are very welcome to contribute your comments, questions, resources, and apps as [issues](https://github.com/giswqs/streamlit-geospatial/issues) or 
+    [pull requests](https://github.com/giswqs/streamlit-geospatial/pulls) to the [GitHub repository](https://github.com/giswqs/streamlit-geospatial).
+
+    """
+)
+
+st.info("Click on the left sidebar menu to navigate to the different apps.")
+
+st.subheader("Timelapse of Satellite Imagery")
+st.markdown(
+    """
+    The following timelapse animations were created using the Timelapse web app. Click `Timelapse` on the left sidebar menu to create your own timelapse for any location around the globe.
+"""
+)
+
+row1_col1, row1_col2 = st.columns(2)
+with row1_col1:
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/spain.gif")
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/las_vegas.gif")
+
+with row1_col2:
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/goes.gif")
+    st.image("https://github.com/giswqs/data/raw/main/timelapse/fire.gif")

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Qiusheng Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,11 +1,11 @@
 ---
-title: VertGis
-emoji: 📚
-colorFrom: blue
-colorTo: blue
+title: Streamlit
+emoji: 🔥
+colorFrom: indigo
+colorTo: green
 sdk: streamlit
-sdk_version: 1.39.0
-app_file: app.py
+sdk_version: 1.34.0
+app_file: Home.py
 pinned: false
 license: mit
 ---

data/cog_files.txt

@@ -0,0 +1,77 @@
+https://www.maxar.com/open-data/california-colorado-fires
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2018-02-16/pine-gulch-fire20/1030010076004E00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2018-08-18/pine-gulch-fire20/1040010041D3B300.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2018-11-13/grizzly-creek-fire20/1040010045785200.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2018-11-13/grizzly-creek-fire20/10400100443AEC00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-02-06/czu-lightning-complex-fire/104001004941E100.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-02-18/cameron-peak-fire20/103001008DA5B500.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-02-22/czu-lightning-complex-fire/103001008DB2E200.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-04-01/grizzly-creek-fire20/104001004881EF00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-04-17/czu-lightning-complex-fire/103001008F905300.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-04-17/czu-lightning-complex-fire/1030010092B22200.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-06-27/czu-lightning-complex-fire/1030010094A52300.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-09-08/czu-lightning-complex-fire/103001009C9FBB00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-09-24/lnu-lightning-complex-fire/103001009A079B00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-10-05/czu-lightning-complex-fire/103001009C10F800.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-10-05/czu-lightning-complex-fire/103001009A266800.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-11-04/czu-lightning-complex-fire/1050010019917900.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-11-04/czu-lightning-complex-fire/1050010019917800.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-11-18/czu-lightning-complex-fire/1050010019C2F600.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-11-28/cameron-peak-fire20/103001009D72E000.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-12-10/czu-lightning-complex-fire/105001001A3A8700.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-12-28/lnu-lightning-complex-fire/10300100A1972700.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2019-12-28/lnu-lightning-complex-fire/103001009F5D6B00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-01-15/cameron-peak-fire20/1040010057992100.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-04-15/lnu-lightning-complex-fire/10300100A4B23600.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-04-23/czu-lightning-complex-fire/10300100A589D100.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-05-09/lnu-lightning-complex-fire/10300100A332EE00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-05-23/river-carmel-fires/10300100A77E9400.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-05-23/river-carmel-fires/10300100A500A500.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-05-24/river-carmel-fires/105001001D64E200.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-06-27/lnu-lightning-complex-fire/10300100A8663800.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-06-30/river-carmel-fires/10300100A9D60C00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-06-30/czu-lightning-complex-fire/10300100A8C66400.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-06-30/czu-lightning-complex-fire/10300100A8892900.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-07-11/czu-lightning-complex-fire/10300100AB381200.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-07-11/czu-lightning-complex-fire/10300100AA180600.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-07-13/pine-gulch-fire20/10300100AA57D700.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-07-20/lnu-lightning-complex-fire/104001005C529000.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/pre-event/2020-07-28/pine-gulch-fire20/104001005DB06E00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-14/pine-gulch-fire20/10300100AAC8DD00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-16/pine-gulch-fire20/104001005D4A6100.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-17/grizzly-creek-fire20/10300100ACCA3700.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-17/cameron-peak-fire20/10300100AB4ED400.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-20/swir-cog/104A0100606FFE00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-20/pine-gulch-fire20/10300100ACD06200.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-20/pine-gulch-fire20/10300100AAD4A000.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-20/pine-gulch-fire20/10300100AA293800.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-20/lnu-lightning-complex-fire/10400100606FFE00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-21/river-carmel-fires/10300100ACBA2B00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-21/river-carmel-fires/10300100AA49F600.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-21/lnu-lightning-complex-fire/104001005C1AC900.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-21/river-carmel-fires/104001005F9F5300.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-21/river-carmel-fires/104001005F453300.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-21/river-carmel-fires/10300100ADC14400.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-21/czu-lightning-complex-fire/104001005F43D400.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-23/grizzly-creek-fire20/104001005FA09C00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-23/grizzly-creek-fire20/104001005DC71000.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-26/river-carmel-fires/105001001F58F000.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-26/lnu-lightning-complex-fire/10300100AC163A00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-29/river-carmel-fires/10300100AAD27500.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-08-29/river-carmel-fires/10300100A9C75A00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-09-03/cameron-peak-fire20/1040010060188800.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-09-03/cameron-peak-fire20/104001005F7E6500.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-09-03/cameron-peak-fire20/10300100AE685A00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-09-04/cameron-peak-fire20/1040010060761C00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-05/cameron-peak-fire20/104001006113B700.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-05/cameron-peak-fire20/10400100610CD400.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-12/cameron-peak-fire20/1040010062B14C00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-12/cameron-peak-fire20/10400100626BFA00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-12/cameron-peak-fire20/10400100622A6600.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-12/cameron-peak-fire20/10400100606B6300.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-12/cameron-peak-fire20/104001005F908800.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-15/cameron-peak-fire20/10500100205EDA00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-15/cameron-peak-fire20/10500100205ED900.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-22/east-troublesome-fire20/10300100B0004A00.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-22/east-troublesome-fire20/10300100AD0D1200.tif
+https://opendata.digitalglobe.com/events/california-fire-2020/post-event/2020-10-22/east-troublesome-fire20/10300100AD0CA600.tif

data/html/sfo_buildings.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <!-- Include the CesiumJS JavaScript and CSS files -->
+  <script src="https://cesium.com/downloads/cesiumjs/releases/1.88/Build/Cesium/Cesium.js"></script>
+  <link href="https://cesium.com/downloads/cesiumjs/releases/1.88/Build/Cesium/Widgets/widgets.css" rel="stylesheet">
+</head>
+<body>
+  <div id="cesiumContainer"></div>
+  <script>
+    // Your access token can be found at: https://cesium.com/ion/tokens.
+    // Replace `your_access_token` with your Cesium ion access token.
+
+    Cesium.Ion.defaultAccessToken = 'your_access_token';
+
+    // Initialize the Cesium Viewer in the HTML element with the `cesiumContainer` ID.
+    const viewer = new Cesium.Viewer('cesiumContainer', {
+      terrainProvider: Cesium.createWorldTerrain()
+    });    
+    // Add Cesium OSM Buildings, a global 3D buildings layer.
+    const buildingTileset = viewer.scene.primitives.add(Cesium.createOsmBuildings());   
+    // Fly the camera to San Francisco at the given longitude, latitude, and height.
+    viewer.camera.flyTo({
+      destination : Cesium.Cartesian3.fromDegrees(-122.4175, 37.655, 400),
+      orientation : {
+        heading : Cesium.Math.toRadians(0.0),
+        pitch : Cesium.Math.toRadians(-15.0),
+      }
+    });
+  </script>
+ </div>
+</body>
+</html>

data/realtor_data_dict.csv

@@ -0,0 +1,37 @@
+Name,Label,Description
+median_listing_price,Median Listing Price,The median listing price within the specified geography during the specified month.
+median_listing_price_mm,Median Listing Price M/M,The percentage change in the median listing price from the previous month.
+median_listing_price_yy,Median Listing Price Y/Y,The percentage change in the median listing price from the same month in the previous year.
+active_listing_count,Active Listing Count,"The count of active listings within the specified geography during the specified month. The active listing count tracks the number of for sale properties on the market, excluding pending listings where a pending status is available. This is a snapshot measure of how many active listings can be expected on any given day of the specified month."
+active_listing_count_mm,Active Listing Count M/M,The percentage change in the active listing count from the previous month.
+active_listing_count_yy,Active Listing Count Y/Y,The percentage change in the active listing count from the same month in the previous year.
+median_days_on_market,Days on Market,The median number of days property listings spend on the market within the specified geography during the specified month. Time spent on the market is defined as the time between the initial listing of a property and either its closing date or the date it is taken off the market.
+median_days_on_market_mm,Days on Market M/M,The percentage change in the median days on market from the previous month.
+median_days_on_market_yy,Days on Market Y/Y,The percentage change in the median days on market from the same month in the previous year.
+new_listing_count,New Listing Count,The count of new listings added to the market within the specified geography. The new listing count represents a typical week’s worth of new listings in a given month. The new listing count can be multiplied by the number of weeks in a month to produce a monthly new listing count.
+new_listing_count_mm,New Listing Count M/M,The percentage change in the new listing count from the previous month.
+new_listing_count_yy,New Listing Count Y/Y,The percentage change in the new listing count from the same month in the previous year.
+price_increased_count,Price Increase Count,The count of listings which have had their price increased within the specified geography. The price increase count represents a typical week’s worth of listings which have had their price increased in a given month. The price increase count can be multiplied by the number of weeks in a month to produce a monthly price increase count.
+price_increased_count_mm,Price Increase Count M/M,The percentage change in the price increase count from the previous month.
+price_increased_count_yy,Price Increase Count Y/Y,The percentage change in the price increase count from the same month in the previous year.
+price_reduced_count,Price Decrease Count,The count of listings which have had their price reduced within the specified geography. The price decrease count represents a typical week’s worth of listings which have had their price reduced in a given month. The price decrease count can be multiplied by the number of weeks in a month to produce a monthly price decrease count.
+price_reduced_count_mm,Price Decrease Count M/M,The percentage change in the price decrease count from the previous month.
+price_reduced_count_yy,Price Decrease Count Y/Y,The percentage change in the price decrease count from the same month in the previous year.
+pending_listing_count,Pending Listing Count,"The count of pending listings within the specified geography during the specified month, if a pending definition is available for that geography. This is a snapshot measure of how many pending listings can be expected on any given day of the specified month."
+pending_listing_count_mm,Pending Listing Count M/M,The percentage change in the pending listing count from the previous month.
+pending_listing_count_yy,Pending Listing Count Y/Y,The percentage change in the pending listing count from the same month in the previous year.
+median_listing_price_per_square_foot,Median List Price Per Sqft,The median listing price per square foot within the specified geography during the specified month.
+median_listing_price_per_square_foot_mm,Median List Price Per Sqft M/M,The percentage change in the median listing price per square foot from the previous month.
+median_listing_price_per_square_foot_yy,Median List Price Per Sqft Y/Y,The percentage change in the median listing price per square foot from the same month in the previous year.
+median_square_feet,Median Listing Sqft,The median listing square feet within the specified geography during the specified month.
+median_square_feet_mm,Median Listing Sqft M/M,The percentage change in the median listing square feet from the previous month.
+median_square_feet_yy,Median Listing Sqft Y/Y,The percentage change in the median listing square feet from the same month in the previous year.
+average_listing_price,Avg Listing Price,The average listing price within the specified geography during the specified month.
+average_listing_price_mm,Avg Listing Price M/M,The percentage change in the average listing price from the previous month.
+average_listing_price_yy,Avg Listing Price Y/Y,The percentage change in the average listing price from the same month in the previous year.
+total_listing_count,Total Listing Count,The total of both active listings and pending listings within the specified geography during the specified month. This is a snapshot measure of how many total listings can be expected on any given day of the specified month.
+total_listing_count_mm,Total Listing Count M/M,The percentage change in the total listing count from the previous month.
+total_listing_count_yy,Total Listing Count Y/Y,The percentage change in the total listing count from the same month in the previous year.
+pending_ratio,Pending Ratio,The ratio of the pending listing count to the active listing count within the specified geography during the specified month.
+pending_ratio_mm,Pending Ratio M/M,The change in the pending ratio from the previous month.
+pending_ratio_yy,Pending Ratio Y/Y,The change in the pending ratio from the same month in the previous year.

data/scotland_xyz.tsv

@@ -0,0 +1,51 @@
+Name	URL
+Ordnance Survey - Air Photos, 1944-1950 - 1:10,560	https://geo.nls.uk/maps/air-photos/{z}/{x}/{y}.png
+Ordnance Survey - Six Inch Scotland, 1843-1882 - 1:10,560	https://mapseries-tilesets.s3.amazonaws.com/os/6inchfirst/{z}/{x}/{y}.png
+War Office, Great Britain 1:25,000. GSGS 3906, 1940-43	https://mapseries-tilesets.s3.amazonaws.com/gsgs3906/{z}/{x}/{y}.png
+Roy - Roy Highlands, 1747-1752 - 1:36000	https://mapseries-tilesets.s3.amazonaws.com/roy/highlands/{z}/{x}/{y}.png
+Roy - Roy Lowlands, 1752-1755 - 1:36000	https://mapseries-tilesets.s3.amazonaws.com/roy/lowlands/{z}/{x}/{y}.png
+Great Britain - OS 1:10,560, 1949-1970	https://mapseries-tilesets.s3.amazonaws.com/os/britain10knatgrid/{z}/{x}/{y}.png
+Great Britain - Bartholomew Half Inch, 1897-1907	https://mapseries-tilesets.s3.amazonaws.com/bartholomew_great_britain/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Scotland South 	https://mapseries-tilesets.s3.amazonaws.com/25_inch/scotland_1/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Scotland North 	https://mapseries-tilesets.s3.amazonaws.com/25_inch/scotland_2/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Bedfordshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/bedfordshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Berkshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/berkshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Buckinghamshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/buckingham/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Cambridgeshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/cambridge/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Cheshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/cheshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Cornwall	https://mapseries-tilesets.s3.amazonaws.com/25_inch/cornwall/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Cumberland	https://mapseries-tilesets.s3.amazonaws.com/25_inch/cumberland/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Devon	https://mapseries-tilesets.s3.amazonaws.com/25_inch/devon/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Dorset	https://mapseries-tilesets.s3.amazonaws.com/25_inch/dorset/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Durham	https://mapseries-tilesets.s3.amazonaws.com/25_inch/durham/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Essex	https://mapseries-tilesets.s3.amazonaws.com/25_inch/essex/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Gloucestershire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/gloucestershire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Hampshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/hampshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Herefordshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/herefordshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Hertfordshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/hertfordshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Huntingdon	https://mapseries-tilesets.s3.amazonaws.com/25_inch/huntingdon/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Kent	https://mapseries-tilesets.s3.amazonaws.com/25_inch/kent/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Lancashire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/lancashire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Leicestershire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/leicestershire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Lincolnshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/lincolnshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - London	https://mapseries-tilesets.s3.amazonaws.com/25_inch/london/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Middlesex	https://mapseries-tilesets.s3.amazonaws.com/25_inch/middlesex/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Norfolk	https://mapseries-tilesets.s3.amazonaws.com/25_inch/norfolk/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Northamptonshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/northampton/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Northumberland	https://mapseries-tilesets.s3.amazonaws.com/25_inch/northumberland/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Nottinghamshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/nottinghamshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Oxford	https://mapseries-tilesets.s3.amazonaws.com/25_inch/oxford/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Rutland	https://mapseries-tilesets.s3.amazonaws.com/25_inch/rutland/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Shropshire / Derbyshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/Shrop_Derby/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Somerset	https://mapseries-tilesets.s3.amazonaws.com/25_inch/somerset/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Stafford	https://mapseries-tilesets.s3.amazonaws.com/25_inch/stafford/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Suffolk	https://mapseries-tilesets.s3.amazonaws.com/25_inch/suffolk/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Surrey	https://mapseries-tilesets.s3.amazonaws.com/25_inch/surrey/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Sussex	https://mapseries-tilesets.s3.amazonaws.com/25_inch/sussex/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Wales	https://mapseries-tilesets.s3.amazonaws.com/25_inch/wales/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Warwick	https://mapseries-tilesets.s3.amazonaws.com/25_inch/warwick/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Westmorland	https://mapseries-tilesets.s3.amazonaws.com/25_inch/westmorland/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Wiltshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/wiltshire2nd/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Worcestershire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/Worcestershire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 - Yorkshire	https://mapseries-tilesets.s3.amazonaws.com/25_inch/yorkshire/{z}/{x}/{y}.png
+OS 25 inch, 1892-1914 'Holes' (fills gaps in series)	https://geo.nls.uk/mapdata3/os/25_inch_holes_england/{z}/{x}/{y}.png

packages.txt

@@ -0,0 +1,9 @@
+ffmpeg
+gifsicle
+build-essential
+python3-dev
+gdal-bin
+libgdal-dev
+libproj-dev
+libgeos-dev
+proj-bin

pages/10_🌍_Earth_Engine_Datasets.py

@@ -0,0 +1,162 @@
+import ee
+import json
+import streamlit as st
+import geemap.foliumap as geemap
+
+st.set_page_config(layout="wide")
+
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/@giswqs) | [LinkedIn](https://www.linkedin.com/in/giswqs)
+    """
+)
+
+
+def nlcd():
+
+    # st.header("National Land Cover Database (NLCD)")
+
+    row1_col1, row1_col2 = st.columns([3, 1])
+    width = 950
+    height = 600
+
+    Map = geemap.Map(center=[40, -100], zoom=4)
+
+    # Select the seven NLCD epoches after 2000.
+    years = ["2001", "2004", "2006", "2008", "2011", "2013", "2016", "2019"]
+
+    # Get an NLCD image by year.
+    def getNLCD(year):
+        # Import the NLCD collection.
+        dataset = ee.ImageCollection("USGS/NLCD_RELEASES/2019_REL/NLCD")
+
+        # Filter the collection by year.
+        nlcd = dataset.filter(ee.Filter.eq("system:index", year)).first()
+
+        # Select the land cover band.
+        landcover = nlcd.select("landcover")
+        return landcover
+
+    with row1_col2:
+        selected_year = st.multiselect("Select a year", years)
+        add_legend = st.checkbox("Show legend")
+
+    if selected_year:
+        for year in selected_year:
+            Map.addLayer(getNLCD(year), {}, "NLCD " + year)
+
+        if add_legend:
+            Map.add_legend(
+                legend_title="NLCD Land Cover Classification", builtin_legend="NLCD"
+            )
+        with row1_col1:
+            Map.to_streamlit(width=width, height=height)
+
+    else:
+        with row1_col1:
+            Map.to_streamlit(width=width, height=height)
+
+
+def search_data():
+
+    # st.header("Search Earth Engine Data Catalog")
+
+    Map = geemap.Map()
+
+    if "ee_assets" not in st.session_state:
+        st.session_state["ee_assets"] = None
+    if "asset_titles" not in st.session_state:
+        st.session_state["asset_titles"] = None
+
+    col1, col2 = st.columns([2, 1])
+
+    dataset = None
+    with col2:
+        keyword = st.text_input("Enter a keyword to search (e.g., elevation)", "")
+        if keyword:
+            ee_assets = geemap.search_ee_data(keyword)
+            asset_titles = [x["title"] for x in ee_assets]
+            asset_types = [x["type"] for x in ee_assets]
+
+            translate = {
+                "image_collection": "ee.ImageCollection('",
+                "image": "ee.Image('",
+                "table": "ee.FeatureCollection('",
+                "table_collection": "ee.FeatureCollection('",
+            }
+
+            dataset = st.selectbox("Select a dataset", asset_titles)
+            if len(ee_assets) > 0:
+                st.session_state["ee_assets"] = ee_assets
+                st.session_state["asset_titles"] = asset_titles
+
+            if dataset is not None:
+                with st.expander("Show dataset details", True):
+                    index = asset_titles.index(dataset)
+
+                    html = geemap.ee_data_html(st.session_state["ee_assets"][index])
+                    html = html.replace("\n", "")
+                    st.markdown(html, True)
+
+                ee_id = ee_assets[index]["id"]
+                uid = ee_assets[index]["uid"]
+                st.markdown(f"""**Earth Engine Snippet:** `{ee_id}`""")
+                ee_asset = f"{translate[asset_types[index]]}{ee_id}')"
+
+                if ee_asset.startswith("ee.ImageCollection"):
+                    ee_asset = ee.ImageCollection(ee_id)
+                elif ee_asset.startswith("ee.Image"):
+                    ee_asset = ee.Image(ee_id)
+                elif ee_asset.startswith("ee.FeatureCollection"):
+                    ee_asset = ee.FeatureCollection(ee_id)
+
+                vis_params = st.text_input(
+                    "Enter visualization parameters as a dictionary", {}
+                )
+                layer_name = st.text_input("Enter a layer name", uid)
+                button = st.button("Add dataset to map")
+                if button:
+                    vis = {}
+                    try:
+                        if vis_params.strip() == "":
+                            # st.error("Please enter visualization parameters")
+                            vis_params = "{}"
+                        vis = json.loads(vis_params.replace("'", '"'))
+                        if not isinstance(vis, dict):
+                            st.error("Visualization parameters must be a dictionary")
+                        try:
+                            Map.addLayer(ee_asset, vis, layer_name)
+                        except Exception as e:
+                            st.error(f"Error adding layer: {e}")
+                    except Exception as e:
+                        st.error(f"Invalid visualization parameters: {e}")
+
+            with col1:
+                Map.to_streamlit()
+        else:
+            with col1:
+                Map.to_streamlit()
+
+
+def app():
+    st.title("Earth Engine Data Catalog")
+
+    apps = ["Search Earth Engine Data Catalog", "National Land Cover Database (NLCD)"]
+
+    selected_app = st.selectbox("Select an app", apps)
+
+    if selected_app == "National Land Cover Database (NLCD)":
+        nlcd()
+    elif selected_app == "Search Earth Engine Data Catalog":
+        search_data()
+
+
+app()

pages/12_🌲_VertXtractor.py

@@ -0,0 +1,443 @@
+import streamlit as st
+import folium
+from streamlit_folium import st_folium
+from folium.plugins import Draw
+import geopandas as gpd
+import tempfile
+import os
+import urllib.request
+import json
+from pathlib import Path
+import datetime
+from osgeo import gdal
+import io
+import zipfile
+import base64
+import concurrent.futures
+import requests
+from functools import partial
+
+# Constants
+CATEGORIES = {
+    'Gebueschwald': 'Forêt buissonnante',
+    'Wald': 'Forêt',
+    'Wald offen': 'Forêt claisemée',
+    'Gehoelzflaeche': 'Zone boisée',
+}
+MERGE_CATEGORIES = True
+
+URL_STAC_SWISSTOPO_BASE = 'https://data.geo.admin.ch/api/stac/v0.9/collections/'
+
+DIC_LAYERS = {
+    'ortho': 'ch.swisstopo.swissimage-dop10',
+    'mnt': 'ch.swisstopo.swissalti3d',
+    'mns': 'ch.swisstopo.swisssurface3d-raster',
+    'bati3D_v2': 'ch.swisstopo.swissbuildings3d_2',
+    'bati3D_v3': 'ch.swisstopo.swissbuildings3d_3_0',
+}
+
+# Helper functions
+def wgs84_to_lv95(lat, lon):
+    url = f'http://geodesy.geo.admin.ch/reframe/wgs84tolv95?easting={lon}&northing={lat}&format=json'
+    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'
+    with urllib.request.urlopen(url) as response:
+        data = json.load(response)
+    return data['northing'], data['easting']
+
+def detect_and_convert_bbox(bbox):
+    xmin, ymin, xmax, ymax = bbox
+    
+    wgs84_margin = 0.9
+    wgs84_bounds = {
+        'xmin': 5.96 - wgs84_margin,
+        'ymin': 45.82 - wgs84_margin,
+        'xmax': 10.49 + wgs84_margin,
+        'ymax': 47.81 + wgs84_margin
+    }
+    
+    lv95_margin = 100000
+    lv95_bounds = {
+        'xmin': 2485000 - lv95_margin,
+        'ymin': 1075000 - lv95_margin,
+        'xmax': 2834000 + lv95_margin,
+        'ymax': 1296000 + lv95_margin
+    }
+    
+    if (wgs84_bounds['xmin'] <= xmin <= wgs84_bounds['xmax'] and
+        wgs84_bounds['ymin'] <= ymin <= wgs84_bounds['ymax'] and
+        wgs84_bounds['xmin'] <= xmax <= wgs84_bounds['xmax'] and
+        wgs84_bounds['ymin'] <= ymax <= wgs84_bounds['ymax']):
+        
+        lv95_min = wgs84_to_lv95(ymin, xmin)
+        lv95_max = wgs84_to_lv95(ymax, xmax)
+        
+        bbox_lv95 = (lv95_min[0], lv95_min[1], lv95_max[0], lv95_max[1])
+        return (bbox, bbox_lv95)
+    
+    if (lv95_bounds['xmin'] <= xmin <= lv95_bounds['xmax'] and
+        lv95_bounds['ymin'] <= ymin <= lv95_bounds['ymax'] and
+        lv95_bounds['xmin'] <= xmax <= lv95_bounds['xmax'] and
+        lv95_bounds['ymin'] <= ymax <= lv95_bounds['ymax']):
+        
+        wgs84_min = lv95_to_wgs84(xmin, ymin)
+        wgs84_max = lv95_to_wgs84(xmax, ymax)
+        
+        bbox_wgs84 = (wgs84_min[1], wgs84_min[0], wgs84_max[1], wgs84_max[0])
+        return (bbox_wgs84, bbox)
+    
+    return None
+
+def get_list_from_STAC_swisstopo(url, est, sud, ouest, nord, gdb=False):
+    if gdb:
+        lst_indesirables = []
+    else:
+        lst_indesirables = ['.xyz.zip', '.gdb.zip']
+
+    sufixe_url = f"/items?bbox={est},{sud},{ouest},{nord}"
+    url += sufixe_url
+    res = []
+
+    while url:
+        with urllib.request.urlopen(url) as response:
+            json_res = json.load(response)
+        url = None
+        links = json_res.get('links', None)
+        if links:
+            for link in links:
+                if link['rel'] == 'next':
+                    url = link['href']   
+        
+        for item in json_res['features']:
+            for k, dic in item['assets'].items():
+                href = dic['href']
+                if gdb:
+                    if href[-8:] == '.gdb.zip':
+                        if len(dic['href'].split('/')[-1].split('_')) == 7:
+                            res.append(dic['href'])
+                else:
+                    if href[-8:] not in lst_indesirables:
+                        res.append(dic['href'])           
+    return res
+
+def suppr_doublons_bati3D_v2(lst_url):    
+    dico = {}
+    dxf_files = [url for url in lst_url if url[-8:] == '.dxf.zip']
+    for dxf in dxf_files:
+        *a, date, feuille = dxf.split('/')[-2].split('_')
+        dico.setdefault(feuille, []).append((date, dxf))
+    res = []
+    for k, liste in dico.items():
+        res.append(sorted(liste, reverse=True)[0][1])
+    return res
+
+def suppr_doublons_bati3D_v3(lst_url):    
+    dico = {}
+    gdb_files = [url for url in lst_url if url[-8:] == '.gdb.zip']
+    for gdb in gdb_files:
+        *a, date, feuille = gdb.split('/')[-2].split('_')
+        dico.setdefault(feuille, []).append((date, gdb))
+    res = []
+    for k, liste in dico.items():
+        res.append(sorted(liste, reverse=True)[0][1])
+    return res
+
+def suppr_doublons_list_ortho(lst):
+    dic = {}
+    for url in lst:
+        nom, an, noflle, taille_px, epsg = url.split('/')[-1][:-4].split('_')
+        dic.setdefault((noflle, float(taille_px)), []).append((an, url))
+    res = []
+    for noflle, lst in dic.items():
+        an, url = sorted(lst, reverse=True)[0]
+        res.append(url)
+    return res
+
+def suppr_doublons_list_mnt(lst):
+    dic = {}
+    for url in lst:
+        nom, an, noflle, taille_px, epsg, inconnu = url.split('/')[-1][:-4].split('_')
+        dic.setdefault((noflle, float(taille_px)), []).append((an, url))
+    res = []
+    for noflle, lst in dic.items():
+        an, url = sorted(lst, reverse=True)[0]
+        res.append(url)
+    return res
+
+@st.cache_data
+def get_urls(bbox_wgs84, data_types, resolutions):
+    urls = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+        future_to_data_type = {
+            executor.submit(
+                get_urls_for_data_type, 
+                data_type, 
+                bbox_wgs84, 
+                resolutions.get(data_type)
+            ): data_type for data_type, enabled in data_types.items() if enabled
+        }
+        for future in concurrent.futures.as_completed(future_to_data_type):
+            data_type = future_to_data_type[future]
+            try:
+                urls.extend(future.result())
+            except Exception as exc:
+                st.error(f"Error fetching URLs for {data_type}: {exc}")
+    return urls
+
+def get_urls_for_data_type(data_type, bbox_wgs84, resolution=None):
+    url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS[data_type]
+    if data_type in ['mnt', 'ortho']:
+        tri = f'_{resolution}_'
+        lst = [v for v in get_list_from_STAC_swisstopo(url, *bbox_wgs84) if tri in v]
+        if data_type == 'mnt':
+            return suppr_doublons_list_mnt(lst)
+        else:
+            return 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]
+        return suppr_doublons_list_mnt(lst)
+    elif data_type == 'bati3D_v2':
+        lst = get_list_from_STAC_swisstopo(url, *bbox_wgs84)
+        return suppr_doublons_bati3D_v2(lst)
+    elif data_type == 'bati3D_v3':
+        lst = get_list_from_STAC_swisstopo(url, *bbox_wgs84, gdb=True)
+        return suppr_doublons_bati3D_v3(lst)
+    return []
+
+def fetch_url(url):
+    response = requests.get(url)
+    return response.content
+
+def merge_ortho_images(urls, output_format='GTiff'):
+    try:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            local_files = []
+            with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+                future_to_url = {executor.submit(fetch_url, url): url for url in urls}
+                for i, future in enumerate(concurrent.futures.as_completed(future_to_url)):
+                    url = future_to_url[future]
+                    try:
+                        data = future.result()
+                        local_filename = os.path.join(temp_dir, f"ortho_{i}.tif")
+                        with open(local_filename, 'wb') as f:
+                            f.write(data)
+                        local_files.append(local_filename)
+                    except Exception as exc:
+                        st.error(f"Error downloading {url}: {exc}")
+            
+            if not local_files:
+                st.error("No ortho images were successfully downloaded.")
+                return None
+            
+            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
+            
+            output_path = os.path.join(temp_dir, f"merged.{output_format.lower()}")
+            if output_format == 'GTiff':
+                translate_options = gdal.TranslateOptions(format="GTiff", creationOptions=["COMPRESS=LZW", "TILED=YES"])
+            elif output_format == 'JPEG':
+                translate_options = gdal.TranslateOptions(format="JPEG", creationOptions=["QUALITY=85"])
+            elif output_format == 'PNG':
+                translate_options = gdal.TranslateOptions(format="PNG", creationOptions=["COMPRESS=DEFLATE"])
+            else:
+                st.error(f"Unsupported output format: {output_format}")
+                return None
+            
+            gdal.Translate(output_path, vrt_path, options=translate_options)
+            
+            if not os.path.exists(output_path):
+                st.error(f"Failed to create merged image: {output_path}")
+                return None
+            
+            with open(output_path, 'rb') as f:
+                return f.read()
+    except Exception as e:
+        st.error(f"Error in merge_ortho_images: {e}")
+        return None
+
+def create_geojson_with_links(urls, bbox):
+    features = []
+    for url in urls:
+        feature = {
+            "type": "Feature",
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": [bbox]
+            },
+            "properties": {
+                "url": url,
+                "type": url.split('/')[-2].split('_')[0]
+            }
+        }
+        features.append(feature)
+    
+    geojson = {
+        "type": "FeatureCollection",
+        "features": features
+    }
+    return json.dumps(geojson)
+
+@st.cache_data
+def prepare_download_package(urls, bbox, ortho_format):
+    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
+    
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        zip_file.writestr('download_links.geojson', geojson_data)
+        if ortho_data:
+            zip_file.writestr(f'merged_ortho.{ortho_format.lower()}', ortho_data)
+        else:
+            st.warning("Failed to merge ortho images. Only download links will be included in the package.")
+    
+    return zip_buffer.getvalue()
+
+def geojson_forest(bbox, fn_geojson):
+    xmin, ymin, xmax, ymax = bbox
+    url_base = 'https://hepiadata.hesge.ch/arcgis/rest/services/suisse/TLM_C4D_couverture_sol/FeatureServer/1/query?'
+
+    sql = ' OR '.join([f"OBJEKTART='{cat}'" for cat in CATEGORIES.keys()])
+
+    params = {
+        "geometry": f"{xmin},{ymin},{xmax},{ymax}",
+        "geometryType": "esriGeometryEnvelope",
+        "returnGeometry": "true",
+        "outFields": "OBJEKTART",
+        "orderByFields": "OBJEKTART",
+        "where": sql,
+        "returnZ": "true",
+        "outSR": '2056',
+        "spatialRel": "esriSpatialRelIntersects",
+        "f": "geojson"
+    }
+    query_string = urllib.parse.urlencode(params)
+    url = url_base + query_string
+    
+    with urllib.request.urlopen(url) as response:
+        data = json.load(response)
+        
+    with open(fn_geojson, 'w') as f:
+        json.dump(data, f)
+
+# Streamlit app
+st.set_page_config(page_title="Swiss Geospatial Data Downloader", layout="wide")
+
+st.title("Swiss Geospatial Data Downloader")
+
+# 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("Select Bounding Box")
+
+# Create a map centered on Switzerland
+m = folium.Map(location=[46.8182, 8.2275], zoom_start=8)
+
+# Add rectangle draw control
+draw = Draw(
+    draw_options={
+        'rectangle': True,
+        'polygon': False,
+        'polyline': False,
+        'circle': False,
+        'marker': False,
+        'circlemarker': False
+    },
+    edit_options={'edit': False}
+)
+draw.add_to(m)
+
+# Use st_folium to render the map and get the drawn bbox
+output = st_folium(m, width=700, height=500)
+
+# Initialize session state for bbox
+if 'bbox' not in st.session_state:
+    st.session_state.bbox = [6.0, 46.0, 10.0, 47.0]  # Default values for Switzerland
+
+# Update bbox if a new one is drawn
+if output['last_active_drawing']:
+    coordinates = output['last_active_drawing']['geometry']['coordinates'][0]
+    st.session_state.bbox = [
+        min(coord[0] for coord in coordinates),
+        min(coord[1] for coord in coordinates),
+        max(coord[0] for coord in coordinates),
+        max(coord[1] for coord in coordinates)
+    ]
+
+# Display and allow editing of bounding box coordinates
+st.subheader("Enter Bounding Box Coordinates")
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    xmin = st.number_input("Min Longitude", value=st.session_state.bbox[0], format="%.4f", key="xmin")
+with col2:
+    ymin = st.number_input("Min Latitude", value=st.session_state.bbox[1], format="%.4f", key="ymin")
+with col3:
+    xmax = st.number_input("Max Longitude", value=st.session_state.bbox[2], format="%.4f", key="xmax")
+with col4:
+    ymax = st.number_input("Max Latitude", value=st.session_state.bbox[3], format="%.4f", key="ymax")
+
+# Update session state if coordinates are manually changed
+st.session_state.bbox = [xmin, ymin, xmax, ymax]
+
+if st.session_state.bbox:
+    st.write(f"Selected bounding box (WGS84): {st.session_state.bbox}")
+    
+    bbox_results = detect_and_convert_bbox(st.session_state.bbox)
+    
+    if bbox_results:
+        bbox_wgs84, bbox_lv95 = bbox_results
+        st.write(f"Converted bounding box (LV95): {bbox_lv95}")
+        
+        if st.button("Get Download Package"):
+            with st.spinner("Preparing download package..."):
+                urls = get_urls(bbox_wgs84, data_types, resolutions)
+                if urls:
+                    zip_data = prepare_download_package(urls, bbox_wgs84, ortho_format)
+                    b64 = base64.b64encode(zip_data).decode()
+                    href = f'<a href="data:application/zip;base64,{b64}" download="swiss_geospatial_data.zip">Download All Data</a>'
+                    st.markdown(href, unsafe_allow_html=True)
+                    st.success("Download package prepared. Click the link above to download.")
+                else:
+                    st.warning("No files found for the selected area and options.")
+        
+        if st.button("Download Forest Data"):
+            with st.spinner("Downloading forest data..."):
+                with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.geojson') as tmp:
+                    geojson_forest(bbox_lv95, tmp.name)
+                    gdf = gpd.read_file(tmp.name)
+                    st.write(gdf)
+                    
+                    # Provide download link for forest data
+                    with open(tmp.name, 'r') as f:
+                        forest_data = f.read()
+                    b64 = base64.b64encode(forest_data.encode()).decode()
+                    href = f'<a href="data:application/json;base64,{b64}" download="forest_data.geojson">Download Forest Data</a>'
+                    st.markdown(href, unsafe_allow_html=True)
+                
+                os.unlink(tmp.name)
+                st.success("Forest data prepared. Click the link above to download.")
+    else:
+        st.error("Selected area is outside Switzerland. Please select an area within Switzerland.")
+
+st.sidebar.info("This application allows you to download various types of geospatial data for Switzerland. Select the data types you want, draw a bounding box on the map, and click 'Get Download Package' to prepare all data for download.")

pages/1_🖼️_VertBox.py

@@ -0,0 +1,422 @@
+import streamlit as st
+import folium
+from streamlit_folium import st_folium
+from folium.plugins import Draw
+import geopandas as gpd
+import tempfile
+import os
+import urllib.request
+import json
+from pathlib import Path
+import datetime
+from osgeo import gdal
+import io
+import zipfile
+import base64
+import concurrent.futures
+import requests
+from functools import partial
+
+# Constants
+CATEGORIES = {
+    'Gebueschwald': 'Forêt buissonnante',
+    'Wald': 'Forêt',
+    'Wald offen': 'Forêt claisemée',
+    'Gehoelzflaeche': 'Zone boisée',
+}
+MERGE_CATEGORIES = True
+URL_STAC_SWISSTOPO_BASE = 'https://data.geo.admin.ch/api/stac/v0.9/collections/'
+DIC_LAYERS = {
+    'ortho': 'ch.swisstopo.swissimage-dop10',
+    'mnt': 'ch.swisstopo.swissalti3d',
+    'mns': 'ch.swisstopo.swisssurface3d-raster',
+    'bati3D_v2': 'ch.swisstopo.swissbuildings3d_2',
+    'bati3D_v3': 'ch.swisstopo.swissbuildings3d_3_0',
+}
+
+# Helper functions
+def wgs84_to_lv95(lat, lon):
+    url = f'http://geodesy.geo.admin.ch/reframe/wgs84tolv95?easting={lon}&northing={lat}&format=json'
+    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'
+    with urllib.request.urlopen(url) as response:
+        data = json.load(response)
+    return data['northing'], data['easting']
+
+def detect_and_convert_bbox(bbox):
+    xmin, ymin, xmax, ymax = bbox
+    wgs84_margin = 0.9
+    wgs84_bounds = {
+        'xmin': 5.96 - wgs84_margin,
+        'ymin': 45.82 - wgs84_margin,
+        'xmax': 10.49 + wgs84_margin,
+        'ymax': 47.81 + wgs84_margin
+    }
+    lv95_margin = 100000
+    lv95_bounds = {
+        'xmin': 2485000 - lv95_margin,
+        'ymin': 1075000 - lv95_margin,
+        'xmax': 2834000 + lv95_margin,
+        'ymax': 1296000 + lv95_margin
+    }
+
+    if (wgs84_bounds['xmin'] <= xmin <= wgs84_bounds['xmax'] and
+        wgs84_bounds['ymin'] <= ymin <= wgs84_bounds['ymax'] and
+        wgs84_bounds['xmin'] <= xmax <= wgs84_bounds['xmax'] and
+        wgs84_bounds['ymin'] <= ymax <= wgs84_bounds['ymax']):
+        lv95_min = wgs84_to_lv95(ymin, xmin)
+        lv95_max = wgs84_to_lv95(ymax, xmax)
+        bbox_lv95 = (lv95_min[0], lv95_min[1], lv95_max[0], lv95_max[1])
+        return (bbox, bbox_lv95)
+
+    if (lv95_bounds['xmin'] <= xmin <= lv95_bounds['xmax'] and
+        lv95_bounds['ymin'] <= ymin <= lv95_bounds['ymax'] and
+        lv95_bounds['xmin'] <= xmax <= lv95_bounds['xmax'] and
+        lv95_bounds['ymin'] <= ymax <= lv95_bounds['ymax']):
+        wgs84_min = lv95_to_wgs84(xmin, ymin)
+        wgs84_max = lv95_to_wgs84(xmax, ymax)
+        bbox_wgs84 = (wgs84_min[1], wgs84_min[0], wgs84_max[1], wgs84_max[0])
+        return (bbox_wgs84, bbox)
+
+    return None
+
+def get_list_from_STAC_swisstopo(url, est, sud, ouest, nord, gdb=False):
+    lst_indesirables = [] if gdb else ['.xyz.zip', '.gdb.zip']
+    sufixe_url = f"/items?bbox={est},{sud},{ouest},{nord}"
+    url += sufixe_url
+    res = []
+    
+    while url:
+        with urllib.request.urlopen(url) as response:
+            json_res = json.load(response)
+        
+        url = None
+        links = json_res.get('links', None)
+        if links:
+            for link in links:
+                if link['rel'] == 'next':
+                    url = link['href']
+        
+        for item in json_res['features']:
+            for k, dic in item['assets'].items():
+                href = dic['href']
+                if gdb:
+                    if href[-8:] == '.gdb.zip' and len(dic['href'].split('/')[-1].split('_')) == 7:
+                        res.append(dic['href'])
+                else:
+                    if href[-8:] not in lst_indesirables:
+                        res.append(dic['href'])
+    
+    return res
+
+def suppr_doublons_bati3D_v2(lst_url):
+    dico = {}
+    dxf_files = [url for url in lst_url if url[-8:] == '.dxf.zip']
+    for dxf in dxf_files:
+        *a, date, feuille = dxf.split('/')[-2].split('_')
+        dico.setdefault(feuille, []).append((date, dxf))
+    res = []
+    for k, liste in dico.items():
+        res.append(sorted(liste, reverse=True)[0][1])
+    return res
+
+def suppr_doublons_bati3D_v3(lst_url):
+    dico = {}
+    gdb_files = [url for url in lst_url if url[-8:] == '.gdb.zip']
+    for gdb in gdb_files:
+        *a, date, feuille = gdb.split('/')[-2].split('_')
+        dico.setdefault(feuille, []).append((date, gdb))
+    res = []
+    for k, liste in dico.items():
+        res.append(sorted(liste, reverse=True)[0][1])
+    return res
+
+def suppr_doublons_list_ortho(lst):
+    dic = {}
+    for url in lst:
+        nom, an, noflle, taille_px, epsg = url.split('/')[-1][:-4].split('_')
+        dic.setdefault((noflle, float(taille_px)), []).append((an, url))
+    res = []
+    for noflle, lst in dic.items():
+        an, url = sorted(lst, reverse=True)[0]
+        res.append(url)
+    return res
+
+def suppr_doublons_list_mnt(lst):
+    dic = {}
+    for url in lst:
+        nom, an, noflle, taille_px, epsg, inconnu = url.split('/')[-1][:-4].split('_')
+        dic.setdefault((noflle, float(taille_px)), []).append((an, url))
+    res = []
+    for noflle, lst in dic.items():
+        an, url = sorted(lst, reverse=True)[0]
+        res.append(url)
+    return res
+
+@st.cache_data
+def get_urls(bbox_wgs84, data_types, resolutions):
+    urls = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+        future_to_data_type = {
+            executor.submit(
+                get_urls_for_data_type,
+                data_type,
+                bbox_wgs84,
+                resolutions.get(data_type)
+            ): data_type
+            for data_type, enabled in data_types.items() if enabled
+        }
+        for future in concurrent.futures.as_completed(future_to_data_type):
+            data_type = future_to_data_type[future]
+            try:
+                urls.extend(future.result())
+            except Exception as exc:
+                st.error(f"Error fetching URLs for {data_type}: {exc}")
+    return urls
+
+def get_urls_for_data_type(data_type, bbox_wgs84, resolution=None):
+    url = URL_STAC_SWISSTOPO_BASE + DIC_LAYERS[data_type]
+    if data_type in ['mnt', 'ortho']:
+        tri = f'_{resolution}_'
+        lst = [v for v in get_list_from_STAC_swisstopo(url, *bbox_wgs84) if tri in v]
+        if data_type == 'mnt':
+            return suppr_doublons_list_mnt(lst)
+        else:
+            return 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]
+        return suppr_doublons_list_mnt(lst)
+    elif data_type == 'bati3D_v2':
+        lst = get_list_from_STAC_swisstopo(url, *bbox_wgs84)
+        return suppr_doublons_bati3D_v2(lst)
+    elif data_type == 'bati3D_v3':
+        lst = get_list_from_STAC_swisstopo(url, *bbox_wgs84, gdb=True)
+        return suppr_doublons_bati3D_v3(lst)
+    return []
+
+def fetch_url(url):
+    response = requests.get(url)
+    return response.content
+
+def merge_ortho_images(urls, output_format='GTiff'):
+    try:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            local_files = []
+            with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+                future_to_url = {executor.submit(fetch_url, url): url for url in urls}
+                for i, future in enumerate(concurrent.futures.as_completed(future_to_url)):
+                    url = future_to_url[future]
+                    try:
+                        data = future.result()
+                        local_filename = os.path.join(temp_dir, f"ortho_{i}.tif")
+                        with open(local_filename, 'wb') as f:
+                            f.write(data)
+                        local_files.append(local_filename)
+                    except Exception as exc:
+                        st.error(f"Error downloading {url}: {exc}")
+
+            if not local_files:
+                st.error("No ortho images were successfully downloaded.")
+                return None
+
+            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
+
+            output_path = os.path.join(temp_dir, f"merged.{output_format.lower()}")
+            if output_format == 'GTiff':
+                translate_options = gdal.TranslateOptions(format="GTiff", creationOptions=["COMPRESS=LZW", "TILED=YES"])
+            elif output_format == 'JPEG':
+                translate_options = gdal.TranslateOptions(format="JPEG", creationOptions=["QUALITY=85"])
+            elif output_format == 'PNG':
+                translate_options = gdal.TranslateOptions(format="PNG", creationOptions=["COMPRESS=DEFLATE"])
+            else:
+                st.error(f"Unsupported output format: {output_format}")
+                return None
+
+            gdal.Translate(output_path, vrt_path, options=translate_options)
+
+            if not os.path.exists(output_path):
+                st.error(f"Failed to create merged image: {output_path}")
+                return None
+
+            with open(output_path, 'rb') as f:
+                return f.read()
+    except Exception as e:
+        st.error(f"Error in merge_ortho_images: {e}")
+        return None
+
+def create_geojson_with_links(urls, bbox):
+    features = []
+    for url in urls:
+        feature = {
+            "type": "Feature",
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": [bbox]
+            },
+            "properties": {
+                "url": url,
+                "type": url.split('/')[-2].split('_')[0]
+            }
+        }
+        features.append(feature)
+    
+    geojson = {
+        "type": "FeatureCollection",
+        "features": features
+    }
+    return json.dumps(geojson)
+
+@st.cache_data
+def prepare_download_package(urls, bbox, ortho_format):
+    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
+
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        zip_file.writestr('download_links.geojson', geojson_data)
+        if ortho_data:
+            zip_file.writestr(f'merged_ortho.{ortho_format.lower()}', ortho_data)
+        else:
+            st.warning("Failed to merge ortho images. Only download links will be included in the package.")
+
+    return zip_buffer.getvalue()
+
+def geojson_forest(bbox, fn_geojson):
+    xmin, ymin, xmax, ymax = bbox
+    url_base = 'https://hepiadata.hesge.ch/arcgis/rest/services/suisse/TLM_C4D_couverture_sol/FeatureServer/1/query?'
+    sql = ' OR '.join([f"OBJEKTART='{cat}'" for cat in CATEGORIES.keys()])
+    params = {
+        "geometry": f"{xmin},{ymin},{xmax},{ymax}",
+        "geometryType": "esriGeometryEnvelope",
+        "returnGeometry": "true",
+        "outFields": "OBJEKTART",
+        "orderByFields": "OBJEKTART",
+        "where": sql,
+        "returnZ": "true",
+        "outSR": '2056',
+        "spatialRel": "esriSpatialRelIntersects",
+        "f": "geojson"
+    }
+    query_string = urllib.parse.urlencode(params)
+    url = url_base + query_string
+    with urllib.request.urlopen(url) as response:
+        data = json.load(response)
+    with open(fn_geojson, 'w') as f:
+        json.dump(data, f)
+
+# Streamlit app
+st.set_page_config(page_title="Swiss Geospatial Data Downloader", layout="wide")
+st.title("Swiss Geospatial Data Downloader")
+
+# 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("Select Bounding Box")
+
+# Create a map centered on Switzerland
+m = folium.Map(location=[46.8182, 8.2275], zoom_start=8)
+
+# Add rectangle draw control
+draw = Draw(
+    draw_options={
+        'rectangle': True,
+        'polygon': False,
+        'polyline': False,
+        'circle': False,
+        'marker': False,
+        'circlemarker': False
+    },
+    edit_options={'edit': False}
+)
+draw.add_to(m)
+
+# Use st_folium to render the map and get the drawn bbox
+output = st_folium(m, width=700, height=500)
+
+# Initialize session state for bbox
+if 'bbox' not in st.session_state:
+    st.session_state.bbox = [6.0, 46.0, 10.0, 47.0]  # Default values for Switzerland
+
+# Update bbox if a new one is drawn
+if output['last_active_drawing']:
+    coordinates = output['last_active_drawing']['geometry']['coordinates'][0]
+    st.session_state.bbox = [
+        min(coord[0] for coord in coordinates),
+        min(coord[1] for coord in coordinates),
+        max(coord[0] for coord in coordinates),
+        max(coord[1] for coord in coordinates)
+    ]
+
+# Display and allow editing of bounding box coordinates
+st.subheader("Enter Bounding Box Coordinates")
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    xmin = st.number_input("Min Longitude", value=st.session_state.bbox[0], format="%.4f", key="xmin")
+with col2:
+    ymin = st.number_input("Min Latitude", value=st.session_state.bbox[1], format="%.4f", key="ymin")
+with col3:
+    xmax = st.number_input("Max Longitude", value=st.session_state.bbox[2], format="%.4f", key="xmax")
+with col4:
+    ymax = st.number_input("Max Latitude", value=st.session_state.bbox[3], format="%.4f", key="ymax")
+
+# Update session state if coordinates are manually changed
+st.session_state.bbox = [xmin, ymin, xmax, ymax]
+
+if st.session_state.bbox:
+    st.write(f"Selected bounding box (WGS84): {st.session_state.bbox}")
+    bbox_results = detect_and_convert_bbox(st.session_state.bbox)
+    if bbox_results:
+        bbox_wgs84, bbox_lv95 = bbox_results
+        st.write(f"Converted bounding box (LV95): {bbox_lv95}")
+
+        if st.button("Get Download Package"):
+            with st.spinner("Preparing download package..."):
+                urls = get_urls(bbox_wgs84, data_types, resolutions)
+                if urls:
+                    zip_data = prepare_download_package(urls, bbox_wgs84, ortho_format)
+                    b64 = base64.b64encode(zip_data).decode()
+                    href = f'<a href="data:application/zip;base64,{b64}" download="swiss_geospatial_data.zip">Download All Data</a>'
+                    st.markdown(href, unsafe_allow_html=True)
+                    st.success("Download package prepared. Click the link above to download.")
+                else:
+                    st.warning("No files found for the selected area and options.")
+
+        if st.button("Download Forest Data"):
+            with st.spinner("Downloading forest data..."):
+                with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.geojson') as tmp:
+                    geojson_forest(bbox_lv95, tmp.name)
+                    gdf = gpd.read_file(tmp.name)
+                    st.write(gdf)
+                    # Provide download link for forest data
+                    with open(tmp.name, 'r') as f:
+                        forest_data = f.read()
+                    b64 = base64.b64encode(forest_data.encode()).decode()
+                    href = f'<a href="data:application/json;base64,{b64}" download="forest_data.geojson">Download Forest Data</a>'
+                    st.markdown(href, unsafe_allow_html=True)
+                os.unlink(tmp.name)
+                st.success("Forest data prepared. Click the link above to download.")
+    else:
+        st.error("Selected area is outside Switzerland. Please select an area within Switzerland.")
+
+st.sidebar.info("This application allows you to download various types of geospatial data for Switzerland. Select the data types you want, draw a bounding box on the map, and click 'Get Download Package' to prepare all data for download.")

pages/3_🪟_Split_Map.py

@@ -0,0 +1,30 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+st.set_page_config(layout="wide")
+
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/@giswqs) | [LinkedIn](https://www.linkedin.com/in/giswqs)
+    """
+)
+
+st.title("Split-panel Map")
+
+with st.expander("See source code"):
+    with st.echo():
+        m = leafmap.Map()
+        m.split_map(
+            left_layer="ESA WorldCover 2020 S2 FCC", right_layer="ESA WorldCover 2020"
+        )
+        m.add_legend(title="ESA Land Cover", builtin_legend="ESA_WorldCover")
+
+m.to_streamlit(height=700)

pages/4_🔥_Heatmap.py

@@ -0,0 +1,34 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+st.set_page_config(layout="wide")
+
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/@giswqs) | [LinkedIn](https://www.linkedin.com/in/giswqs)
+    """
+)
+
+st.title("Heatmap")
+
+with st.expander("See source code"):
+    with st.echo():
+        filepath = "https://raw.githubusercontent.com/giswqs/leafmap/master/examples/data/us_cities.csv"
+        m = leafmap.Map(center=[40, -100], zoom=4)
+        m.add_heatmap(
+            filepath,
+            latitude="latitude",
+            longitude="longitude",
+            value="pop_max",
+            name="Heat map",
+            radius=20,
+        )
+m.to_streamlit(height=700)

pages/5_📍_VertXtractor.py

@@ -0,0 +1,320 @@
+import streamlit as st
+import urllib
+import json
+from pathlib import Path
+import datetime
+import folium
+from streamlit_folium import folium_static
+import geopandas as gpd
+import tempfile
+import os
+
+# Constants
+CATEGORIES = {
+    'Gebueschwald': 'Forêt buissonnante',
+    'Wald': 'Forêt',
+    'Wald offen': 'Forêt claisemée',
+    'Gehoelzflaeche': 'Zone boisée',
+}
+
+MERGE_CATEGORIES = True
+URL_STAC_SWISSTOPO_BASE = 'https://data.geo.admin.ch/api/stac/v0.9/collections/'
+DIC_LAYERS = {
+    'ortho': 'ch.swisstopo.swissimage-dop10',
+    'mnt': 'ch.swisstopo.swissalti3d',
+    'mns': 'ch.swisstopo.swisssurface3d-raster',
+    'bati3D_v2': 'ch.swisstopo.swissbuildings3d_2',
+    'bati3D_v3': 'ch.swisstopo.swissbuildings3d_3_0',
+}
+
+# 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)
+    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
+
+def detect_and_convert_bbox(bbox):
+    xmin, ymin, xmax, ymax = bbox
+    wgs84_margin = 0.9
+    wgs84_bounds = {
+        'xmin': 5.96 - wgs84_margin,
+        'ymin': 45.82 - wgs84_margin,
+        'xmax': 10.49 + wgs84_margin,
+        'ymax': 47.81 + wgs84_margin
+    }
+    lv95_margin = 100000
+    lv95_bounds = {
+        'xmin': 2485000 - lv95_margin,
+        'ymin': 1075000 - lv95_margin,
+        'xmax': 2834000 + lv95_margin,
+        'ymax': 1296000 + lv95_margin
+    }
+
+    if (wgs84_bounds['xmin'] <= xmin <= wgs84_bounds['xmax'] and
+        wgs84_bounds['ymin'] <= ymin <= wgs84_bounds['ymax'] and
+        wgs84_bounds['xmin'] <= xmax <= wgs84_bounds['xmax'] and
+        wgs84_bounds['ymin'] <= ymax <= wgs84_bounds['ymax']):
+        lv95_min = wgs84_to_lv95(xmin, ymin)
+        lv95_max = wgs84_to_lv95(xmax, ymax)
+        bbox_lv95 = (lv95_min[0], lv95_min[1], lv95_max[0], lv95_max[1])
+        return (bbox, bbox_lv95)
+    
+    if (lv95_bounds['xmin'] <= xmin <= lv95_bounds['xmax'] and
+        lv95_bounds['ymin'] <= ymin <= lv95_bounds['ymax'] and
+        lv95_bounds['xmin'] <= xmax <= lv95_bounds['xmax'] and
+        lv95_bounds['ymin'] <= ymax <= lv95_bounds['ymax']):
+        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'])
+        return (bbox_wgs84, bbox)
+    
+    return None
+
+def get_list_from_STAC_swisstopo(url, est, sud, ouest, nord, gdb=False):
+    if gdb:
+        lst_indesirables = []
+    else:
+        lst_indesirables = ['.xyz.zip', '.gdb.zip']
+    
+    sufixe_url = f"/items?bbox={est},{sud},{ouest},{nord}"
+    url += sufixe_url
+    res = []
+    
+    while url:
+        f = urllib.request.urlopen(url)
+        txt = f.read().decode('utf-8')
+        json_res = json.loads(txt)
+        url = None
+        links = json_res.get('links', None)
+        if links:
+            for link in links:
+                if link['rel'] == 'next':
+                    url = link['href']
+        for item in json_res['features']:
+            for k, dic in item['assets'].items():
+                href = dic['href']
+                if gdb:
+                    if href[-8:] == '.gdb.zip':
+                        if len(dic['href'].split('/')[-1].split('_')) == 7:
+                            res.append(dic['href'])
+                else:
+                    if href[-8:] not in lst_indesirables:
+                        res.append(dic['href'])
+    return res
+
+def suppr_doublons_list_ortho(lst):
+    dic = {}
+    for url in lst:
+        nom, an, noflle, taille_px, epsg = url.split('/')[-1][:-4].split('_')
+        dic.setdefault((noflle, float(taille_px)), []).append((an, url))
+    res = []
+    for noflle, lst in dic.items():
+        an, url = sorted(lst, reverse=True)[0]
+        res.append(url)
+    return res
+
+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]
+        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]
+        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)
+        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)
+        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 and v.endswith('.png')]
+        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'
+            elif resol == '2':
+                resol = '2m'
+            dirname = f'{name}_{an}_{resol}'
+        elif dirname == 'swisssurface3d-raster':
+            name, an, no_flle, resol, *a = fn.split('_')
+            if resol == '0.5':
+                resol = '50cm'
+            dirname = f'{name}_{an}_{resol}'
+        elif dirname == 'swissimage-dop10':
+            name, an, no_flle, resol, *a = fn.split('_')
+            if resol == '0.1':
+                resol = '10cm'
+            elif resol == '2':
+                resol = '2m'
+            dirname = f'{name}_{an}_{resol}_png'
+
+        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 geojson_forest(bbox, fn_geojson):
+    xmin, ymin, xmax, ymax = bbox
+    url_base = 'https://hepiadata.hesge.ch/arcgis/rest/services/suisse/TLM_C4D_couverture_sol/FeatureServer/1/query?'
+    sql = ' OR '.join([f"OBJEKTART='{cat}'" for cat in CATEGORIES.keys()])
+    params = {
+        "geometry": f"{xmin},{ymin},{xmax},{ymax}",
+        "geometryType": "esriGeometryEnvelope",
+        "returnGeometry": "true",
+        "outFields": "OBJEKTART",
+        "orderByFields": "OBJEKTART",
+        "where": sql,
+        "returnZ": "true",
+        "outSR": '2056',
+        "spatialRel": "esriSpatialRelIntersects",
+        "f": "geojson"
+    }
+    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)
+
+# Streamlit app
+st.set_page_config(page_title="Swiss Geospatial Data Downloader", layout="wide")
+st.title("Swiss Geospatial Data Downloader")
+
+# Sidebar for data selection
+st.sidebar.header("Data Selection")
+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)
+mnt_resol = st.sidebar.selectbox("MNT Resolution", [0.5, 2.0], index=0)
+ortho_resol = st.sidebar.selectbox("Orthophoto Resolution", [0.1, 2.0], 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.0, step=0.1)
+with col2:
+    ymin = st.number_input("Min Latitude", value=46.0, step=0.1)
+with col3:
+    xmax = st.number_input("Max Longitude", value=10.0, step=0.1)
+with col4:
+    ymax = st.number_input("Max Latitude", value=47.0, step=0.1)
+
+if st.button("Set Bounding Box"):
+    st.session_state.bbox = [xmin, ymin, xmax, ymax]
+
+if 'bbox' in st.session_state:
+    st.write(f"Selected bounding box (WGS84): {st.session_state.bbox}")
+    bbox_results = detect_and_convert_bbox(st.session_state.bbox)
+    if bbox_results:
+        bbox_wgs84, bbox_lv95 = bbox_results
+        st.write(f"Converted bounding box (LV95): {bbox_lv95}")
+        
+        if st.button("Get Download Links"):
+            with st.spinner("Fetching download links..."):
+                urls = get_urls(bbox_wgs84, mnt, mns, bati3D_v2, bati3D_v3, ortho, mnt_resol, ortho_resol)
+                if urls:
+                    st.success(f"Found {len(urls)} files to download:")
+                    for url in urls:
+                        st.write(url)
+                    
+                    if st.button("Download Files"):
+                        with st.spinner("Downloading files..."):
+                            download_path = download_files(urls, "downloads")
+                            st.success(f"Files downloaded to: {download_path}")
+                else:
+                    st.warning("No files found for the selected area and options.")
+        
+       # Option to download forest data
+if st.button("Download Forest Data"):
+    with st.spinner("Downloading forest data..."):
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.geojson') as tmp:
+            geojson_forest(bbox_lv95, tmp.name)
+            gdf = gpd.read_file(tmp.name)
+            st.write(gdf)
+            
+            # Display the forest data on a map
+            m = folium.Map(location=[(ymin + ymax) / 2, (xmin + xmax) / 2], zoom_start=10)
+            folium.GeoJson(gdf).add_to(m)
+            folium_static(m)
+            
+            # Option to download the GeoJSON file
+            st.download_button(
+                label="Download Forest GeoJSON",
+                data=gdf.to_json(),
+                file_name="forest_data.geojson",
+                mime="application/json"
+            )
+            
+            os.unlink(tmp.name)
+        st.success("Forest data downloaded, displayed, and available for download.")
+
+else:
+    st.error("Selected area is outside Switzerland. Please select an area within Switzerland.")
+
+# Add information about the app in the sidebar
+st.sidebar.info("""
+This application allows you to download various types of geospatial data for Switzerland. 
+Select the data types you want, enter the bounding box coordinates, and click 'Get Download Links' to see available files.
+You can also download forest data for the selected area.
+""")
+
+# Add a footer
+st.markdown("""
+---
+Created with ❤️ by Your Name
+""")

pages/6_🗺️_Basemaps.py

@@ -0,0 +1,62 @@
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+st.set_page_config(layout="wide")
+
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/@giswqs) | [LinkedIn](https://www.linkedin.com/in/giswqs)
+    """
+)
+
+
+def app():
+    st.title("Search Basemaps")
+    st.markdown(
+        """
+    This app is a demonstration of searching and loading basemaps from [xyzservices](https://github.com/geopandas/xyzservices) and [Quick Map Services (QMS)](https://github.com/nextgis/quickmapservices). Selecting from 1000+ basemaps with a few clicks.
+    """
+    )
+
+    with st.expander("See demo"):
+        st.image("https://i.imgur.com/0SkUhZh.gif")
+
+    row1_col1, row1_col2 = st.columns([3, 1])
+    width = 800
+    height = 600
+    tiles = None
+
+    with row1_col2:
+
+        checkbox = st.checkbox("Search Quick Map Services (QMS)")
+        keyword = st.text_input("Enter a keyword to search and press Enter:")
+        empty = st.empty()
+
+        if keyword:
+            options = leafmap.search_xyz_services(keyword=keyword)
+            if checkbox:
+                qms = leafmap.search_qms(keyword=keyword)
+                if qms is not None:
+                    options = options + qms
+
+            tiles = empty.multiselect("Select XYZ tiles to add to the map:", options)
+
+        with row1_col1:
+            m = leafmap.Map()
+
+            if tiles is not None:
+                for tile in tiles:
+                    m.add_xyz_service(tile)
+
+            m.to_streamlit(height=height)
+
+
+app()

pages/7_📦_Web_Map_Service.py

@@ -0,0 +1,105 @@
+import ast
+import json
+import streamlit as st
+import leafmap.foliumap as leafmap
+
+st.set_page_config(layout="wide")
+
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/@giswqs) | [LinkedIn](https://www.linkedin.com/in/giswqs)
+    """
+)
+
+# Define a whitelist of trusted URLs
+trusted_urls = [
+    "https://services.terrascope.be/wms/v2",
+    # Add more trusted URLs here
+]
+
+
+@st.cache_data
+def get_layers(url):
+    options = leafmap.get_wms_layers(url)
+    return options
+
+
+def is_trusted_url(url):
+    return url in trusted_urls
+
+
+def app():
+    st.title("Web Map Service (WMS)")
+    st.markdown(
+        """
+    This app is a demonstration of loading Web Map Service (WMS) layers. Simply enter the URL of the WMS service
+    in the text box below and press Enter to retrieve the layers. Go to https://apps.nationalmap.gov/services to find
+    some WMS URLs if needed.
+    """
+    )
+
+    row1_col1, row1_col2 = st.columns([3, 1.3])
+    width = 800
+    height = 600
+    layers = None
+
+    with row1_col2:
+
+        esa_landcover = "https://services.terrascope.be/wms/v2"
+        url = st.text_input(
+            "Enter a WMS URL:", value="https://services.terrascope.be/wms/v2"
+        )
+        empty = st.empty()
+
+        if url:
+
+            if is_trusted_url(url):
+                options = get_layers(url)
+                # Process options as needed
+            else:
+                st.error(
+                    "The entered URL is not trusted. Please enter a valid WMS URL."
+                )
+
+            default = None
+            if url == esa_landcover:
+                default = "WORLDCOVER_2020_MAP"
+            layers = empty.multiselect(
+                "Select WMS layers to add to the map:", options, default=default
+            )
+            add_legend = st.checkbox("Add a legend to the map", value=True)
+            if default == "WORLDCOVER_2020_MAP":
+                legend = str(leafmap.builtin_legends["ESA_WorldCover"])
+            else:
+                legend = ""
+            if add_legend:
+                legend_text = st.text_area(
+                    "Enter a legend as a dictionary {label: color}",
+                    value=legend,
+                    height=200,
+                )
+
+        with row1_col1:
+            m = leafmap.Map(center=(36.3, 0), zoom=2)
+
+            if layers is not None:
+                for layer in layers:
+                    m.add_wms_layer(
+                        url, layers=layer, name=layer, attribution=" ", transparent=True
+                    )
+            if add_legend and legend_text:
+                legend_dict = json.loads(legend_text.replace("'", '"'))
+                m.add_legend(legend_dict=legend_dict)
+
+            m.to_streamlit(height=height)
+
+
+app()

pages/8_🏜️_Raster_Data_Visualization.py

@@ -0,0 +1,117 @@
+import json
+import os
+import leafmap.foliumap as leafmap
+import leafmap.colormaps as cm
+import streamlit as st
+
+st.set_page_config(layout="wide")
+
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/@giswqs) | [LinkedIn](https://www.linkedin.com/in/giswqs)
+    """
+)
+
+
+@st.cache_data
+def load_cog_list():
+    print(os.getcwd())
+    in_txt = os.path.join(os.getcwd(), "data/cog_files.txt")
+    with open(in_txt) as f:
+        return [line.strip() for line in f.readlines()[1:]]
+
+
+@st.cache_data
+def get_palettes():
+    return list(cm.palettes.keys())
+    # palettes = dir(palettable.matplotlib)[:-16]
+    # return ["matplotlib." + p for p in palettes]
+
+
+st.title("Visualize Raster Datasets")
+st.markdown(
+    """
+An interactive web app for visualizing local raster datasets and Cloud Optimized GeoTIFF ([COG](https://www.cogeo.org)). The app was built using [streamlit](https://streamlit.io), [leafmap](https://leafmap.org), and [Titiler](https://developmentseed.org/titiler/).
+
+
+"""
+)
+
+
+def is_trusted_url(url):
+    if url.startswith("https://opendata.digitalglobe.com/events/california-fire-2020/"):
+        return True
+    else:
+        return False
+
+
+row1_col1, row1_col2 = st.columns([2, 1])
+
+with row1_col1:
+    cog_list = load_cog_list()
+    cog = st.selectbox("Select a sample Cloud Opitmized GeoTIFF (COG)", cog_list)
+
+with row1_col2:
+    empty = st.empty()
+
+    url = empty.text_input(
+        "Enter a HTTP URL to a Cloud Optimized GeoTIFF (COG)",
+        cog,
+    )
+
+    if is_trusted_url(url):
+        try:
+            options = leafmap.cog_bands(url)
+        except Exception as e:
+            st.error(e)
+        if len(options) > 3:
+            default = options[:3]
+        else:
+            default = options[0]
+        bands = st.multiselect("Select bands to display", options, default=options)
+
+        if len(bands) == 1 or len(bands) == 3:
+            pass
+        else:
+            st.error("Please select one or three bands")
+    else:
+        st.error("Please enter a trusted URL")
+
+    add_params = st.checkbox("Add visualization parameters")
+    if add_params:
+        vis_params = st.text_area("Enter visualization parameters", "{}")
+    else:
+        vis_params = {}
+
+    if len(vis_params) > 0:
+        try:
+            vis_params = json.loads(vis_params.replace("'", '"'))
+        except Exception as e:
+            st.error(
+                f"Invalid visualization parameters. It should be a dictionary. Error: {e}"
+            )
+            vis_params = {}
+
+    submit = st.button("Submit")
+
+m = leafmap.Map(latlon_control=False)
+
+if submit:
+    if url:
+        try:
+            m.add_cog_layer(url, bands=bands, **vis_params)
+        except Exception as e:
+            with row1_col2:
+                st.error(e)
+                st.error("Work in progress. Try it again later.")
+
+with row1_col1:
+    m.to_streamlit()

pages/9_🔲_Vector_Data_Visualization.py

@@ -0,0 +1,128 @@
+import os
+import fiona
+import geopandas as gpd
+import streamlit as st
+
+st.set_page_config(layout="wide")
+
+st.sidebar.info(
+    """
+    - Web App URL: <https://streamlit.gishub.org>
+    - GitHub repository: <https://github.com/giswqs/streamlit-geospatial>
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/@giswqs) | [LinkedIn](https://www.linkedin.com/in/giswqs)
+    """
+)
+
+
+# Define a whitelist of trusted URLs
+trusted_urls = [
+    "https://github.com/giswqs/streamlit-geospatial/raw/master/data/us_states.geojson",
+    # Add more trusted URLs here
+]
+
+
+def is_trusted_url(url):
+    return url in trusted_urls
+
+
+def save_uploaded_file(file_content, file_name):
+    """
+    Save the uploaded file to a temporary directory
+    """
+    import tempfile
+    import os
+    import uuid
+
+    _, file_extension = os.path.splitext(file_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(file_content.getbuffer())
+
+    return file_path
+
+
+def app():
+
+    st.title("Upload Vector Data")
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+    width = 950
+    height = 600
+
+    with row1_col2:
+
+        backend = st.selectbox(
+            "Select a plotting backend", ["folium", "kepler.gl", "pydeck"], index=2
+        )
+
+        if backend == "folium":
+            import leafmap.foliumap as leafmap
+        elif backend == "kepler.gl":
+            import leafmap.kepler as leafmap
+        elif backend == "pydeck":
+            import leafmap.deck as leafmap
+
+        url = st.text_input(
+            "Enter a URL to a vector dataset",
+            "https://github.com/giswqs/streamlit-geospatial/raw/master/data/us_states.geojson",
+        )
+
+        data = st.file_uploader(
+            "Upload a vector dataset", type=["geojson", "kml", "zip", "tab"]
+        )
+
+        container = st.container()
+
+        if data or is_trusted_url(url):
+            if data:
+                file_path = save_uploaded_file(data, data.name)
+                layer_name = os.path.splitext(data.name)[0]
+            elif url:
+                file_path = url
+                layer_name = url.split("/")[-1].split(".")[0]
+
+            with row1_col1:
+                if file_path.lower().endswith(".kml"):
+                    fiona.drvsupport.supported_drivers["KML"] = "rw"
+                    gdf = gpd.read_file(file_path, driver="KML")
+                else:
+                    gdf = gpd.read_file(file_path)
+                lon, lat = leafmap.gdf_centroid(gdf)
+                if backend == "pydeck":
+
+                    column_names = gdf.columns.values.tolist()
+                    random_column = None
+                    with container:
+                        random_color = st.checkbox("Apply random colors", True)
+                        if random_color:
+                            random_column = st.selectbox(
+                                "Select a column to apply random colors", column_names
+                            )
+
+                    m = leafmap.Map(center=(lat, lon))
+                    m.add_gdf(gdf, random_color_column=random_column)
+                    st.pydeck_chart(m)
+
+                else:
+                    m = leafmap.Map(center=(lat, lon), draw_export=True)
+                    m.add_gdf(gdf, layer_name=layer_name)
+                    # m.add_vector(file_path, layer_name=layer_name)
+                    if backend == "folium":
+                        m.zoom_to_gdf(gdf)
+                    m.to_streamlit(width=width, height=height)
+
+        else:
+            with row1_col1:
+                m = leafmap.Map()
+                st.pydeck_chart(m)
+
+
+app()

pages/HQTimelapse.py

@@ -0,0 +1,229 @@
+import streamlit as st
+import geopandas as gpd
+import folium
+from folium import plugins
+import requests
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import imageio
+import tempfile
+import os
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
+import base64
+import asyncio
+import aiohttp
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
+
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles
+AVAILABLE_DATES = [
+    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231, 18971231, 18981231, 18991231,
+    19001231, 19011231, 19021231, 19031231, 19041231, 19051231, 19061231, 19071231, 19081231, 19091231,
+    19101231, 19111231, 19121231, 19131231, 19141231, 19151231, 19161231, 19171231, 19181231, 19191231,
+    19201231, 19211231, 19221231, 19231231, 19241231, 19251231, 19261231, 19271231, 19281231, 19291231,
+    19301231, 19311231, 19321231, 19331231, 19341231, 19351231, 19361231, 19371231, 19381231, 19391231,
+    19401231, 19411231, 19421231, 19431231, 19441231, 19451231, 19461231, 19471231, 19481231, 19491231,
+    19501231, 19511231, 19521231, 19531231, 19541231, 19551231, 19561231, 19571231, 19581231, 19591231,
+    19601231, 19611231, 19621231, 19631231, 19641231, 19651231, 19661231, 19671231, 19681231, 19691231,
+    19701231, 19711231, 19721231, 19731231, 19741231, 19751231, 19761231, 19771231, 19781231, 19791231,
+    19801231, 19811231, 19821231, 19831231, 19841231, 19851231, 19861231, 19871231, 19881231, 19891231,
+    19901231, 19911231, 19921231, 19931231, 19941231, 19951231, 19961231, 19971231, 19981231, 19991231,
+    20001231, 20011231, 20021231, 20031231, 20041231, 20051231, 20061231, 20071231, 20081231, 20091231,
+    20101231, 20111231, 20121231, 20131231, 20141231, 20151231, 20161231, 20171231, 20181231, 20191231,
+    20201231, 20211231
+]
+
+@st.cache_data
+def uploaded_file_to_gdf(data):
+    import tempfile
+    import os
+    import uuid
+
+    _, 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
+
+@lru_cache(maxsize=128)
+def get_wms_url(bbox, width, height, time):
+    url = "https://wms.geo.admin.ch/"
+    params = {
+        "SERVICE": "WMS",
+        "REQUEST": "GetMap",
+        "VERSION": "1.3.0",
+        "LAYERS": "ch.swisstopo.zeitreihen",
+        "STYLES": "",
+        "CRS": "EPSG:2056",
+        "BBOX": ",".join(map(str, bbox)),
+        "WIDTH": str(width),
+        "HEIGHT": str(height),
+        "FORMAT": "image/png",
+        "TIME": str(time),
+        "TILED": "true"
+    }
+    return url + "?" + "&".join(f"{k}={v}" for k, v in params.items())
+
+def add_date_to_image(image, date):
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.load_default()
+    text = str(date)
+    
+    bbox = draw.textbbox((0, 0), text, font=font)
+    textwidth = bbox[2] - bbox[0]
+    textheight = bbox[3] - bbox[1]
+    
+    margin = 10
+    x = image.width - textwidth - margin
+    y = image.height - textheight - margin
+    draw.rectangle((x-5, y-5, x+textwidth+5, y+textheight+5), fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+    return image
+
+async def fetch_image(session, url, date):
+    async with session.get(url) as response:
+        if response.status == 200:
+            data = await response.read()
+            img = Image.open(BytesIO(data))
+            return add_date_to_image(img, date)
+    return None
+
+async def download_images(bbox, width, height, available_years):
+    async with aiohttp.ClientSession() as session:
+        tasks = []
+        for date in available_years:
+            url = get_wms_url(bbox, width, height, date)
+            tasks.append(fetch_image(session, url, date))
+        return await asyncio.gather(*tasks)
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Download {file_label}</a>'
+    return href
+
+def app():
+    st.title("Swiss Historical Timelapse Generator")
+
+    st.markdown(
+        """
+        An interactive web app for creating historical timelapses of Switzerland using WMS-Time.
+        """
+    )
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+
+    with row1_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 row1_col2:
+        data = st.file_uploader(
+            "Upload a GeoJSON file to use as an ROI. Customize timelapse parameters and then click the Submit button 😇👇",
+            type=["geojson", "kml", "zip"],
+        )
+
+        with st.form("submit_form"):
+            start_year = st.selectbox("Select start year:", [date // 10000 for date in AVAILABLE_DATES])
+            end_year = st.selectbox("Select end year:", [date // 10000 for date in AVAILABLE_DATES], index=len(AVAILABLE_DATES)-1)
+            
+            width = st.slider("Image width:", 100, 1000, 800)
+            height = st.slider("Image height:", 100, 1000, 600)
+            
+            speed = st.slider("Frames per second:", 1, 30, 5)
+
+            submitted = st.form_submit_button("Generate Timelapse")
+
+        if submitted:
+            if data is None:
+                st.warning("Please upload a GeoJSON file.")
+            else:
+                gdf = uploaded_file_to_gdf(data)
+                gdf_2056 = gdf.to_crs(epsg=2056)
+                bbox = tuple(gdf_2056.total_bounds)
+
+                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+                
+                # Création des dossiers temporaires pour stocker les images et les vidéos
+                temp_dir = tempfile.mkdtemp()
+                images_dir = os.path.join(temp_dir, "images")
+                os.makedirs(images_dir, exist_ok=True)
+                
+                progress_bar = st.progress(0)
+                
+                # Téléchargement asynchrone des images
+                images = asyncio.run(download_images(bbox, width, height, available_years))
+                
+                all_image_files = []
+                for i, img in enumerate(images):
+                    if img:
+                        img_file = os.path.join(images_dir, f"image_{i}.png")
+                        img.save(img_file, format='PNG')
+                        all_image_files.append(img_file)
+                    progress_bar.progress((i + 1) / len(available_years))
+
+                if all_image_files:
+                    # Génération du GIF
+                    gif_path = os.path.join(temp_dir, "timelapse.gif")
+                    with ThreadPoolExecutor() as executor:
+                        frames = list(executor.map(imageio.imread, all_image_files))
+                    imageio.mimsave(gif_path, frames, fps=speed, loop=0)
+                    st.success("GIF Timelapse created successfully!")
+                    st.image(gif_path)
+                    st.markdown(get_binary_file_downloader_html(gif_path, 'Timelapse GIF'), unsafe_allow_html=True)
+
+                    # Génération du MP4
+                    mp4_path = os.path.join(temp_dir, "timelapse.mp4")
+                    imageio.mimsave(mp4_path, frames, fps=speed, format='FFMPEG', quality=9)
+                    st.success("MP4 Timelapse created successfully!")
+                    st.video(mp4_path)
+                    st.markdown(get_binary_file_downloader_html(mp4_path, 'Timelapse MP4'), unsafe_allow_html=True)
+
+                    # Création du ZIP avec les images individuelles
+                    zip_path = os.path.join(temp_dir, "images.zip")
+                    with zipfile.ZipFile(zip_path, 'w') as zipf:
+                        for file in all_image_files:
+                            zipf.write(file, os.path.basename(file))
+                    
+                    st.success("Individual images saved successfully!")
+                    st.markdown(get_binary_file_downloader_html(zip_path, 'Individual Images (ZIP)'), unsafe_allow_html=True)
+
+                    # Nettoyage des fichiers temporaires
+                    for file in all_image_files:
+                        os.unlink(file)
+                    os.rmdir(images_dir)
+                    os.unlink(gif_path)
+                    os.unlink(mp4_path)
+                    os.unlink(zip_path)
+                    os.rmdir(temp_dir)
+                else:
+                    st.error("Failed to create timelapse. No images were generated.")
+
+if __name__ == "__main__":
+    app()

pages/_📷_Timelapse.py

@@ -0,0 +1,238 @@
+import streamlit as st
+import geopandas as gpd
+import folium
+from folium import plugins
+import requests
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import imageio
+import tempfile
+import os
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
+import base64
+import asyncio
+import aiohttp
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
+
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles
+AVAILABLE_DATES = [
+    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231, 18971231, 18981231, 18991231,
+    19001231, 19011231, 19021231, 19031231, 19041231, 19051231, 19061231, 19071231, 19081231, 19091231,
+    19101231, 19111231, 19121231, 19131231, 19141231, 19151231, 19161231, 19171231, 19181231, 19191231,
+    19201231, 19211231, 19221231, 19231231, 19241231, 19251231, 19261231, 19271231, 19281231, 19291231,
+    19301231, 19311231, 19321231, 19331231, 19341231, 19351231, 19361231, 19371231, 19381231, 19391231,
+    19401231, 19411231, 19421231, 19431231, 19441231, 19451231, 19461231, 19471231, 19481231, 19491231,
+    19501231, 19511231, 19521231, 19531231, 19541231, 19551231, 19561231, 19571231, 19581231, 19591231,
+    19601231, 19611231, 19621231, 19631231, 19641231, 19651231, 19661231, 19671231, 19681231, 19691231,
+    19701231, 19711231, 19721231, 19731231, 19741231, 19751231, 19761231, 19771231, 19781231, 19791231,
+    19801231, 19811231, 19821231, 19831231, 19841231, 19851231, 19861231, 19871231, 19881231, 19891231,
+    19901231, 19911231, 19921231, 19931231, 19941231, 19951231, 19961231, 19971231, 19981231, 19991231,
+    20001231, 20011231, 20021231, 20031231, 20041231, 20051231, 20061231, 20071231, 20081231, 20091231,
+    20101231, 20111231, 20121231, 20131231, 20141231, 20151231, 20161231, 20171231, 20181231, 20191231,
+    20201231, 20211231
+]
+
+@st.cache_data
+def uploaded_file_to_gdf(data):
+    import tempfile
+    import os
+    import uuid
+
+    _, 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
+
+@lru_cache(maxsize=128)
+def get_wms_url(bbox, width, height, time):
+    url = "https://wms.geo.admin.ch/"
+    params = {
+        "SERVICE": "WMS",
+        "REQUEST": "GetMap",
+        "VERSION": "1.3.0",
+        "LAYERS": "ch.swisstopo.zeitreihen",
+        "STYLES": "",
+        "CRS": "EPSG:2056",
+        "BBOX": ",".join(map(str, bbox)),
+        "WIDTH": str(width),
+        "HEIGHT": str(height),
+        "FORMAT": "image/png",
+        "TIME": str(time),
+        "TILED": "true"
+    }
+    return url + "?" + "&".join(f"{k}={v}" for k, v in params.items())
+
+def add_date_to_image(image, date):
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.load_default()
+    text = str(date)
+    
+    bbox = draw.textbbox((0, 0), text, font=font)
+    textwidth = bbox[2] - bbox[0]
+    textheight = bbox[3] - bbox[1]
+    
+    margin = 10
+    x = image.width - textwidth - margin
+    y = image.height - textheight - margin
+    draw.rectangle((x-5, y-5, x+textwidth+5, y+textheight+5), fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+    return image
+
+async def fetch_image(session, url, date, semaphore):
+    async with semaphore:
+        async with session.get(url) as response:
+            if response.status == 200:
+                data = await response.read()
+                img = Image.open(BytesIO(data))
+                return add_date_to_image(img, date)
+    return None
+
+async def download_images(bbox, width, height, available_years):
+    semaphore = asyncio.Semaphore(10)  # Limite le nombre de requêtes simultanées
+    async with aiohttp.ClientSession() as session:
+        tasks = []
+        for date in available_years:
+            url = get_wms_url(bbox, width, height, date)
+            tasks.append(fetch_image(session, url, date, semaphore))
+        return await asyncio.gather(*tasks)
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Download {file_label}</a>'
+    return href
+
+def process_images(images, format_option, speed, temp_dir):
+    results = {}
+    
+    if "GIF" in format_option:
+        gif_path = os.path.join(temp_dir, "timelapse.gif")
+        imageio.mimsave(gif_path, images, fps=speed, loop=0)
+        results["GIF"] = gif_path
+
+    if "MP4" in format_option:
+        mp4_path = os.path.join(temp_dir, "timelapse.mp4")
+        imageio.mimsave(mp4_path, images, fps=speed, format='FFMPEG', quality=9)
+        results["MP4"] = mp4_path
+
+    if "Individual Images (ZIP)" in format_option:
+        zip_path = os.path.join(temp_dir, "images.zip")
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
+            for i, img in enumerate(images):
+                img_path = os.path.join(temp_dir, f"image_{i}.png")
+                img.save(img_path)
+                zipf.write(img_path, os.path.basename(img_path))
+                os.unlink(img_path)
+        results["ZIP"] = zip_path
+
+    return results
+
+def app():
+    st.title("Swiss Historical Timelapse Generator")
+
+    st.markdown(
+        """
+        An interactive web app for creating historical timelapses of Switzerland using WMS-Time.
+        """
+    )
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+
+    with row1_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 row1_col2:
+        data = st.file_uploader(
+            "Upload a GeoJSON file to use as an ROI. Customize timelapse parameters and then click the Submit button 😇👇",
+            type=["geojson", "kml", "zip"],
+        )
+
+        with st.form("submit_form"):
+            start_year = st.selectbox("Select start year:", [date // 10000 for date in AVAILABLE_DATES])
+            end_year = st.selectbox("Select end year:", [date // 10000 for date in AVAILABLE_DATES], index=len(AVAILABLE_DATES)-1)
+            
+            width = st.slider("Image width:", 100, 4000, 800)
+            height = st.slider("Image height:", 100, 4000, 600)
+            
+            if width * height > 4000 * 4000:
+                st.warning("Warning: The image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            
+            speed = st.slider("Frames per second:", 1, 30, 5)
+
+            format_option = st.multiselect("Choose output format(s):", ["GIF", "MP4", "Individual Images (ZIP)"], default=["GIF", "MP4", "Individual Images (ZIP)"])
+
+            submitted = st.form_submit_button("Generate Timelapse")
+
+        if submitted:
+            if data is None:
+                st.warning("Please upload a GeoJSON file.")
+            elif width * height > 4000 * 4000:
+                st.error("Image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            else:
+                gdf = uploaded_file_to_gdf(data)
+                gdf_2056 = gdf.to_crs(epsg=2056)
+                bbox = tuple(gdf_2056.total_bounds)
+
+                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+                
+                total_requests = len(available_years)
+                
+                if total_requests > 500:
+                    st.warning(f"You are requesting {total_requests} images. This exceeds the limit of 500 requests per second set by swisstopo. The process may take longer than expected.")
+                
+                progress_bar = st.progress(0)
+                
+                images = asyncio.run(download_images(bbox, width, height, available_years))
+                
+                progress_bar.progress(100)
+
+                if images:
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        results = process_images(images, format_option, speed, temp_dir)
+
+                        for format, path in results.items():
+                            if format == "GIF":
+                                st.success("GIF Timelapse created successfully!")
+                                st.image(path)
+                                st.markdown(get_binary_file_downloader_html(path, 'Timelapse GIF'), unsafe_allow_html=True)
+                            elif format == "MP4":
+                                st.success("MP4 Timelapse created successfully!")
+                                st.video(path)
+                                st.markdown(get_binary_file_downloader_html(path, 'Timelapse MP4'), unsafe_allow_html=True)
+                            elif format == "ZIP":
+                                st.success("Individual images saved successfully!")
+                                st.markdown(get_binary_file_downloader_html(path, 'Individual Images (ZIP)'), unsafe_allow_html=True)
+                else:
+                    st.error("Failed to create timelapse. No images were generated.")
+
+if __name__ == "__main__":
+    app()

pages/histoire.py

@@ -0,0 +1,206 @@
+import streamlit as st
+import geopandas as gpd
+import folium
+from folium import plugins
+import requests
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import imageio
+import tempfile
+import os
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
+import base64
+
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles
+AVAILABLE_DATES = [
+    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231, 18971231, 18981231, 18991231,
+    19001231, 19011231, 19021231, 19031231, 19041231, 19051231, 19061231, 19071231, 19081231, 19091231,
+    19101231, 19111231, 19121231, 19131231, 19141231, 19151231, 19161231, 19171231, 19181231, 19191231,
+    19201231, 19211231, 19221231, 19231231, 19241231, 19251231, 19261231, 19271231, 19281231, 19291231,
+    19301231, 19311231, 19321231, 19331231, 19341231, 19351231, 19361231, 19371231, 19381231, 19391231,
+    19401231, 19411231, 19421231, 19431231, 19441231, 19451231, 19461231, 19471231, 19481231, 19491231,
+    19501231, 19511231, 19521231, 19531231, 19541231, 19551231, 19561231, 19571231, 19581231, 19591231,
+    19601231, 19611231, 19621231, 19631231, 19641231, 19651231, 19661231, 19671231, 19681231, 19691231,
+    19701231, 19711231, 19721231, 19731231, 19741231, 19751231, 19761231, 19771231, 19781231, 19791231,
+    19801231, 19811231, 19821231, 19831231, 19841231, 19851231, 19861231, 19871231, 19881231, 19891231,
+    19901231, 19911231, 19921231, 19931231, 19941231, 19951231, 19961231, 19971231, 19981231, 19991231,
+    20001231, 20011231, 20021231, 20031231, 20041231, 20051231, 20061231, 20071231, 20081231, 20091231,
+    20101231, 20111231, 20121231, 20131231, 20141231, 20151231, 20161231, 20171231, 20181231, 20191231,
+    20201231, 20211231
+]
+
+@st.cache_data
+def uploaded_file_to_gdf(data):
+    import tempfile
+    import os
+    import uuid
+
+    _, 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_wms_image(bbox, width, height, time):
+    url = "https://wms.geo.admin.ch/"
+    params = {
+        "SERVICE": "WMS",
+        "REQUEST": "GetMap",
+        "VERSION": "1.3.0",
+        "LAYERS": "ch.swisstopo.zeitreihen",
+        "STYLES": "",
+        "CRS": "EPSG:2056",
+        "BBOX": ",".join(map(str, bbox)),
+        "WIDTH": str(width),
+        "HEIGHT": str(height),
+        "FORMAT": "image/png",
+        "TIME": str(time),
+        "TILED": "true"
+    }
+    response = requests.get(url, params=params)
+    if response.status_code == 200:
+        return Image.open(BytesIO(response.content))
+    else:
+        st.error(f"Failed to fetch image: {response.status_code}")
+        return None
+
+def add_date_to_image(image, date):
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.load_default()
+    text = str(date)
+    
+    bbox = draw.textbbox((0, 0), text, font=font)
+    textwidth = bbox[2] - bbox[0]
+    textheight = bbox[3] - bbox[1]
+    
+    margin = 10
+    x = image.width - textwidth - margin
+    y = image.height - textheight - margin
+    draw.rectangle((x-5, y-5, x+textwidth+5, y+textheight+5), fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+    return image
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Download {file_label}</a>'
+    return href
+
+def app():
+    st.title("Swiss Historical Timelapse Generator")
+
+    st.markdown(
+        """
+        An interactive web app for creating historical timelapses of Switzerland using WMS-Time.
+        """
+    )
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+
+    with row1_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 row1_col2:
+        data = st.file_uploader(
+            "Upload a GeoJSON file to use as an ROI. Customize timelapse parameters and then click the Submit button 😇👇",
+            type=["geojson", "kml", "zip"],
+        )
+
+        with st.form("submit_form"):
+            start_year = st.selectbox("Select start year:", [date // 10000 for date in AVAILABLE_DATES])
+            end_year = st.selectbox("Select end year:", [date // 10000 for date in AVAILABLE_DATES], index=len(AVAILABLE_DATES)-1)
+            
+            width = st.slider("Image width:", 100, 1000, 800)
+            height = st.slider("Image height:", 100, 1000, 600)
+            
+            speed = st.slider("Frames per second:", 1, 30, 5)
+
+            format_option = st.radio("Choose output format:", ("GIF", "MP4", "Both"))
+
+            submitted = st.form_submit_button("Generate Timelapse")
+
+        if submitted:
+            if data is None:
+                st.warning("Please upload a GeoJSON file.")
+            else:
+                gdf = uploaded_file_to_gdf(data)
+                gdf_2056 = gdf.to_crs(epsg=2056)
+                bbox = gdf_2056.total_bounds
+
+                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+                images = []
+                image_files = []
+
+                progress_bar = st.progress(0)
+                for i, date in enumerate(available_years):
+                    img = get_wms_image(bbox, width, height, date)
+                    if img:
+                        img_with_date = add_date_to_image(img, date)
+                        images.append(img_with_date)
+                        
+                        # Save individual image
+                        img_file = tempfile.NamedTemporaryFile(delete=False, suffix=f"_{date}.png")
+                        img_with_date.save(img_file.name)
+                        image_files.append(img_file.name)
+                        
+                    progress_bar.progress((i + 1) / len(available_years))
+
+                if images:
+                    if format_option in ["GIF", "Both"]:
+                        with tempfile.NamedTemporaryFile(suffix=".gif", delete=False) as tmp_file:
+                            imageio.mimsave(tmp_file.name, images, fps=speed, loop=0)
+                            st.success("GIF Timelapse created successfully!")
+                            st.image(tmp_file.name)
+                            st.markdown(get_binary_file_downloader_html(tmp_file.name, 'Timelapse GIF'), unsafe_allow_html=True)
+
+                    if format_option in ["MP4", "Both"]:
+                        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_file:
+                            imageio.mimsave(tmp_file.name, images, fps=speed, format='FFMPEG')
+                            st.success("MP4 Timelapse created successfully!")
+                            st.video(tmp_file.name)
+                            st.markdown(get_binary_file_downloader_html(tmp_file.name, 'Timelapse MP4'), unsafe_allow_html=True)
+                    
+                    # Create ZIP file with individual images
+                    with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
+                        with zipfile.ZipFile(tmp_zip.name, 'w') as zipf:
+                            for img_file in image_files:
+                                zipf.write(img_file, os.path.basename(img_file))
+                    
+                    st.success("Individual images saved successfully!")
+                    st.markdown(get_binary_file_downloader_html(tmp_zip.name, 'Individual Images (ZIP)'), unsafe_allow_html=True)
+                    
+                    # Clean up temporary image files
+                    for img_file in image_files:
+                        os.unlink(img_file)
+                else:
+                    st.error("Failed to create timelapse. No images were generated.")
+
+if __name__ == "__main__":
+    app()

pages/lastime.py

@@ -0,0 +1,298 @@
+import streamlit as st
+import geopandas as gpd
+import folium
+from folium import plugins
+import requests
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import imageio
+import tempfile
+import os
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
+import base64
+import asyncio
+import aiohttp
+import concurrent.futures
+import logging
+import numpy as np
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Configuration de la page Streamlit
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles
+AVAILABLE_DATES = [
+    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231, 18971231, 18981231, 18991231,
+    19001231, 19011231, 19021231, 19031231, 19041231, 19051231, 19061231, 19071231, 19081231, 19091231,
+    19101231, 19111231, 19121231, 19131231, 19141231, 19151231, 19161231, 19171231, 19181231, 19191231,
+    19201231, 19211231, 19221231, 19231231, 19241231, 19251231, 19261231, 19271231, 19281231, 19291231,
+    19301231, 19311231, 19321231, 19331231, 19341231, 19351231, 19361231, 19371231, 19381231, 19391231,
+    19401231, 19411231, 19421231, 19431231, 19441231, 19451231, 19461231, 19471231, 19481231, 19491231,
+    19501231, 19511231, 19521231, 19531231, 19541231, 19551231, 19561231, 19571231, 19581231, 19591231,
+    19601231, 19611231, 19621231, 19631231, 19641231, 19651231, 19661231, 19671231, 19681231, 19691231,
+    19701231, 19711231, 19721231, 19731231, 19741231, 19751231, 19761231, 19771231, 19781231, 19791231,
+    19801231, 19811231, 19821231, 19831231, 19841231, 19851231, 19861231, 19871231, 19881231, 19891231,
+    19901231, 19911231, 19921231, 19931231, 19941231, 19951231, 19961231, 19971231, 19981231, 19991231,
+    20001231, 20011231, 20021231, 20031231, 20041231, 20051231, 20061231, 20071231, 20081231, 20091231,
+    20101231, 20111231, 20121231, 20131231, 20141231, 20151231, 20161231, 20171231, 20181231, 20191231,
+    20201231, 20211231
+]
+
+@st.cache_data
+def uploaded_file_to_gdf(data):
+    import tempfile
+    import os
+    import uuid
+
+    _, 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
+
+@st.cache_data
+def get_wms_url(bbox, width, height, time):
+    url = "https://wms.geo.admin.ch/"
+    params = {
+        "SERVICE": "WMS",
+        "REQUEST": "GetMap",
+        "VERSION": "1.3.0",
+        "LAYERS": "ch.swisstopo.zeitreihen",
+        "STYLES": "",
+        "CRS": "EPSG:2056",
+        "BBOX": ",".join(map(str, bbox)),
+        "WIDTH": str(width),
+        "HEIGHT": str(height),
+        "FORMAT": "image/png",
+        "TIME": str(time),
+        "TILED": "true"
+    }
+    return url + "?" + "&".join(f"{k}={v}" for k, v in params.items())
+
+def add_date_to_image(image, date):
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.load_default()
+    text = str(date // 10000)  # Extraire seulement l'année
+    
+    bbox = draw.textbbox((0, 0), text, font=font)
+    textwidth = bbox[2] - bbox[0]
+    textheight = bbox[3] - bbox[1]
+    
+    margin = 10
+    x = image.width - textwidth - margin
+    y = image.height - textheight - margin
+    draw.rectangle((x-5, y-5, x+textwidth+5, y+textheight+5), fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+    return image
+
+async def fetch_image(session, url, date, semaphore):
+    async with semaphore:
+        try:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    data = await response.read()
+                    img = Image.open(BytesIO(data))
+                    return add_date_to_image(img, date)
+        except Exception as e:
+            logger.error(f"Error fetching image for date {date}: {str(e)}")
+    return None
+
+async def download_images(bbox, width, height, available_years, max_concurrent_requests):
+    semaphore = asyncio.Semaphore(max_concurrent_requests)
+    async with aiohttp.ClientSession() as session:
+        tasks = [fetch_image(session, get_wms_url(bbox, width, height, date), date, semaphore) for date in available_years]
+        return await asyncio.gather(*tasks)
+
+def process_single_image(args):
+    img, i, format_option, temp_dir = args
+    results = {}
+    if img:
+        if "GIF" in format_option or "MP4" in format_option:
+            img_array = np.array(img)
+            results['array'] = img_array
+        if "Individual Images (ZIP)" in format_option:
+            img_path = os.path.join(temp_dir, f"image_{i}.png")
+            img.save(img_path)
+            results['path'] = img_path
+    return results
+
+def process_images(images, format_option, temp_dir, batch_size=100):
+    results = {"GIF": [], "MP4": [], "ZIP": []}
+    
+    for i in range(0, len(images), batch_size):
+        batch = images[i:i+batch_size]
+        with concurrent.futures.ProcessPoolExecutor() as executor:
+            batch_results = list(executor.map(process_single_image, [(img, j, format_option, temp_dir) for j, img in enumerate(batch, start=i) if img is not None]))
+        
+        for result in batch_results:
+            if 'array' in result:
+                results["GIF"].append(result['array'])
+                results["MP4"].append(result['array'])
+            if 'path' in result:
+                results["ZIP"].append(result['path'])
+    
+    return results
+
+def create_timelapse(images, format_option, speed, temp_dir):
+    results = {}
+    
+    if "GIF" in format_option:
+        gif_path = os.path.join(temp_dir, "timelapse.gif")
+        imageio.mimsave(gif_path, images["GIF"], fps=speed)
+        results["GIF"] = gif_path
+    
+    if "MP4" in format_option:
+        mp4_path = os.path.join(temp_dir, "timelapse.mp4")
+        imageio.mimsave(mp4_path, images["MP4"], fps=speed, format='FFMPEG', quality=8)
+        results["MP4"] = mp4_path
+    
+    if "Individual Images (ZIP)" in format_option:
+        zip_path = os.path.join(temp_dir, "images.zip")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for img_path in images["ZIP"]:
+                zipf.write(img_path, os.path.basename(img_path))
+                os.unlink(img_path)
+        results["ZIP"] = zip_path
+    
+    return results
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Download {file_label}</a>'
+    return href
+
+def app():
+    st.title("Swiss Historical Timelapse Generator")
+
+    st.markdown(
+        """
+        An interactive web app for creating historical timelapses of Switzerland using WMS-Time.
+        """
+    )
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+
+    with row1_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 row1_col2:
+        data = st.file_uploader(
+            "Upload a GeoJSON file to use as an ROI. Customize timelapse parameters and then click the Submit button 😇👇",
+            type=["geojson", "kml", "zip"],
+        )
+
+        with st.form("submit_form"):
+            start_year = st.selectbox("Select start year:", [date // 10000 for date in AVAILABLE_DATES])
+            end_year = st.selectbox("Select end year:", [date // 10000 for date in AVAILABLE_DATES], index=len(AVAILABLE_DATES)-1)
+            
+            size_options = {
+                "HD (720p)": (1280, 720),
+                "Full HD (1080p)": (1920, 1080),
+                "2K": (2560, 1440),
+                "4K": (3840, 2160),
+                "Custom": None
+            }
+            
+            size_choice = st.selectbox("Choose image size:", list(size_options.keys()))
+            
+            if size_choice == "Custom":
+                col1, col2 = st.columns(2)
+                with col1:
+                    width = st.number_input("Width:", min_value=100, max_value=4000, value=800)
+                with col2:
+                    height = st.number_input("Height:", min_value=100, max_value=4000, value=600)
+            else:
+                width, height = size_options[size_choice]
+            
+            if width * height > 4000 * 4000:
+                st.warning("Warning: The image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            
+            speed = st.slider("Frames per second:", 1, 30, 5)
+
+            format_option = st.multiselect("Choose output format(s):", ["GIF", "MP4", "Individual Images (ZIP)"], default=["GIF", "MP4", "Individual Images (ZIP)"])
+
+            with st.expander("Advanced Options"):
+                batch_size = st.slider("Batch Size", 50, 500, 100)
+                max_concurrent_requests = st.slider("Max Concurrent Requests", 10, 50, 20)
+
+            submitted = st.form_submit_button("Generate Timelapse")
+
+        if submitted:
+            if data is None:
+                st.warning("Please upload a GeoJSON file.")
+            elif width * height > 4000 * 4000:
+                st.error("Image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            else:
+                gdf = uploaded_file_to_gdf(data)
+                gdf_2056 = gdf.to_crs(epsg=2056)
+                bbox = tuple(gdf_2056.total_bounds)
+
+                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+                
+                total_requests = len(available_years)
+                
+                if total_requests > 500:
+                    st.warning(f"You are requesting {total_requests} images. This exceeds the limit of 500 requests per second set by swisstopo. The process may take longer than expected.")
+                
+                progress_bar = st.progress(0)
+                
+                with st.spinner('Downloading images...'):
+                    images = asyncio.run(download_images(bbox, width, height, available_years, max_concurrent_requests))
+                progress_bar.progress(50)
+
+                if images:
+                    logger.info(f"Retrieved {len(images)} images successfully")
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        with st.spinner('Processing images...'):
+                            processed_images = process_images(images, format_option, temp_dir, batch_size)
+                            results = create_timelapse(processed_images, format_option, speed, temp_dir)
+                        progress_bar.progress(100)
+
+                        for format, path in results.items():
+                            if os.path.exists(path):
+                                if format == "GIF":
+                                    st.success("GIF Timelapse created successfully!")
+                                    st.image(path)
+                                elif format == "MP4":
+                                    st.success("MP4 Timelapse created successfully!")
+                                    st.video(path)
+                                elif format == "ZIP":
+                                    st.success("Individual images saved successfully!")
+                                st.markdown(get_binary_file_downloader_html(path, f'Timelapse {format}'), unsafe_allow_html=True)
+                            else:
+                                st.error(f"{format} file was not created successfully.")
+                else:
+                    logger.error("No images were retrieved")
+                    st.error("Failed to create timelapse. No images were generated.")
+
+if __name__ == "__main__":
+    app()

pages/lastime_v1.py

@@ -0,0 +1,280 @@
+import streamlit as st
+import geopandas as gpd
+import folium
+from folium import plugins
+import requests
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import imageio
+import tempfile
+import os
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
+import base64
+import asyncio
+import aiohttp
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+from functools import lru_cache
+import logging
+import numpy as np
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles
+AVAILABLE_DATES = [
+    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231, 18971231, 18981231, 18991231,
+    19001231, 19011231, 19021231, 19031231, 19041231, 19051231, 19061231, 19071231, 19081231, 19091231,
+    19101231, 19111231, 19121231, 19131231, 19141231, 19151231, 19161231, 19171231, 19181231, 19191231,
+    19201231, 19211231, 19221231, 19231231, 19241231, 19251231, 19261231, 19271231, 19281231, 19291231,
+    19301231, 19311231, 19321231, 19331231, 19341231, 19351231, 19361231, 19371231, 19381231, 19391231,
+    19401231, 19411231, 19421231, 19431231, 19441231, 19451231, 19461231, 19471231, 19481231, 19491231,
+    19501231, 19511231, 19521231, 19531231, 19541231, 19551231, 19561231, 19571231, 19581231, 19591231,
+    19601231, 19611231, 19621231, 19631231, 19641231, 19651231, 19661231, 19671231, 19681231, 19691231,
+    19701231, 19711231, 19721231, 19731231, 19741231, 19751231, 19761231, 19771231, 19781231, 19791231,
+    19801231, 19811231, 19821231, 19831231, 19841231, 19851231, 19861231, 19871231, 19881231, 19891231,
+    19901231, 19911231, 19921231, 19931231, 19941231, 19951231, 19961231, 19971231, 19981231, 19991231,
+    20001231, 20011231, 20021231, 20031231, 20041231, 20051231, 20061231, 20071231, 20081231, 20091231,
+    20101231, 20111231, 20121231, 20131231, 20141231, 20151231, 20161231, 20171231, 20181231, 20191231,
+    20201231, 20211231
+]
+
+@st.cache_data
+def uploaded_file_to_gdf(data):
+    import tempfile
+    import os
+    import uuid
+
+    _, 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
+
+@lru_cache(maxsize=128)
+def get_wms_url(bbox, width, height, time):
+    url = "https://wms.geo.admin.ch/"
+    params = {
+        "SERVICE": "WMS",
+        "REQUEST": "GetMap",
+        "VERSION": "1.3.0",
+        "LAYERS": "ch.swisstopo.zeitreihen",
+        "STYLES": "",
+        "CRS": "EPSG:2056",
+        "BBOX": ",".join(map(str, bbox)),
+        "WIDTH": str(width),
+        "HEIGHT": str(height),
+        "FORMAT": "image/png",
+        "TIME": str(time),
+        "TILED": "true"
+    }
+    return url + "?" + "&".join(f"{k}={v}" for k, v in params.items())
+
+def add_date_to_image(image, date):
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.load_default()
+    text = str(date // 10000)  # Extraire seulement l'année
+    
+    bbox = draw.textbbox((0, 0), text, font=font)
+    textwidth = bbox[2] - bbox[0]
+    textheight = bbox[3] - bbox[1]
+    
+    margin = 10
+    x = image.width - textwidth - margin
+    y = image.height - textheight - margin
+    draw.rectangle((x-5, y-5, x+textwidth+5, y+textheight+5), fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+    return image
+
+async def fetch_image(session, url, date, semaphore):
+    async with semaphore:
+        try:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    data = await response.read()
+                    img = Image.open(BytesIO(data))
+                    return add_date_to_image(img, date)
+        except Exception as e:
+            logger.error(f"Error fetching image for date {date}: {str(e)}")
+    return None
+
+async def download_images(bbox, width, height, available_years):
+    semaphore = asyncio.Semaphore(20)  # Limité à 20 requêtes simultanées
+    async with aiohttp.ClientSession() as session:
+        tasks = [fetch_image(session, get_wms_url(bbox, width, height, date), date, semaphore) for date in available_years]
+        return await asyncio.gather(*tasks)
+
+def process_image(args):
+    img, i, temp_dir, format_option = args
+    results = {}
+    if img:
+        if "GIF" in format_option or "MP4" in format_option:
+            img_array = np.array(img)
+            results['array'] = img_array
+        if "Individual Images (ZIP)" in format_option:
+            img_path = os.path.join(temp_dir, f"image_{i}.png")
+            img.save(img_path)
+            results['path'] = img_path
+    return results
+
+def process_images(images, format_option, speed, temp_dir):
+    results = {}
+    
+    with ProcessPoolExecutor() as executor:
+        processed_images = list(executor.map(process_image, [(img, i, temp_dir, format_option) for i, img in enumerate(images) if img is not None]))
+
+    if "GIF" in format_option:
+        gif_path = os.path.join(temp_dir, "timelapse.gif")
+        imageio.mimsave(gif_path, [img['array'] for img in processed_images if 'array' in img], fps=speed, loop=0)
+        results["GIF"] = gif_path
+
+    if "MP4" in format_option:
+        mp4_path = os.path.join(temp_dir, "timelapse.mp4")
+        imageio.mimsave(mp4_path, [img['array'] for img in processed_images if 'array' in img], fps=speed, format='FFMPEG', quality=9)
+        results["MP4"] = mp4_path
+
+    if "Individual Images (ZIP)" in format_option:
+        zip_path = os.path.join(temp_dir, "images.zip")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for img in processed_images:
+                if 'path' in img:
+                    zipf.write(img['path'], os.path.basename(img['path']))
+                    os.unlink(img['path'])
+        results["ZIP"] = zip_path
+
+    return results
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Download {file_label}</a>'
+    return href
+
+def app():
+    st.title("Swiss Historical Timelapse Generator")
+
+    st.markdown(
+        """
+        An interactive web app for creating historical timelapses of Switzerland using WMS-Time.
+        """
+    )
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+
+    with row1_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 row1_col2:
+        data = st.file_uploader(
+            "Upload a GeoJSON file to use as an ROI. Customize timelapse parameters and then click the Submit button 😇👇",
+            type=["geojson", "kml", "zip"],
+        )
+
+        with st.form("submit_form"):
+            start_year = st.selectbox("Select start year:", [date // 10000 for date in AVAILABLE_DATES])
+            end_year = st.selectbox("Select end year:", [date // 10000 for date in AVAILABLE_DATES], index=len(AVAILABLE_DATES)-1)
+            
+            # Options prédéfinies pour la taille des images
+            size_options = {
+                "HD (720p)": (1280, 720),
+                "Full HD (1080p)": (1920, 1080),
+                "2K": (2560, 1440),
+                "4K": (3840, 2160),
+                "Custom": None
+            }
+            
+            size_choice = st.selectbox("Choose image size:", list(size_options.keys()))
+            
+            if size_choice == "Custom":
+                col1, col2 = st.columns(2)
+                with col1:
+                    width = st.number_input("Width:", min_value=100, max_value=4000, value=800)
+                with col2:
+                    height = st.number_input("Height:", min_value=100, max_value=4000, value=600)
+            else:
+                width, height = size_options[size_choice]
+            
+            if width * height > 4000 * 4000:
+                st.warning("Warning: The image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            
+            speed = st.slider("Frames per second:", 1, 30, 5)
+
+            format_option = st.multiselect("Choose output format(s):", ["GIF", "MP4", "Individual Images (ZIP)"], default=["GIF", "MP4", "Individual Images (ZIP)"])
+
+            submitted = st.form_submit_button("Generate Timelapse")
+
+        if submitted:
+            if data is None:
+                st.warning("Please upload a GeoJSON file.")
+            elif width * height > 4000 * 4000:
+                st.error("Image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            else:
+                gdf = uploaded_file_to_gdf(data)
+                gdf_2056 = gdf.to_crs(epsg=2056)
+                bbox = tuple(gdf_2056.total_bounds)
+
+                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+                
+                total_requests = len(available_years)
+                
+                if total_requests > 500:
+                    st.warning(f"You are requesting {total_requests} images. This exceeds the limit of 500 requests per second set by swisstopo. The process may take longer than expected.")
+                
+                progress_bar = st.progress(0)
+                
+                images = asyncio.run(download_images(bbox, width, height, available_years))
+                
+                progress_bar.progress(100)
+
+                if images:
+                    logger.info(f"Retrieved {len(images)} images successfully")
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        with st.spinner('Processing images... This may take a while for large images.'):
+                            results = process_images(images, format_option, speed, temp_dir)
+
+                        for format, path in results.items():
+                            if os.path.exists(path):
+                                if format == "GIF":
+                                    st.success("GIF Timelapse created successfully!")
+                                    st.image(path)
+                                elif format == "MP4":
+                                    st.success("MP4 Timelapse created successfully!")
+                                    st.video(path)
+                                elif format == "ZIP":
+                                    st.success("Individual images saved successfully!")
+                                st.markdown(get_binary_file_downloader_html(path, f'Timelapse {format}'), unsafe_allow_html=True)
+                            else:
+                                st.error(f"{format} file was not created successfully.")
+                else:
+                    logger.error("No images were retrieved")
+                    st.error("Failed to create timelapse. No images were generated.")
+
+if __name__ == "__main__":
+    app()

pages/lastimev2.py

@@ -0,0 +1,346 @@
+import streamlit as st
+import geopandas as gpd
+import folium
+from folium import plugins
+import requests
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import imageio
+import tempfile
+import os
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
+import base64
+import asyncio
+import aiohttp
+import logging
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Configuration de la page Streamlit
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles
+AVAILABLE_DATES = [
+    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231, 18971231, 18981231, 18991231,
+    19001231, 19011231, 19021231, 19031231, 19041231, 19051231, 19061231, 19071231, 19081231, 19091231,
+    19101231, 19111231, 19121231, 19131231, 19141231, 19151231, 19161231, 19171231, 19181231, 19191231,
+    19201231, 19211231, 19221231, 19231231, 19241231, 19251231, 19261231, 19271231, 19281231, 19291231,
+    19301231, 19311231, 19321231, 19331231, 19341231, 19351231, 19361231, 19371231, 19381231, 19391231,
+    19401231, 19411231, 19421231, 19431231, 19441231, 19451231, 19461231, 19471231, 19481231, 19491231,
+    19501231, 19511231, 19521231, 19531231, 19541231, 19551231, 19561231, 19571231, 19581231, 19591231,
+    19601231, 19611231, 19621231, 19631231, 19641231, 19651231, 19661231, 19671231, 19681231, 19691231,
+    19701231, 19711231, 19721231, 19731231, 19741231, 19751231, 19761231, 19771231, 19781231, 19791231,
+    19801231, 19811231, 19821231, 19831231, 19841231, 19851231, 19861231, 19871231, 19881231, 19891231,
+    19901231, 19911231, 19921231, 19931231, 19941231, 19951231, 19961231, 19971231, 19981231, 19991231,
+    20001231, 20011231, 20021231, 20031231, 20041231, 20051231, 20061231, 20071231, 20081231, 20091231,
+    20101231, 20111231, 20121231, 20131231, 20141231, 20151231, 20161231, 20171231, 20181231, 20191231,
+    20201231, 20211231
+]
+
+@st.cache_data
+def uploaded_file_to_gdf(data):
+    """
+    Convertit un fichier uploadé en GeoDataFrame.
+    
+    Args:
+        data (UploadedFile): Le fichier uploadé par l'utilisateur.
+    
+    Returns:
+        GeoDataFrame: Le GeoDataFrame créé à partir du fichier.
+    """
+    import tempfile
+    import os
+    import uuid
+
+    _, 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
+
+@st.cache_data
+def get_wms_url(bbox, width, height, time):
+    """
+    Génère l'URL pour la requête WMS.
+    
+    Args:
+        bbox (tuple): Les coordonnées de la bounding box.
+        width (int): La largeur de l'image.
+        height (int): La hauteur de l'image.
+        time (int): La date de la carte.
+    
+    Returns:
+        str: L'URL complète pour la requête WMS.
+    """
+    url = "https://wms.geo.admin.ch/"
+    params = {
+        "SERVICE": "WMS",
+        "REQUEST": "GetMap",
+        "VERSION": "1.3.0",
+        "LAYERS": "ch.swisstopo.zeitreihen",
+        "STYLES": "default",
+        "CRS": "EPSG:2056",
+        "BBOX": ",".join(map(str, bbox)),
+        "WIDTH": str(width),
+        "HEIGHT": str(height),
+        "FORMAT": "image/png",
+        "TIME": str(time)
+    }
+    return url + "?" + "&".join(f"{k}={v}" for k, v in params.items())
+
+def add_date_to_image(image, date):
+    """
+    Ajoute la date à l'image.
+    
+    Args:
+        image (PIL.Image): L'image à modifier.
+        date (int): La date à ajouter.
+    
+    Returns:
+        PIL.Image: L'image avec la date ajoutée.
+    """
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.load_default()
+    text = str(date // 10000)  # Extraire seulement l'année
+    
+    bbox = draw.textbbox((0, 0), text, font=font)
+    textwidth = bbox[2] - bbox[0]
+    textheight = bbox[3] - bbox[1]
+    
+    margin = 10
+    x = image.width - textwidth - margin
+    y = image.height - textheight - margin
+    draw.rectangle((x-5, y-5, x+textwidth+5, y+textheight+5), fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+    return image
+
+async def fetch_image(session, url, date, semaphore):
+    """
+    Télécharge une image de manière asynchrone.
+    
+    Args:
+        session (aiohttp.ClientSession): La session HTTP.
+        url (str): L'URL de l'image.
+        date (int): La date de l'image.
+        semaphore (asyncio.Semaphore): Le sémaphore pour limiter les requêtes concurrentes.
+    
+    Returns:
+        PIL.Image or None: L'image téléchargée ou None en cas d'erreur.
+    """
+    async with semaphore:
+        try:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    data = await response.read()
+                    img = Image.open(BytesIO(data))
+                    return add_date_to_image(img, date)
+        except Exception as e:
+            logger.error(f"Error fetching image for date {date}: {str(e)}")
+    return None
+
+async def download_images(bbox, width, height, available_years, max_concurrent_requests):
+    """
+    Télécharge toutes les images de manière asynchrone.
+    
+    Args:
+        bbox (tuple): Les coordonnées de la bounding box.
+        width (int): La largeur des images.
+        height (int): La hauteur des images.
+        available_years (list): Les années disponibles.
+        max_concurrent_requests (int): Le nombre maximum de requêtes simultanées.
+    
+    Returns:
+        list: Liste des images téléchargées.
+    """
+    semaphore = asyncio.Semaphore(max_concurrent_requests)
+    async with aiohttp.ClientSession() as session:
+        tasks = [fetch_image(session, get_wms_url(bbox, width, height, date), date, semaphore) for date in available_years]
+        return await asyncio.gather(*tasks)
+
+def create_timelapse(images, format_option, speed, temp_dir):
+    """
+    Crée le timelapse dans les formats sélectionnés.
+    
+    Args:
+        images (list): Liste des images.
+        format_option (list): Options de format sélectionnées.
+        speed (int): Vitesse du timelapse (FPS).
+        temp_dir (str): Répertoire temporaire pour les fichiers.
+    
+    Returns:
+        dict: Chemins des fichiers de timelapse créés.
+    """
+    results = {}
+    
+    if "GIF" in format_option:
+        gif_path = os.path.join(temp_dir, "timelapse.gif")
+        imageio.mimsave(gif_path, images, fps=speed)
+        results["GIF"] = gif_path
+    
+    if "MP4" in format_option:
+        mp4_path = os.path.join(temp_dir, "timelapse.mp4")
+        imageio.mimsave(mp4_path, images, fps=speed, format='FFMPEG', quality=8)
+        results["MP4"] = mp4_path
+    
+    if "Individual Images (ZIP)" in format_option:
+        zip_path = os.path.join(temp_dir, "images.zip")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for i, img in enumerate(images):
+                img_path = os.path.join(temp_dir, f"image_{i}.png")
+                img.save(img_path)
+                zipf.write(img_path, os.path.basename(img_path))
+                os.unlink(img_path)
+        results["ZIP"] = zip_path
+    
+    return results
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    """
+    Génère un lien HTML pour le téléchargement d'un fichier binaire.
+    
+    Args:
+        bin_file (str): Chemin du fichier binaire.
+        file_label (str): Étiquette pour le lien de téléchargement.
+    
+    Returns:
+        str: Code HTML pour le lien de téléchargement.
+    """
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Download {file_label}</a>'
+    return href
+
+def app():
+    """
+    Fonction principale de l'application Streamlit.
+    """
+    st.title("Swiss Historical Timelapse Generator")
+
+    st.markdown(
+        """
+        An interactive web app for creating historical timelapses of Switzerland using WMS-Time.
+        """
+    )
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+
+    with row1_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 row1_col2:
+        data = st.file_uploader(
+            "Upload a GeoJSON file to use as an ROI. Customize timelapse parameters and then click the Submit button 😇👇",
+            type=["geojson", "kml", "zip"],
+        )
+
+        with st.form("submit_form"):
+            start_year = st.selectbox("Select start year:", [date // 10000 for date in AVAILABLE_DATES])
+            end_year = st.selectbox("Select end year:", [date // 10000 for date in AVAILABLE_DATES], index=len(AVAILABLE_DATES)-1)
+            
+            size_options = {
+                "HD (720p)": (1280, 720),
+                "Full HD (1080p)": (1920, 1080),
+                "2K": (2560, 1440),
+                "4K": (3840, 2160),
+                "Custom": None
+            }
+            
+            size_choice = st.selectbox("Choose image size:", list(size_options.keys()))
+            
+            if size_choice == "Custom":
+                col1, col2 = st.columns(2)
+                with col1:
+                    width = st.number_input("Width:", min_value=100, max_value=4000, value=800)
+                with col2:
+                    height = st.number_input("Height:", min_value=100, max_value=4000, value=600)
+            else:
+                width, height = size_options[size_choice]
+            
+            if width * height > 4000 * 4000:
+                st.warning("Warning: The image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            
+            speed = st.slider("Frames per second:", 1, 30, 5)
+
+            format_option = st.multiselect("Choose output format(s):", ["GIF", "MP4", "Individual Images (ZIP)"], default=["GIF", "MP4", "Individual Images (ZIP)"])
+
+            with st.expander("Advanced Options"):
+                max_concurrent_requests = st.slider("Max Concurrent Requests", 10, 50, 20)
+
+            submitted = st.form_submit_button("Generate Timelapse")
+
+        if submitted:
+            if data is None:
+                st.warning("Please upload a GeoJSON file.")
+            elif width * height > 4000 * 4000:
+                st.error("Image size exceeds the maximum allowed by swisstopo (4000x4000 pixels). Please reduce the width or height.")
+            else:
+                gdf = uploaded_file_to_gdf(data)
+                gdf_2056 = gdf.to_crs(epsg=2056)
+                bbox = tuple(gdf_2056.total_bounds)
+
+                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+                
+                total_requests = len(available_years)
+                
+                if total_requests > 500:
+                    st.warning(f"You are requesting {total_requests} images. This exceeds the limit of 500 requests per second set by swisstopo. The process may take longer than expected.")
+                
+                progress_bar = st.progress(0)
+                
+                with st.spinner('Downloading images...'):
+                    images = asyncio.run(download_images(bbox, width, height, available_years, max_concurrent_requests))
+                progress_bar.progress(50)
+
+                if images:
+                    logger.info(f"Retrieved {len(images)} images successfully")
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        with st.spinner('Processing images...'):
+                            results = create_timelapse(images, format_option, speed, temp_dir)
+                        progress_bar.progress(100)
+
+                        for format, path in results.items():
+                            if os.path.exists(path):
+                                if format == "GIF":
+                                    st.success("GIF Timelapse created successfully!")
+                                    st.image(path)
+                                elif format == "MP4":
+                                    st.success("MP4 Timelapse created successfully!")
+                                    st.video(path)
+                                elif format == "ZIP":
+                                    st.success("Individual images saved successfully!")
+                                st.markdown(get_binary_file_downloader_html(path, f'Timelapse {format}'), unsafe_allow_html=True)
+                            else:
+                                st.error(f"{format} file was not created successfully.")
+                else:
+                    logger.error("No images were retrieved")
+                    st.error("Failed to create timelapse. No images were generated.")
+
+if __name__ == "__main__":
+    app()

pages/lastimev3.py

@@ -0,0 +1,352 @@
+import streamlit as st
+import geopandas as gpd
+import folium
+from folium import plugins
+import requests
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import imageio
+import tempfile
+import os
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
+import base64
+import asyncio
+import aiohttp
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
+import logging
+import numpy as np
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuration de la page Streamlit
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles
+AVAILABLE_DATES = [
+    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231, 18971231, 18981231, 18991231,
+    19001231, 19011231, 19021231, 19031231, 19041231, 19051231, 19061231, 19071231, 19081231, 19091231,
+    19101231, 19111231, 19121231, 19131231, 19141231, 19151231, 19161231, 19171231, 19181231, 19191231,
+    19201231, 19211231, 19221231, 19231231, 19241231, 19251231, 19261231, 19271231, 19281231, 19291231,
+    19301231, 19311231, 19321231, 19331231, 19341231, 19351231, 19361231, 19371231, 19381231, 19391231,
+    19401231, 19411231, 19421231, 19431231, 19441231, 19451231, 19461231, 19471231, 19481231, 19491231,
+    19501231, 19511231, 19521231, 19531231, 19541231, 19551231, 19561231, 19571231, 19581231, 19591231,
+    19601231, 19611231, 19621231, 19631231, 19641231, 19651231, 19661231, 19671231, 19681231, 19691231,
+    19701231, 19711231, 19721231, 19731231, 19741231, 19751231, 19761231, 19771231, 19781231, 19791231,
+    19801231, 19811231, 19821231, 19831231, 19841231, 19851231, 19861231, 19871231, 19881231, 19891231,
+    19901231, 19911231, 19921231, 19931231, 19941231, 19951231, 19961231, 19971231, 19981231, 19991231,
+    20001231, 20011231, 20021231, 20031231, 20041231, 20051231, 20061231, 20071231, 20081231, 20091231,
+    20101231, 20111231, 20121231, 20131231, 20141231, 20151231, 20161231, 20171231, 20181231, 20191231,
+    20201231, 20211231
+]
+
+@st.cache_data
+def uploaded_file_to_gdf(data):
+    """
+    Convertit le fichier uploadé en GeoDataFrame.
+    
+    Args:
+        data: Le fichier uploadé par l'utilisateur.
+    
+    Returns:
+        GeoDataFrame: Le GeoDataFrame créé à partir du fichier uploadé.
+    """
+    import tempfile
+    import os
+    import uuid
+
+    _, 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
+
+@lru_cache(maxsize=128)
+def get_wms_url(bbox, width, height, time):
+    """
+    Génère l'URL pour la requête WMS.
+    
+    Args:
+        bbox: La bounding box de la zone d'intérêt.
+        width: La largeur de l'image.
+        height: La hauteur de l'image.
+        time: La date pour laquelle récupérer l'image.
+    
+    Returns:
+        str: L'URL complète pour la requête WMS.
+    """
+    url = "https://wms.geo.admin.ch/"
+    params = {
+        "SERVICE": "WMS",
+        "REQUEST": "GetMap",
+        "VERSION": "1.3.0",
+        "LAYERS": "ch.swisstopo.zeitreihen",
+        "STYLES": "",
+        "CRS": "EPSG:2056",
+        "BBOX": ",".join(map(str, bbox)),
+        "WIDTH": str(width),
+        "HEIGHT": str(height),
+        "FORMAT": "image/png",
+        "TIME": str(time),
+        "TILED": "true"
+    }
+    return url + "?" + "&".join(f"{k}={v}" for k, v in params.items())
+
+def add_date_to_image(image, date):
+    """
+    Ajoute la date à l'image.
+    
+    Args:
+        image: L'image à modifier.
+        date: La date à ajouter à l'image.
+    
+    Returns:
+        Image: L'image modifiée avec la date ajoutée.
+    """
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.load_default()
+    text = str(date // 10000)  # Extraire seulement l'année
+    
+    bbox = draw.textbbox((0, 0), text, font=font)
+    textwidth = bbox[2] - bbox[0]
+    textheight = bbox[3] - bbox[1]
+    
+    margin = 10
+    x = image.width - textwidth - margin
+    y = image.height - textheight - margin
+    draw.rectangle((x-5, y-5, x+textwidth+5, y+textheight+5), fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+    return image
+
+async def fetch_image(session, url, date, semaphore):
+    """
+    Récupère une image de manière asynchrone.
+    
+    Args:
+        session: La session aiohttp.
+        url: L'URL de l'image à récupérer.
+        date: La date correspondant à l'image.
+        semaphore: Le sémaphore pour limiter les requêtes simultanées.
+    
+    Returns:
+        Image: L'image récupérée et modifiée, ou None en cas d'erreur.
+    """
+    async with semaphore:
+        try:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    data = await response.read()
+                    img = Image.open(BytesIO(data))
+                    return add_date_to_image(img, date)
+        except Exception as e:
+            logger.error(f"Erreur lors de la récupération de l'image pour la date {date}: {str(e)}")
+    return None
+
+async def download_images(bbox, width, height, available_years):
+    """
+    Télécharge les images de manière asynchrone.
+    
+    Args:
+        bbox: La bounding box de la zone d'intérêt.
+        width: La largeur des images.
+        height: La hauteur des images.
+        available_years: Les années disponibles pour le téléchargement.
+    
+    Returns:
+        list: Une liste des images téléchargées.
+    """
+    semaphore = asyncio.Semaphore(20)  # Limité à 20 requêtes simultanées
+    async with aiohttp.ClientSession() as session:
+        tasks = [fetch_image(session, get_wms_url(bbox, width, height, date), date, semaphore) for date in available_years]
+        return await asyncio.gather(*tasks)
+
+def process_images_stream(images, format_option, speed, temp_dir):
+    """
+    Traite les images en utilisant une approche par flux pour optimiser l'utilisation de la mémoire.
+    
+    Args:
+        images: La liste des images à traiter.
+        format_option: Les options de format choisies par l'utilisateur.
+        speed: La vitesse de lecture des images (en FPS).
+        temp_dir: Le répertoire temporaire pour stocker les fichiers générés.
+    
+    Returns:
+        dict: Un dictionnaire contenant les chemins des fichiers générés.
+    """
+    results = {}
+
+    if "GIF" in format_option:
+        gif_path = os.path.join(temp_dir, "timelapse.gif")
+        with imageio.get_writer(gif_path, mode='I', fps=speed, loop=0) as writer:
+            for img in images:
+                if img is not None:
+                    writer.append_data(np.array(img))
+        results["GIF"] = gif_path
+
+    if "MP4" in format_option:
+        mp4_path = os.path.join(temp_dir, "timelapse.mp4")
+        with imageio.get_writer(mp4_path, fps=speed, quality=9) as writer:
+            for img in images:
+                if img is not None:
+                    writer.append_data(np.array(img))
+        results["MP4"] = mp4_path
+
+    if "Individual Images (ZIP)" in format_option:
+        zip_path = os.path.join(temp_dir, "images.zip")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for i, img in enumerate(images):
+                if img is not None:
+                    img_path = os.path.join(temp_dir, f"image_{i}.png")
+                    img.save(img_path)
+                    zipf.write(img_path, os.path.basename(img_path))
+                    os.unlink(img_path)
+        results["ZIP"] = zip_path
+
+    return results
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    """
+    Génère le HTML pour le téléchargement d'un fichier binaire.
+    
+    Args:
+        bin_file: Le chemin du fichier binaire.
+        file_label: Le label à afficher pour le lien de téléchargement.
+    
+    Returns:
+        str: Le HTML pour le lien de téléchargement.
+    """
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Télécharger {file_label}</a>'
+    return href
+
+def app():
+    """
+    Fonction principale de l'application Streamlit.
+    """
+    st.title("Générateur de Timelapse Historique Suisse")
+
+    st.markdown(
+        """
+        Une application web interactive pour créer des timelapses historiques de la Suisse en utilisant WMS-Time.
+        """
+    )
+
+    row1_col1, row1_col2 = st.columns([2, 1])
+
+    with row1_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 row1_col2:
+        data = st.file_uploader(
+            "Téléchargez un fichier GeoJSON à utiliser comme ROI. Personnalisez les paramètres du timelapse puis cliquez sur le bouton Soumettre 😇👇",
+            type=["geojson", "kml", "zip"],
+        )
+
+        with st.form("submit_form"):
+            start_year = st.selectbox("Sélectionnez l'année de début:", [date // 10000 for date in AVAILABLE_DATES])
+            end_year = st.selectbox("Sélectionnez l'année de fin:", [date // 10000 for date in AVAILABLE_DATES], index=len(AVAILABLE_DATES)-1)
+            
+            size_options = {
+                "HD (720p)": (1280, 720),
+                "Full HD (1080p)": (1920, 1080),
+                "2K": (2560, 1440),
+                "4K": (3840, 2160),
+                "Personnalisé": None
+            }
+            
+            size_choice = st.selectbox("Choisissez la taille de l'image:", list(size_options.keys()))
+            
+            if size_choice == "Personnalisé":
+                col1, col2 = st.columns(2)
+                with col1:
+                    width = st.number_input("Largeur:", min_value=100, max_value=4000, value=800)
+                with col2:
+                    height = st.number_input("Hauteur:", min_value=100, max_value=4000, value=600)
+            else:
+                width, height = size_options[size_choice]
+            
+            if width * height > 4000 * 4000:
+                st.warning("Attention: La taille de l'image dépasse le maximum autorisé par swisstopo (4000x4000 pixels). Veuillez réduire la largeur ou la hauteur.")
+            
+            speed = st.slider("Images par seconde:", 1, 30, 5)
+
+            format_option = st.multiselect("Choisissez le(s) format(s) de sortie:", ["GIF", "MP4", "Images individuelles (ZIP)"], default=["GIF", "MP4", "Images individuelles (ZIP)"])
+
+            submitted = st.form_submit_button("Générer le Timelapse")
+
+        if submitted:
+            if data is None:
+                st.warning("Veuillez télécharger un fichier GeoJSON.")
+            elif width * height > 4000 * 4000:
+                st.error("La taille de l'image dépasse le maximum autorisé par swisstopo (4000x4000 pixels). Veuillez réduire la largeur ou la hauteur.")
+            else:
+                gdf = uploaded_file_to_gdf(data)
+                gdf_2056 = gdf.to_crs(epsg=2056)
+                bbox = tuple(gdf_2056.total_bounds)
+
+                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+                
+                total_requests = len(available_years)
+                
+                if total_requests > 500:
+                    st.warning(f"Vous demandez {total_requests} images. Cela dépasse la limite de 500 requêtes par seconde fixée par swisstopo. Le processus peut prendre plus de temps que prévu.")
+                
+                progress_bar = st.progress(0)
+                
+                images = asyncio.run(download_images(bbox, width, height, available_years))
+                
+                progress_bar.progress(100)
+
+                if images:
+                    logger.info(f"Récupération réussie de {len(images)} images")
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        with st.spinner('Traitement des images en cours... Cela peut prendre un certain temps pour les grandes images.'):
+                            results = process_images_stream(images, format_option, speed, temp_dir)
+
+                        for format, path in results.items():
+                            if os.path.exists(path):
+                                if format == "GIF":
+                                    st.success("Timelapse GIF créé avec succès!")
+                                    st.image(path)
+                                elif format == "MP4":
+                                    st.success("Timelapse MP4 créé avec succès!")
+                                    st.video(path)
+                                elif format == "ZIP":
+                                    st.success("Images individuelles sauvegardées avec succès!")
+                                st.markdown(get_binary_file_downloader_html(path, f'Timelapse {format}'), unsafe_allow_html=True)
+                            else:
+                                st.error(f"Le fichier {format} n'a pas été créé avec succès.")
+                else:
+                    logger.error("Aucune image n'a été récupérée")
+                    st.error("Échec de la création du timelapse. Aucune image n'a été générée.")
+
+if __name__ == "__main__":
+    app ()

pages/photo2timelapse.py

@@ -0,0 +1,121 @@
+import streamlit as st
+import cv2
+import numpy as np
+import tempfile
+import os
+from PIL import Image
+import io
+import base64
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from moviepy.editor import ImageSequenceClip
+import logging
+from tqdm import tqdm
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Fonction pour compresser une image avec différentes méthodes
+def compress_image(image_path, quality=85, method='pillow'):
+    if method == 'pillow':
+        with Image.open(image_path) as img:
+            img_byte_arr = io.BytesIO()
+            img.save(img_byte_arr, format='JPEG', quality=quality, optimize=True)
+            return Image.open(img_byte_arr)
+    elif method == 'cv2':
+        img = cv2.imread(image_path)
+        encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
+        _, encimg = cv2.imencode('.jpg', img, encode_param)
+        return cv2.imdecode(encimg, 1)
+
+# Fonction pour créer un GIF optimisé
+def create_optimized_gif(image_paths, output_path, fps=10, max_size_mb=8):
+    frames = []
+    for img_path in tqdm(image_paths, desc="Traitement des images pour GIF"):
+        with Image.open(img_path) as img:
+            frames.append(img.copy())
+    
+    durations = [1000//fps] * len(frames)
+    
+    for quality in range(100, 0, -10):
+        with io.BytesIO() as buffer:
+            frames[0].save(buffer, format="GIF", save_all=True, append_images=frames[1:], 
+                           optimize=True, duration=durations, loop=0, quality=quality)
+            if buffer.tell() <= max_size_mb * 1024 * 1024:
+                with open(output_path, "wb") as f:
+                    f.write(buffer.getvalue())
+                logging.info(f"GIF créé avec succès. Qualité: {quality}")
+                return
+    
+    logging.warning("Impossible de créer un GIF sous la taille maximale spécifiée.")
+
+# Fonction pour créer une vidéo MP4 optimisée
+def create_optimized_video(image_paths, output_path, fps=30, quality='high'):
+    clip = ImageSequenceClip(image_paths, fps=fps)
+    
+    if quality == 'high':
+        clip.write_videofile(output_path, codec='libx264', audio=False, fps=fps, bitrate="8000k")
+    elif quality == 'medium':
+        clip.write_videofile(output_path, codec='libx264', audio=False, fps=fps, bitrate="4000k")
+    else:
+        clip.write_videofile(output_path, codec='libx264', audio=False, fps=fps, bitrate="2000k")
+    
+    logging.info(f"Vidéo MP4 créée avec succès. Qualité: {quality}")
+
+# Fonction pour traiter une image en parallèle
+def process_image(args):
+    img_path, temp_dir, compress = args
+    if compress:
+        img = compress_image(img_path, quality=85, method='pillow')
+        output_path = os.path.join(temp_dir, os.path.basename(img_path))
+        img.save(output_path, "JPEG", quality=85)
+    else:
+        output_path = img_path
+    return output_path
+
+# Fonction pour générer un lien de téléchargement
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">{file_label}</a>'
+    return href
+
+# Application Streamlit principale
+def main():
+    st.title("Générateur de Timelapse Suprême")
+
+    uploaded_files = st.file_uploader("Uploadez vos images", type=["png", "jpg", "jpeg"], accept_multiple_files=True)
+    
+    if uploaded_files:
+        output_format = st.radio("Choisissez le format de sortie", ["GIF optimisé", "Vidéo MP4"])
+        
+        if output_format == "Vidéo MP4":
+            quality = st.select_slider("Qualité vidéo", options=['low', 'medium', 'high'], value='medium')
+        
+        fps = st.slider("Images par seconde", min_value=1, max_value=60, value=30)
+        compress_images = st.checkbox("Compresser les images avant traitement", value=True)
+        
+        if st.button("Générer Timelapse"):
+            with st.spinner("Génération du timelapse en cours..."):
+                with tempfile.TemporaryDirectory() as temp_dir:
+                    # Traitement parallèle des images
+                    with ThreadPoolExecutor() as executor:
+                        futures = [executor.submit(process_image, (file, temp_dir, compress_images)) for file in uploaded_files]
+                        processed_images = [future.result() for future in as_completed(futures)]
+                    
+                    if output_format == "GIF optimisé":
+                        output_path = os.path.join(temp_dir, "optimized_timelapse.gif")
+                        create_optimized_gif(processed_images, output_path, fps=fps)
+                        st.success("GIF optimisé généré!")
+                        st.image(output_path)
+                        st.markdown(get_binary_file_downloader_html(output_path, 'Télécharger le GIF'), unsafe_allow_html=True)
+                    
+                    elif output_format == "Vidéo MP4":
+                        output_path = os.path.join(temp_dir, "timelapse.mp4")
+                        create_optimized_video(processed_images, output_path, fps=fps, quality=quality)
+                        st.success("Vidéo MP4 générée!")
+                        st.video(output_path)
+                        st.markdown(get_binary_file_downloader_html(output_path, 'Télécharger la vidéo MP4'), unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,46 @@
+# Dépendances principales
+streamlit
+folium
+streamlit-folium
+
+# Traitement géospatial
+GDAL
+geopandas
+fiona
+pyproj
+rasterio
+
+# Visualisation et cartographie
+leafmap>=0.35.2
+plotly
+palettable
+# cartopy  # Commenté car peut causer des problèmes d'installation
+
+# Traitement d'images et vidéo
+Pillow
+imageio
+imageio[ffmpeg]
+opencv-python-headless
+moviepy
+ffmpeg-python
+
+# Autres utilitaires
+numpy
+owslib
+trimesh
+
+# Dépendances GitHub
+git+https://github.com/giswqs/geemap
+
+# Dépendances spécifiques (décommentez si nécessaire)
+# ipywidgets<8.0.5
+# jupyter-server-proxy
+# keplergl
+# localtileserver
+# nbserverproxy
+# streamlit-bokeh-events
+# streamlit-keplergl
+# tropycal
+# altair<5
+
+--find-links=https://girder.github.io/large_image_wheels GDAL