Create app.py

app.py

@@ -0,0 +1,412 @@
+import streamlit as st
+import ee
+import geemap.foliumap as geemap
+import folium
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, date
+import json
+
+# Configure Streamlit page
+st.set_page_config(
+    page_title="Interactive Landsat 9 Analysis",
+    page_icon="🛰️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize Earth Engine function
+@st.cache_resource
+def init_ee_with_project(project_id=None):
+    try:
+        if project_id:
+            ee.Initialize(project=project_id)
+        else:
+            ee.Initialize()
+        return True, None
+    except Exception as e:
+        return False, str(e)
+
+# Main title and description
+st.title("🛰️ Interactive Landsat 9 OLI/TIRS Analysis")
+st.markdown("""
+This interactive application allows you to analyze Landsat 9 satellite imagery with various spectral indices 
+and visualizations. Customize your analysis parameters using the sidebar controls.
+""")
+
+# Earth Engine initialization with project handling
+ee_initialized = False
+
+# Try to initialize without project first
+success, error = init_ee_with_project()
+
+if not success:
+    st.warning("Earth Engine initialization failed. Please provide your Google Cloud Project ID.")
+    st.info("""
+    **To get your Project ID:**
+    1. Go to https://console.cloud.google.com/
+    2. Create a new project or select an existing one
+    3. Enable the Earth Engine API for your project
+    4. Copy the Project ID from the project selector
+    """)
+    
+    project_id = st.text_input(
+        "Enter your Google Cloud Project ID:",
+        help="Find this in your Google Cloud Console dashboard"
+    )
+    
+    if project_id:
+        success, error = init_ee_with_project(project_id)
+        if success:
+            st.success(f"Successfully initialized Earth Engine with project: {project_id}")
+            ee_initialized = True
+        else:
+            st.error(f"Failed to initialize with project {project_id}: {error}")
+    
+    if not ee_initialized:
+        st.stop()
+else:
+    ee_initialized = True
+    st.success("Earth Engine initialized successfully!")
+
+# Sidebar controls
+st.sidebar.header("🎛️ Analysis Parameters")
+
+# Location settings
+st.sidebar.subheader("📍 Location Settings")
+center_lat = st.sidebar.number_input("Center Latitude", value=34.741, format="%.3f")
+center_lon = st.sidebar.number_input("Center Longitude", value=71.878, format="%.3f")
+buffer_size = st.sidebar.slider("Buffer Size (km)", min_value=10, max_value=100, value=50)
+
+# Date range settings
+st.sidebar.subheader("📅 Date Range")
+start_date = st.sidebar.date_input("Start Date", value=date(2022, 1, 1))
+end_date = st.sidebar.date_input("End Date", value=date(2022, 12, 31))
+
+# Cloud cover filter
+cloud_cover = st.sidebar.slider("Maximum Cloud Cover (%)", min_value=0, max_value=100, value=20)
+
+# Visualization options
+st.sidebar.subheader("🎨 Visualization Options")
+vis_options = {
+    "True Color (432)": {"bands": ["B4", "B3", "B2"], "min": 8000, "max": 18000},
+    "False Color (543)": {"bands": ["B5", "B4", "B3"], "min": 8000, "max": 20000},
+    "Agriculture (654)": {"bands": ["B6", "B5", "B4"], "min": 8000, "max": 20000},
+    "Geology (764)": {"bands": ["B7", "B6", "B4"], "min": 8000, "max": 20000},
+    "Bathymetric (431)": {"bands": ["B4", "B3", "B1"], "min": 8000, "max": 18000}
+}
+
+selected_vis = st.sidebar.selectbox("Select Band Combination", list(vis_options.keys()))
+
+# Index calculations
+st.sidebar.subheader("📊 Spectral Indices")
+show_indices = st.sidebar.multiselect(
+    "Select Indices to Display",
+    ["NDVI", "EVI", "SAVI", "NDWI", "MNDWI", "NDBI", "NBR", "NDSI"],
+    default=["NDVI", "NDWI"]
+)
+
+# Analysis function
+@st.cache_data
+def perform_analysis(lat, lon, buffer_km, start_dt, end_dt, max_cloud):
+    # Define area of interest
+    aoi = ee.Geometry.Point([lon, lat]).buffer(buffer_km * 1000)
+    
+    # Load Landsat 9 dataset
+    dataset = ee.ImageCollection('LANDSAT/LC09/C02/T1') \
+                .filterDate(start_dt.strftime('%Y-%m-%d'), end_dt.strftime('%Y-%m-%d')) \
+                .filterBounds(aoi) \
+                .filter(ee.Filter.lt('CLOUD_COVER', max_cloud)) \
+                .sort('CLOUD_COVER')
+    
+    # Get dataset info
+    size = dataset.size().getInfo()
+    
+    if size == 0:
+        return None, None, "No images found for the specified criteria."
+    
+    # Create composite
+    composite = dataset.median().clip(aoi)
+    
+    # Calculate indices
+    indices = {}
+    
+    # Vegetation indices
+    indices['NDVI'] = composite.normalizedDifference(['B5', 'B4']).rename('NDVI')
+    indices['EVI'] = composite.expression(
+        '2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))', {
+            'NIR': composite.select('B5'),
+            'RED': composite.select('B4'),
+            'BLUE': composite.select('B2')
+        }).rename('EVI')
+    indices['SAVI'] = composite.expression(
+        '((NIR - RED) / (NIR + RED + 0.5)) * (1 + 0.5)', {
+            'NIR': composite.select('B5'),
+            'RED': composite.select('B4')
+        }).rename('SAVI')
+    
+    # Water indices
+    indices['NDWI'] = composite.normalizedDifference(['B3', 'B5']).rename('NDWI')
+    indices['MNDWI'] = composite.normalizedDifference(['B3', 'B6']).rename('MNDWI')
+    
+    # Urban indices
+    indices['NDBI'] = composite.normalizedDifference(['B6', 'B5']).rename('NDBI')
+    
+    # Burn index
+    indices['NBR'] = composite.normalizedDifference(['B5', 'B7']).rename('NBR')
+    
+    # Snow index
+    indices['NDSI'] = composite.normalizedDifference(['B3', 'B6']).rename('NDSI')
+    
+    # Calculate statistics
+    stats = {}
+    for name, index in indices.items():
+        stat = index.reduceRegion(
+            reducer=ee.Reducer.mean().combine(ee.Reducer.stdDev(), sharedInputs=True),
+            geometry=aoi,
+            scale=30,
+            maxPixels=1e9
+        ).getInfo()
+        stats[name] = stat
+    
+    return composite, indices, stats, aoi, size
+
+# Run analysis button
+if st.sidebar.button("🚀 Run Analysis", type="primary"):
+    with st.spinner("Analyzing Landsat 9 imagery..."):
+        try:
+            result = perform_analysis(
+                center_lat, center_lon, buffer_size, 
+                start_date, end_date, cloud_cover
+            )
+            
+            if result[0] is None:
+                st.error(result[2])
+            else:
+                composite, indices, stats, aoi, image_count = result
+                st.success(f"Analysis complete! Found {image_count} images.")
+                
+                # Store results in session state
+                st.session_state.composite = composite
+                st.session_state.indices = indices
+                st.session_state.stats = stats
+                st.session_state.aoi = aoi
+                st.session_state.analysis_params = {
+                    'lat': center_lat, 'lon': center_lon, 'buffer': buffer_size
+                }
+                
+        except Exception as e:
+            st.error(f"Analysis failed: {str(e)}")
+
+# Display results if analysis has been run
+if 'composite' in st.session_state:
+    # Create tabs for different views
+    tab1, tab2, tab3, tab4 = st.tabs(["🗺️ Interactive Map", "📊 Statistics", "📈 Charts", "📋 Data Export"])
+    
+    with tab1:
+        st.subheader("Interactive Satellite Imagery Map")
+        
+        # Create the map
+        Map = geemap.Map(center=[st.session_state.analysis_params['lat'], 
+                                st.session_state.analysis_params['lon']], zoom=12)
+        
+        # Add selected visualization
+        vis_params = vis_options[selected_vis]
+        Map.addLayer(
+            st.session_state.composite.select(vis_params['bands']),
+            {
+                'min': vis_params['min'],
+                'max': vis_params['max'],
+                'bands': vis_params['bands']
+            },
+            selected_vis
+        )
+        
+        # Add selected indices
+        index_vis_params = {
+            'NDVI': {'min': -0.5, 'max': 0.8, 'palette': ['red', 'yellow', 'green']},
+            'EVI': {'min': -0.5, 'max': 0.8, 'palette': ['red', 'yellow', 'green']},
+            'SAVI': {'min': -0.5, 'max': 0.8, 'palette': ['red', 'yellow', 'green']},
+            'NDWI': {'min': -0.5, 'max': 0.5, 'palette': ['white', 'blue']},
+            'MNDWI': {'min': -0.5, 'max': 0.5, 'palette': ['white', 'blue']},
+            'NDBI': {'min': -0.5, 'max': 0.5, 'palette': ['blue', 'white', 'red']},
+            'NBR': {'min': -0.5, 'max': 0.5, 'palette': ['green', 'yellow', 'red']},
+            'NDSI': {'min': 0, 'max': 0.8, 'palette': ['red', 'yellow', 'white']}
+        }
+        
+        for index_name in show_indices:
+            if index_name in st.session_state.indices:
+                Map.addLayer(
+                    st.session_state.indices[index_name].selfMask(),
+                    index_vis_params[index_name],
+                    index_name,
+                    False  # Start with layer hidden
+                )
+        
+        # Add AOI boundary
+        Map.addLayer(st.session_state.aoi, {'color': 'yellow'}, 'Area of Interest')
+        
+        # Display the map
+        Map.to_streamlit(height=600)
+    
+    with tab2:
+        st.subheader("📊 Spectral Index Statistics")
+        
+        # Create statistics dataframe
+        stats_data = []
+        for index_name, stat_dict in st.session_state.stats.items():
+            if index_name in show_indices:
+                mean_key = f"{index_name}_mean"
+                std_key = f"{index_name}_stdDev"
+                
+                mean_val = stat_dict.get(mean_key, 0)
+                std_val = stat_dict.get(std_key, 0)
+                
+                stats_data.append({
+                    'Index': index_name,
+                    'Mean': round(mean_val, 4) if mean_val else 0,
+                    'Standard Deviation': round(std_val, 4) if std_val else 0,
+                    'Range': f"{round(mean_val - std_val, 4)} to {round(mean_val + std_val, 4)}" if mean_val and std_val else "N/A"
+                })
+        
+        if stats_data:
+            df_stats = pd.DataFrame(stats_data)
+            st.dataframe(df_stats, use_container_width=True)
+            
+            # Create bar chart of mean values
+            fig_bar = px.bar(
+                df_stats, 
+                x='Index', 
+                y='Mean', 
+                title='Mean Values of Spectral Indices',
+                color='Mean',
+                color_continuous_scale='viridis'
+            )
+            fig_bar.update_layout(height=400)
+            st.plotly_chart(fig_bar, use_container_width=True)
+    
+    with tab3:
+        st.subheader("📈 Data Visualization")
+        
+        # Index interpretation guide
+        with st.expander("📖 Index Interpretation Guide"):
+            st.markdown("""
+            **Vegetation Indices:**
+            - **NDVI**: -1 to 1 (higher = more vegetation)
+            - **EVI**: -1 to 1 (enhanced vegetation, reduces atmospheric effects)
+            - **SAVI**: -1 to 1 (soil-adjusted vegetation index)
+            
+            **Water Indices:**
+            - **NDWI**: -1 to 1 (higher = more water)
+            - **MNDWI**: -1 to 1 (modified NDWI, better for water detection)
+            
+            **Urban/Built-up:**
+            - **NDBI**: -1 to 1 (higher = more built-up areas)
+            
+            **Environmental:**
+            - **NBR**: -1 to 1 (normalized burn ratio for fire detection)
+            - **NDSI**: 0 to 1 (normalized difference snow index)
+            """)
+        
+        # Create comparison chart if multiple indices selected
+        if len(show_indices) > 1:
+            comparison_data = []
+            for index_name in show_indices:
+                if index_name in st.session_state.stats:
+                    stat_dict = st.session_state.stats[index_name]
+                    mean_key = f"{index_name}_mean"
+                    mean_val = stat_dict.get(mean_key, 0)
+                    comparison_data.append({'Index': index_name, 'Mean Value': mean_val})
+            
+            if comparison_data:
+                df_comparison = pd.DataFrame(comparison_data)
+                fig_comparison = px.bar(
+                    df_comparison,
+                    x='Index',
+                    y='Mean Value',
+                    title='Spectral Index Comparison',
+                    color='Mean Value',
+                    color_continuous_scale='RdYlGn'
+                )
+                fig_comparison.update_layout(height=400)
+                st.plotly_chart(fig_comparison, use_container_width=True)
+    
+    with tab4:
+        st.subheader("📋 Data Export Options")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("**📊 Statistics Export**")
+            if st.button("Download Statistics as CSV"):
+                if 'stats' in st.session_state:
+                    stats_data = []
+                    for index_name, stat_dict in st.session_state.stats.items():
+                        mean_key = f"{index_name}_mean"
+                        std_key = f"{index_name}_stdDev"
+                        stats_data.append({
+                            'Index': index_name,
+                            'Mean': stat_dict.get(mean_key, 0),
+                            'Standard_Deviation': stat_dict.get(std_key, 0)
+                        })
+                    
+                    df_export = pd.DataFrame(stats_data)
+                    csv = df_export.to_csv(index=False)
+                    st.download_button(
+                        label="📥 Download CSV",
+                        data=csv,
+                        file_name=f"landsat9_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                        mime="text/csv"
+                    )
+        
+        with col2:
+            st.markdown("**🗺️ Map Export**")
+            st.info("Use the map's built-in export tools to save visualizations as images.")
+        
+        # Analysis summary
+        st.markdown("**📋 Analysis Summary**")
+        summary_info = f"""
+        - **Location**: {st.session_state.analysis_params['lat']:.3f}°N, {st.session_state.analysis_params['lon']:.3f}°E
+        - **Buffer Size**: {st.session_state.analysis_params['buffer']} km
+        - **Date Range**: {start_date} to {end_date}
+        - **Cloud Cover**: ≤ {cloud_cover}%
+        - **Selected Visualization**: {selected_vis}
+        - **Active Indices**: {', '.join(show_indices)}
+        """
+        st.markdown(summary_info)
+
+else:
+    # Instructions when no analysis has been run
+    st.info("👈 Configure your analysis parameters in the sidebar and click 'Run Analysis' to get started!")
+    
+    # Feature overview
+    st.markdown("""
+    ## 🌟 Features
+    
+    **🛰️ Satellite Data Analysis**
+    - Landsat 9 OLI/TIRS imagery (30m resolution)
+    - Customizable date ranges and cloud cover filtering
+    - Multiple band combinations for different applications
+    
+    **📊 Spectral Indices**
+    - Vegetation: NDVI, EVI, SAVI
+    - Water: NDWI, MNDWI  
+    - Urban: NDBI
+    - Environmental: NBR (burn), NDSI (snow)
+    
+    **🎨 Interactive Visualizations**
+    - True color, false color, and specialized composites
+    - Statistical analysis and charting
+    - Export capabilities for further analysis
+    
+    **🗺️ Interactive Mapping**
+    - Zoom, pan, and layer control
+    - Real-time visualization switching
+    - Area of interest boundary display
+    """)
+
+# Footer
+st.markdown("---")
+st.markdown("Built with ❤️ using Streamlit, Google Earth Engine, and geemap")