Update pages/photo2timelapse.py

pages/photo2timelapse.py

@@ -1,121 +1,255 @@
 import streamlit as st
-import cv2
-import numpy as np
+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
-from PIL import Image
-import io
+import zipfile
+from datetime import datetime
+from streamlit_folium import folium_static
 import base64
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from moviepy.editor import ImageSequenceClip
+import asyncio
+import aiohttp
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
 import logging
-from tqdm import tqdm
+import numpy as np
 
 # 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.")
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# 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")
+# Configuration de la page Streamlit
+st.set_page_config(layout="wide")
+
+# Liste des dates disponibles pour SWISSIMAGE Voyage dans le temps
+AVAILABLE_DATES = [
+    1946, 1959, 1965, 1980, 1985, 1990, 1995, 2000, 2005, 2010, 2015, 2018, 2021
+]
+
+@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:
-        clip.write_videofile(output_path, codec='libx264', audio=False, fps=fps, bitrate="2000k")
+        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.swissimage-product_timeseries",
+        "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)
     
-    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
+    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"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):
+    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):
+    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 "Images individuelles (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.remove(img_path)
+        results["ZIP"] = zip_path
+
+    return results
 
-# 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>'
+    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
 
-# Application Streamlit principale
-def main():
-    st.title("Générateur de Timelapse Suprême")
+def app():
+    st.title("Générateur de Timelapse SWISSIMAGE Voyage dans le temps")
 
-    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)
+    st.markdown(
+        """
+        Une application web interactive pour créer des timelapses historiques de la Suisse en utilisant SWISSIMAGE Voyage dans le temps.
+        """
+    )
+
+    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.swissimage/default/current/3857/{z}/{x}/{y}.jpeg",
+            attr="© swisstopo",
+            name="SWISSIMAGE",
+            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:", AVAILABLE_DATES)
+            end_year = st.selectbox("Sélectionnez l'année de fin:", 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 = [year for year in AVAILABLE_DATES if start_year <= year <= 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 == "ZIP":
+                                    st.success("Images individuelles (ZIP) créées avec succès!")
+                                else:
+                                    st.success(f"Timelapse {format} créé avec succès!")
+                                st.markdown(get_binary_file_downloader_html(path, f'Timelapse {format if format != "ZIP" else "Images individuelles (ZIP)"}'), 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__":
-    main()
+    app()