Test StreamGEE

src/streamlit_app.py

@@ -1,33 +1,214 @@
-import os
+#service_account = os.getenv("service_account")
+#private_key = os.getenv("private_key")
+
 import streamlit as st
 import ee
-from pathlib import Path
+import geemap.foliumap as geemap
+import base64
+import json
+import tempfile
+import os
+import datetime
+import pandas as pd  # Added for data manipulation and plotting
+import altair as alt  # Added for custom chart coloring
 
-# Create a .streamlit/secrets.toml file manually at runtime
-def ensure_streamlit_secrets():
-    secrets_path = Path("/root/.streamlit/secrets.toml")
-    secrets_path.parent.mkdir(parents=True, exist_ok=True)
+# --- Configuration ---
+st.set_page_config(layout="wide")
+st.title("🇪🇺 European Capitals Satellite Viewer")
 
-    service_account = os.getenv("GEE_SERVICE_ACCOUNT")
-    private_key = os.getenv("GEE_PRIVATE_KEY")
+# Define a list of major European capitals and their coordinates (Lon, Lat)
+EUROPEAN_CAPITALS = {
+    "Rome, Italy": (12.4964, 41.9028),
+    "Stockholm, Sweden": (18.0656, 59.3327),
+    "Paris, France": (2.3522, 48.8566),
+    "Berlin, Germany": (13.4050, 52.5200),
+    "London, UK": (-0.1278, 51.5074),
+    "Madrid, Spain": (-3.7038, 40.4168),
+    "Vienna, Austria": (16.3738, 48.2082),
+    "Athens, Greece": (23.7275, 37.9838),
+    "Warsaw, Poland": (21.0118, 52.2297),
+    "Amsterdam, Netherlands": (4.8952, 52.3702),
+    "Oslo, Norway": (10.7522, 59.9139),
+    "Lisbon, Portugal": (-9.1393, 38.7223),
+}
 
-    if not service_account or not private_key:
-        st.error("❌ Missing GEE credentials in environment variables.")
-        st.stop()
+# --- Initialize EE (using the temporary file method) ---
+
+
+@st.cache_resource
+def initialize_ee_session():
+    """Initializes the Earth Engine session and caches the result."""
+    try:
+        # Ensure secrets are available
+        SERVICE_ACCOUNT = os.getenv("service_account")
+        PRIVATE_KEY_B64 = os.getenv("private_key")
+
+        # Decode the private key and write it to a temporary file for ee.Initialize
+        decoded = base64.b64decode(PRIVATE_KEY_B64).decode("utf-8")
+        with tempfile.NamedTemporaryFile(mode="w+", suffix=".json", delete=False) as f:
+            f.write(decoded)
+            temp_path = f.name
+
+        credentials = ee.ServiceAccountCredentials(SERVICE_ACCOUNT, temp_path)
+        ee.Initialize(credentials)
+        os.remove(temp_path)
+
+        return True
+    except Exception as e:
+        st.error(f"❌ Error initializing Earth Engine. Check your Streamlit secrets configuration. Error: {e}")
+        return False
+
+
+# Run the initialization only once
+if initialize_ee_session():
+    st.success(f"✅ Earth Engine initialized successfully (Cached).")
+else:
+    st.stop()
+
+
+# --- User Inputs ---
+st.sidebar.image("image/logo.png")
+
+st.sidebar.header("Controls")
+
+selected_city = st.sidebar.selectbox(
+    "1. Select a European Capital:",
+    options=list(EUROPEAN_CAPITALS.keys())
+)
+
+col1, col2 = st.sidebar.columns(2)
+with col1:
+    # Fixed: Use datetime.date for Streamlit compatibility
+    start_date = st.date_input("2. Start Date:", value=datetime.date(2023, 9, 1))
+with col2:
+    # Fixed: Use datetime.date for Streamlit compatibility
+    end_date = st.date_input("3. End Date:", value=datetime.date(2024, 3, 1))
+
+cloud_filter = st.sidebar.slider(
+    "4. Max Cloud Filter (%):",
+    min_value=1,
+    max_value=100,
+    value=15
+)
+
+
+# --- Processing Logic ---
 
-    # Create a TOML file Streamlit can read
-    secrets_content = f'''GEE_SERVICE_ACCOUNT = "{service_account}"
+# Get selected city coordinates
+lon, lat = EUROPEAN_CAPITALS[selected_city]
+# Define a buffer around the city point (e.g., 25km radius)
+city_point = ee.Geometry.Point([lon, lat])
+aoi = city_point.buffer(25000)
 
-GEE_PRIVATE_KEY = """{private_key}"""
-'''
-    secrets_path.write_text(secrets_content)
+# 1. Collection filtered ONLY by date and bounds (used for comprehensive plotting)
+s2_unfiltered_collection = ee.ImageCollection("COPERNICUS/S2_HARMONIZED") \
+    .filterDate(start_date.isoformat(), end_date.isoformat()) \
+    .filterBounds(aoi)
 
-# Ensure the file exists before Streamlit tries to access it
-ensure_streamlit_secrets()
+# 2. Collection filtered by date, bounds, AND cloud percentage (used for composite)
+# This ensures only images under the cloud_filter threshold are used for the median composite.
+s2_composite_collection = s2_unfiltered_collection \
+    .filterMetadata('CLOUDY_PIXEL_PERCENTAGE', 'less_than', cloud_filter)
 
-st.title("Secret Check")
+# Calculate the size of the *composite* collection (blocking call)
+collection_size = s2_composite_collection.size().getInfo()
+unfiltered_collection_size = s2_unfiltered_collection.size().getInfo()
 
 try:
-    st.write("Secrets keys:", list(st.secrets.keys()))
+    if collection_size == 0:
+        st.warning(
+            f"⚠️ No Sentinel-2 images found for **{selected_city}** that meet the **{cloud_filter}%** max cloudiness filter. Try expanding the date range or increasing the cloud filter.")
+        # Create a map centered on the city even if no image is found
+        Map = geemap.Map(center=[lat, lon], zoom=11, plugin_Draw=False)
+        Map.to_streamlit(width=800, height=500)
+        st.stop()
+    else:
+        # Calculate the median composite image
+        s2_composite = s2_composite_collection.median()
+
+        # --- Data Extraction for Plotting (Using UNFILTERED Collection) ---
+        # Get list of properties for each image in the UNFILTERED collection
+        feature_list = s2_unfiltered_collection.toList(unfiltered_collection_size).getInfo()
+        data_for_df = []
+        for feature in feature_list:
+            props = feature['properties']
+            data_for_df.append({
+                'Acquisition Date': props['system:time_start'],
+                'Cloudiness (%)': props['CLOUDY_PIXEL_PERCENTAGE']
+            })
+
+        # Convert to Pandas DataFrame and format the date
+        df = pd.DataFrame(data_for_df)
+        # Convert Earth Engine Unix timestamp (milliseconds) to datetime objects
+        df['Acquisition Date'] = pd.to_datetime(df['Acquisition Date'], unit='ms')
+        df = df.set_index('Acquisition Date').sort_index()
+
+        # Add color column based on the user's filter threshold (Blue <= threshold, Red > threshold)
+        df['Color'] = df['Cloudiness (%)'].apply(
+            lambda x: 'blue' if x <= cloud_filter else 'red'
+        )
+
+        # Calculate the average cloudiness of the source images (from the UNFILTERED set for proper reporting)
+        mean_cloud_percentage = s2_unfiltered_collection.aggregate_mean('CLOUDY_PIXEL_PERCENTAGE').getInfo()
+
+        # Display analysis results
+        st.subheader(f"Data Analysis for {selected_city}")
+        st.info(f"📸 Total available images (date/bounds filtered): **{unfiltered_collection_size}**")
+        st.info(f"✅ Images used for composite (under {cloud_filter}% cloudiness): **{collection_size}**")
+        st.info(f"☁️ Average Cloudiness of all available images: **{mean_cloud_percentage:.2f}%**")
+
+        # --- PLOT CLOUDINESS OVER TIME with Conditional Colors using Altair ---
+        st.subheader("Cloudiness Over Time vs. Filter Threshold")
+        st.markdown(
+            f"Bars are colored **blue** if cloudiness is below the **{cloud_filter}%** threshold (used for composite) and **red** if above.")
+
+        # Define custom color scale to ensure blue and red are used
+        color_scale = alt.Scale(domain=['blue', 'red'], range=['blue', 'red'])
+
+        # Create the Altair chart
+        chart = alt.Chart(df.reset_index()).mark_bar().encode(
+            x=alt.X('Acquisition Date', title='Acquisition Date'),
+            y=alt.Y('Cloudiness (%)', title='Cloudiness (%)'),
+            color=alt.Color('Color', scale=color_scale),  # Use the pre-calculated color column
+            tooltip=['Acquisition Date', 'Cloudiness (%)']
+        ).properties(
+            height=300
+        ).interactive()  # Make the chart zoomable/pannable
+
+        # Add a horizontal line to represent the user's cloud filter threshold
+        rule = alt.Chart(pd.DataFrame({'y': [cloud_filter]})).mark_rule(color='green', strokeDash=[5, 5]).encode(
+            y='y'
+        )
+
+        st.altair_chart(chart + rule, use_container_width=True)
+        # --- END PLOT ---
+
+        # Visualization parameters (Natural Color RGB)
+        vis_params = {
+            "bands": ["B4", "B3", "B2"],
+            "min": 0,
+            "max": 3000,
+            "gamma": 1.4
+        }
+
+        # Create a map centered on the selected city
+        Map = geemap.Map(center=[lat, lon], zoom=10)
+
+        # Add the composite layer to the map
+        Map.addLayer(s2_composite, vis_params, f"Sentinel-2 Composite: {selected_city}")
+
+        # Add a marker for the capital city center
+        Map.add_marker([lat, lon], tooltip=selected_city)
+        #Map.add_ee_layer(aoi.bounds(), {'color': 'red'}, 'Area of Interest')
+
+        # Display the map in Streamlit
+        st.subheader("Satellite Composite Visualization")
+        Map.to_streamlit(width=900, height=600)
+
 except Exception as e:
-    st.error(f"Error loading secrets: {e}")
+    st.error(f"An Earth Engine error occurred during processing: {e}")
+
+st.markdown("""
+---
+*Data Source: ESA Copernicus Sentinel-2 Level 2A data via Google Earth Engine.*
+""")