Update app.py

app.py

@@ -985,6 +985,7 @@ def ocr_page():
         else:
             st.warning("OCR not available in this deployment.")
 # Locator Page (with Earth Engine auth at top)
+# Locator Page (with Earth Engine auth at top)
 
 import os
 import json
@@ -995,46 +996,59 @@ import matplotlib.pyplot as plt
 from datetime import datetime
 from io import BytesIO
 import base64
-from streamlit_folium import st_folium
+import folium
+
+import tempfile
+
+def export_map_snapshot(m, width=800, height=600):
+    """
+    Export geemap Map object to PNG snapshot (returns bytes).
+    - m: geemap.Map
+    - width, height: dimensions of snapshot
+    """
+    try:
+        # geemap has a built-in screenshot method
+        tmpfile = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+        m.screenshot(filename=tmpfile.name, region=None, dimensions=(width, height))
+        with open(tmpfile.name, "rb") as f:
+            return f.read()
+    except Exception as e:
+        st.warning(f"Map snapshot failed: {e}")
+        return None
+
 
 def locator_page():
     """
     Robust locator page:
-    - Uses your initialize_ee() auth routine (expects EARTHENGINE_TOKEN / SERVICE_ACCOUNT in env)
-    - Shows interactive map with many basemaps and overlays
-    - Safe reducers with fallbacks and caching
-    - Stores results in st.session_state['soil_json'] AND in the active site entry under Earth Engine fields
+    - Uses initialize_ee() auth routine (expects EARTHENGINE_TOKEN / SERVICE_ACCOUNT in env)
+    - Shows interactive map with basemaps and overlays
+    - Captures ROI drawn on the map
+    - Computes summaries and saves them into active site and soil_json
     """
 
     st.title("🌍 GeoMate Interactive Earth Explorer")
     st.markdown(
         "Draw a polygon (or rectangle) on the map using the drawing tool. "
-        "The app will compute regional summaries (soil clay, elevation, seismic, flood occurrence, landcover, NDVI) "
-        "and save results for reports."
+        "Then press **Compute Summaries** to compute soil clay, elevation, seismic, flood occurrence, landcover, and NDVI."
     )
 
     # ----------------------------
-    # Use your existing EE init function if present
+    # EE Auth
+    # ----------------------------
     EARTHENGINE_TOKEN = os.getenv("EARTHENGINE_TOKEN")
-    SERVICE_ACCOUNT = os.getenv("SERVICE_ACCOUNT")  # optional: service account email
+    SERVICE_ACCOUNT = os.getenv("SERVICE_ACCOUNT")
 
     def initialize_ee():
-        """Initialize Earth Engine with multiple fallbacks."""
         if "ee_initialized" in st.session_state and st.session_state["ee_initialized"]:
             return True
-
         if EARTHENGINE_TOKEN and SERVICE_ACCOUNT:
             try:
-                creds = ee.ServiceAccountCredentials(
-                    email=SERVICE_ACCOUNT,
-                    key_data=EARTHENGINE_TOKEN
-                )
+                creds = ee.ServiceAccountCredentials(email=SERVICE_ACCOUNT, key_data=EARTHENGINE_TOKEN)
                 ee.Initialize(creds)
                 st.session_state["ee_initialized"] = True
                 return True
             except Exception as e:
-                st.warning(f"Service account init failed: {e} — trying default/interactive auth...")
-
+                st.warning(f"Service account init failed: {e}, falling back...")
         try:
             ee.Initialize()
             st.session_state["ee_initialized"] = True
@@ -1046,119 +1060,52 @@ def locator_page():
                 st.session_state["ee_initialized"] = True
                 return True
             except Exception as e:
-                st.error(f"Earth Engine authentication failed: {e}")
+                st.error(f"Earth Engine auth failed: {e}")
                 return False
 
     if not initialize_ee():
         st.stop()
 
     # ----------------------------
-    # I assume your file defines initialize_ee() exactly like your earlier message.
-    try:
-        init_ok = initialize_ee()  # call your auth initializer
-    except NameError:
-        st.error("Auth initializer `initialize_ee()` not found. Ensure your auth code exists above this function.")
-        return
-    if not init_ok:
-        return
-
+    # Safe reducers
     # ----------------------------
-    # Helper: safe reducers + caching
-    # ----------------------------
-    # --- Ensure roi exists in the local scope to avoid UnboundLocalError ---
-    roi = None
     def safe_get_reduce(region, image, band, scale=1000, default=None, max_pixels=int(1e7)):
-        """Return float or None. Uses reduceRegion mean safely."""
-        cache_key = f"reduce::{region.toGeoJSONString()[:200]}::{str(image)}::{band}::{scale}"
-        # check cache
-        cache = st.session_state.setdefault("_ee_cache", {})
-        if cache_key in cache:
-            return cache[cache_key]
-
         try:
-            rr = image.reduceRegion(
-                reducer=ee.Reducer.mean(),
-                geometry=region,
-                scale=int(scale),
-                maxPixels=int(max_pixels)
-            )
+            rr = image.reduceRegion(ee.Reducer.mean(), region, scale=scale, maxPixels=max_pixels)
             val = rr.get(band)
-            if val is None:
-                cache[cache_key] = default
-                return default
-            v = val.getInfo()
-            if v is None:
-                cache[cache_key] = default
-                return default
-            got = float(v)
-            cache[cache_key] = got
-            return got
-        except Exception as e:
-            # log to session for debugging if desired
-            st.session_state.setdefault("_ee_errors", []).append(str(e))
-            cache[cache_key] = default
+            return float(val.getInfo()) if val else default
+        except Exception:
             return default
 
     def safe_reduce_histogram(region, image, band, scale=1000, max_pixels=int(1e7)):
-        """Return a frequency histogram dict or {}."""
-        cache_key = f"hist::{region.toGeoJSONString()[:200]}::{str(image)}::{band}::{scale}"
-        cache = st.session_state.setdefault("_ee_cache", {})
-        if cache_key in cache:
-            return cache[cache_key]
         try:
-            rr = image.reduceRegion(
-                reducer=ee.Reducer.frequencyHistogram(),
-                geometry=region,
-                scale=int(scale),
-                maxPixels=int(max_pixels)
-            )
-            val = rr.get(band)
-            if val is None:
-                cache[cache_key] = {}
-                return {}
-            hist = val.getInfo()
-            if hist is None:
-                cache[cache_key] = {}
-                return {}
-            cache[cache_key] = hist
-            return hist
-        except Exception as e:
-            st.session_state.setdefault("_ee_errors", []).append(str(e))
-            cache[cache_key] = {}
+            rr = image.reduceRegion(ee.Reducer.frequencyHistogram(), region, scale=scale, maxPixels=max_pixels)
+            hist = rr.get(band)
+            return hist.getInfo() if hist else {}
+        except Exception:
             return {}
 
     def safe_time_series(region, collection, band, start, end, reducer=ee.Reducer.mean(), scale=1000, max_pixels=int(1e7)):
-        """Return simple timeseries list of (date, value) for a collection."""
         try:
-            # reduce each image over region, map to list
             def per_image(img):
                 date = img.date().format("YYYY-MM-dd")
-                val = img.reduceRegion(reducer=reducer, geometry=region, scale=int(scale), maxPixels=int(max_pixels)).get(band)
+                val = img.reduceRegion(reducer, region, scale=scale, maxPixels=max_pixels).get(band)
                 return ee.Feature(None, {"date": date, "val": val})
-
             feats = collection.filterDate(start, end).map(per_image).filter(ee.Filter.notNull(["val"])).getInfo()
-            # feats is a dict with 'features' list
-            points = []
+            pts = []
             for f in feats.get("features", []):
-                props = f.get("properties", {})
-                date = props.get("date")
-                val = props.get("val")
-                if val is not None:
-                    try:
-                        points.append((date, float(val)))
-                    except Exception:
-                        pass
-            return points
-        except Exception as e:
-            st.session_state.setdefault("_ee_errors", []).append(str(e))
+                p = f.get("properties", {})
+                if p.get("val") is not None:
+                    pts.append((p.get("date"), float(p.get("val"))))
+            return pts
+        except Exception:
             return []
 
     # ----------------------------
     # Map setup
     # ----------------------------
-    m = geemap.Map(center=[28.0, 72.0], zoom=5, draw_export=True)
+    m = geemap.Map(center=[28.0, 72.0], zoom=5, plugin_Draw=True, draw_export=True, locate_control=True)
 
-    # enriched basemaps list (many options; geemap will ignore unknown)
     basemaps = [
         "HYBRID", "ROADMAP", "TERRAIN", "SATELLITE",
         "Esri.WorldImagery", "Esri.WorldTopoMap", "Esri.WorldShadedRelief",
@@ -1174,391 +1121,238 @@ def locator_page():
             pass
 
     # ----------------------------
-    # Datasets (choose stable EE catalog IDs)
-    # Terrain (DEM) -> prefer NASADEM then SRTM fallback
+    # Datasets (DEM, Soil, Seismic, Flood, Landcover, NDVI)
     # ----------------------------
-    # Try NASADEM (higher quality), fallback to SRTM:
+    
+    # --- DEM ---
     try:
-        dem = ee.Image("NASA/NASADEM_HGT/001")  # NASADEM if available
+        dem = ee.Image("NASA/NASADEM_HGT/001")  # NASADEM ~30m global
         dem_band_name = "elevation"
+        st.info("Using NASADEM dataset for elevation (30m).")
     except Exception:
-        dem = ee.Image("USGS/SRTMGL1_003")
-        dem_band_name = "elevation"
-
-    # ----------------------------
-    # Soil -> use OpenLandMap clay fraction (v02) which provides multiple bands like b0,b10,b30,... and is available
-    # (fallback to SoilGrids if OpenLandMap missing)
-    # ----------------------------
+        try:
+            dem = ee.Image("USGS/SRTMGL1_003")  # SRTM ~30m fallback
+            dem_band_name = "elevation"
+            st.warning("Fallback to SRTM DEM (30m).")
+        except Exception:
+            dem = None
+            dem_band_name = None
+            st.error("No DEM dataset available.")
+    
+    # --- Soil Clay Fraction ---
     soil_img = None
-    soil_band = "b200"  # default deep band
+    soil_band = None
+    chosen_soil_band = None
     try:
         soil_img = ee.Image("OpenLandMap/SOL/SOL_CLAY-WFRACTION_USDA-3A1A1A_M/v02")
-        # pick default band b200 (100-200cm). Offer depth selection below in UI.
+        bands = soil_img.bandNames().getInfo()
+        # interactive soil band selector
+        chosen_soil_band = st.selectbox(
+            "Select soil depth / clay band",
+            options=bands,
+            index=bands.index("b200") if "b200" in bands else 0
+        )
+        st.info(f"Using OpenLandMap Clay Fraction — Band: {chosen_soil_band}")
     except Exception:
-        # fallback to SoilGrids if available
         try:
             soil_img = ee.Image("projects/soilgrids-isric/clay_mean")
-            # SoilGrids band names like 'clay_0-5cm_mean' etc — we will pick a default after UI selection.
-            soil_band = "clay_0-5cm_mean"
+            bands = soil_img.bandNames().getInfo()
+            chosen_soil_band = st.selectbox(
+                "Select soil depth (SoilGrids)",
+                options=bands,
+                index=0
+            )
+            st.warning(f"Fallback to SoilGrids Clay dataset — Band: {chosen_soil_band}")
         except Exception:
             soil_img = None
-
-    # ----------------------------
-    # Seismic -> attempt SEDAC GSHAP, then GEM
-    # ----------------------------
-    seismic_img = None
+            chosen_soil_band = None
+            st.error("No soil dataset available.")
+    
+    # --- Seismic Hazard ---
     try:
-        seismic_img = ee.Image("SEDAC/GSHAPSeismicHazard")  # band "gshap"
+        seismic_img = ee.Image("SEDAC/GSHAPSeismicHazard")
         seismic_band = "gshap"
+        st.info("Using SEDAC Global Seismic Hazard dataset.")
     except Exception:
-        try:
-            seismic_img = ee.Image("GEM/2015/GlobalSeismicHazard")  # may or may not exist
-            # many GEM products use band b0 etc.
-            seismic_band = "b0"
-        except Exception:
-            seismic_img = None
-            seismic_band = None
-
-    # ----------------------------
-    # Flood -> JRC Global Surface Water
-    # ----------------------------
+        seismic_img = None
+        seismic_band = None
+        st.error("No seismic hazard dataset available.")
+    
+    # --- Flood Occurrence ---
     try:
         water = ee.Image("JRC/GSW1_4/GlobalSurfaceWater")
         water_band = "occurrence"
+        st.info("Using JRC Global Surface Water Occurrence (1984–2020).")
     except Exception:
         water = None
         water_band = None
-
-    # ----------------------------
-    # Landcover -> ESA WorldCover v200 (10 m) - "Map" band
-    # ----------------------------
+        st.error("No flood dataset available.")
+    
+    # --- Landcover ---
     try:
         landcover = ee.Image("ESA/WorldCover/v200")
         lc_band = "Map"
+        st.info("Using ESA WorldCover v200 (2020, 10m).")
     except Exception:
         landcover = None
         lc_band = None
-
-    # ----------------------------
-    # NDVI collection (MODIS 1km as robust global product)
-    # ----------------------------
+        st.error("No landcover dataset available.")
+    
+    # --- NDVI ---
     try:
         ndvi_col = ee.ImageCollection("MODIS/061/MOD13A2").select("NDVI")
+        st.info("Using MODIS NDVI (16-day, 1km, global).")
     except Exception:
         ndvi_col = None
-
+        st.error("No NDVI dataset available.")
+    
     # ----------------------------
-    # Add layers to map (visuals)
+    # Add Layers to Map
     # ----------------------------
-    # Add DEM visualization
-    try:
-        m.addLayer(dem, {"min": 0, "max": 4000, "palette": ["blue", "green", "brown", "white"]}, "DEM / Topography")
-    except Exception:
-        pass
-
-    # Add soil view (if available) — user will pick depth later
-    if soil_img:
+    if dem:
         try:
-            # show the dataset (choose one band to display; if band missing, geemap will raise — catch it)
-            # prefer b0 or b200 if available; if both missing, show first band
-            available_bands = soil_img.bandNames().getInfo()
-            # find a band to display
-            display_band = soil_band if soil_band in available_bands else available_bands[0]
-            m.addLayer(soil_img.select(display_band), {"min": 0.0, "max": 0.6, "palette": ["#ffffcc","#c2e699","#78c679","#31a354"]}, f"Soil Clay ({display_band})")
+            m.addLayer(
+                dem,
+                {"min": 0, "max": 4000, "palette": ["blue", "green", "brown", "white"]},
+                "DEM / Elevation"
+            )
         except Exception:
             pass
-
-    # Seismic
+    
+    if soil_img and chosen_soil_band:
+        try:
+            m.addLayer(
+                soil_img.select(chosen_soil_band),
+                {"min": 0.0, "max": 0.6, "palette": ["#ffffcc", "#c2e699", "#78c679", "#31a354"]},
+                f"Soil Clay Fraction ({chosen_soil_band})"
+            )
+        except Exception:
+            pass
+    
     if seismic_img:
         try:
-            # for SEDAC band "gshap" map 0-1
-            m.addLayer(seismic_img, {"min": 0, "max": 1, "palette": ["white", "yellow", "red"]}, "Seismic Hazard")
+            m.addLayer(
+                seismic_img,
+                {"min": 0, "max": 1, "palette": ["white", "yellow", "red"]},
+                "Seismic Hazard"
+            )
         except Exception:
             pass
-
-    # Flood
-    if water is not None:
+    
+    if water:
         try:
-            m.addLayer(water.select(water_band), {"min":0,"max":100,"palette":["white","blue"]}, "Water Occurrence (JRC)")
+            m.addLayer(
+                water.select(water_band),
+                {"min": 0, "max": 100, "palette": ["white", "blue"]},
+                "Flood Occurrence (%)"
+            )
         except Exception:
             pass
-
-    # Landcover
-    if landcover is not None:
+    
+    if landcover:
         try:
-            m.addLayer(landcover, {"min":10,"max":100,"palette":["#006400","#ffbb22","#ffff4c","#f096ff","#fa0000","#b4b4b4","#f0f0f0","#0064c8","#0096a0","#00cf75"]}, "Landcover (WorldCover)")
+            m.addLayer(
+                landcover,
+                {
+                    "min": 10,
+                    "max": 100,
+                    "palette": [
+                        "#006400", "#ffbb22", "#ffff4c", "#f096ff", "#fa0000",
+                        "#b4b4b4", "#f0f0f0", "#0064c8", "#0096a0", "#00cf75"
+                    ]
+                },
+                "Landcover (ESA WorldCover)"
+            )
         except Exception:
             pass
-
-    # Add country boundaries & graticule
+    
     try:
         countries = ee.FeatureCollection("USDOS/LSIB_SIMPLE/2017")
-        m.addLayer(countries.style(**{"color": "black", "fillColor": "00000000", "width": 1}), {}, "Country Boundaries")
-    except Exception:
-        pass
-    try:
-        m.addLayer(geemap.latlon_grid(5.0, region=ee.Geometry.Rectangle([-180, -90, 180, 90])).style(**{"color":"gray","width":0.5}), {}, "Lat/Lon Grid")
+        m.addLayer(
+            countries.style(**{"color": "black", "fillColor": "00000000", "width": 1}),
+            {},
+            "Country Boundaries"
+        )
     except Exception:
         pass
+    
+    # ----------------------------
+    # Show map + draw tool
+    # ----------------------------
+    st.markdown("👉 Draw a polygon/rectangle and press **Compute Summaries**")
+    m.to_streamlit(height=650, responsive=True)
 
-    # --------------------------------------------------------------------------
-    # Section: Display Map, Handle Drawings, and Trigger Computation
-    # --------------------------------------------------------------------------
-    st.markdown("👉 Draw a polygon/rectangle/circle on the map (use draw tool). After drawing, click **Compute Summaries**.")
-
-    # create the map (basemaps already defined earlier)
-    m = geemap.Map(plugin_Draw=True, draw_export=True, locate_control=True)
-
-    # --- Lat/Lon grid ---
-    try:
-        grid = geemap.latlon_grid(lat_step=1, lon_step=1, west=-180, east=180, south=-85, north=85)
-        m.addLayer(grid, {"color": "gray"}, "Lat/Lon Grid")
-    except Exception as e:
-        import folium
-        for lat in range(-90, 91, 5):
-            folium.PolyLine([[lat, -180], [lat, 180]], weight=0.5, opacity=0.6).add_to(m)
-        for lon in range(-180, 181, 5):
-            folium.PolyLine([[-90, lon], [90, lon]], weight=0.5, opacity=0.6).add_to(m)
-        st.info(f"Lat/Lon grid fallback used (error: {e})")
-
-    # --- Render the map ---
-    m.to_streamlit(height=700, responsive=True)
-
-    # --- Capture draw events ---
-    if m.user_roi:
-        try:
-            st.session_state["roi_geojson"] = m.user_roi.toGeoJSONString()
-        except Exception:
-            pass
-    elif m.draw_features:
-        st.session_state["roi_geojson"] = json.dumps(m.draw_features[-1])
-
-    # --- Helper: parse stored ROI into ee.Geometry ---
+    # --- Capture ROI ---
     def get_roi_from_map():
-        if "roi_geojson" in st.session_state and st.session_state["roi_geojson"]:
+        if m.draw_features:
+            feat = m.draw_features[-1]
+            geom = feat.get("geometry") if "geometry" in feat else feat
             try:
-                gj = st.session_state["roi_geojson"]
-                if isinstance(gj, str):
-                    gj = json.loads(gj)
-                    geom = gj.get("geometry") if isinstance(gj, dict) else gj
-                    return ee.Geometry(geom)
-            except Exception as e:
-                st.warning(f"Could not parse the stored ROI. Please redraw. Error: {e}")
-                st.session_state.pop("roi_geojson", None)
+                return ee.Geometry(geom)
+            except Exception:
                 return None
         return None
 
-    # --- Compute summaries ---
+    # --- Compute Summaries ---
     if st.button("Compute Summaries"):
         roi = get_roi_from_map()
         if roi is None:
-            st.error("⚠️ No drawn ROI found. Please draw a polygon/rectangle/circle and press 'Compute Summaries' again.")
-        else:
-            st.success("✅ Polygon found — computing (this may take a few seconds)...")
-            st.session_state["roi_final"] = roi  # persist globally
-
-            # --- Soil band selection ---
-            chosen_soil_band = None
-            if soil_img is not None:
-                try:
-                    bands = soil_img.bandNames().getInfo()
-                    depth_choice = st.selectbox(
-                    "Soil depth / band to analyze",
-                    options=bands,
-                    index=bands.index(soil_band) if soil_band in bands else 0
-                    )
-                    chosen_soil_band = depth_choice
-                except Exception:
-                    chosen_soil_band = None
-
-            # --- Run computations ---
-            soil_val = safe_get_reduce(roi, soil_img.select(chosen_soil_band), chosen_soil_band, scale=1000, default=None, max_pixels=int(5e7)) if soil_img and chosen_soil_band else None
-            elev_val = safe_get_reduce(roi, dem, dem_band_name if dem_band_name else "elevation", scale=1000, default=None, max_pixels=int(5e7))
-            seismic_val = safe_get_reduce(roi, seismic_img, seismic_band, scale=5000, default=None, max_pixels=int(5e7)) if seismic_img and seismic_band else None
-            flood_val = safe_get_reduce(roi, water.select(water_band), water_band, scale=30, default=None, max_pixels=int(5e7)) if water and water_band else None
-            lc_stats = safe_reduce_histogram(roi, landcover, lc_band, scale=30, max_pixels=int(5e7)) if landcover and lc_band else {}
-            ndvi_ts = []
-            if ndvi_col is not None:
-                end = datetime.utcnow().strftime("%Y-%m-%d")
-                start = (datetime.utcnow().replace(year=datetime.utcnow().year - 2)).strftime("%Y-%m-%d")
-                ndvi_ts = safe_time_series(roi, ndvi_col, "NDVI", start, end, reducer=ee.Reducer.mean(), scale=1000, max_pixels=int(5e7))
-
-            # --- Save results into active site ---
-            active_site = st.session_state.get("active_site", 0)
-            site = st.session_state["sites"][active_site]
-            site["ROI"] = st.session_state.get("roi_geojson")
-            site["Soil Clay"] = f"{soil_val} (band {chosen_soil_band})" if soil_val is not None else "Not available"
-            site["Elevation (avg)"] = elev_val
-            site["Seismic Hazard"] = seismic_val
-            site["Flood Occurrence"] = flood_val
-            site["Landcover Histogram"] = lc_stats
-            site["NDVI Timeseries"] = ndvi_ts
-
-            # --- Display results ---
-            st.subheader("📊 Regional Data Summary")
-            st.write(f"**Soil ({chosen_soil_band}):** {soil_val}")
-            st.write(f"**Average Elevation:** {elev_val} m")
-            st.write(f"**Seismic Hazard (mean):** {seismic_val}")
-            st.write(f"**Flood occurrence (mean %):** {flood_val}")
-            st.json(lc_stats)
-
-            if ndvi_ts:
-                import matplotlib.pyplot as plt
-                dates, values = zip(*ndvi_ts)
-                fig, ax = plt.subplots()
-                ax.plot(dates, values, marker="o")
-                ax.set_title("NDVI (last 2 years)")
-                ax.set_xlabel("Date")
-                ax.set_ylabel("NDVI")
-                st.pyplot(fig)
-    
-        # ----------------------------
-        # UI: display numeric summary
-        # ----------------------------
-        def pretty(x, fmt="{:.2f}"):
-            return "N/A" if x is None else fmt.format(x)
-
-        st.subheader("📊 Regional Data Summary")
-        st.write(f"**Soil ({chosen_soil_band}):** {pretty(soil_val)}")
-        st.write(f"**Average Elevation:** {pretty(elev_val, '{:.1f}')} m")
-        st.write(f"**Seismic (mean):** {pretty(seismic_val)}")
-        st.write(f"**Flood occurrence (mean %):** {pretty(flood_val)}")
-
-        # Landcover pie chart (colored)
-        if lc_stats:
-            # convert keys into ints if possible (WorldCover class codes)
-            labels = []
-            values = []
-            for k, v in lc_stats.items():
-                labels.append(str(k))
-                values.append(v)
-            fig1, ax1 = plt.subplots(figsize=(6,4))
-            ax1.pie(values, labels=labels, autopct="%1.1f%%", startangle=90)
-            ax1.set_title("Landcover Distribution (class codes)")
-            st.pyplot(fig1)
-        else:
-            st.info("No landcover histogram available.")
-
-        # NDVI timeseries plot
+            st.error("⚠️ No drawn ROI found. Please draw and try again.")
+            return
+        st.success("✅ ROI found — computing...")
+
+        chosen_soil_band = None
+        if soil_img:
+            bands = soil_img.bandNames().getInfo()
+            chosen_soil_band = st.selectbox("Soil band to analyze", bands, index=bands.index(soil_band) if soil_band in bands else 0)
+
+        soil_val = safe_get_reduce(roi, soil_img.select(chosen_soil_band), chosen_soil_band, 1000) if soil_img and chosen_soil_band else None
+        elev_val = safe_get_reduce(roi, dem, dem_band_name, 1000)
+        seismic_val = safe_get_reduce(roi, seismic_img, seismic_band, 5000) if seismic_img else None
+        flood_val = safe_get_reduce(roi, water.select(water_band), water_band, 30) if water else None
+        lc_stats = safe_reduce_histogram(roi, landcover, lc_band, 30) if landcover else {}
+        ndvi_ts = []
+        if ndvi_col:
+            end = datetime.utcnow().strftime("%Y-%m-%d")
+            start = (datetime.utcnow().replace(year=datetime.utcnow().year-2)).strftime("%Y-%m-%d")
+            ndvi_ts = safe_time_series(roi, ndvi_col, "NDVI", start, end)
+
+        # Save results
+        active = st.session_state.get("active_site", 0)
+        if "sites" in st.session_state:
+            site = st.session_state["sites"][active]
+            site["ROI"] = roi.getInfo()
+            site["Soil Profile"] = f"{soil_val} ({chosen_soil_band})" if soil_val else "N/A"
+            site["Topo Data"] = f"{elev_val} m" if elev_val else "N/A"
+            site["Seismic Data"] = seismic_val
+            site["Flood Data"] = flood_val
+            site["Environmental Data"] = {"Landcover": lc_stats, "NDVI": ndvi_ts}
+        st.session_state["soil_json"] = {
+            "Soil": soil_val, "Soil Band": chosen_soil_band,
+            "Elevation": elev_val, "Seismic": seismic_val,
+            "Flood": flood_val, "Landcover Stats": lc_stats,
+            "NDVI TS": ndvi_ts
+        }
+        # --- Save map snapshot ---
+        map_bytes = export_map_snapshot(m)
+        if map_bytes:
+            st.session_state["last_map_snapshot"] = map_bytes
+            if "sites" in st.session_state:
+                st.session_state["sites"][active]["map_snapshot"] = map_bytes
+            st.image(map_bytes, caption="Map Snapshot", use_column_width=True)
+
+        # Display
+        st.subheader("📊 Summary")
+        st.write(f"**Soil:** {soil_val}")
+        st.write(f"**Elevation:** {elev_val}")
+        st.write(f"**Seismic:** {seismic_val}")
+        st.write(f"**Flood:** {flood_val}")
+        st.json(lc_stats)
         if ndvi_ts:
-            dates = [d for d, v in ndvi_ts]
-            vals = [v for d, v in ndvi_ts]
-            fig2, ax2 = plt.subplots(figsize=(8,3))
-            ax2.plot(dates, vals, marker="o")
-            ax2.set_title("NDVI (mean) — last 2 years")
-            ax2.set_xlabel("Date")
-            ax2.set_ylabel("NDVI (scaled)")
-            plt.xticks(rotation=45)
-            st.pyplot(fig2)
-        else:
-            st.info("NDVI timeseries not available or too sparse.")
-
-        # Soil histogram (if available)
-        soil_hist = None
-        try:
-            soil_hist = soil_img.reduceRegion(
-                reducer=ee.Reducer.histogram(maxBuckets=20),
-                geometry=roi,
-                scale=1000,
-                maxPixels=int(5e7)
-            ).get(chosen_soil_band).getInfo() if (soil_img is not None and chosen_soil_band) else None
-        except Exception:
-            soil_hist = None
-
-        if soil_hist and isinstance(soil_hist, dict) and "bucketMeans" in soil_hist:
-            fig3, ax3 = plt.subplots(figsize=(6,4))
-            ax3.bar(soil_hist["bucketMeans"], soil_hist["histogram"], width= (soil_hist["bucketMeans"][1]-soil_hist["bucketMeans"][0]) if len(soil_hist["bucketMeans"])>1 else 1, color="saddlebrown")
-            ax3.set_title(f"Soil histogram ({chosen_soil_band})")
-            ax3.set_xlabel("Clay fraction (kg/kg)")
-            ax3.set_ylabel("Pixel count")
-            st.pyplot(fig3)
-
-        # ----------------------------
-        # Save results to session_state for reports
-        # ----------------------------
-        # Ensure sites and active site exist
-        if "sites" not in st.session_state or "active_site" not in st.session_state:
-            # just store soil_json if site structure not present
-            st.session_state["soil_json"] = {
-                "Soil": None if soil_val is None else float(soil_val),
-                "Soil Band": chosen_soil_band,
-                "Elevation": None if elev_val is None else float(elev_val),
-                "Seismic": None if seismic_val is None else float(seismic_val),
-                "Flood": None if flood_val is None else float(flood_val),
-                "Landcover Stats": lc_stats or {},
-                "NDVI TS": ndvi_ts or []
-            }
-            st.success("Saved results to st.session_state['soil_json']. (No active site present.)")
-        else:
-            # Save into active site JSON fields (keeping your field names unchanged)
-            active = st.session_state["active_site"]
-            try:
-                site_obj = st.session_state["sites"][active]
-            except Exception:
-                # if your sites is a list of dicts with Site ID matching idx, try to match
-                try:
-                    site_obj = st.session_state["sites"][int(active)]
-                except Exception:
-                    site_obj = None
-
-            # fallback: if site_obj is None just write soil_json and exit
-            if site_obj is None:
-                st.session_state["soil_json"] = {
-                    "Soil": None if soil_val is None else float(soil_val),
-                    "Soil Band": chosen_soil_band,
-                    "Elevation": None if elev_val is None else float(elev_val),
-                    "Seismic": None if seismic_val is None else float(seismic_val),
-                    "Flood": None if flood_val is None else float(flood_val),
-                    "Landcover Stats": lc_stats or {},
-                    "NDVI TS": ndvi_ts or []
-                }
-                st.success("Saved results to st.session_state['soil_json']. (Could not find active site object.)")
-            else:
-                # update the exact fields you requested (names unchanged)
-                site_obj["Soil Profile"] = f"{round(soil_val,3)} ({chosen_soil_band})" if soil_val is not None else "No data"
-                site_obj["Topo Data"] = f"{round(elev_val,2)} m (mean)" if elev_val is not None else "No data"
-                site_obj["Seismic Data"] = f"{round(seismic_val,4)}" if seismic_val is not None else "No data"
-                site_obj["Flood Data"] = f"{round(flood_val,2)} %" if flood_val is not None else "No data"
-                # Environmental Data: combine landcover summary + NDVI basic stats
-                env_summary = {
-                    "Landcover Histogram": lc_stats or {},
-                    "NDVI_timeseries_points": ndvi_ts or []
-                }
-                site_obj["Environmental Data"] = env_summary
-
-                # Save drawn polygon GeoJSON for future map restore and report inclusion
-                try:
-                    # fetch GeoJSON from ROI
-                    geojson = roi.toGeoJSON() if hasattr(roi, "toGeoJSON") else ee.Geometry(roi).getInfo()
-                    site_obj["drawn_polygon"] = geojson
-                except Exception:
-                    site_obj["drawn_polygon"] = None
-
-                # Save to soil_json as well (for report block that expects it)
-                st.session_state["soil_json"] = {
-                    "Soil": None if soil_val is None else float(soil_val),
-                    "Soil Band": chosen_soil_band,
-                    "Elevation": None if elev_val is None else float(elev_val),
-                    "Seismic": None if seismic_val is None else float(seismic_val),
-                    "Flood": None if flood_val is None else float(flood_val),
-                    "Landcover Stats": lc_stats or {},
-                    "NDVI TS": ndvi_ts or []
-                }
-                st.success("📑 Results saved to active site and st.session_state['soil_json'] for report integration.")
-
-        # Snapshot map as HTML and save path into site object (map snapshot - small HTML content)
-        try:
-            snap_html = m.to_html(None)  # returns HTML string if path None
-            # store minimal snapshot content into site or soil_json (may be large; consider storing link)
-            if "sites" in st.session_state and site_obj is not None:
-                site_obj["map_snapshot"] = snap_html  # caution: large string
-            st.session_state["last_map_snapshot"] = snap_html
-        except Exception:
-            pass
-
-    # end of Compute Summaries block
-
-# end locator_page()
+            d,v = zip(*ndvi_ts)
+            fig, ax = plt.subplots()
+            ax.plot(d, v, marker="o"); ax.set_title("NDVI"); ax.set_xlabel("Date")
+            st.pyplot(fig)
 
 # GeoMate Ask (RAG) — simple chat with memory per site and auto-extract numeric values
 import re, json, pickle