Initial commit

.gitignore

@@ -0,0 +1,66 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+env/
+venv/
+ENV/
+.venv/
+rehabwatch_env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Logs
+*.log
+streamlit_*.log
+nohup.out
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+*.pdf
+*.csv
+*.pptx
+CLAUDE.md
+pitch_deck_generator.py
+runtime.txt
+tests/

.streamlit/config.toml

@@ -0,0 +1,23 @@
+[theme]
+primaryColor = "#2E7D32"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F5F5F5"
+textColor = "#212121"
+
+[server]
+maxUploadSize = 50
+enableCORS = false
+enableXsrfProtection = true
+headless = true
+runOnSave = false
+
+[browser]
+gatherUsageStats = false
+
+[client]
+showErrorDetails = false
+toolbarMode = "minimal"
+
+[runner]
+magicEnabled = true
+fastReruns = true

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies for GDAL
+RUN apt-get update && apt-get install -y \
+    gdal-bin \
+    libgdal-dev \
+    libgeos-dev \
+    libproj-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set GDAL environment variables
+ENV GDAL_CONFIG=/usr/bin/gdal-config
+
+# Copy requirements first for caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Expose Streamlit port
+EXPOSE 7860
+
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.headless=true"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RehabWatch
+
+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

@@ -0,0 +1,9 @@
+---
+title: MineWatchAI
+emoji: 🤖
+colorFrom: green
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
+---

app.py

@@ -0,0 +1,636 @@
+"""
+MineWatchAI - AI-Powered Mining Rehabilitation Monitoring
+Main Streamlit Application
+
+AI-powered environmental intelligence for measurable,
+audit-ready mining rehabilitation.
+"""
+
+import streamlit as st
+import json
+import gc
+from datetime import datetime, timedelta
+from pathlib import Path
+
+# Page configuration - MUST be first Streamlit command
+st.set_page_config(
+    page_title="MineWatchAI - Green Tech",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Show loading message while imports happen
+with st.spinner("Loading MineWatchAI..."):
+    # Lazy imports for faster initial load
+    from streamlit_folium import st_folium
+    import folium
+
+
+def load_css():
+    """Load custom CSS styling."""
+    css_path = Path(__file__).parent / "assets" / "style.css"
+    if css_path.exists():
+        with open(css_path) as f:
+            st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+
+@st.cache_data
+def load_examples():
+    """Load example mines data from JSON file."""
+    json_path = Path(__file__).parent / "data" / "examples.json"
+    if json_path.exists():
+        with open(json_path) as f:
+            return json.load(f)
+    return {"examples": [], "default_location": {"center": [-28.0, 121.0], "zoom": 6}}
+
+
+def get_bbox_from_example(example: dict) -> tuple:
+    """Get bounding box from example mine data."""
+    geom = example.get("geometry", {})
+    coords = geom.get("coordinates", [])
+    if len(coords) == 4:
+        return tuple(coords)
+    else:
+        center = example.get("center", [-28.0, 121.0])
+        lat, lon = center
+        return (lon - 0.05, lat - 0.05, lon + 0.05, lat + 0.05)
+
+
+def create_simple_map(center, zoom=10, bbox=None):
+    """Create a simple Folium map."""
+    m = folium.Map(location=center, zoom_start=zoom)
+
+    # Add satellite imagery
+    folium.TileLayer(
+        tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr='Esri',
+        name='Satellite',
+        overlay=False
+    ).add_to(m)
+
+    if bbox is not None:
+        min_lon, min_lat, max_lon, max_lat = bbox
+        boundary_coords = [
+            [min_lat, min_lon],
+            [min_lat, max_lon],
+            [max_lat, max_lon],
+            [max_lat, min_lon],
+            [min_lat, min_lon]
+        ]
+        folium.Polygon(
+            locations=boundary_coords,
+            color='#1B5E20',
+            weight=3,
+            fill=True,
+            fillColor='#2E7D32',
+            fillOpacity=0.2,
+            popup='Analysis Area'
+        ).add_to(m)
+
+    folium.LayerControl().add_to(m)
+    return m
+
+
+def run_analysis(bbox, mine_info, date_before, date_after):
+    """Run the comprehensive vegetation change analysis."""
+    # Import heavy modules only when needed
+    from src.stac_utils import get_bbox_center
+    from src.analysis import (
+        analyze_vegetation_change,
+        analyze_terrain,
+        analyze_land_cover,
+        calculate_reference_ndvi,
+        calculate_rehab_score,
+        calculate_comprehensive_rehab_score,
+        generate_interpretation
+    )
+
+    progress = st.progress(0, text="Initializing analysis...")
+
+    try:
+        progress.progress(10, text="Searching for satellite imagery...")
+
+        # Run vegetation change analysis with all indices
+        results = analyze_vegetation_change(
+            bbox,
+            date_before,
+            date_after,
+            window_days=15,
+            cloud_threshold=30
+        )
+
+        progress.progress(50, text="Analyzing terrain...")
+
+        # Run terrain analysis
+        bsi_after = results.get('indices_after', {}).get('bsi')
+        terrain_results = analyze_terrain(bbox, bsi=bsi_after)
+        terrain_stats = terrain_results.get('stats', {})
+
+        progress.progress(70, text="Analyzing land cover...")
+
+        # Run land cover analysis
+        year_before = int(date_before[:4])
+        year_after = int(date_after[:4])
+        # Clamp years to available data range (2017-2023)
+        year_before = max(2017, min(2023, year_before))
+        year_after = max(2017, min(2023, year_after))
+
+        land_cover_results = analyze_land_cover(bbox, year_before, year_after)
+        land_cover_stats = land_cover_results.get('stats', {})
+
+        progress.progress(85, text="Calculating rehabilitation metrics...")
+
+        # Calculate reference NDVI
+        reference_ndvi = calculate_reference_ndvi(
+            bbox,
+            date_after,
+            window_days=15,
+            buffer_deg=0.01
+        )
+
+        # Calculate comprehensive rehabilitation scores
+        rehab_scores = calculate_comprehensive_rehab_score(
+            results['stats'],
+            terrain_stats=terrain_stats,
+            land_cover_stats=land_cover_stats,
+            reference_ndvi=reference_ndvi if reference_ndvi > 0 else 0.5
+        )
+
+        # Legacy score for backwards compatibility
+        site_ndvi = results['stats']['ndvi_after_mean']
+        rehab_score = calculate_rehab_score(site_ndvi, reference_ndvi)
+
+        progress.progress(95, text="Generating interpretation...")
+
+        # Generate comprehensive interpretation
+        interpretation = generate_interpretation(
+            results['stats'],
+            rehab_score,
+            terrain_stats=terrain_stats,
+            land_cover_stats=land_cover_stats
+        )
+
+        # Get center coordinates
+        center = get_bbox_center(bbox)
+
+        progress.progress(100, text="Analysis complete!")
+
+        # Store only necessary results (exclude large arrays to save memory)
+        st.session_state.analysis_results = {
+            'ndvi_before': results['ndvi_before'],
+            'ndvi_after': results['ndvi_after'],
+            'ndvi_change': results['ndvi_change'],
+            'indices_after': results.get('indices_after', {}),
+            'index_changes': results.get('index_changes', {}),
+            'stats': results['stats'],
+            'date_before': results['date_before'],
+            'date_after': results['date_after'],
+            'bbox': results['bbox'],
+            'terrain_results': terrain_results,
+            'terrain_stats': terrain_stats,
+            'land_cover_results': land_cover_results,
+            'land_cover_stats': land_cover_stats,
+            'rehab_score': rehab_score,
+            'rehab_scores': rehab_scores,
+            'reference_ndvi': reference_ndvi,
+            'interpretation': interpretation,
+            'mine_info': mine_info,
+            'center': center
+        }
+
+        # Clean up memory
+        del results
+        gc.collect()
+
+        return True
+
+    except ValueError as e:
+        st.error(f"Analysis Error: {str(e)}")
+        return False
+    except Exception as e:
+        st.error(f"Unexpected error: {str(e)}")
+        st.info("Try adjusting the date range or selecting a different site.")
+        return False
+
+
+def display_results():
+    """Display comprehensive analysis results."""
+    # Import visualization only when showing results
+    from src.visualization import (
+        create_comparison_map,
+        create_multi_index_map,
+        create_terrain_map,
+        create_land_cover_map,
+        create_comprehensive_stats_display,
+        create_area_breakdown_chart,
+        create_ndvi_comparison_chart,
+        create_multi_index_chart,
+        create_terrain_stats_chart,
+        create_land_cover_chart,
+        create_vegetation_health_chart,
+        create_environmental_indicators_chart,
+        create_statistics_table,
+        create_time_series_chart
+    )
+    from src.report import generate_pdf_report, stats_to_csv
+
+    results = st.session_state.analysis_results
+    stats = results['stats']
+    rehab_score = results['rehab_score']
+    rehab_scores = results.get('rehab_scores', {})
+    interpretation = results['interpretation']
+    mine_info = results.get('mine_info', {})
+    terrain_stats = results.get('terrain_stats', {})
+    land_cover_stats = results.get('land_cover_stats', {})
+    terrain_results = results.get('terrain_results', {})
+    land_cover_results = results.get('land_cover_results', {})
+
+    mine_name = mine_info.get('name', 'Selected Site')
+    tenement_id = mine_info.get('tenement_id', 'N/A')
+
+    st.markdown(f"### Analysis Results: {mine_name}")
+    st.markdown(f"*Tenement: {tenement_id} | Period: {results['date_before']} to {results['date_after']}*")
+
+    if st.button("🔄 New Analysis", type="secondary"):
+        st.session_state.analysis_results = None
+        st.rerun()
+
+    st.markdown("---")
+
+    # Map section with tabs for different views
+    st.markdown("### Maps")
+    map_tab1, map_tab2, map_tab3, map_tab4 = st.tabs([
+        "Vegetation Change", "Multi-Index", "Terrain", "Land Cover"
+    ])
+
+    with map_tab1:
+        with st.spinner("Rendering vegetation change map..."):
+            comparison_map = create_comparison_map(
+                bbox=results['bbox'],
+                ndvi_before=results['ndvi_before'],
+                ndvi_after=results['ndvi_after'],
+                ndvi_change=results['ndvi_change'],
+                center_coords=results['center'],
+                zoom=mine_info.get('zoom', 13)
+            )
+            st_folium(comparison_map, width=None, height=450, returned_objects=[])
+        st.caption("Green = improvement, Red = decline. Use layer control to toggle views.")
+
+    with map_tab2:
+        with st.spinner("Rendering multi-index map..."):
+            indices_after = results.get('indices_after', {})
+            index_changes = results.get('index_changes', {})
+            if indices_after:
+                multi_map = create_multi_index_map(
+                    bbox=results['bbox'],
+                    indices_after=indices_after,
+                    index_changes=index_changes,
+                    center_coords=results['center'],
+                    zoom=mine_info.get('zoom', 13)
+                )
+                st_folium(multi_map, width=None, height=450, returned_objects=[])
+                st.caption("Toggle layers to view different indices: NDVI, SAVI, EVI, BSI, NDWI, NDMI")
+            else:
+                st.info("Multi-index data not available")
+
+    with map_tab3:
+        if terrain_results and 'slope' in terrain_results:
+            with st.spinner("Rendering terrain map..."):
+                terrain_map = create_terrain_map(
+                    bbox=results['bbox'],
+                    slope=terrain_results['slope'],
+                    aspect=terrain_results.get('aspect'),
+                    erosion_risk=terrain_results.get('erosion_risk'),
+                    center_coords=results['center'],
+                    zoom=mine_info.get('zoom', 13)
+                )
+                st_folium(terrain_map, width=None, height=450, returned_objects=[])
+                st.caption("Slope analysis from Copernicus DEM GLO-30")
+        else:
+            st.info("Terrain data not available for this location")
+
+    with map_tab4:
+        if land_cover_results and 'lulc_after' in land_cover_results:
+            with st.spinner("Rendering land cover map..."):
+                lulc_map = create_land_cover_map(
+                    bbox=results['bbox'],
+                    lulc=land_cover_results['lulc_after'],
+                    center_coords=results['center'],
+                    zoom=mine_info.get('zoom', 13),
+                    year=land_cover_stats.get('year_after', 2023)
+                )
+                st_folium(lulc_map, width=None, height=450, returned_objects=[])
+                st.caption("IO-LULC land cover classification")
+        else:
+            st.info("Land cover data not available for this location")
+
+    st.markdown("---")
+
+    # Main analysis tabs
+    tab1, tab2, tab3, tab4, tab5 = st.tabs([
+        "Summary", "All Indices", "Terrain & Land Cover", "Time Series", "Export"
+    ])
+
+    with tab1:
+        # Use comprehensive stats display
+        create_comprehensive_stats_display(
+            stats, rehab_score,
+            terrain_stats=terrain_stats,
+            land_cover_stats=land_cover_stats
+        )
+
+        st.markdown("---")
+        st.markdown("### Interpretation")
+        st.info(interpretation)
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.plotly_chart(create_area_breakdown_chart(stats), use_container_width=True)
+        with col2:
+            st.plotly_chart(create_vegetation_health_chart(stats), use_container_width=True)
+
+        # Environmental indicators radar chart
+        st.plotly_chart(create_environmental_indicators_chart(stats), use_container_width=True)
+
+    with tab2:
+        st.markdown("### Multi-Index Analysis")
+        st.markdown("""
+        Multiple vegetation and soil indices provide a comprehensive view:
+        - **NDVI**: Overall vegetation health
+        - **SAVI**: Better for sparse vegetation (soil-adjusted)
+        - **EVI**: Better for dense vegetation
+        - **NDWI**: Water presence
+        - **NDMI**: Vegetation moisture content
+        - **BSI**: Bare soil extent
+        """)
+
+        st.plotly_chart(create_multi_index_chart(stats), use_container_width=True)
+
+        # Detailed stats table
+        st.markdown("### Detailed Statistics")
+        create_statistics_table(stats)
+
+    with tab3:
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.markdown("### Terrain Analysis")
+            if terrain_stats:
+                st.plotly_chart(create_terrain_stats_chart(terrain_stats), use_container_width=True)
+
+                st.markdown("**Terrain Metrics:**")
+                st.write(f"- Mean Slope: {terrain_stats.get('slope_mean', 0):.1f}°")
+                st.write(f"- Max Slope: {terrain_stats.get('slope_max', 0):.1f}°")
+                st.write(f"- Elevation Range: {terrain_stats.get('elevation_min', 0):.0f}m - {terrain_stats.get('elevation_max', 0):.0f}m")
+                if 'percent_high_erosion_risk' in terrain_stats:
+                    st.write(f"- High Erosion Risk: {terrain_stats['percent_high_erosion_risk']:.1f}%")
+            else:
+                st.info("Terrain analysis not available")
+
+        with col2:
+            st.markdown("### Land Cover Change")
+            if land_cover_stats and 'class_changes' in land_cover_stats:
+                st.plotly_chart(create_land_cover_chart(land_cover_stats), use_container_width=True)
+
+                st.markdown("**Land Cover Metrics:**")
+                st.write(f"- Vegetation Cover: {land_cover_stats.get('vegetation_cover_after', 0):.1f}%")
+                st.write(f"- Vegetation Change: {land_cover_stats.get('vegetation_cover_change', 0):+.1f}%")
+                st.write(f"- Bare Ground: {land_cover_stats.get('bare_ground_after', 0):.1f}%")
+                st.write(f"- Bare Ground Change: {land_cover_stats.get('bare_ground_change', 0):+.1f}%")
+            else:
+                st.info("Land cover analysis not available")
+
+    with tab4:
+        st.markdown("### Time Series")
+        st.info("Click button below to load historical NDVI data (may take a few minutes)")
+
+        if st.button("Load Time Series"):
+            from src.analysis import get_monthly_ndvi_timeseries
+
+            date_before = datetime.strptime(results['date_before'], '%Y-%m-%d')
+            date_after = datetime.strptime(results['date_after'], '%Y-%m-%d')
+
+            with st.spinner("Loading time series..."):
+                try:
+                    timeseries = get_monthly_ndvi_timeseries(
+                        results['bbox'],
+                        date_before.year,
+                        date_after.year
+                    )
+                    if timeseries:
+                        fig = create_time_series_chart(timeseries)
+                        st.plotly_chart(fig, use_container_width=True)
+                    else:
+                        st.warning("No time series data available.")
+                except Exception as e:
+                    st.error(f"Error: {e}")
+
+    with tab5:
+        st.markdown("### Export Results")
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.markdown("#### PDF Report")
+            pdf_bytes = generate_pdf_report(
+                tenement_id=tenement_id,
+                stats=stats,
+                rehab_score=rehab_score,
+                interpretation=interpretation,
+                date_before=results['date_before'],
+                date_after=results['date_after'],
+                mine_name=mine_name
+            )
+            st.download_button(
+                "Download PDF",
+                data=pdf_bytes,
+                file_name=f"rehabwatch_{tenement_id.replace(' ', '_')}.pdf",
+                mime="application/pdf",
+                use_container_width=True
+            )
+
+        with col2:
+            st.markdown("#### CSV Data")
+            csv_data = stats_to_csv(
+                stats=stats,
+                tenement_id=tenement_id,
+                rehab_score=rehab_score,
+                date_before=results['date_before'],
+                date_after=results['date_after'],
+                mine_name=mine_name
+            )
+            st.download_button(
+                "Download CSV",
+                data=csv_data,
+                file_name=f"rehabwatch_{tenement_id.replace(' ', '_')}.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+
+def main():
+    """Main application function."""
+    load_css()
+
+    examples_data = load_examples()
+    examples = examples_data.get("examples", [])
+    default_location = examples_data.get("default_location", {"center": [-28.0, 121.0], "zoom": 6})
+
+    # Initialize session state
+    if "analysis_results" not in st.session_state:
+        st.session_state.analysis_results = None
+    if "selected_bbox" not in st.session_state:
+        st.session_state.selected_bbox = None
+    if "selected_mine" not in st.session_state:
+        st.session_state.selected_mine = None
+    if "analyzing" not in st.session_state:
+        st.session_state.analyzing = False
+
+    # Sidebar
+    with st.sidebar:
+        st.markdown("## 🌱 Analysis Hub")
+        st.markdown("**MineWatchAI**")
+        st.markdown("---")
+
+        st.markdown("### Select Mining Site")
+
+        example_names = ["Select a mine..."] + [e["name"] for e in examples]
+        selected_name = st.selectbox("Choose a mine:", example_names)
+
+        if selected_name != "Select a mine...":
+            for example in examples:
+                if example["name"] == selected_name:
+                    st.session_state.selected_mine = example
+                    base_bbox = get_bbox_from_example(example)
+
+                    # Area size adjustment
+                    st.markdown("#### Adjust Analysis Area")
+                    area_scale = st.slider(
+                        "Area Size",
+                        min_value=0.5,
+                        max_value=2.0,
+                        value=1.0,
+                        step=0.1,
+                        help="Adjust the analysis area: <1.0 = smaller, >1.0 = larger"
+                    )
+
+                    # Apply scaling to bbox
+                    min_lon, min_lat, max_lon, max_lat = base_bbox
+                    center_lon = (min_lon + max_lon) / 2
+                    center_lat = (min_lat + max_lat) / 2
+                    half_width = (max_lon - min_lon) / 2 * area_scale
+                    half_height = (max_lat - min_lat) / 2 * area_scale
+
+                    st.session_state.selected_bbox = (
+                        center_lon - half_width,
+                        center_lat - half_height,
+                        center_lon + half_width,
+                        center_lat + half_height
+                    )
+
+                    st.info(f"📌 {example['description']}")
+                    break
+
+        st.markdown("---")
+        st.markdown("### Analysis Period")
+
+        col1, col2, col3 = st.columns(3)
+        today = datetime.now().date()
+
+        with col1:
+            if st.button("1Y", use_container_width=True):
+                st.session_state.date_before = today - timedelta(days=365)
+                st.session_state.date_after = today
+        with col2:
+            if st.button("2Y", use_container_width=True):
+                st.session_state.date_before = today - timedelta(days=730)
+                st.session_state.date_after = today
+        with col3:
+            if st.button("5Y", use_container_width=True):
+                st.session_state.date_before = today - timedelta(days=1825)
+                st.session_state.date_after = today
+
+        default_before = st.session_state.get("date_before", today - timedelta(days=730))
+        default_after = st.session_state.get("date_after", today)
+
+        date_before = st.date_input("Start Date", value=default_before, max_value=today)
+        date_after = st.date_input("End Date", value=default_after, max_value=today)
+
+        if date_after <= date_before:
+            st.error("End date must be after start date")
+
+        st.markdown("---")
+
+        analyze_disabled = st.session_state.selected_bbox is None or date_after <= date_before
+
+        if st.button("🤖 AI-Analyze", type="primary", use_container_width=True, disabled=analyze_disabled):
+            st.session_state.analyzing = True
+
+        if analyze_disabled:
+            st.caption("Select a mine and valid dates")
+
+        st.markdown("---")
+
+        with st.expander("ℹ️ About"):
+            st.markdown("""
+            **MineWatchAI** - AI-driven green technology
+            for sustainable mining rehabilitation.
+
+            ---
+
+            Developed by [Ashkan Taghipour](https://ashkantaghipour.github.io/)
+
+            ⚠️ *This is a research startup project currently
+            under active development.*
+            """)
+
+    # Main area
+    st.markdown("# 🤖 MineWatchAI")
+    st.markdown("*AI-powered environmental intelligence for measurable, audit-ready mining rehabilitation*")
+
+    # Handle analysis
+    if st.session_state.analyzing:
+        st.session_state.analyzing = False
+        success = run_analysis(
+            st.session_state.selected_bbox,
+            st.session_state.selected_mine,
+            str(date_before),
+            str(date_after)
+        )
+        if success:
+            st.rerun()
+
+    # Display results or initial map
+    if st.session_state.analysis_results is not None:
+        display_results()
+    else:
+        st.markdown("### Select a Mining Site")
+
+        if st.session_state.selected_bbox is not None:
+            mine = st.session_state.selected_mine
+            center = mine.get("center", default_location["center"])
+            zoom = mine.get("zoom", 12)
+
+            st.markdown(f"**Selected:** {mine['name']} ({mine['tenement_id']})")
+            m = create_simple_map(tuple(center), zoom, st.session_state.selected_bbox)
+            st_folium(m, width=None, height=400, returned_objects=[])
+        else:
+            st.info("👆 Select a mining site from the sidebar")
+            m = create_simple_map(tuple(default_location["center"]), default_location["zoom"])
+            st_folium(m, width=None, height=400, returned_objects=[])
+
+            st.markdown("### Available Sites")
+            cols = st.columns(len(examples))
+            for i, ex in enumerate(examples):
+                with cols[i]:
+                    st.markdown(f"**{ex['name']}**")
+                    st.caption(ex['tenement_id'])
+
+    # Footer
+    st.markdown("---")
+    st.caption("MineWatchAI - AI-driven green technology for sustainable mining rehabilitation.")
+
+
+if __name__ == "__main__":
+    main()

assets/style.css

@@ -0,0 +1,328 @@
+/* RehabWatch Custom Styles */
+
+/* Main container styling */
+.main .block-container {
+    padding-top: 2rem;
+    padding-bottom: 2rem;
+    max-width: 1200px;
+}
+
+/* Header styling */
+h1 {
+    color: #2E7D32;
+}
+
+h2, h3 {
+    color: #1B5E20;
+}
+
+/* Sidebar styling */
+.css-1d391kg {
+    background-color: #F5F5F5;
+}
+
+/* Sidebar header - Analysis Hub */
+[data-testid="stSidebar"] > div:first-child {
+    padding-top: 1rem;
+}
+
+[data-testid="stSidebar"] h2 {
+    background: linear-gradient(135deg, #2E7D32, #4CAF50);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    font-weight: 700;
+}
+
+/* Mobile sidebar toggle enhancement */
+[data-testid="collapsedControl"] {
+    background-color: #2E7D32;
+    border-radius: 8px;
+    padding: 8px;
+}
+
+[data-testid="collapsedControl"]:hover {
+    background-color: #1B5E20;
+}
+
+[data-testid="collapsedControl"] svg {
+    color: white;
+}
+
+/* Button styling */
+.stButton > button {
+    border-radius: 8px;
+    font-weight: 600;
+    transition: all 0.3s ease;
+}
+
+.stButton > button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(46, 125, 50, 0.3);
+}
+
+/* Primary button */
+.stButton > button[kind="primary"] {
+    background-color: #2E7D32;
+    border-color: #2E7D32;
+}
+
+.stButton > button[kind="primary"]:hover {
+    background-color: #1B5E20;
+    border-color: #1B5E20;
+}
+
+/* Metric cards */
+[data-testid="metric-container"] {
+    background-color: #FAFAFA;
+    border: 1px solid #E0E0E0;
+    border-radius: 8px;
+    padding: 1rem;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+
+[data-testid="metric-container"]:hover {
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+
+/* Success/Error messages */
+.stSuccess {
+    background-color: #E8F5E9;
+    border-left: 4px solid #4CAF50;
+}
+
+.stError {
+    background-color: #FFEBEE;
+    border-left: 4px solid #F44336;
+}
+
+.stWarning {
+    background-color: #FFF3E0;
+    border-left: 4px solid #FF9800;
+}
+
+.stInfo {
+    background-color: #E3F2FD;
+    border-left: 4px solid #2196F3;
+}
+
+/* Tab styling */
+.stTabs [data-baseweb="tab-list"] {
+    gap: 8px;
+}
+
+.stTabs [data-baseweb="tab"] {
+    background-color: #F5F5F5;
+    border-radius: 8px 8px 0 0;
+    padding: 10px 20px;
+}
+
+.stTabs [aria-selected="true"] {
+    background-color: #2E7D32;
+    color: white;
+}
+
+/* Expander styling */
+.streamlit-expanderHeader {
+    background-color: #F5F5F5;
+    border-radius: 8px;
+}
+
+/* Progress bar */
+.stProgress > div > div > div {
+    background-color: #4CAF50;
+}
+
+/* Map container */
+iframe {
+    border-radius: 8px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+/* Download buttons */
+.stDownloadButton > button {
+    background-color: #1976D2;
+    color: white;
+    border: none;
+}
+
+.stDownloadButton > button:hover {
+    background-color: #1565C0;
+}
+
+/* Date input */
+.stDateInput > div {
+    border-radius: 8px;
+}
+
+/* Select box */
+.stSelectbox > div > div {
+    border-radius: 8px;
+}
+
+/* Text input */
+.stTextInput > div > div {
+    border-radius: 8px;
+}
+
+/* Footer styling */
+footer {
+    visibility: hidden;
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: #F5F5F5;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #BDBDBD;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #9E9E9E;
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .main .block-container {
+        padding-left: 0.5rem;
+        padding-right: 0.5rem;
+    }
+
+    h1 {
+        font-size: 1.6rem;
+    }
+
+    h2 {
+        font-size: 1.3rem;
+    }
+
+    h3 {
+        font-size: 1.1rem;
+    }
+
+    /* Make metrics stack vertically on mobile */
+    [data-testid="metric-container"] {
+        padding: 0.5rem;
+        margin-bottom: 0.5rem;
+    }
+
+    /* Smaller score display on mobile */
+    .score-display span {
+        font-size: 48px !important;
+    }
+
+    /* Make charts more compact */
+    .plotly-graph-div {
+        height: 280px !important;
+    }
+
+    /* Improve tab navigation on mobile */
+    .stTabs [data-baseweb="tab"] {
+        padding: 8px 12px;
+        font-size: 0.85rem;
+    }
+
+    /* Better button sizing on mobile */
+    .stButton > button {
+        padding: 0.6rem 1rem;
+        font-size: 0.9rem;
+    }
+
+    /* Reduce map height on mobile */
+    iframe {
+        max-height: 350px;
+    }
+}
+
+/* Extra small screens */
+@media (max-width: 480px) {
+    .main .block-container {
+        padding-left: 0.3rem;
+        padding-right: 0.3rem;
+    }
+
+    h1 {
+        font-size: 1.4rem;
+    }
+
+    /* Stack columns on very small screens */
+    [data-testid="column"] {
+        width: 100% !important;
+        flex: 100% !important;
+    }
+}
+
+/* Animation for loading */
+@keyframes pulse {
+    0%, 100% {
+        opacity: 1;
+    }
+    50% {
+        opacity: 0.5;
+    }
+}
+
+.loading {
+    animation: pulse 1.5s ease-in-out infinite;
+}
+
+/* Score display styling */
+.score-display {
+    text-align: center;
+    padding: 20px;
+    border-radius: 10px;
+    margin-bottom: 20px;
+}
+
+.score-excellent {
+    background-color: rgba(27, 94, 32, 0.1);
+}
+
+.score-good {
+    background-color: rgba(76, 175, 80, 0.1);
+}
+
+.score-moderate {
+    background-color: rgba(255, 152, 0, 0.1);
+}
+
+.score-low {
+    background-color: rgba(183, 28, 28, 0.1);
+}
+
+/* Chart container */
+.plotly-graph-div {
+    border-radius: 8px;
+}
+
+/* Table styling */
+.dataframe {
+    border-radius: 8px;
+    overflow: hidden;
+}
+
+.dataframe th {
+    background-color: #2E7D32;
+    color: white;
+}
+
+.dataframe tr:nth-child(even) {
+    background-color: #F5F5F5;
+}
+
+/* Tooltip styling */
+[data-testid="stTooltipIcon"] {
+    color: #757575;
+}
+
+[data-testid="stTooltipIcon"]:hover {
+    color: #2E7D32;
+}

data/examples.json

@@ -0,0 +1,70 @@
+{
+  "examples": [
+    {
+      "name": "Boddington Gold Mine",
+      "tenement_id": "M 70/1198",
+      "center": [-32.7500, 116.3700],
+      "zoom": 13,
+      "description": "Large gold/copper mine with active rehabilitation",
+      "geometry": {
+        "type": "rectangle",
+        "coordinates": [116.30, -32.80, 116.45, -32.70]
+      }
+    },
+    {
+      "name": "Kalgoorlie Super Pit",
+      "tenement_id": "M 26/767",
+      "center": [-30.7749, 121.5040],
+      "zoom": 13,
+      "description": "Iconic open-pit gold mine",
+      "geometry": {
+        "type": "rectangle",
+        "coordinates": [121.45, -30.82, 121.55, -30.74]
+      }
+    },
+    {
+      "name": "Greenbushes Lithium",
+      "tenement_id": "M 70/1412",
+      "center": [-33.8500, 116.0600],
+      "zoom": 14,
+      "description": "Major lithium mining operation",
+      "geometry": {
+        "type": "rectangle",
+        "coordinates": [116.02, -33.88, 116.10, -33.82]
+      }
+    },
+    {
+      "name": "Worsley Alumina",
+      "tenement_id": "M 70/199",
+      "center": [-33.2600, 116.0800],
+      "zoom": 13,
+      "description": "Bauxite mining with progressive rehabilitation",
+      "geometry": {
+        "type": "rectangle",
+        "coordinates": [115.98, -33.32, 116.18, -33.20]
+      }
+    },
+    {
+      "name": "Wiluna Gold",
+      "tenement_id": "M 53/1085",
+      "center": [-26.5900, 120.2300],
+      "zoom": 14,
+      "description": "Historical gold mining area",
+      "geometry": {
+        "type": "rectangle",
+        "coordinates": [120.18, -26.65, 120.28, -26.53]
+      }
+    }
+  ],
+  "default_location": {
+    "center": [-28.0, 121.0],
+    "zoom": 6,
+    "description": "Western Australia mining region"
+  },
+  "analysis_parameters": {
+    "cloud_threshold": 20,
+    "window_days": 15,
+    "change_threshold": 0.05,
+    "scale": 10
+  }
+}

requirements.txt

@@ -0,0 +1,33 @@
+# Core Streamlit
+streamlit>=1.28.0,<2.0.0
+
+# Satellite Data Access (Planetary Computer)
+pystac-client>=0.7.0,<1.0.0
+planetary-computer>=1.0.0,<2.0.0
+stackstac>=0.5.0,<1.0.0
+
+# Geospatial Processing
+rioxarray>=0.15.0,<1.0.0
+xarray>=2023.1.0,<2025.0.0
+rasterio>=1.3.0,<2.0.0
+geopandas>=0.14.0,<1.0.0
+shapely>=2.0.0,<3.0.0
+pyproj>=3.6.0,<4.0.0
+
+# Data Processing
+pandas>=2.0.0,<3.0.0
+numpy>=1.24.0,<2.0.0
+dask>=2023.1.0,<2025.0.0
+
+# Visualization
+plotly>=5.18.0,<6.0.0
+folium>=0.15.0,<1.0.0
+streamlit-folium>=0.15.0,<1.0.0
+matplotlib>=3.7.0,<4.0.0
+
+# Reporting
+fpdf2>=2.7.0,<3.0.0
+
+# Utilities
+requests>=2.31.0,<3.0.0
+Pillow>=10.0.0,<11.0.0

src/analysis.py

@@ -0,0 +1,742 @@
+"""
+Comprehensive vegetation and terrain analysis module for RehabWatch.
+
+Performs multi-index analysis including:
+- Vegetation indices (NDVI, SAVI, EVI)
+- Soil/water indices (BSI, NDWI, NDMI, NBR)
+- Terrain analysis (slope, aspect, erosion risk)
+- Land cover classification and change
+- Rehabilitation metrics and scoring
+"""
+
+import numpy as np
+import xarray as xr
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional, Tuple, List
+
+from .stac_utils import (
+    get_sentinel_composite,
+    calculate_ndvi,
+    calculate_savi,
+    calculate_evi,
+    calculate_ndwi,
+    calculate_ndmi,
+    calculate_bsi,
+    calculate_nbr,
+    calculate_all_indices,
+    calculate_vegetation_heterogeneity,
+    get_dem_data,
+    calculate_slope,
+    calculate_aspect,
+    calculate_terrain_ruggedness,
+    calculate_erosion_risk,
+    get_land_cover,
+    get_worldcover,
+    calculate_land_cover_change,
+    calculate_vegetation_cover_percent,
+    calculate_bare_ground_percent,
+    search_sentinel2,
+    create_reference_bbox,
+    get_bbox_center,
+    LULC_CLASSES,
+    WORLDCOVER_CLASSES
+)
+
+
+def analyze_vegetation_change(
+    bbox: Tuple[float, float, float, float],
+    date_before: str,
+    date_after: str,
+    window_days: int = 15,
+    cloud_threshold: int = 25
+) -> Dict[str, Any]:
+    """
+    Analyze vegetation change between two dates using multiple indices.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        date_before: Start date (YYYY-MM-DD)
+        date_after: End date (YYYY-MM-DD)
+        window_days: Days before/after each date for composite (default 15)
+        cloud_threshold: Maximum cloud cover percentage
+
+    Returns:
+        Dict containing composites, indices, and statistics
+    """
+    # Parse dates and create windows
+    before_dt = datetime.strptime(date_before, '%Y-%m-%d')
+    after_dt = datetime.strptime(date_after, '%Y-%m-%d')
+
+    before_start = (before_dt - timedelta(days=window_days)).strftime('%Y-%m-%d')
+    before_end = (before_dt + timedelta(days=window_days)).strftime('%Y-%m-%d')
+    after_start = (after_dt - timedelta(days=window_days)).strftime('%Y-%m-%d')
+    after_end = (after_dt + timedelta(days=window_days)).strftime('%Y-%m-%d')
+
+    # Get cloud-free composites
+    composite_before = get_sentinel_composite(
+        bbox, before_start, before_end, cloud_threshold
+    )
+    composite_after = get_sentinel_composite(
+        bbox, after_start, after_end, cloud_threshold
+    )
+
+    # Calculate all indices for both periods
+    indices_before = calculate_all_indices(composite_before)
+    indices_after = calculate_all_indices(composite_after)
+
+    # Calculate changes for each index
+    index_changes = {}
+    for key in indices_before:
+        index_changes[key] = indices_after[key] - indices_before[key]
+
+    # Calculate vegetation heterogeneity (proxy for diversity)
+    heterogeneity_before = calculate_vegetation_heterogeneity(indices_before['ndvi'])
+    heterogeneity_after = calculate_vegetation_heterogeneity(indices_after['ndvi'])
+
+    # Calculate comprehensive statistics
+    stats = calculate_statistics(
+        indices_before, indices_after, index_changes, bbox
+    )
+
+    return {
+        'composite_before': composite_before,
+        'composite_after': composite_after,
+        'indices_before': indices_before,
+        'indices_after': indices_after,
+        'index_changes': index_changes,
+        'ndvi_before': indices_before['ndvi'],
+        'ndvi_after': indices_after['ndvi'],
+        'ndvi_change': index_changes['ndvi'],
+        'heterogeneity_before': heterogeneity_before,
+        'heterogeneity_after': heterogeneity_after,
+        'stats': stats,
+        'date_before': date_before,
+        'date_after': date_after,
+        'bbox': bbox
+    }
+
+
+def analyze_terrain(
+    bbox: Tuple[float, float, float, float],
+    bsi: Optional[xr.DataArray] = None
+) -> Dict[str, Any]:
+    """
+    Analyze terrain characteristics including slope, aspect, and erosion risk.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        bsi: Bare Soil Index array (optional, for erosion risk)
+
+    Returns:
+        Dict containing terrain data and statistics
+    """
+    try:
+        # Get DEM data
+        dem = get_dem_data(bbox)
+
+        # Calculate terrain derivatives
+        slope = calculate_slope(dem)
+        aspect = calculate_aspect(dem)
+        ruggedness = calculate_terrain_ruggedness(dem)
+
+        # Calculate erosion risk if BSI provided
+        erosion_risk = None
+        if bsi is not None:
+            # Resample BSI to match DEM resolution if needed
+            erosion_risk = calculate_erosion_risk(slope, bsi)
+
+        # Calculate statistics
+        terrain_stats = {
+            'elevation_min': float(np.nanmin(dem.values)),
+            'elevation_max': float(np.nanmax(dem.values)),
+            'elevation_mean': float(np.nanmean(dem.values)),
+            'slope_mean': float(np.nanmean(slope.values)),
+            'slope_max': float(np.nanmax(slope.values)),
+            'ruggedness_mean': float(np.nanmean(ruggedness.values)),
+        }
+
+        # Slope classification
+        flat_pixels = np.sum(slope.values < 5)
+        gentle_pixels = np.sum((slope.values >= 5) & (slope.values < 15))
+        moderate_pixels = np.sum((slope.values >= 15) & (slope.values < 30))
+        steep_pixels = np.sum(slope.values >= 30)
+        total_pixels = slope.size
+
+        terrain_stats['percent_flat'] = round((flat_pixels / total_pixels) * 100, 1)
+        terrain_stats['percent_gentle'] = round((gentle_pixels / total_pixels) * 100, 1)
+        terrain_stats['percent_moderate'] = round((moderate_pixels / total_pixels) * 100, 1)
+        terrain_stats['percent_steep'] = round((steep_pixels / total_pixels) * 100, 1)
+
+        if erosion_risk is not None:
+            terrain_stats['erosion_risk_mean'] = float(np.nanmean(erosion_risk.values))
+            high_risk = np.sum(erosion_risk.values > 0.6)
+            terrain_stats['percent_high_erosion_risk'] = round((high_risk / total_pixels) * 100, 1)
+
+        return {
+            'dem': dem,
+            'slope': slope,
+            'aspect': aspect,
+            'ruggedness': ruggedness,
+            'erosion_risk': erosion_risk,
+            'stats': terrain_stats
+        }
+
+    except Exception as e:
+        return {
+            'error': str(e),
+            'stats': {}
+        }
+
+
+def analyze_land_cover(
+    bbox: Tuple[float, float, float, float],
+    year_before: int,
+    year_after: int
+) -> Dict[str, Any]:
+    """
+    Analyze land cover and its changes between two years.
+
+    Args:
+        bbox: Bounding box
+        year_before: Earlier year (2017-2023)
+        year_after: Later year (2017-2023)
+
+    Returns:
+        Dict containing land cover data and statistics
+    """
+    try:
+        # Get land cover for both years
+        lulc_before = get_land_cover(bbox, year_before)
+        lulc_after = get_land_cover(bbox, year_after)
+
+        # Calculate change statistics
+        change_stats = calculate_land_cover_change(lulc_before, lulc_after)
+
+        # Calculate vegetation and bare ground percentages
+        veg_cover_before = calculate_vegetation_cover_percent(lulc_before)
+        veg_cover_after = calculate_vegetation_cover_percent(lulc_after)
+        bare_before = calculate_bare_ground_percent(lulc_before)
+        bare_after = calculate_bare_ground_percent(lulc_after)
+
+        land_cover_stats = {
+            'vegetation_cover_before': round(veg_cover_before, 1),
+            'vegetation_cover_after': round(veg_cover_after, 1),
+            'vegetation_cover_change': round(veg_cover_after - veg_cover_before, 1),
+            'bare_ground_before': round(bare_before, 1),
+            'bare_ground_after': round(bare_after, 1),
+            'bare_ground_change': round(bare_after - bare_before, 1),
+            'year_before': year_before,
+            'year_after': year_after,
+            'class_changes': change_stats['changes']
+        }
+
+        return {
+            'lulc_before': lulc_before,
+            'lulc_after': lulc_after,
+            'stats': land_cover_stats,
+            'classes': LULC_CLASSES
+        }
+
+    except Exception as e:
+        return {
+            'error': str(e),
+            'stats': {}
+        }
+
+
+def calculate_statistics(
+    indices_before: Dict[str, xr.DataArray],
+    indices_after: Dict[str, xr.DataArray],
+    index_changes: Dict[str, xr.DataArray],
+    bbox: Tuple[float, float, float, float]
+) -> Dict[str, float]:
+    """
+    Calculate comprehensive vegetation and soil statistics.
+
+    Args:
+        indices_before: Dict of index arrays at start date
+        indices_after: Dict of index arrays at end date
+        index_changes: Dict of index change arrays
+        bbox: Bounding box for area calculation
+
+    Returns:
+        Dict with comprehensive statistics
+    """
+    stats = {}
+
+    # Get NDVI arrays
+    ndvi_before = indices_before['ndvi']
+    ndvi_after = indices_after['ndvi']
+    ndvi_change = index_changes['ndvi']
+
+    # Get valid (non-NaN) data
+    valid_before = ndvi_before.values[~np.isnan(ndvi_before.values)]
+    valid_after = ndvi_after.values[~np.isnan(ndvi_after.values)]
+    valid_change = ndvi_change.values[~np.isnan(ndvi_change.values)]
+
+    # NDVI statistics
+    stats['ndvi_before_mean'] = round(float(np.nanmean(valid_before)), 4) if len(valid_before) > 0 else 0
+    stats['ndvi_after_mean'] = round(float(np.nanmean(valid_after)), 4) if len(valid_after) > 0 else 0
+    stats['ndvi_change_mean'] = round(float(np.nanmean(valid_change)), 4) if len(valid_change) > 0 else 0
+    stats['ndvi_change_std'] = round(float(np.nanstd(valid_change)), 4) if len(valid_change) > 0 else 0
+
+    # Calculate percent change
+    if stats['ndvi_before_mean'] > 0:
+        stats['percent_change'] = round(((stats['ndvi_after_mean'] - stats['ndvi_before_mean']) /
+                                          stats['ndvi_before_mean']) * 100, 2)
+    else:
+        stats['percent_change'] = 0
+
+    # All other indices - before/after means
+    for idx_name in ['savi', 'evi', 'ndwi', 'ndmi', 'bsi', 'nbr']:
+        if idx_name in indices_before and idx_name in indices_after:
+            before_vals = indices_before[idx_name].values
+            after_vals = indices_after[idx_name].values
+
+            valid_b = before_vals[~np.isnan(before_vals)]
+            valid_a = after_vals[~np.isnan(after_vals)]
+
+            stats[f'{idx_name}_before_mean'] = round(float(np.nanmean(valid_b)), 4) if len(valid_b) > 0 else 0
+            stats[f'{idx_name}_after_mean'] = round(float(np.nanmean(valid_a)), 4) if len(valid_a) > 0 else 0
+            stats[f'{idx_name}_change'] = round(stats[f'{idx_name}_after_mean'] - stats[f'{idx_name}_before_mean'], 4)
+
+    # Area calculations (improved, degraded, stable)
+    pixel_area_ha = (10 * 10) / 10000  # 0.01 ha per pixel
+
+    total_pixels = len(valid_change)
+    improved_pixels = np.sum(valid_change > 0.05)
+    degraded_pixels = np.sum(valid_change < -0.05)
+    stable_pixels = np.sum((valid_change >= -0.05) & (valid_change <= 0.05))
+
+    stats['area_improved_ha'] = round(float(improved_pixels * pixel_area_ha), 2)
+    stats['area_degraded_ha'] = round(float(degraded_pixels * pixel_area_ha), 2)
+    stats['area_stable_ha'] = round(float(stable_pixels * pixel_area_ha), 2)
+    stats['total_area_ha'] = round(float(total_pixels * pixel_area_ha), 2)
+
+    # Calculate percentages
+    if total_pixels > 0:
+        stats['percent_improved'] = round((improved_pixels / total_pixels) * 100, 2)
+        stats['percent_degraded'] = round((degraded_pixels / total_pixels) * 100, 2)
+        stats['percent_stable'] = round((stable_pixels / total_pixels) * 100, 2)
+    else:
+        stats['percent_improved'] = 0
+        stats['percent_degraded'] = 0
+        stats['percent_stable'] = 0
+
+    # Water presence (from NDWI)
+    if 'ndwi' in indices_after:
+        ndwi_vals = indices_after['ndwi'].values
+        valid_ndwi = ndwi_vals[~np.isnan(ndwi_vals)]
+        water_pixels = np.sum(valid_ndwi > 0)
+        stats['percent_water'] = round((water_pixels / len(valid_ndwi)) * 100, 2) if len(valid_ndwi) > 0 else 0
+
+    # Bare soil extent (from BSI)
+    if 'bsi' in indices_after:
+        bsi_vals = indices_after['bsi'].values
+        valid_bsi = bsi_vals[~np.isnan(bsi_vals)]
+        bare_pixels = np.sum(valid_bsi > 0.1)
+        stats['percent_bare_soil'] = round((bare_pixels / len(valid_bsi)) * 100, 2) if len(valid_bsi) > 0 else 0
+
+    # Moisture stress (from NDMI)
+    if 'ndmi' in indices_after:
+        ndmi_vals = indices_after['ndmi'].values
+        valid_ndmi = ndmi_vals[~np.isnan(ndmi_vals)]
+        stressed_pixels = np.sum(valid_ndmi < 0)
+        stats['percent_moisture_stressed'] = round((stressed_pixels / len(valid_ndmi)) * 100, 2) if len(valid_ndmi) > 0 else 0
+
+    # Vegetation health classification
+    if len(valid_after) > 0:
+        sparse = np.sum((valid_after > 0) & (valid_after <= 0.2))
+        low = np.sum((valid_after > 0.2) & (valid_after <= 0.4))
+        moderate = np.sum((valid_after > 0.4) & (valid_after <= 0.6))
+        dense = np.sum(valid_after > 0.6)
+
+        stats['percent_sparse_veg'] = round((sparse / len(valid_after)) * 100, 2)
+        stats['percent_low_veg'] = round((low / len(valid_after)) * 100, 2)
+        stats['percent_moderate_veg'] = round((moderate / len(valid_after)) * 100, 2)
+        stats['percent_dense_veg'] = round((dense / len(valid_after)) * 100, 2)
+
+    return stats
+
+
+def calculate_reference_ndvi(
+    bbox: Tuple[float, float, float, float],
+    date: str,
+    window_days: int = 15,
+    cloud_threshold: int = 25,
+    buffer_deg: float = 0.01
+) -> float:
+    """
+    Calculate mean NDVI for reference area (buffer around site).
+    """
+    dt = datetime.strptime(date, '%Y-%m-%d')
+    start = (dt - timedelta(days=window_days)).strftime('%Y-%m-%d')
+    end = (dt + timedelta(days=window_days)).strftime('%Y-%m-%d')
+
+    ref_bbox = create_reference_bbox(bbox, buffer_deg)
+
+    try:
+        composite = get_sentinel_composite(ref_bbox, start, end, cloud_threshold)
+        ndvi = calculate_ndvi(composite)
+
+        valid_ndvi = ndvi.values[~np.isnan(ndvi.values)]
+        return float(np.nanmean(valid_ndvi)) if len(valid_ndvi) > 0 else 0
+
+    except Exception:
+        return 0
+
+
+def calculate_rehab_score(site_ndvi: float, reference_ndvi: float) -> int:
+    """
+    Calculate rehabilitation score (0-100).
+
+    The score represents how close the site's vegetation is to
+    the reference (undisturbed) area.
+    """
+    if reference_ndvi <= 0:
+        return 0
+
+    score = (site_ndvi / reference_ndvi) * 100
+    return min(100, max(0, round(score)))
+
+
+def calculate_comprehensive_rehab_score(
+    stats: Dict[str, float],
+    terrain_stats: Optional[Dict[str, float]] = None,
+    land_cover_stats: Optional[Dict[str, float]] = None,
+    reference_ndvi: float = 0.5
+) -> Dict[str, Any]:
+    """
+    Calculate comprehensive rehabilitation score using multiple metrics.
+
+    Returns:
+        Dict with component scores and overall score
+    """
+    scores = {}
+
+    # Vegetation score (based on NDVI)
+    site_ndvi = stats.get('ndvi_after_mean', 0)
+    scores['vegetation_score'] = min(100, max(0, round((site_ndvi / reference_ndvi) * 100)))
+
+    # Improvement score (based on change)
+    improvement = stats.get('percent_improved', 0)
+    degradation = stats.get('percent_degraded', 0)
+    scores['improvement_score'] = min(100, max(0, round(50 + improvement - degradation)))
+
+    # Soil stability score (based on BSI - lower is better)
+    bare_soil = stats.get('percent_bare_soil', 50)
+    scores['soil_stability_score'] = min(100, max(0, round(100 - bare_soil)))
+
+    # Moisture score (based on NDMI)
+    moisture_stressed = stats.get('percent_moisture_stressed', 50)
+    scores['moisture_score'] = min(100, max(0, round(100 - moisture_stressed)))
+
+    # Terrain score (if available)
+    if terrain_stats:
+        erosion_risk = terrain_stats.get('percent_high_erosion_risk', 50)
+        scores['terrain_score'] = min(100, max(0, round(100 - erosion_risk)))
+
+    # Land cover score (if available)
+    if land_cover_stats:
+        veg_cover = land_cover_stats.get('vegetation_cover_after', 0)
+        scores['land_cover_score'] = min(100, max(0, round(veg_cover)))
+
+    # Calculate weighted overall score
+    weights = {
+        'vegetation_score': 0.30,
+        'improvement_score': 0.25,
+        'soil_stability_score': 0.20,
+        'moisture_score': 0.10,
+        'terrain_score': 0.10,
+        'land_cover_score': 0.05
+    }
+
+    total_weight = 0
+    weighted_sum = 0
+    for key, weight in weights.items():
+        if key in scores:
+            weighted_sum += scores[key] * weight
+            total_weight += weight
+
+    scores['overall_score'] = round(weighted_sum / total_weight) if total_weight > 0 else 0
+
+    return scores
+
+
+def generate_interpretation(
+    stats: Dict[str, float],
+    rehab_score: int,
+    terrain_stats: Optional[Dict] = None,
+    land_cover_stats: Optional[Dict] = None
+) -> str:
+    """
+    Generate comprehensive plain-language interpretation of the analysis results.
+    """
+    interpretation_parts = []
+
+    # Vegetation change interpretation
+    change = stats.get('percent_change', 0)
+    if change > 10:
+        change_text = f"Vegetation cover has significantly improved by {change:.1f}%"
+    elif change > 0:
+        change_text = f"Vegetation cover has moderately improved by {change:.1f}%"
+    elif change > -10:
+        change_text = f"Vegetation cover has slightly declined by {abs(change):.1f}%"
+    else:
+        change_text = f"Vegetation cover has significantly declined by {abs(change):.1f}%"
+
+    interpretation_parts.append(change_text + " over the analysis period.")
+
+    # Area breakdown
+    if stats.get('percent_improved', 0) > stats.get('percent_degraded', 0):
+        area_text = (f"Approximately {stats['percent_improved']:.0f}% of the site "
+                     f"({stats['area_improved_ha']:.1f} ha) shows vegetation improvement, "
+                     f"while {stats['percent_degraded']:.0f}% ({stats['area_degraded_ha']:.1f} ha) "
+                     "shows decline.")
+    else:
+        area_text = (f"Approximately {stats['percent_degraded']:.0f}% of the site "
+                     f"({stats['area_degraded_ha']:.1f} ha) shows vegetation decline, "
+                     f"while {stats['percent_improved']:.0f}% ({stats['area_improved_ha']:.1f} ha) "
+                     "shows improvement.")
+
+    interpretation_parts.append(area_text)
+
+    # Soil and moisture conditions
+    bare_soil = stats.get('percent_bare_soil', 0)
+    moisture_stress = stats.get('percent_moisture_stressed', 0)
+
+    if bare_soil > 30:
+        interpretation_parts.append(f"Bare soil covers {bare_soil:.0f}% of the area, indicating potential erosion risk.")
+    elif bare_soil > 10:
+        interpretation_parts.append(f"Moderate bare soil exposure ({bare_soil:.0f}%) is present.")
+
+    if moisture_stress > 50:
+        interpretation_parts.append(f"Significant moisture stress detected in {moisture_stress:.0f}% of vegetation.")
+
+    # Water presence
+    water = stats.get('percent_water', 0)
+    if water > 5:
+        interpretation_parts.append(f"Water bodies or saturated areas cover {water:.0f}% of the site.")
+
+    # Terrain interpretation
+    if terrain_stats:
+        steep = terrain_stats.get('percent_steep', 0)
+        erosion = terrain_stats.get('percent_high_erosion_risk', 0)
+
+        if steep > 20:
+            interpretation_parts.append(f"The terrain includes {steep:.0f}% steep slopes (>30 degrees).")
+
+        if erosion > 30:
+            interpretation_parts.append(f"High erosion risk identified in {erosion:.0f}% of the area.")
+
+    # Land cover interpretation
+    if land_cover_stats:
+        veg_change = land_cover_stats.get('vegetation_cover_change', 0)
+        bare_change = land_cover_stats.get('bare_ground_change', 0)
+
+        if veg_change > 5:
+            interpretation_parts.append(f"Land cover analysis shows {veg_change:.0f}% increase in vegetated area.")
+        elif veg_change < -5:
+            interpretation_parts.append(f"Land cover analysis shows {abs(veg_change):.0f}% decrease in vegetated area.")
+
+        if bare_change < -5:
+            interpretation_parts.append(f"Bare ground has decreased by {abs(bare_change):.0f}%.")
+
+    # Rehabilitation score interpretation
+    if rehab_score >= 80:
+        rehab_text = (f"The site has achieved {rehab_score}% of reference vegetation conditions, "
+                      "indicating excellent rehabilitation progress.")
+    elif rehab_score >= 60:
+        rehab_text = (f"The site has achieved {rehab_score}% of reference vegetation conditions, "
+                      "indicating good rehabilitation progress.")
+    elif rehab_score >= 40:
+        rehab_text = (f"The site has achieved {rehab_score}% of reference vegetation conditions, "
+                      "indicating moderate rehabilitation progress.")
+    elif rehab_score >= 20:
+        rehab_text = (f"The site has achieved {rehab_score}% of reference vegetation conditions, "
+                      "indicating early-stage rehabilitation.")
+    else:
+        rehab_text = (f"The site has achieved {rehab_score}% of reference vegetation conditions, "
+                      "indicating limited rehabilitation progress to date.")
+
+    interpretation_parts.append(rehab_text)
+
+    return " ".join(interpretation_parts)
+
+
+def get_monthly_ndvi_timeseries(
+    bbox: Tuple[float, float, float, float],
+    start_year: int,
+    end_year: int,
+    cloud_threshold: int = 30
+) -> List[Dict[str, Any]]:
+    """
+    Get monthly NDVI time series for a bounding box.
+    """
+    results = []
+
+    for year in range(start_year, end_year + 1):
+        for month in range(1, 13):
+            now = datetime.now()
+            if year > now.year or (year == now.year and month > now.month):
+                continue
+
+            start_date = f"{year}-{month:02d}-01"
+
+            if month == 12:
+                end_date = f"{year}-12-31"
+            else:
+                next_month = datetime(year, month + 1, 1)
+                end_of_month = next_month - timedelta(days=1)
+                end_date = end_of_month.strftime('%Y-%m-%d')
+
+            try:
+                items = search_sentinel2(bbox, start_date, end_date, cloud_threshold)
+
+                if len(items) > 0:
+                    composite = get_sentinel_composite(
+                        bbox, start_date, end_date, cloud_threshold
+                    )
+                    ndvi = calculate_ndvi(composite)
+                    valid_ndvi = ndvi.values[~np.isnan(ndvi.values)]
+
+                    if len(valid_ndvi) > 0:
+                        mean_ndvi = float(np.nanmean(valid_ndvi))
+                        results.append({
+                            'date': f"{year}-{month:02d}-15",
+                            'ndvi': mean_ndvi
+                        })
+
+            except Exception:
+                continue
+
+    return sorted(results, key=lambda x: x['date'])
+
+
+def get_multi_index_timeseries(
+    bbox: Tuple[float, float, float, float],
+    start_year: int,
+    end_year: int,
+    cloud_threshold: int = 30
+) -> List[Dict[str, Any]]:
+    """
+    Get monthly time series for multiple indices.
+    """
+    results = []
+
+    for year in range(start_year, end_year + 1):
+        for month in range(1, 13):
+            now = datetime.now()
+            if year > now.year or (year == now.year and month > now.month):
+                continue
+
+            start_date = f"{year}-{month:02d}-01"
+
+            if month == 12:
+                end_date = f"{year}-12-31"
+            else:
+                next_month = datetime(year, month + 1, 1)
+                end_of_month = next_month - timedelta(days=1)
+                end_date = end_of_month.strftime('%Y-%m-%d')
+
+            try:
+                items = search_sentinel2(bbox, start_date, end_date, cloud_threshold)
+
+                if len(items) > 0:
+                    composite = get_sentinel_composite(
+                        bbox, start_date, end_date, cloud_threshold
+                    )
+
+                    indices = calculate_all_indices(composite)
+
+                    record = {'date': f"{year}-{month:02d}-15"}
+
+                    for idx_name, idx_data in indices.items():
+                        valid_vals = idx_data.values[~np.isnan(idx_data.values)]
+                        if len(valid_vals) > 0:
+                            record[idx_name] = float(np.nanmean(valid_vals))
+
+                    if len(record) > 1:
+                        results.append(record)
+
+            except Exception:
+                continue
+
+    return sorted(results, key=lambda x: x['date'])
+
+
+def calculate_seasonal_stability(timeseries: List[Dict[str, Any]]) -> Dict[str, float]:
+    """
+    Calculate seasonal stability metrics from time series data.
+    Lower variance indicates more stable ecosystem function.
+    """
+    if len(timeseries) < 4:
+        return {}
+
+    ndvi_values = [r.get('ndvi', 0) for r in timeseries if 'ndvi' in r]
+
+    if len(ndvi_values) < 4:
+        return {}
+
+    return {
+        'ndvi_mean': round(float(np.mean(ndvi_values)), 4),
+        'ndvi_std': round(float(np.std(ndvi_values)), 4),
+        'ndvi_cv': round(float(np.std(ndvi_values) / np.mean(ndvi_values)) * 100, 2),
+        'ndvi_min': round(float(np.min(ndvi_values)), 4),
+        'ndvi_max': round(float(np.max(ndvi_values)), 4),
+        'ndvi_range': round(float(np.max(ndvi_values) - np.min(ndvi_values)), 4)
+    }
+
+
+def ndvi_to_image_array(ndvi: xr.DataArray) -> np.ndarray:
+    """Convert NDVI xarray to a colored numpy array for visualization."""
+    import matplotlib.pyplot as plt
+    from matplotlib.colors import LinearSegmentedColormap
+
+    colors = ['#8B4513', '#D2B48C', '#FFFF00', '#90EE90', '#228B22', '#006400']
+    cmap = LinearSegmentedColormap.from_list('ndvi', colors)
+
+    ndvi_normalized = (ndvi.values - (-0.1)) / (0.8 - (-0.1))
+    ndvi_normalized = np.clip(ndvi_normalized, 0, 1)
+
+    rgba = cmap(ndvi_normalized)
+    rgb = (rgba[:, :, :3] * 255).astype(np.uint8)
+
+    return rgb
+
+
+def change_to_image_array(change: xr.DataArray) -> np.ndarray:
+    """Convert NDVI change xarray to a colored numpy array for visualization."""
+    import matplotlib.pyplot as plt
+    from matplotlib.colors import LinearSegmentedColormap
+
+    colors = ['#B71C1C', '#EF9A9A', '#FFFFFF', '#A5D6A7', '#1B5E20']
+    cmap = LinearSegmentedColormap.from_list('change', colors)
+
+    change_normalized = (change.values - (-0.3)) / (0.3 - (-0.3))
+    change_normalized = np.clip(change_normalized, 0, 1)
+
+    rgba = cmap(change_normalized)
+    rgb = (rgba[:, :, :3] * 255).astype(np.uint8)
+
+    return rgb
+
+
+def index_to_image_array(
+    data: xr.DataArray,
+    colormap: str = 'viridis',
+    vmin: float = -1,
+    vmax: float = 1
+) -> np.ndarray:
+    """Convert any index xarray to a colored numpy array."""
+    import matplotlib.pyplot as plt
+
+    cmap = plt.get_cmap(colormap)
+
+    data_normalized = (data.values - vmin) / (vmax - vmin)
+    data_normalized = np.clip(data_normalized, 0, 1)
+
+    rgba = cmap(data_normalized)
+    rgb = (rgba[:, :, :3] * 255).astype(np.uint8)
+
+    return rgb

src/report.py

@@ -0,0 +1,357 @@
+"""
+Report generation module for RehabWatch.
+Creates PDF reports and CSV exports.
+"""
+
+from fpdf import FPDF
+from datetime import datetime
+from typing import Dict, Any, Optional
+import io
+
+
+class RehabWatchPDF(FPDF):
+    """Custom PDF class for RehabWatch reports."""
+
+    def header(self):
+        """Add header to each page."""
+        self.set_font('Helvetica', 'B', 16)
+        self.set_text_color(46, 125, 50)  # Green
+        self.cell(0, 10, 'RehabWatch', 0, 0, 'L')
+        self.set_font('Helvetica', '', 10)
+        self.set_text_color(100, 100, 100)
+        self.cell(0, 10, 'Mining Rehabilitation Assessment', 0, 1, 'R')
+        self.line(10, 25, 200, 25)
+        self.ln(10)
+
+    def footer(self):
+        """Add footer to each page."""
+        self.set_y(-15)
+        self.set_font('Helvetica', 'I', 8)
+        self.set_text_color(128, 128, 128)
+        self.cell(0, 10, f'Page {self.page_no()}/{{nb}}', 0, 0, 'C')
+
+    def chapter_title(self, title: str):
+        """Add a section title."""
+        self.set_font('Helvetica', 'B', 14)
+        self.set_text_color(33, 33, 33)
+        self.cell(0, 10, title, 0, 1, 'L')
+        self.ln(2)
+
+    def chapter_body(self, body: str):
+        """Add body text."""
+        self.set_font('Helvetica', '', 11)
+        self.set_text_color(66, 66, 66)
+        self.multi_cell(0, 6, body)
+        self.ln(4)
+
+
+def generate_pdf_report(
+    tenement_id: str,
+    stats: Dict[str, float],
+    rehab_score: int,
+    interpretation: str,
+    date_before: str,
+    date_after: str,
+    mine_name: Optional[str] = None
+) -> bytes:
+    """
+    Generate a PDF report of the rehabilitation assessment.
+
+    Args:
+        tenement_id: Mining tenement identifier
+        stats: Statistics dictionary from analysis
+        rehab_score: Rehabilitation score (0-100)
+        interpretation: Plain-language interpretation
+        date_before: Analysis start date
+        date_after: Analysis end date
+        mine_name: Optional name of the mine
+
+    Returns:
+        PDF as bytes for download
+    """
+    pdf = RehabWatchPDF()
+    pdf.alias_nb_pages()
+    pdf.add_page()
+
+    # Title
+    pdf.set_font('Helvetica', 'B', 24)
+    pdf.set_text_color(33, 33, 33)
+    pdf.cell(0, 15, 'Rehabilitation Assessment Report', 0, 1, 'C')
+    pdf.ln(5)
+
+    # Site Information
+    pdf.set_font('Helvetica', '', 12)
+    pdf.set_text_color(66, 66, 66)
+
+    if mine_name:
+        pdf.cell(0, 8, f'Site: {mine_name}', 0, 1, 'C')
+    pdf.cell(0, 8, f'Tenement ID: {tenement_id}', 0, 1, 'C')
+    pdf.cell(0, 8, f'Analysis Period: {date_before} to {date_after}', 0, 1, 'C')
+    pdf.cell(0, 8, f'Report Generated: {datetime.now().strftime("%Y-%m-%d %H:%M")}', 0, 1, 'C')
+    pdf.ln(10)
+
+    # Rehabilitation Score Box
+    pdf.set_fill_color(240, 240, 240)
+    pdf.rect(60, pdf.get_y(), 90, 35, 'F')
+
+    pdf.set_font('Helvetica', 'B', 12)
+    pdf.set_text_color(66, 66, 66)
+    pdf.cell(0, 8, 'Rehabilitation Score', 0, 1, 'C')
+
+    # Score color based on value
+    if rehab_score >= 60:
+        pdf.set_text_color(46, 125, 50)  # Green
+    elif rehab_score >= 40:
+        pdf.set_text_color(255, 152, 0)  # Orange
+    else:
+        pdf.set_text_color(183, 28, 28)  # Red
+
+    pdf.set_font('Helvetica', 'B', 36)
+    pdf.cell(0, 15, f'{rehab_score}/100', 0, 1, 'C')
+    pdf.ln(15)
+
+    # Interpretation
+    pdf.chapter_title('Summary')
+    pdf.chapter_body(interpretation)
+
+    # Statistics Table
+    pdf.chapter_title('Detailed Statistics')
+
+    # Table header
+    pdf.set_font('Helvetica', 'B', 10)
+    pdf.set_fill_color(46, 125, 50)
+    pdf.set_text_color(255, 255, 255)
+    pdf.cell(90, 8, 'Metric', 1, 0, 'C', True)
+    pdf.cell(50, 8, 'Value', 1, 0, 'C', True)
+    pdf.cell(50, 8, 'Unit', 1, 1, 'C', True)
+
+    # Table data
+    pdf.set_font('Helvetica', '', 10)
+    pdf.set_text_color(66, 66, 66)
+
+    table_data = [
+        ('NDVI Before (mean)', f"{stats['ndvi_before_mean']:.4f}", 'index'),
+        ('NDVI After (mean)', f"{stats['ndvi_after_mean']:.4f}", 'index'),
+        ('NDVI Change (mean)', f"{stats['ndvi_change_mean']:.4f}", 'index'),
+        ('Relative Change', f"{stats['percent_change']:.2f}", '%'),
+        ('SAVI (mean)', f"{stats.get('savi_after_mean', 0):.4f}", 'index'),
+        ('EVI (mean)', f"{stats.get('evi_after_mean', 0):.4f}", 'index'),
+        ('NDMI (moisture)', f"{stats.get('ndmi_after_mean', 0):.4f}", 'index'),
+        ('BSI (bare soil)', f"{stats.get('bsi_after_mean', 0):.4f}", 'index'),
+        ('Water Presence', f"{stats.get('percent_water', 0):.2f}", '%'),
+        ('Bare Soil Extent', f"{stats.get('percent_bare_soil', 0):.2f}", '%'),
+        ('Moisture Stressed', f"{stats.get('percent_moisture_stressed', 0):.2f}", '%'),
+        ('Area Improved', f"{stats['area_improved_ha']:.2f}", 'hectares'),
+        ('Area Stable', f"{stats['area_stable_ha']:.2f}", 'hectares'),
+        ('Area Degraded', f"{stats['area_degraded_ha']:.2f}", 'hectares'),
+        ('Total Area', f"{stats['total_area_ha']:.2f}", 'hectares'),
+        ('Percentage Improved', f"{stats['percent_improved']:.2f}", '%'),
+        ('Percentage Degraded', f"{stats['percent_degraded']:.2f}", '%'),
+    ]
+
+    fill = False
+    for row in table_data:
+        if fill:
+            pdf.set_fill_color(245, 245, 245)
+        else:
+            pdf.set_fill_color(255, 255, 255)
+        pdf.cell(90, 7, row[0], 1, 0, 'L', fill)
+        pdf.cell(50, 7, row[1], 1, 0, 'C', fill)
+        pdf.cell(50, 7, row[2], 1, 1, 'C', fill)
+        fill = not fill
+
+    pdf.ln(10)
+
+    # Methodology
+    pdf.chapter_title('Methodology')
+    methodology_text = """This assessment uses multiple vegetation and soil indices derived from Sentinel-2 satellite imagery, Copernicus DEM, and IO-LULC land cover data.
+
+Vegetation Indices:
+- NDVI (Normalized Difference Vegetation Index): Overall vegetation health
+- SAVI (Soil Adjusted Vegetation Index): Better for sparse vegetation
+- EVI (Enhanced Vegetation Index): Better for dense vegetation
+
+Soil & Water Indices:
+- BSI (Bare Soil Index): Identifies exposed soil areas
+- NDWI (Normalized Difference Water Index): Water body detection
+- NDMI (Normalized Difference Moisture Index): Vegetation moisture content
+
+Terrain Analysis:
+- Slope and aspect from Copernicus DEM GLO-30 (30m resolution)
+- Erosion risk combining slope steepness and bare soil exposure
+
+Land Cover:
+- IO-LULC annual land cover classification (2017-2023)
+
+The Rehabilitation Score combines vegetation health, improvement trends, soil stability, and moisture status compared to reference conditions."""
+
+    pdf.chapter_body(methodology_text)
+
+    # Data Sources and Disclaimers
+    pdf.add_page()
+    pdf.chapter_title('Data Sources')
+    sources_text = """- Satellite Imagery: Copernicus Sentinel-2 L2A (Surface Reflectance)
+- Spatial Resolution: 10 meters
+- Temporal Resolution: ~5 days revisit
+- Cloud Masking: Applied using Scene Classification Layer (SCL)
+- Compositing Method: Median composite over 30-day windows
+- Digital Elevation: Copernicus DEM GLO-30 (30m resolution)
+- Land Cover: IO-LULC Annual v02 (10m resolution, 2017-2023)
+- Data Access: Microsoft Planetary Computer (free, open access)"""
+
+    pdf.chapter_body(sources_text)
+
+    pdf.chapter_title('Disclaimer')
+    disclaimer_text = """This report is generated automatically using satellite remote sensing data and should be used for preliminary assessment purposes only. Results may be affected by:
+
+- Cloud cover and atmospheric conditions
+- Seasonal vegetation variations
+- Sensor calibration differences
+- Topographic effects
+
+For regulatory compliance or detailed rehabilitation assessment, ground-based verification is recommended. This analysis does not constitute professional advice and should be interpreted by qualified personnel.
+
+RehabWatch is a demonstration tool and the developers assume no liability for decisions made based on this analysis."""
+
+    pdf.chapter_body(disclaimer_text)
+
+    # Output PDF bytes
+    return bytes(pdf.output())
+
+
+def stats_to_csv(
+    stats: Dict[str, float],
+    tenement_id: str,
+    rehab_score: int,
+    date_before: str,
+    date_after: str,
+    mine_name: Optional[str] = None
+) -> str:
+    """
+    Convert statistics to CSV format.
+
+    Args:
+        stats: Statistics dictionary
+        tenement_id: Mining tenement identifier
+        rehab_score: Rehabilitation score
+        date_before: Analysis start date
+        date_after: Analysis end date
+        mine_name: Optional mine name
+
+    Returns:
+        CSV string for download
+    """
+    lines = []
+
+    # Header
+    lines.append("RehabWatch Rehabilitation Assessment Export")
+    lines.append(f"Generated,{datetime.now().strftime('%Y-%m-%d %H:%M')}")
+    if mine_name:
+        lines.append(f"Site Name,{mine_name}")
+    lines.append(f"Tenement ID,{tenement_id}")
+    lines.append(f"Analysis Start Date,{date_before}")
+    lines.append(f"Analysis End Date,{date_after}")
+    lines.append("")
+
+    # Statistics
+    lines.append("Metric,Value,Unit")
+    lines.append(f"Rehabilitation Score,{rehab_score},/100")
+    lines.append(f"NDVI Before (mean),{stats['ndvi_before_mean']:.4f},index")
+    lines.append(f"NDVI After (mean),{stats['ndvi_after_mean']:.4f},index")
+    lines.append(f"NDVI Change (mean),{stats['ndvi_change_mean']:.4f},index")
+    lines.append(f"NDVI Change (std dev),{stats['ndvi_change_std']:.4f},index")
+    lines.append(f"Relative Change,{stats['percent_change']:.2f},%")
+    lines.append(f"SAVI Before,{stats.get('savi_before_mean', 0):.4f},index")
+    lines.append(f"SAVI After,{stats.get('savi_after_mean', 0):.4f},index")
+    lines.append(f"EVI Before,{stats.get('evi_before_mean', 0):.4f},index")
+    lines.append(f"EVI After,{stats.get('evi_after_mean', 0):.4f},index")
+    lines.append(f"NDWI After,{stats.get('ndwi_after_mean', 0):.4f},index")
+    lines.append(f"NDMI After,{stats.get('ndmi_after_mean', 0):.4f},index")
+    lines.append(f"BSI After,{stats.get('bsi_after_mean', 0):.4f},index")
+    lines.append(f"Water Presence,{stats.get('percent_water', 0):.2f},%")
+    lines.append(f"Bare Soil Extent,{stats.get('percent_bare_soil', 0):.2f},%")
+    lines.append(f"Moisture Stressed,{stats.get('percent_moisture_stressed', 0):.2f},%")
+    lines.append(f"Sparse Vegetation,{stats.get('percent_sparse_veg', 0):.2f},%")
+    lines.append(f"Low Vegetation,{stats.get('percent_low_veg', 0):.2f},%")
+    lines.append(f"Moderate Vegetation,{stats.get('percent_moderate_veg', 0):.2f},%")
+    lines.append(f"Dense Vegetation,{stats.get('percent_dense_veg', 0):.2f},%")
+    lines.append(f"Area Improved,{stats['area_improved_ha']:.2f},hectares")
+    lines.append(f"Area Stable,{stats['area_stable_ha']:.2f},hectares")
+    lines.append(f"Area Degraded,{stats['area_degraded_ha']:.2f},hectares")
+    lines.append(f"Total Area,{stats['total_area_ha']:.2f},hectares")
+    lines.append(f"Percentage Improved,{stats['percent_improved']:.2f},%")
+    lines.append(f"Percentage Stable,{stats['percent_stable']:.2f},%")
+    lines.append(f"Percentage Degraded,{stats['percent_degraded']:.2f},%")
+
+    return "\n".join(lines)
+
+
+def generate_summary_text(
+    tenement_id: str,
+    stats: Dict[str, float],
+    rehab_score: int,
+    interpretation: str,
+    date_before: str,
+    date_after: str
+) -> str:
+    """
+    Generate a plain text summary of the assessment.
+
+    Args:
+        tenement_id: Mining tenement identifier
+        stats: Statistics dictionary
+        rehab_score: Rehabilitation score
+        interpretation: Interpretation text
+        date_before: Analysis start date
+        date_after: Analysis end date
+
+    Returns:
+        Formatted text summary
+    """
+    summary = f"""
+================================================================================
+                    REHABWATCH REHABILITATION ASSESSMENT
+================================================================================
+
+Tenement: {tenement_id}
+Analysis Period: {date_before} to {date_after}
+Report Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}
+
+--------------------------------------------------------------------------------
+                           REHABILITATION SCORE
+--------------------------------------------------------------------------------
+
+                              {rehab_score} / 100
+
+--------------------------------------------------------------------------------
+                              KEY FINDINGS
+--------------------------------------------------------------------------------
+
+{interpretation}
+
+--------------------------------------------------------------------------------
+                           DETAILED STATISTICS
+--------------------------------------------------------------------------------
+
+Vegetation Index (NDVI):
+  - Before:  {stats['ndvi_before_mean']:.4f}
+  - After:   {stats['ndvi_after_mean']:.4f}
+  - Change:  {stats['ndvi_change_mean']:.4f} ({stats['percent_change']:.2f}%)
+
+Area Analysis:
+  - Total Area:      {stats['total_area_ha']:.2f} ha
+  - Area Improved:   {stats['area_improved_ha']:.2f} ha ({stats['percent_improved']:.2f}%)
+  - Area Stable:     {stats['area_stable_ha']:.2f} ha ({stats['percent_stable']:.2f}%)
+  - Area Degraded:   {stats['area_degraded_ha']:.2f} ha ({stats['percent_degraded']:.2f}%)
+
+================================================================================
+                              DATA SOURCES
+================================================================================
+
+Satellite: Copernicus Sentinel-2 L2A
+Resolution: 10 meters
+Analysis: NDVI vegetation index
+
+================================================================================
+"""
+    return summary

src/stac_utils.py

@@ -0,0 +1,752 @@
+"""
+STAC/Planetary Computer utilities for RehabWatch.
+Handles satellite data access via Microsoft Planetary Computer.
+
+Data Sources:
+- Sentinel-2 L2A: Multispectral imagery for vegetation indices
+- Copernicus DEM GLO-30: Digital elevation model for terrain analysis
+- IO-LULC: Land cover classification (2017-2023)
+- ESA WorldCover: Land cover classification (2020-2021)
+"""
+
+import numpy as np
+import xarray as xr
+import rioxarray
+import stackstac
+import planetary_computer
+from pystac_client import Client
+from shapely.geometry import box, shape, mapping
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict, Any, Tuple
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# Planetary Computer STAC endpoint
+STAC_URL = "https://planetarycomputer.microsoft.com/api/stac/v1"
+
+# Collection names
+SENTINEL2_COLLECTION = "sentinel-2-l2a"
+COPERNICUS_DEM_COLLECTION = "cop-dem-glo-30"
+IO_LULC_COLLECTION = "io-lulc-annual-v02"
+ESA_WORLDCOVER_COLLECTION = "esa-worldcover"
+
+# Land cover class mappings for IO-LULC
+LULC_CLASSES = {
+    1: "Water",
+    2: "Trees",
+    4: "Flooded Vegetation",
+    5: "Crops",
+    7: "Built Area",
+    8: "Bare Ground",
+    9: "Snow/Ice",
+    10: "Clouds",
+    11: "Rangeland"
+}
+
+# ESA WorldCover class mappings
+WORLDCOVER_CLASSES = {
+    10: "Tree cover",
+    20: "Shrubland",
+    30: "Grassland",
+    40: "Cropland",
+    50: "Built-up",
+    60: "Bare / sparse vegetation",
+    70: "Snow and ice",
+    80: "Permanent water bodies",
+    90: "Herbaceous wetland",
+    95: "Mangroves",
+    100: "Moss and lichen"
+}
+
+
+def get_stac_client() -> Client:
+    """
+    Get a STAC client for Planetary Computer.
+
+    Returns:
+        pystac_client.Client instance
+    """
+    return Client.open(STAC_URL, modifier=planetary_computer.sign_inplace)
+
+
+# =============================================================================
+# SENTINEL-2 DATA ACCESS
+# =============================================================================
+
+def search_sentinel2(
+    bbox: Tuple[float, float, float, float],
+    start_date: str,
+    end_date: str,
+    cloud_cover: int = 20
+) -> List[Any]:
+    """
+    Search for Sentinel-2 scenes in the Planetary Computer catalog.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        start_date: Start date (YYYY-MM-DD)
+        end_date: End date (YYYY-MM-DD)
+        cloud_cover: Maximum cloud cover percentage
+
+    Returns:
+        List of STAC items
+    """
+    client = get_stac_client()
+
+    search = client.search(
+        collections=[SENTINEL2_COLLECTION],
+        bbox=bbox,
+        datetime=f"{start_date}/{end_date}",
+        query={"eo:cloud_cover": {"lt": cloud_cover}}
+    )
+
+    items = list(search.items())
+    return items
+
+
+def get_sentinel_composite(
+    bbox: Tuple[float, float, float, float],
+    start_date: str,
+    end_date: str,
+    cloud_threshold: int = 20,
+    resolution: int = 20
+) -> xr.DataArray:
+    """
+    Get a cloud-free Sentinel-2 composite for a given bbox and date range.
+    Includes all bands needed for comprehensive vegetation analysis.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        start_date: Start date string (YYYY-MM-DD)
+        end_date: End date string (YYYY-MM-DD)
+        cloud_threshold: Maximum cloud cover percentage (0-100)
+        resolution: Output resolution in meters (default 20m for memory efficiency)
+
+    Returns:
+        xarray DataArray with median composite
+
+    Raises:
+        ValueError: If no images found for the specified criteria
+    """
+    items = search_sentinel2(bbox, start_date, end_date, cloud_threshold)
+
+    if len(items) == 0:
+        raise ValueError(
+            f"No Sentinel-2 images found for the specified location and date range "
+            f"({start_date} to {end_date}) with cloud cover below {cloud_threshold}%. "
+            "Try expanding the date range or increasing the cloud threshold."
+        )
+
+    # Limit number of items to reduce memory usage
+    if len(items) > 5:
+        items = sorted(items, key=lambda x: x.properties.get('eo:cloud_cover', 100))[:5]
+
+    # Select all bands needed for indices:
+    # B02 (Blue), B03 (Green), B04 (Red), B05 (Red Edge 1),
+    # B06 (Red Edge 2), B07 (Red Edge 3), B08 (NIR),
+    # B8A (NIR narrow), B11 (SWIR1), B12 (SWIR2), SCL (Scene Classification)
+    bands = ["B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B11", "B12", "SCL"]
+
+    stack = stackstac.stack(
+        items,
+        assets=bands,
+        bounds_latlon=bbox,
+        resolution=resolution,
+        epsg=32750,  # UTM zone for Western Australia
+        dtype="float64",
+        rescale=False,
+        fill_value=np.nan,
+        chunksize=1024  # Smaller chunks for memory efficiency
+    )
+
+    # Apply cloud masking using SCL (Scene Classification Layer)
+    scl = stack.sel(band="SCL")
+    cloud_mask = (scl >= 7) & (scl <= 10)
+
+    # Apply mask to reflectance bands
+    masked = stack.where(~cloud_mask)
+
+    # Calculate median composite
+    composite = masked.median(dim="time", skipna=True)
+
+    # Scale to 0-1 reflectance (Sentinel-2 L2A is in 0-10000)
+    composite = composite / 10000.0
+
+    return composite.compute()
+
+
+# =============================================================================
+# VEGETATION INDICES
+# =============================================================================
+
+def calculate_ndvi(data: xr.DataArray) -> xr.DataArray:
+    """
+    Calculate NDVI (Normalized Difference Vegetation Index).
+
+    NDVI = (NIR - Red) / (NIR + Red)
+
+    Range: -1 to 1 (higher = more vegetation)
+    """
+    red = data.sel(band="B04")
+    nir = data.sel(band="B08")
+
+    ndvi = (nir - red) / (nir + red + 1e-10)
+    return ndvi.clip(-1, 1)
+
+
+def calculate_savi(data: xr.DataArray, L: float = 0.5) -> xr.DataArray:
+    """
+    Calculate SAVI (Soil Adjusted Vegetation Index).
+
+    SAVI = ((NIR - Red) / (NIR + Red + L)) * (1 + L)
+
+    Better than NDVI for areas with sparse vegetation.
+    L = 0.5 works well for most conditions.
+
+    Range: -1 to 1
+    """
+    red = data.sel(band="B04")
+    nir = data.sel(band="B08")
+
+    savi = ((nir - red) / (nir + red + L + 1e-10)) * (1 + L)
+    return savi.clip(-1, 1)
+
+
+def calculate_evi(data: xr.DataArray) -> xr.DataArray:
+    """
+    Calculate EVI (Enhanced Vegetation Index).
+
+    EVI = 2.5 * ((NIR - Red) / (NIR + 6*Red - 7.5*Blue + 1))
+
+    More sensitive in high biomass regions, corrects for atmospheric influences.
+
+    Range: approximately -1 to 1
+    """
+    blue = data.sel(band="B02")
+    red = data.sel(band="B04")
+    nir = data.sel(band="B08")
+
+    evi = 2.5 * ((nir - red) / (nir + 6 * red - 7.5 * blue + 1 + 1e-10))
+    return evi.clip(-1, 1)
+
+
+def calculate_ndwi(data: xr.DataArray) -> xr.DataArray:
+    """
+    Calculate NDWI (Normalized Difference Water Index).
+
+    NDWI = (Green - NIR) / (Green + NIR)
+
+    Detects water bodies. Higher values indicate water presence.
+
+    Range: -1 to 1
+    """
+    green = data.sel(band="B03")
+    nir = data.sel(band="B08")
+
+    ndwi = (green - nir) / (green + nir + 1e-10)
+    return ndwi.clip(-1, 1)
+
+
+def calculate_ndmi(data: xr.DataArray) -> xr.DataArray:
+    """
+    Calculate NDMI (Normalized Difference Moisture Index).
+
+    NDMI = (NIR - SWIR1) / (NIR + SWIR1)
+
+    Measures vegetation water content/moisture stress.
+
+    Range: -1 to 1 (higher = more moisture)
+    """
+    nir = data.sel(band="B08")
+    swir1 = data.sel(band="B11")
+
+    ndmi = (nir - swir1) / (nir + swir1 + 1e-10)
+    return ndmi.clip(-1, 1)
+
+
+def calculate_bsi(data: xr.DataArray) -> xr.DataArray:
+    """
+    Calculate BSI (Bare Soil Index).
+
+    BSI = ((SWIR1 + Red) - (NIR + Blue)) / ((SWIR1 + Red) + (NIR + Blue))
+
+    Identifies bare soil areas. Higher values indicate more bare soil.
+
+    Range: -1 to 1
+    """
+    blue = data.sel(band="B02")
+    red = data.sel(band="B04")
+    nir = data.sel(band="B08")
+    swir1 = data.sel(band="B11")
+
+    bsi = ((swir1 + red) - (nir + blue)) / ((swir1 + red) + (nir + blue) + 1e-10)
+    return bsi.clip(-1, 1)
+
+
+def calculate_nbr(data: xr.DataArray) -> xr.DataArray:
+    """
+    Calculate NBR (Normalized Burn Ratio).
+
+    NBR = (NIR - SWIR2) / (NIR + SWIR2)
+
+    Useful for detecting burned areas and vegetation disturbance.
+
+    Range: -1 to 1
+    """
+    nir = data.sel(band="B08")
+    swir2 = data.sel(band="B12")
+
+    nbr = (nir - swir2) / (nir + swir2 + 1e-10)
+    return nbr.clip(-1, 1)
+
+
+def calculate_all_indices(data: xr.DataArray) -> Dict[str, xr.DataArray]:
+    """
+    Calculate all vegetation and soil indices from Sentinel-2 data.
+
+    Returns:
+        Dictionary with index names as keys and DataArrays as values
+    """
+    return {
+        'ndvi': calculate_ndvi(data),
+        'savi': calculate_savi(data),
+        'evi': calculate_evi(data),
+        'ndwi': calculate_ndwi(data),
+        'ndmi': calculate_ndmi(data),
+        'bsi': calculate_bsi(data),
+        'nbr': calculate_nbr(data)
+    }
+
+
+def calculate_vegetation_heterogeneity(ndvi: xr.DataArray, window_size: int = 5) -> xr.DataArray:
+    """
+    Calculate vegetation heterogeneity as local standard deviation of NDVI.
+
+    Higher values indicate more diverse/heterogeneous vegetation.
+    This serves as a proxy for species diversity.
+
+    Args:
+        ndvi: NDVI DataArray
+        window_size: Size of the moving window (default 5 = 50m at 10m resolution)
+
+    Returns:
+        DataArray with heterogeneity values
+    """
+    # Use rolling window to calculate local std
+    heterogeneity = ndvi.rolling(x=window_size, y=window_size, center=True).std()
+    return heterogeneity
+
+
+# =============================================================================
+# COPERNICUS DEM DATA ACCESS
+# =============================================================================
+
+def get_dem_data(
+    bbox: Tuple[float, float, float, float],
+    resolution: int = 30
+) -> xr.DataArray:
+    """
+    Get Copernicus DEM GLO-30 elevation data.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        resolution: Output resolution in meters (default 30m)
+
+    Returns:
+        xarray DataArray with elevation values in meters
+    """
+    client = get_stac_client()
+
+    search = client.search(
+        collections=[COPERNICUS_DEM_COLLECTION],
+        bbox=bbox
+    )
+
+    items = list(search.items())
+
+    if len(items) == 0:
+        raise ValueError("No DEM data found for the specified location.")
+
+    stack = stackstac.stack(
+        items,
+        assets=["data"],
+        bounds_latlon=bbox,
+        resolution=resolution,
+        epsg=32750,
+        dtype="float32",
+        fill_value=np.nan,
+        chunksize=2048
+    )
+
+    # Take the first (or merge if multiple tiles)
+    dem = stack.median(dim="time", skipna=True).squeeze()
+
+    return dem.compute()
+
+
+def calculate_slope(dem: xr.DataArray, resolution: float = 30.0) -> xr.DataArray:
+    """
+    Calculate slope from DEM in degrees.
+
+    Args:
+        dem: Elevation DataArray
+        resolution: Pixel resolution in meters
+
+    Returns:
+        Slope in degrees (0-90)
+    """
+    # Calculate gradients
+    dy, dx = np.gradient(dem.values, resolution)
+
+    # Calculate slope in degrees
+    slope = np.degrees(np.arctan(np.sqrt(dx**2 + dy**2)))
+
+    # Create DataArray with same coordinates
+    slope_da = xr.DataArray(
+        slope,
+        dims=dem.dims,
+        coords=dem.coords,
+        name='slope'
+    )
+
+    return slope_da
+
+
+def calculate_aspect(dem: xr.DataArray, resolution: float = 30.0) -> xr.DataArray:
+    """
+    Calculate aspect from DEM in degrees.
+
+    Args:
+        dem: Elevation DataArray
+        resolution: Pixel resolution in meters
+
+    Returns:
+        Aspect in degrees (0-360, 0=North, 90=East)
+    """
+    dy, dx = np.gradient(dem.values, resolution)
+
+    # Calculate aspect
+    aspect = np.degrees(np.arctan2(-dx, dy))
+    aspect = np.where(aspect < 0, aspect + 360, aspect)
+
+    aspect_da = xr.DataArray(
+        aspect,
+        dims=dem.dims,
+        coords=dem.coords,
+        name='aspect'
+    )
+
+    return aspect_da
+
+
+def calculate_terrain_ruggedness(dem: xr.DataArray, window_size: int = 3) -> xr.DataArray:
+    """
+    Calculate Terrain Ruggedness Index (TRI).
+
+    TRI is the mean of the absolute differences between the center cell
+    and its surrounding cells.
+
+    Args:
+        dem: Elevation DataArray
+        window_size: Size of the moving window
+
+    Returns:
+        TRI values (higher = more rugged terrain)
+    """
+    # Calculate local range as a proxy for ruggedness
+    rolling = dem.rolling(x=window_size, y=window_size, center=True)
+    tri = rolling.max() - rolling.min()
+
+    return tri
+
+
+def calculate_erosion_risk(
+    slope: xr.DataArray,
+    bsi: xr.DataArray,
+    slope_weight: float = 0.6,
+    bare_soil_weight: float = 0.4
+) -> xr.DataArray:
+    """
+    Calculate erosion risk index combining slope and bare soil.
+
+    Higher values indicate greater erosion risk.
+
+    Args:
+        slope: Slope in degrees
+        bsi: Bare Soil Index
+        slope_weight: Weight for slope component
+        bare_soil_weight: Weight for bare soil component
+
+    Returns:
+        Erosion risk index (0-1)
+    """
+    # Normalize slope to 0-1 (assuming max slope of 45 degrees)
+    slope_norm = (slope / 45.0).clip(0, 1)
+
+    # Normalize BSI to 0-1
+    bsi_norm = ((bsi + 1) / 2).clip(0, 1)
+
+    # Combined erosion risk
+    erosion_risk = slope_weight * slope_norm + bare_soil_weight * bsi_norm
+
+    return erosion_risk.clip(0, 1)
+
+
+# =============================================================================
+# LAND COVER DATA ACCESS
+# =============================================================================
+
+def get_land_cover(
+    bbox: Tuple[float, float, float, float],
+    year: int = 2023,
+    resolution: int = 10
+) -> xr.DataArray:
+    """
+    Get IO-LULC annual land cover data.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        year: Year of land cover data (2017-2023)
+        resolution: Output resolution in meters
+
+    Returns:
+        xarray DataArray with land cover classes
+    """
+    client = get_stac_client()
+
+    search = client.search(
+        collections=[IO_LULC_COLLECTION],
+        bbox=bbox,
+        datetime=f"{year}-01-01/{year}-12-31"
+    )
+
+    items = list(search.items())
+
+    if len(items) == 0:
+        raise ValueError(f"No land cover data found for year {year}.")
+
+    stack = stackstac.stack(
+        items,
+        assets=["data"],
+        bounds_latlon=bbox,
+        resolution=resolution,
+        epsg=32750,
+        dtype="uint8",
+        fill_value=0,
+        chunksize=2048
+    )
+
+    lulc = stack.max(dim="time").squeeze()
+
+    return lulc.compute()
+
+
+def get_worldcover(
+    bbox: Tuple[float, float, float, float],
+    year: int = 2021,
+    resolution: int = 10
+) -> xr.DataArray:
+    """
+    Get ESA WorldCover land cover data.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        year: Year (2020 or 2021)
+        resolution: Output resolution in meters
+
+    Returns:
+        xarray DataArray with land cover classes
+    """
+    client = get_stac_client()
+
+    search = client.search(
+        collections=[ESA_WORLDCOVER_COLLECTION],
+        bbox=bbox,
+        datetime=f"{year}-01-01/{year}-12-31"
+    )
+
+    items = list(search.items())
+
+    if len(items) == 0:
+        raise ValueError(f"No WorldCover data found for year {year}.")
+
+    stack = stackstac.stack(
+        items,
+        assets=["map"],
+        bounds_latlon=bbox,
+        resolution=resolution,
+        epsg=32750,
+        dtype="uint8",
+        fill_value=0,
+        chunksize=2048
+    )
+
+    worldcover = stack.max(dim="time").squeeze()
+
+    return worldcover.compute()
+
+
+def calculate_land_cover_change(
+    lulc_before: xr.DataArray,
+    lulc_after: xr.DataArray
+) -> Dict[str, Any]:
+    """
+    Calculate land cover change statistics between two periods.
+
+    Args:
+        lulc_before: Land cover data for earlier period
+        lulc_after: Land cover data for later period
+
+    Returns:
+        Dictionary with change statistics
+    """
+    # Calculate pixel counts for each class
+    before_counts = {}
+    after_counts = {}
+
+    for class_id, class_name in LULC_CLASSES.items():
+        before_counts[class_name] = int((lulc_before == class_id).sum().values)
+        after_counts[class_name] = int((lulc_after == class_id).sum().values)
+
+    # Calculate changes
+    changes = {}
+    for class_name in LULC_CLASSES.values():
+        before = before_counts.get(class_name, 0)
+        after = after_counts.get(class_name, 0)
+        changes[class_name] = {
+            'before': before,
+            'after': after,
+            'change': after - before,
+            'percent_change': ((after - before) / (before + 1)) * 100
+        }
+
+    return {
+        'before': before_counts,
+        'after': after_counts,
+        'changes': changes
+    }
+
+
+def calculate_vegetation_cover_percent(
+    lulc: xr.DataArray,
+    source: str = 'io-lulc'
+) -> float:
+    """
+    Calculate percentage of area covered by vegetation.
+
+    Args:
+        lulc: Land cover DataArray
+        source: 'io-lulc' or 'worldcover'
+
+    Returns:
+        Vegetation cover percentage (0-100)
+    """
+    total_pixels = lulc.size
+
+    if source == 'io-lulc':
+        # Vegetation classes: Trees (2), Flooded Vegetation (4), Crops (5), Rangeland (11)
+        veg_classes = [2, 4, 5, 11]
+    else:  # worldcover
+        # Vegetation classes: Tree cover (10), Shrubland (20), Grassland (30),
+        # Cropland (40), Herbaceous wetland (90), Mangroves (95)
+        veg_classes = [10, 20, 30, 40, 90, 95]
+
+    veg_pixels = sum(int((lulc == c).sum().values) for c in veg_classes)
+
+    return (veg_pixels / total_pixels) * 100
+
+
+def calculate_bare_ground_percent(
+    lulc: xr.DataArray,
+    source: str = 'io-lulc'
+) -> float:
+    """
+    Calculate percentage of area that is bare ground.
+
+    Args:
+        lulc: Land cover DataArray
+        source: 'io-lulc' or 'worldcover'
+
+    Returns:
+        Bare ground percentage (0-100)
+    """
+    total_pixels = lulc.size
+
+    if source == 'io-lulc':
+        bare_classes = [8]  # Bare Ground
+    else:  # worldcover
+        bare_classes = [60]  # Bare / sparse vegetation
+
+    bare_pixels = sum(int((lulc == c).sum().values) for c in bare_classes)
+
+    return (bare_pixels / total_pixels) * 100
+
+
+# =============================================================================
+# UTILITY FUNCTIONS
+# =============================================================================
+
+def get_image_count(
+    bbox: Tuple[float, float, float, float],
+    start_date: str,
+    end_date: str,
+    cloud_threshold: int = 20
+) -> int:
+    """Get count of available Sentinel-2 images for a location."""
+    items = search_sentinel2(bbox, start_date, end_date, cloud_threshold)
+    return len(items)
+
+
+def get_image_dates(
+    bbox: Tuple[float, float, float, float],
+    start_date: str,
+    end_date: str,
+    cloud_threshold: int = 30
+) -> List[str]:
+    """Get list of available Sentinel-2 image dates for a location."""
+    items = search_sentinel2(bbox, start_date, end_date, cloud_threshold)
+    dates = [item.datetime.strftime("%Y-%m-%d") for item in items if item.datetime]
+    return sorted(list(set(dates)))
+
+
+def geometry_to_bbox(geometry: Dict[str, Any]) -> Tuple[float, float, float, float]:
+    """Convert a GeoJSON geometry to a bounding box."""
+    geom = shape(geometry)
+    bounds = geom.bounds
+    return bounds
+
+
+def bbox_to_geometry(bbox: Tuple[float, float, float, float]) -> Dict[str, Any]:
+    """Convert a bounding box to GeoJSON geometry."""
+    return mapping(box(*bbox))
+
+
+def get_bbox_center(bbox: Tuple[float, float, float, float]) -> Tuple[float, float]:
+    """Get the center point of a bounding box."""
+    min_lon, min_lat, max_lon, max_lat = bbox
+    center_lat = (min_lat + max_lat) / 2
+    center_lon = (min_lon + max_lon) / 2
+    return (center_lat, center_lon)
+
+
+def expand_bbox(
+    bbox: Tuple[float, float, float, float],
+    buffer_deg: float = 0.01
+) -> Tuple[float, float, float, float]:
+    """Expand a bounding box by a buffer in degrees."""
+    min_lon, min_lat, max_lon, max_lat = bbox
+    return (
+        min_lon - buffer_deg,
+        min_lat - buffer_deg,
+        max_lon + buffer_deg,
+        max_lat + buffer_deg
+    )
+
+
+def create_reference_bbox(
+    bbox: Tuple[float, float, float, float],
+    buffer_deg: float = 0.01
+) -> Tuple[float, float, float, float]:
+    """Create a reference bounding box around the site."""
+    return expand_bbox(bbox, buffer_deg)

src/visualization.py

@@ -0,0 +1,1103 @@
+"""
+Visualization module for RehabWatch.
+Creates maps and charts using Folium and Plotly.
+"""
+
+import numpy as np
+import xarray as xr
+import folium
+from folium import plugins
+from folium.raster_layers import ImageOverlay
+import plotly.graph_objects as go
+import streamlit as st
+from typing import Dict, Any, List, Optional, Tuple
+from matplotlib.colors import LinearSegmentedColormap
+import base64
+from io import BytesIO
+from PIL import Image
+
+
+# NDVI color palette (brown to green)
+NDVI_COLORS = ['#8B4513', '#D2B48C', '#FFFF00', '#90EE90', '#228B22', '#006400']
+
+# Change color palette (red-white-green diverging)
+CHANGE_COLORS = ['#B71C1C', '#EF9A9A', '#FFFFFF', '#A5D6A7', '#1B5E20']
+
+
+def array_to_colored_image(
+    data: np.ndarray,
+    colors: List[str],
+    vmin: float,
+    vmax: float
+) -> np.ndarray:
+    """
+    Convert a 2D array to a colored RGBA image.
+
+    Args:
+        data: 2D numpy array
+        colors: List of hex color strings for colormap
+        vmin: Minimum value for normalization
+        vmax: Maximum value for normalization
+
+    Returns:
+        RGBA numpy array (H, W, 4) with values 0-255
+    """
+    cmap = LinearSegmentedColormap.from_list('custom', colors)
+
+    # Normalize data
+    normalized = (data - vmin) / (vmax - vmin)
+    normalized = np.clip(normalized, 0, 1)
+
+    # Handle NaN values
+    mask = np.isnan(data)
+
+    # Apply colormap
+    rgba = cmap(normalized)
+    rgba = (rgba * 255).astype(np.uint8)
+
+    # Set NaN pixels to transparent
+    rgba[mask, 3] = 0
+
+    return rgba
+
+
+def create_image_overlay(
+    data: xr.DataArray,
+    colors: List[str],
+    vmin: float,
+    vmax: float,
+    bounds: List[List[float]]
+) -> str:
+    """
+    Create a base64-encoded PNG image for Folium overlay.
+
+    Args:
+        data: xarray DataArray
+        colors: Color palette
+        vmin: Min value for normalization
+        vmax: Max value for normalization
+        bounds: [[south, west], [north, east]]
+
+    Returns:
+        Base64 encoded PNG string
+    """
+    # Get the 2D array
+    arr = data.values
+    if arr.ndim > 2:
+        arr = arr.squeeze()
+
+    # Create colored image
+    rgba = array_to_colored_image(arr, colors, vmin, vmax)
+
+    # Flip vertically for correct orientation
+    rgba = np.flipud(rgba)
+
+    # Convert to PNG
+    img = Image.fromarray(rgba, mode='RGBA')
+    buffer = BytesIO()
+    img.save(buffer, format='PNG')
+    buffer.seek(0)
+
+    # Encode to base64
+    img_base64 = base64.b64encode(buffer.getvalue()).decode()
+    return f"data:image/png;base64,{img_base64}"
+
+
+def create_comparison_map(
+    bbox: Tuple[float, float, float, float],
+    ndvi_before: xr.DataArray,
+    ndvi_after: xr.DataArray,
+    ndvi_change: xr.DataArray,
+    center_coords: Tuple[float, float],
+    zoom: int = 12
+) -> folium.Map:
+    """
+    Create an interactive comparison map with multiple layers.
+
+    Args:
+        bbox: Bounding box (min_lon, min_lat, max_lon, max_lat)
+        ndvi_before: NDVI xarray at start date
+        ndvi_after: NDVI xarray at end date
+        ndvi_change: NDVI change xarray
+        center_coords: Map center (lat, lon)
+        zoom: Initial zoom level
+
+    Returns:
+        Folium Map object with all layers
+    """
+    # Create base map
+    m = folium.Map(
+        location=center_coords,
+        zoom_start=zoom,
+        tiles=None
+    )
+
+    # Add satellite basemap
+    folium.TileLayer(
+        tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr='Esri',
+        name='Satellite Imagery',
+        overlay=False
+    ).add_to(m)
+
+    # Add OpenStreetMap as alternative
+    folium.TileLayer(
+        tiles='openstreetmap',
+        name='OpenStreetMap',
+        overlay=False
+    ).add_to(m)
+
+    # Calculate bounds for image overlay
+    min_lon, min_lat, max_lon, max_lat = bbox
+    bounds = [[min_lat, min_lon], [max_lat, max_lon]]
+
+    # Add NDVI Before layer
+    try:
+        ndvi_before_img = create_image_overlay(
+            ndvi_before, NDVI_COLORS, -0.1, 0.8, bounds
+        )
+        ImageOverlay(
+            image=ndvi_before_img,
+            bounds=bounds,
+            opacity=0.7,
+            name='NDVI Before',
+            show=False
+        ).add_to(m)
+    except Exception as e:
+        print(f"Error adding NDVI Before layer: {e}")
+
+    # Add NDVI After layer
+    try:
+        ndvi_after_img = create_image_overlay(
+            ndvi_after, NDVI_COLORS, -0.1, 0.8, bounds
+        )
+        ImageOverlay(
+            image=ndvi_after_img,
+            bounds=bounds,
+            opacity=0.7,
+            name='NDVI After',
+            show=False
+        ).add_to(m)
+    except Exception as e:
+        print(f"Error adding NDVI After layer: {e}")
+
+    # Add Change Map layer (shown by default)
+    try:
+        change_img = create_image_overlay(
+            ndvi_change, CHANGE_COLORS, -0.3, 0.3, bounds
+        )
+        ImageOverlay(
+            image=change_img,
+            bounds=bounds,
+            opacity=0.7,
+            name='Vegetation Change',
+            show=True
+        ).add_to(m)
+    except Exception as e:
+        print(f"Error adding Change layer: {e}")
+
+    # Add tenement boundary
+    boundary_coords = [
+        [min_lat, min_lon],
+        [min_lat, max_lon],
+        [max_lat, max_lon],
+        [max_lat, min_lon],
+        [min_lat, min_lon]
+    ]
+    folium.PolyLine(
+        locations=boundary_coords,
+        color='#000000',
+        weight=3,
+        fill=False,
+        popup='Analysis Boundary'
+    ).add_to(m)
+
+    # Add layer control
+    folium.LayerControl(position='topright').add_to(m)
+
+    # Add legends
+    _add_legends(m)
+
+    return m
+
+
+def _add_legends(m: folium.Map) -> None:
+    """Add color legends to the map."""
+    legend_html = '''
+    <div style="position: fixed; bottom: 50px; left: 50px; z-index: 1000;
+                background-color: white; padding: 10px; border-radius: 5px;
+                border: 2px solid grey; font-size: 12px; max-width: 150px;">
+        <p style="margin: 0 0 5px 0; font-weight: bold;">NDVI Scale</p>
+        <div style="background: linear-gradient(to right, #8B4513, #D2B48C, #FFFF00, #90EE90, #228B22, #006400);
+                    width: 100%; height: 15px; border-radius: 3px;"></div>
+        <div style="display: flex; justify-content: space-between;">
+            <span>-0.1</span><span>0.8</span>
+        </div>
+        <hr style="margin: 8px 0;">
+        <p style="margin: 0 0 5px 0; font-weight: bold;">Change</p>
+        <div style="background: linear-gradient(to right, #B71C1C, #EF9A9A, #FFFFFF, #A5D6A7, #1B5E20);
+                    width: 100%; height: 15px; border-radius: 3px;"></div>
+        <div style="display: flex; justify-content: space-between;">
+            <span style="color: #B71C1C;">-0.3</span>
+            <span style="color: #1B5E20;">+0.3</span>
+        </div>
+        <p style="margin: 5px 0 0 0; font-size: 10px; text-align: center;">
+            Red=Decline | Green=Growth
+        </p>
+    </div>
+    '''
+    m.get_root().html.add_child(folium.Element(legend_html))
+
+
+def create_simple_map(
+    center_coords: Tuple[float, float],
+    zoom: int = 10,
+    bbox: Optional[Tuple[float, float, float, float]] = None
+) -> folium.Map:
+    """
+    Create a simple map for location preview.
+
+    Args:
+        center_coords: Map center (lat, lon)
+        zoom: Zoom level
+        bbox: Optional bounding box to display
+
+    Returns:
+        Folium Map object
+    """
+    m = folium.Map(location=center_coords, zoom_start=zoom)
+
+    # Add satellite imagery
+    folium.TileLayer(
+        tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr='Esri',
+        name='Satellite',
+        overlay=False
+    ).add_to(m)
+
+    if bbox is not None:
+        min_lon, min_lat, max_lon, max_lat = bbox
+        boundary_coords = [
+            [min_lat, min_lon],
+            [min_lat, max_lon],
+            [max_lat, max_lon],
+            [max_lat, min_lon],
+            [min_lat, min_lon]
+        ]
+        folium.Polygon(
+            locations=boundary_coords,
+            color='#1B5E20',
+            weight=3,
+            fill=True,
+            fillColor='#2E7D32',
+            fillOpacity=0.2,
+            popup='Analysis Area'
+        ).add_to(m)
+
+    folium.LayerControl().add_to(m)
+    return m
+
+
+def create_time_series_chart(
+    timeseries_data: List[Dict[str, Any]],
+    title: str = "NDVI Time Series"
+) -> go.Figure:
+    """
+    Create an interactive NDVI time series chart.
+
+    Args:
+        timeseries_data: List of dicts with 'date' and 'ndvi' keys
+        title: Chart title
+
+    Returns:
+        Plotly Figure object
+    """
+    if not timeseries_data:
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No time series data available",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=16)
+        )
+        return fig
+
+    dates = [d['date'] for d in timeseries_data]
+    ndvi_values = [d['ndvi'] for d in timeseries_data]
+
+    fig = go.Figure()
+
+    # Add NDVI line
+    fig.add_trace(go.Scatter(
+        x=dates,
+        y=ndvi_values,
+        mode='lines+markers',
+        name='NDVI',
+        line=dict(color='#2E7D32', width=2),
+        marker=dict(size=6),
+        hovertemplate='Date: %{x}<br>NDVI: %{y:.3f}<extra></extra>'
+    ))
+
+    # Add reference lines
+    fig.add_hline(y=0.6, line_dash="dash", line_color="#4CAF50",
+                  annotation_text="Healthy Vegetation", annotation_position="right")
+    fig.add_hline(y=0.2, line_dash="dash", line_color="#FF9800",
+                  annotation_text="Sparse Vegetation", annotation_position="right")
+
+    fig.update_layout(
+        title=dict(text=title, font=dict(size=18)),
+        xaxis_title="Date",
+        yaxis_title="NDVI",
+        yaxis=dict(range=[0, 1]),
+        template="plotly_white",
+        hovermode="x unified",
+        height=400,
+        margin=dict(l=60, r=40, t=60, b=60)
+    )
+
+    return fig
+
+
+def create_stats_display(stats: Dict[str, float], rehab_score: int) -> None:
+    """
+    Display statistics using Streamlit components.
+
+    Args:
+        stats: Statistics dictionary
+        rehab_score: Rehabilitation score (0-100)
+    """
+    # Rehabilitation Score with large display
+    st.markdown("### Rehabilitation Score")
+
+    score_color = _get_score_color(rehab_score)
+    st.markdown(f"""
+    <div style="text-align: center; padding: 20px; background-color: {score_color}20;
+                border-radius: 10px; margin-bottom: 20px;">
+        <span style="font-size: 72px; font-weight: bold; color: {score_color};">
+            {rehab_score}
+        </span>
+        <span style="font-size: 24px; color: {score_color};">/100</span>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Progress bar
+    st.progress(rehab_score / 100)
+
+    # Key Metrics in columns
+    # Logic: arrow direction = numeric delta; color = good/bad for nature
+    st.markdown("### Key Metrics")
+    col1, col2, col3 = st.columns(3)
+
+    ndvi_change = stats.get('ndvi_change_mean', 0)
+    percent_change = stats.get('percent_change', 0)
+
+    with col1:
+        st.metric(
+            label="NDVI Before",
+            value=f"{stats['ndvi_before_mean']:.3f}",
+            help="Normalized Difference Vegetation Index: measures vegetation health (-1 to 1)"
+        )
+        st.metric(
+            label="Area Improved",
+            value=f"{stats['area_improved_ha']:.1f} ha",
+            delta=f"+{stats['percent_improved']:.1f}%",
+            delta_color="normal"  # improvement is always good
+        )
+
+    with col2:
+        # NDVI: increase = good (green), decrease = bad (red)
+        st.metric(
+            label="NDVI After",
+            value=f"{stats['ndvi_after_mean']:.3f}",
+            delta=f"{ndvi_change:+.3f}" if ndvi_change != 0 else None,
+            delta_color="normal",  # green for +, red for -
+            help="Current vegetation index value"
+        )
+        st.metric(
+            label="Area Degraded",
+            value=f"{stats['area_degraded_ha']:.1f} ha",
+            delta=f"-{stats['percent_degraded']:.1f}%",
+            delta_color="inverse"  # degradation showing as negative is correct
+        )
+
+    with col3:
+        # Vegetation Change: increase = good (green), decrease = bad (red)
+        st.metric(
+            label="Vegetation Change",
+            value=f"{percent_change:+.1f}%",
+            delta=f"{percent_change:+.1f}%" if percent_change != 0 else None,
+            delta_color="normal",  # green for +, red for -
+            help="Percentage change in vegetation cover"
+        )
+        st.metric(
+            label="Total Area",
+            value=f"{stats['total_area_ha']:.1f} ha"
+        )
+
+
+def _get_score_color(score: int) -> str:
+    """Get color based on rehabilitation score."""
+    if score >= 80:
+        return "#1B5E20"
+    elif score >= 60:
+        return "#4CAF50"
+    elif score >= 40:
+        return "#FF9800"
+    elif score >= 20:
+        return "#F57C00"
+    else:
+        return "#B71C1C"
+
+
+def create_area_breakdown_chart(stats: Dict[str, float]) -> go.Figure:
+    """
+    Create a pie chart showing area breakdown.
+
+    Args:
+        stats: Statistics dictionary with area values
+
+    Returns:
+        Plotly Figure object
+    """
+    labels = ['Improved', 'Stable', 'Degraded']
+    values = [
+        stats['area_improved_ha'],
+        stats['area_stable_ha'],
+        stats['area_degraded_ha']
+    ]
+    colors = ['#4CAF50', '#FFC107', '#F44336']
+
+    fig = go.Figure(data=[go.Pie(
+        labels=labels,
+        values=values,
+        marker_colors=colors,
+        hole=0.4,
+        textinfo='label+percent',
+        hovertemplate='%{label}<br>%{value:.1f} ha<br>%{percent}<extra></extra>'
+    )])
+
+    fig.update_layout(
+        title="Area Breakdown",
+        annotations=[dict(text='Area', x=0.5, y=0.5, font_size=16, showarrow=False)],
+        showlegend=True,
+        height=350
+    )
+
+    return fig
+
+
+def create_ndvi_comparison_chart(stats: Dict[str, float]) -> go.Figure:
+    """
+    Create a bar chart comparing before/after NDVI.
+
+    Args:
+        stats: Statistics dictionary
+
+    Returns:
+        Plotly Figure object
+    """
+    fig = go.Figure()
+
+    fig.add_trace(go.Bar(
+        x=['Before', 'After'],
+        y=[stats['ndvi_before_mean'], stats['ndvi_after_mean']],
+        marker_color=['#8B4513', '#228B22'],
+        text=[f"{stats['ndvi_before_mean']:.3f}", f"{stats['ndvi_after_mean']:.3f}"],
+        textposition='outside'
+    ))
+
+    fig.update_layout(
+        title="NDVI Comparison",
+        yaxis_title="NDVI",
+        yaxis=dict(range=[0, max(stats['ndvi_after_mean'], stats['ndvi_before_mean']) * 1.3]),
+        template="plotly_white",
+        height=350
+    )
+
+    return fig
+
+
+def create_statistics_table(stats: Dict[str, float]) -> None:
+    """
+    Display full statistics as a formatted table.
+
+    Args:
+        stats: Statistics dictionary
+    """
+    import pandas as pd
+
+    data = {
+        'Metric': [
+            'NDVI Before (mean)',
+            'NDVI After (mean)',
+            'NDVI Change (mean)',
+            'NDVI Change (std dev)',
+            'Relative Change',
+            'Area Improved',
+            'Area Stable',
+            'Area Degraded',
+            'Total Area',
+            '% Improved',
+            '% Stable',
+            '% Degraded'
+        ],
+        'Value': [
+            f"{stats['ndvi_before_mean']:.4f}",
+            f"{stats['ndvi_after_mean']:.4f}",
+            f"{stats['ndvi_change_mean']:.4f}",
+            f"{stats['ndvi_change_std']:.4f}",
+            f"{stats['percent_change']:.2f}%",
+            f"{stats['area_improved_ha']:.2f} ha",
+            f"{stats['area_stable_ha']:.2f} ha",
+            f"{stats['area_degraded_ha']:.2f} ha",
+            f"{stats['total_area_ha']:.2f} ha",
+            f"{stats['percent_improved']:.2f}%",
+            f"{stats['percent_stable']:.2f}%",
+            f"{stats['percent_degraded']:.2f}%"
+        ],
+        'Description': [
+            'Mean vegetation index at analysis start',
+            'Mean vegetation index at analysis end',
+            'Average change in vegetation index',
+            'Variation in vegetation change',
+            'Percentage change in mean NDVI',
+            'Area with NDVI increase > 0.05',
+            'Area with NDVI change between -0.05 and 0.05',
+            'Area with NDVI decrease > 0.05',
+            'Total analyzed area',
+            'Percentage of area showing improvement',
+            'Percentage of area remaining stable',
+            'Percentage of area showing degradation'
+        ]
+    }
+
+    df = pd.DataFrame(data)
+    st.dataframe(df, use_container_width=True, hide_index=True)
+
+
+# =============================================================================
+# NEW EXTENDED VISUALIZATIONS
+# =============================================================================
+
+# Color palettes for different indices
+BSI_COLORS = ['#228B22', '#90EE90', '#FFFF00', '#D2B48C', '#8B4513']  # Green to brown
+WATER_COLORS = ['#8B4513', '#D2B48C', '#87CEEB', '#4169E1', '#000080']  # Brown to blue
+MOISTURE_COLORS = ['#B71C1C', '#FF5722', '#FFEB3B', '#8BC34A', '#1B5E20']  # Dry to wet
+SLOPE_COLORS = ['#1B5E20', '#4CAF50', '#FFEB3B', '#FF9800', '#B71C1C']  # Flat to steep
+EROSION_COLORS = ['#1B5E20', '#4CAF50', '#FFEB3B', '#FF5722', '#B71C1C']  # Low to high risk
+
+# Land cover color mapping
+LULC_COLORS = {
+    1: '#0000FF',   # Water - Blue
+    2: '#228B22',   # Trees - Forest Green
+    4: '#006400',   # Flooded Vegetation - Dark Green
+    5: '#FFD700',   # Crops - Gold
+    7: '#808080',   # Built Area - Gray
+    8: '#D2691E',   # Bare Ground - Chocolate
+    9: '#FFFFFF',   # Snow/Ice - White
+    10: '#C0C0C0',  # Clouds - Silver
+    11: '#9ACD32'   # Rangeland - Yellow Green
+}
+
+
+def create_multi_index_map(
+    bbox: Tuple[float, float, float, float],
+    indices_after: Dict[str, xr.DataArray],
+    index_changes: Dict[str, xr.DataArray],
+    center_coords: Tuple[float, float],
+    zoom: int = 12
+) -> folium.Map:
+    """
+    Create an interactive map with multiple index layers.
+    """
+    m = folium.Map(location=center_coords, zoom_start=zoom, tiles=None)
+
+    # Add basemaps
+    folium.TileLayer(
+        tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr='Esri', name='Satellite', overlay=False
+    ).add_to(m)
+
+    folium.TileLayer(tiles='openstreetmap', name='OpenStreetMap', overlay=False).add_to(m)
+
+    min_lon, min_lat, max_lon, max_lat = bbox
+    bounds = [[min_lat, min_lon], [max_lat, max_lon]]
+
+    # Index configurations: (data, colors, vmin, vmax, name)
+    index_configs = [
+        ('ndvi', NDVI_COLORS, -0.1, 0.8, 'NDVI'),
+        ('savi', NDVI_COLORS, -0.1, 0.8, 'SAVI'),
+        ('evi', NDVI_COLORS, -0.1, 0.8, 'EVI'),
+        ('bsi', BSI_COLORS, -0.5, 0.5, 'Bare Soil Index'),
+        ('ndwi', WATER_COLORS, -0.5, 0.5, 'Water Index (NDWI)'),
+        ('ndmi', MOISTURE_COLORS, -0.5, 0.5, 'Moisture Index (NDMI)'),
+    ]
+
+    # Add current state layers
+    for idx_key, colors, vmin, vmax, name in index_configs:
+        if idx_key in indices_after:
+            try:
+                img = create_image_overlay(indices_after[idx_key], colors, vmin, vmax, bounds)
+                ImageOverlay(
+                    image=img, bounds=bounds, opacity=0.7,
+                    name=f'{name} (Current)', show=(idx_key == 'ndvi')
+                ).add_to(m)
+            except Exception:
+                pass
+
+    # Add change layers
+    for idx_key, _, _, _, name in index_configs:
+        if idx_key in index_changes:
+            try:
+                img = create_image_overlay(index_changes[idx_key], CHANGE_COLORS, -0.3, 0.3, bounds)
+                ImageOverlay(
+                    image=img, bounds=bounds, opacity=0.7,
+                    name=f'{name} Change', show=False
+                ).add_to(m)
+            except Exception:
+                pass
+
+    # Add boundary
+    boundary_coords = [
+        [min_lat, min_lon], [min_lat, max_lon],
+        [max_lat, max_lon], [max_lat, min_lon], [min_lat, min_lon]
+    ]
+    folium.PolyLine(locations=boundary_coords, color='#000000', weight=3).add_to(m)
+
+    folium.LayerControl(position='topright').add_to(m)
+    _add_legends(m)
+
+    return m
+
+
+def create_terrain_map(
+    bbox: Tuple[float, float, float, float],
+    slope: xr.DataArray,
+    aspect: Optional[xr.DataArray],
+    erosion_risk: Optional[xr.DataArray],
+    center_coords: Tuple[float, float],
+    zoom: int = 12
+) -> folium.Map:
+    """
+    Create an interactive terrain analysis map.
+    """
+    m = folium.Map(location=center_coords, zoom_start=zoom, tiles=None)
+
+    folium.TileLayer(
+        tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr='Esri', name='Satellite', overlay=False
+    ).add_to(m)
+
+    min_lon, min_lat, max_lon, max_lat = bbox
+    bounds = [[min_lat, min_lon], [max_lat, max_lon]]
+
+    # Add slope layer
+    try:
+        slope_img = create_image_overlay(slope, SLOPE_COLORS, 0, 45, bounds)
+        ImageOverlay(
+            image=slope_img, bounds=bounds, opacity=0.7,
+            name='Slope (degrees)', show=True
+        ).add_to(m)
+    except Exception:
+        pass
+
+    # Add erosion risk layer
+    if erosion_risk is not None:
+        try:
+            erosion_img = create_image_overlay(erosion_risk, EROSION_COLORS, 0, 1, bounds)
+            ImageOverlay(
+                image=erosion_img, bounds=bounds, opacity=0.7,
+                name='Erosion Risk', show=False
+            ).add_to(m)
+        except Exception:
+            pass
+
+    folium.LayerControl(position='topright').add_to(m)
+
+    return m
+
+
+def create_land_cover_map(
+    bbox: Tuple[float, float, float, float],
+    lulc: xr.DataArray,
+    center_coords: Tuple[float, float],
+    zoom: int = 12,
+    year: int = 2023
+) -> folium.Map:
+    """
+    Create a land cover classification map.
+    """
+    from matplotlib.colors import ListedColormap
+
+    m = folium.Map(location=center_coords, zoom_start=zoom, tiles=None)
+
+    folium.TileLayer(
+        tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr='Esri', name='Satellite', overlay=False
+    ).add_to(m)
+
+    min_lon, min_lat, max_lon, max_lat = bbox
+    bounds = [[min_lat, min_lon], [max_lat, max_lon]]
+
+    # Create categorical colormap
+    try:
+        arr = lulc.values.squeeze()
+        rgba = np.zeros((*arr.shape, 4), dtype=np.uint8)
+
+        for class_id, color in LULC_COLORS.items():
+            mask = arr == class_id
+            r = int(color[1:3], 16)
+            g = int(color[3:5], 16)
+            b = int(color[5:7], 16)
+            rgba[mask] = [r, g, b, 200]
+
+        rgba = np.flipud(rgba)
+        img = Image.fromarray(rgba, mode='RGBA')
+        buffer = BytesIO()
+        img.save(buffer, format='PNG')
+        buffer.seek(0)
+        img_base64 = base64.b64encode(buffer.getvalue()).decode()
+        img_url = f"data:image/png;base64,{img_base64}"
+
+        ImageOverlay(
+            image=img_url, bounds=bounds, opacity=0.7,
+            name=f'Land Cover {year}', show=True
+        ).add_to(m)
+    except Exception:
+        pass
+
+    folium.LayerControl(position='topright').add_to(m)
+
+    return m
+
+
+def create_multi_index_chart(stats: Dict[str, float]) -> go.Figure:
+    """
+    Create a grouped bar chart comparing all indices before/after.
+    """
+    indices = ['NDVI', 'SAVI', 'EVI', 'NDWI', 'NDMI', 'BSI']
+    before_values = []
+    after_values = []
+
+    for idx in ['ndvi', 'savi', 'evi', 'ndwi', 'ndmi', 'bsi']:
+        before_values.append(stats.get(f'{idx}_before_mean', 0))
+        after_values.append(stats.get(f'{idx}_after_mean', 0))
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Bar(
+        name='Before', x=indices, y=before_values,
+        marker_color='#8B4513', text=[f'{v:.3f}' for v in before_values],
+        textposition='outside'
+    ))
+
+    fig.add_trace(go.Bar(
+        name='After', x=indices, y=after_values,
+        marker_color='#228B22', text=[f'{v:.3f}' for v in after_values],
+        textposition='outside'
+    ))
+
+    fig.update_layout(
+        title='Multi-Index Comparison',
+        barmode='group',
+        yaxis_title='Index Value',
+        template='plotly_white',
+        height=400,
+        legend=dict(yanchor="top", y=0.99, xanchor="right", x=0.99)
+    )
+
+    return fig
+
+
+def create_terrain_stats_chart(terrain_stats: Dict[str, float]) -> go.Figure:
+    """
+    Create a chart showing terrain slope distribution.
+    """
+    labels = ['Flat (<5°)', 'Gentle (5-15°)', 'Moderate (15-30°)', 'Steep (>30°)']
+    values = [
+        terrain_stats.get('percent_flat', 0),
+        terrain_stats.get('percent_gentle', 0),
+        terrain_stats.get('percent_moderate', 0),
+        terrain_stats.get('percent_steep', 0)
+    ]
+    colors = ['#1B5E20', '#4CAF50', '#FF9800', '#B71C1C']
+
+    fig = go.Figure(data=[go.Pie(
+        labels=labels, values=values, marker_colors=colors,
+        hole=0.4, textinfo='label+percent'
+    )])
+
+    fig.update_layout(
+        title='Slope Distribution',
+        height=350
+    )
+
+    return fig
+
+
+def create_land_cover_chart(land_cover_stats: Dict[str, Any]) -> go.Figure:
+    """
+    Create a grouped bar chart showing land cover change.
+    """
+    if 'class_changes' not in land_cover_stats:
+        return go.Figure()
+
+    changes = land_cover_stats['class_changes']
+    classes = list(changes.keys())
+    before = [changes[c].get('before', 0) for c in classes]
+    after = [changes[c].get('after', 0) for c in classes]
+
+    # Convert to percentages
+    total_before = sum(before) or 1
+    total_after = sum(after) or 1
+    before_pct = [b / total_before * 100 for b in before]
+    after_pct = [a / total_after * 100 for a in after]
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Bar(
+        name=f"Year {land_cover_stats.get('year_before', 'Before')}",
+        x=classes, y=before_pct, marker_color='#8B4513'
+    ))
+
+    fig.add_trace(go.Bar(
+        name=f"Year {land_cover_stats.get('year_after', 'After')}",
+        x=classes, y=after_pct, marker_color='#228B22'
+    ))
+
+    fig.update_layout(
+        title='Land Cover Change',
+        barmode='group',
+        yaxis_title='Percentage (%)',
+        template='plotly_white',
+        height=400
+    )
+
+    return fig
+
+
+def create_vegetation_health_chart(stats: Dict[str, float]) -> go.Figure:
+    """
+    Create a chart showing vegetation health distribution.
+    """
+    labels = ['Sparse (0-0.2)', 'Low (0.2-0.4)', 'Moderate (0.4-0.6)', 'Dense (>0.6)']
+    values = [
+        stats.get('percent_sparse_veg', 0),
+        stats.get('percent_low_veg', 0),
+        stats.get('percent_moderate_veg', 0),
+        stats.get('percent_dense_veg', 0)
+    ]
+    colors = ['#D2B48C', '#90EE90', '#228B22', '#006400']
+
+    fig = go.Figure(data=[go.Pie(
+        labels=labels, values=values, marker_colors=colors,
+        hole=0.4, textinfo='label+percent'
+    )])
+
+    fig.update_layout(
+        title='Vegetation Health Distribution',
+        height=350
+    )
+
+    return fig
+
+
+def create_environmental_indicators_chart(stats: Dict[str, float]) -> go.Figure:
+    """
+    Create a radar chart showing environmental indicators.
+    """
+    categories = ['Vegetation', 'Moisture', 'Soil Stability', 'Water Presence', 'Dense Veg']
+
+    # Normalize values to 0-100 scale
+    values = [
+        min(100, stats.get('ndvi_after_mean', 0) * 100 / 0.6),  # NDVI
+        max(0, 100 - stats.get('percent_moisture_stressed', 50)),  # Moisture health
+        max(0, 100 - stats.get('percent_bare_soil', 50)),  # Soil stability
+        min(100, stats.get('percent_water', 0) * 10),  # Water presence
+        stats.get('percent_dense_veg', 0)  # Dense vegetation
+    ]
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatterpolar(
+        r=values + [values[0]],  # Close the polygon
+        theta=categories + [categories[0]],
+        fill='toself',
+        fillcolor='rgba(46, 125, 50, 0.3)',
+        line=dict(color='#2E7D32', width=2),
+        name='Current State'
+    ))
+
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(visible=True, range=[0, 100])
+        ),
+        title='Environmental Health Indicators',
+        height=400,
+        showlegend=False
+    )
+
+    return fig
+
+
+def create_comprehensive_stats_display(
+    stats: Dict[str, float],
+    rehab_score: int,
+    terrain_stats: Optional[Dict] = None,
+    land_cover_stats: Optional[Dict] = None
+) -> None:
+    """
+    Display comprehensive statistics with all new metrics.
+    """
+    # Rehabilitation Score
+    st.markdown("### Rehabilitation Score")
+    score_color = _get_score_color(rehab_score)
+    st.markdown(f"""
+    <div style="text-align: center; padding: 20px; background-color: {score_color}20;
+                border-radius: 10px; margin-bottom: 20px;">
+        <span style="font-size: 72px; font-weight: bold; color: {score_color};">
+            {rehab_score}
+        </span>
+        <span style="font-size: 24px; color: {score_color};">/100</span>
+    </div>
+    """, unsafe_allow_html=True)
+    st.progress(rehab_score / 100)
+
+    # Primary Metrics with tooltips
+    # Logic:
+    # - Arrow direction: based on numeric delta (positive=up, negative=down)
+    # - Color: "normal" = green for increase (good), red for decrease (bad)
+    #          "inverse" = red for increase (bad), green for decrease (good)
+    st.markdown("### Key Metrics")
+    col1, col2, col3, col4 = st.columns(4)
+
+    # Get change values for proper arrow direction
+    ndvi_change = stats.get('ndvi_change_mean', 0)
+    percent_change = stats.get('percent_change', 0)
+
+    with col1:
+        # NDVI: increase = good (green), decrease = bad (red)
+        st.metric(
+            "NDVI",
+            f"{stats.get('ndvi_after_mean', 0):.3f}",
+            delta=f"{ndvi_change:+.3f}" if ndvi_change != 0 else None,
+            delta_color="normal",  # green for +, red for -
+            help="Normalized Difference Vegetation Index: measures vegetation health. Values range from -1 to 1, with >0.4 indicating healthy vegetation."
+        )
+
+    with col2:
+        # Vegetation Change: increase = good (green), decrease = bad (red)
+        # Use numeric delta for correct arrow direction
+        st.metric(
+            "Vegetation Change",
+            f"{percent_change:+.1f}%",
+            delta=f"{percent_change:+.1f}%" if percent_change != 0 else None,
+            delta_color="normal",  # green for +, red for -
+            help="Percentage change in vegetation cover between analysis dates."
+        )
+
+    with col3:
+        bsi_change = stats.get('bsi_change', 0)
+        # Bare Soil: increase = bad (red), decrease = good (green)
+        st.metric(
+            "Bare Soil",
+            f"{stats.get('percent_bare_soil', 0):.1f}%",
+            delta=f"{bsi_change:+.3f}" if bsi_change != 0 else None,
+            delta_color="inverse",  # red for +, green for -
+            help="Percentage of area with exposed bare soil. Lower values indicate better vegetation cover."
+        )
+
+    with col4:
+        st.metric(
+            "Water Presence",
+            f"{stats.get('percent_water', 0):.1f}%",
+            help="Percentage of area with water bodies or saturated soil."
+        )
+
+    # Secondary Metrics with tooltips
+    st.markdown("### Additional Indices")
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        savi_change = stats.get('savi_change', 0)
+        # SAVI: increase = good (green), decrease = bad (red)
+        st.metric(
+            "SAVI",
+            f"{stats.get('savi_after_mean', 0):.3f}",
+            delta=f"{savi_change:+.3f}" if savi_change != 0 else None,
+            delta_color="normal",  # green for +, red for -
+            help="Soil Adjusted Vegetation Index: better for sparse vegetation as it accounts for soil brightness."
+        )
+        evi_change = stats.get('evi_change', 0)
+        # EVI: increase = good (green), decrease = bad (red)
+        st.metric(
+            "EVI",
+            f"{stats.get('evi_after_mean', 0):.3f}",
+            delta=f"{evi_change:+.3f}" if evi_change != 0 else None,
+            delta_color="normal",  # green for +, red for -
+            help="Enhanced Vegetation Index: more sensitive in high-biomass areas and corrects for atmospheric effects."
+        )
+
+    with col2:
+        ndmi_change = stats.get('ndmi_change', 0)
+        # NDMI: increase = good (green), decrease = bad (red)
+        st.metric(
+            "NDMI",
+            f"{stats.get('ndmi_after_mean', 0):.3f}",
+            delta=f"{ndmi_change:+.3f}" if ndmi_change != 0 else None,
+            delta_color="normal",  # green for +, red for -
+            help="Normalized Difference Moisture Index: measures vegetation water content. Higher values = more moisture."
+        )
+        bsi_val_change = stats.get('bsi_change', 0)
+        # BSI: increase = bad (red), decrease = good (green)
+        st.metric(
+            "BSI",
+            f"{stats.get('bsi_after_mean', 0):.3f}",
+            delta=f"{bsi_val_change:+.3f}" if bsi_val_change != 0 else None,
+            delta_color="inverse",  # red for +, green for -
+            help="Bare Soil Index: identifies bare soil areas. Higher values indicate more exposed soil (negative for rehab)."
+        )
+
+    with col3:
+        st.metric(
+            "Moisture Stressed",
+            f"{stats.get('percent_moisture_stressed', 0):.1f}%",
+            help="Percentage of vegetation showing signs of water stress."
+        )
+        st.metric(
+            "Dense Vegetation",
+            f"{stats.get('percent_dense_veg', 0):.1f}%",
+            help="Percentage of area with dense, healthy vegetation (NDVI > 0.6)."
+        )
+
+    # Terrain stats if available
+    if terrain_stats and terrain_stats.get('slope_mean'):
+        st.markdown("### Terrain Analysis")
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            st.metric("Mean Slope", f"{terrain_stats.get('slope_mean', 0):.1f}°")
+
+        with col2:
+            st.metric("Steep Areas", f"{terrain_stats.get('percent_steep', 0):.1f}%")
+
+        with col3:
+            if 'percent_high_erosion_risk' in terrain_stats:
+                st.metric("High Erosion Risk", f"{terrain_stats.get('percent_high_erosion_risk', 0):.1f}%",
+                          delta_color="inverse")
+
+    # Land cover stats if available
+    if land_cover_stats and land_cover_stats.get('vegetation_cover_after'):
+        st.markdown("### Land Cover")
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.metric("Vegetation Cover",
+                      f"{land_cover_stats.get('vegetation_cover_after', 0):.1f}%",
+                      delta=f"{land_cover_stats.get('vegetation_cover_change', 0):.1f}%")
+
+        with col2:
+            st.metric("Bare Ground",
+                      f"{land_cover_stats.get('bare_ground_after', 0):.1f}%",
+                      delta=f"{land_cover_stats.get('bare_ground_change', 0):.1f}%",
+                      delta_color="inverse")