Update pages/v4.py

pages/v4.py

@@ -24,7 +24,7 @@ logger = logging.getLogger(__name__)
 # Configuration de la page Streamlit
 st.set_page_config(layout="wide")
 
-# Récupération des clés AWS à partir des secrets
+# Récupération des clés AWS à partir des secrets d'environnement
 aws_access_key = os.environ.get("AWS_ACCESS_KEY_ID")
 aws_secret_key = os.environ.get("AWS_SECRET_ACCESS_KEY")
 
@@ -32,7 +32,7 @@ aws_secret_key = os.environ.get("AWS_SECRET_ACCESS_KEY")
 s3_client = boto3.client(
     "s3",
     aws_access_key_id=aws_access_key,
-    aws_secret_access_key=aws_secret_key
+    aws_secret_access_key=aws_secret_key,
 )
 
 # Fonction pour télécharger un fichier sur AWS S3
@@ -45,12 +45,8 @@ def upload_to_s3(file_path, bucket_name, object_name):
         logger.error(f"Erreur lors du téléchargement vers S3 : {str(e)}")
         return None
 
-# Liste des dates disponibles
-AVAILABLE_DATES = [
-    18641231, 18701231, 18801231, 18901231, 18941231, 18951231, 18961231,
-    # ... (ajoutez toutes les autres dates ici)
-    20201231, 20211231
-]
+# Liste des dates disponibles (extraites pour simplifier)
+AVAILABLE_DATES = [18641231, 18701231, 18801231, 18901231, 20211231]
 
 @st.cache_data
 def uploaded_file_to_gdf(data):
@@ -83,8 +79,20 @@ def get_wms_url(bbox, width, height, time):
 def add_date_to_image(image, date):
     draw = ImageDraw.Draw(image)
     font = ImageFont.load_default()
-    text = str(date // 10000)
-    draw.text((10, 10), text, font=font, fill="white")
+    text = str(date // 10000)  # Extraire seulement l'année
+    
+    # Ajouter un fond noir derrière le texte pour plus de lisibilité
+    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):
@@ -94,116 +102,131 @@ async def fetch_image(session, url, date, semaphore):
                 if response.status == 200:
                     data = await response.read()
                     img = Image.open(BytesIO(data))
+                    
+                    # Vérification si l'image est vide ou transparente (exemple de vérification simple)
+                    if img.mode == 'RGBA' and all(pixel == (0, 0, 0, 0) for pixel in img.getdata()):
+                        logger.error(f"L'image pour {date} est vide ou transparente.")
+                        return None
+                    
                     logger.info(f"Image pour {date} téléchargée avec succès")
                     return add_date_to_image(img, date)
                 else:
                     logger.error(f"Échec de la récupération de l'image pour {date} : {response.status}")
         except Exception as e:
             logger.error(f"Erreur lors de la récupération de l'image pour {date} : {str(e)}")
-    return None
+        return None
 
 async def download_images(bbox, width, height, available_years):
-    semaphore = asyncio.Semaphore(20)
+    semaphore = asyncio.Semaphore(20)  # Limiter à 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]
         images = await asyncio.gather(*tasks)
+        
         # Filtrer les images qui ne sont pas None
         images = [img for img in images if img is not None]
+        
         logger.info(f"{len(images)} images téléchargées avec succès")
         return images
 
 def process_images_stream(images, format_option, speed, temp_dir):
     results = {}
-
+    
     if "GIF" in format_option and images:
         gif_path = os.path.join(temp_dir, "timelapse.gif")
-        with imageio.get_writer(gif_path, mode='I', fps=speed, loop=0) as writer:
+        with imageio.get_writer(gif_path, mode='I', fps=speed) as writer:
             for img in images:
                 writer.append_data(np.array(img))
         results["GIF"] = gif_path
-
+    
     if "MP4" in format_option and images:
         mp4_path = os.path.join(temp_dir, "timelapse.mp4")
-        with imageio.get_writer(mp4_path, fps=speed, quality=9) as writer:
+        with imageio.get_writer(mp4_path, fps=speed) as writer:
             for img in images:
                 writer.append_data(np.array(img))
         results["MP4"] = mp4_path
-
+    
     if "Images individuelles (ZIP)" in format_option and images:
         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))
+                zipf.write(img_path)
                 os.remove(img_path)
         results["ZIP"] = zip_path
-
+    
     return results
 
 def app():
     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"
+            attr="© swisstopo", name="swisstopo"
         ).add_to(m)
+        
         plugins.Draw(export=True).add_to(m)
+        
         folium.LayerControl().add_to(m)
-        folium_static(m, height=400)
+        
+        folium_static(m)
 
     with row1_col2:
         data = st.file_uploader("Téléchargez un fichier GeoJSON à utiliser comme ROI.", type=["geojson", "kml", "zip"])
+        
         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])
-
-        size_options = {
-            "HD (720p)": (1280, 720),
-            "Full HD (1080p)": (1920, 1080),
-            "2K": (2560, 1440),
-            "4K": (3840, 2160)
-        }
+        
+        size_options = {"HD (720p)": (1280, 720), "Full HD (1080p)": (1920, 1080), "2K": (2560, 1440), "4K": (3840, 2160)}
+        
         size_choice = st.selectbox("Choisissez la taille de l'image:", list(size_options.keys()))
+        
         width, height = size_options[size_choice]
-
-        speed = st.slider("Images par seconde:", 1, 30, 5)
+        
+        speed = st.slider("Images par seconde:", 1, 30)
+        
         format_option = st.multiselect(
-            "Choisissez le(s) format(s) de sortie:", 
-            ["GIF", "MP4", "Images individuelles (ZIP)"], 
+            "Choisissez le(s) format(s) de sortie:",
+            ["GIF", "MP4", "Images individuelles (ZIP)"],
             default=["GIF"]
         )
-
+        
         submitted = st.button("Générer le Timelapse")
 
-        if submitted:
-            if data is None:
-                st.warning("Veuillez télécharger un fichier GeoJSON.")
+    if submitted:
+        if data is None:
+            st.warning("Veuillez télécharger un fichier GeoJSON.")
+        
+        else:
+            gdf = uploaded_file_to_gdf(data)
+            bbox = tuple(gdf.total_bounds)
+            
+            available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
+            
+            images = asyncio.run(download_images(bbox, width, height, available_years))
+            
+            if not images:
+                st.error("Aucune image n'a été téléchargée. Veuillez vérifier votre sélection ou réessayer.")
+            
             else:
-                gdf = uploaded_file_to_gdf(data)
-                bbox = tuple(gdf.total_bounds)
-                available_years = [date for date in AVAILABLE_DATES if start_year <= date // 10000 <= end_year]
-                images = asyncio.run(download_images(bbox, width, height, available_years))
-
-                if not images:
-                    st.error("Aucune image n'a été téléchargée. Veuillez vérifier votre sélection ou réessayer.")
-                else:
-                    with tempfile.TemporaryDirectory() as temp_dir:
-                        results = process_images_stream(images, format_option, speed, temp_dir)
-
-                        # Téléchargement des fichiers sur S3 et génération des liens
-                        for format, path in results.items():
-                            s3_url = upload_to_s3(path, "timelapse-storage-vertgis", os.path.basename(path))
-                            if s3_url:
-                                st.markdown(f"[Télécharger le timelapse {format}]({s3_url})", unsafe_allow_html=True)
-                            else:
-                                st.error(f"Le fichier {format} n'a pas pu être téléchargé sur S3.")
+                with tempfile.TemporaryDirectory() as temp_dir:
+                    results = process_images_stream(images, format_option, speed, temp_dir)
+
+                    # Téléchargement des fichiers sur S3 et génération des liens pour chaque format généré.
+                    for format_type, path in results.items():
+                        s3_url = upload_to_s3(path,"nom-du-bucket-s3", os.path.basename(path))
+                        if s3_url:
+                            st.markdown(f"[Télécharger le timelapse {format_type}]({s3_url})", unsafe_allow_html=True)
+                        else:
+                            st.error(f"Le fichier {format_type} n'a pas pu être téléchargé sur S3.")
 
 if __name__ == "__main__":
     app()