Update app.py

app.py

@@ -596,49 +596,82 @@ def build_full_geotech_pdf(site: Dict[str, Any], filename: str, include_map_imag
 if "sites" not in st.session_state:
     # initialize with a default site
     st.session_state["sites"] = [{
-        "Site Name":"home",
-        "Project Name": "Project ",
-        "Soil Class": None,
-        "Soil Recognizer Confidence": None,
-        "Site ID": None,
-        "Coordinates": "",
-        "lat": None,
-        "lon": None,
-        "Project Description": "",
-        # Site Characterization
-        "Topography": None,              # manual / descriptive topo entry
-        "Drainage": None,                # manual drainage notes
-        "Current Land Use": None,        # can be linked to Environmental Data
-        "Regional Geology": None,        # manual geology notes
-        # Investigations & Lab
-        "Field Investigation": [],
-        "Laboratory Results": [],
-        "GSD": None,
-        "USCS": None,
-        "AASHTO": None,
-        "GI": None,
-        # Geotechnical Parameters
-        "Load Bearing Capacity": None,
-        "Skin Shear Strength": None,
-        "Relative Compaction": None,
-        "Rate of Consolidation": None,
-        "Nature of Construction": None,
-        # Earth Engine Data
-        "Soil Profile": None,            # SoilGrids (clay/sand/silt etc.)
-        "Flood Data": None,              # JRC Global Surface Water
-        "Seismic Data": None,            # GSHAP Seismic hazard
-        "Environmental Data": None,      # Landcover, forest loss, urban
-        "Topo Data": None,               # SRTM DEM elevation
-        # Map & Visualization
-        "map_snapshot": None,
-        # AI / Reporting
-        "chat_history": [],
-        "classifier_inputs": {},
-        "classifier_decision": None,
-        "report_convo_state": 0,
-        "report_missing_fields": [],
-        "report_answers": {}
-     }]
+            "Site Name": None,
+            "Project Name": "Project",
+            "Site ID": None,
+            "Soil Class": None,
+            "Soil Recognizer Confidence": None,
+            "Coordinates": "",
+            "lat": None,
+            "lon": None,
+            "Project Description": "",
+            # ---------------------------
+            # Site Characterization
+            # ---------------------------
+            "Topography": None,              # manual topo entry
+            "Drainage": None,                # manual drainage notes
+            "Current Land Use": None,        # can be linked to Environmental Data
+            "Regional Geology": None,        # manual geology notes
+            # ---------------------------
+            # Investigations & Lab
+            # ---------------------------
+            "Field Investigation": [],
+            "Laboratory Results": [],
+            "GSD": None,
+            "USCS": None,
+            "AASHTO": None,
+            "GI": None,
+            # ---------------------------
+            # Geotechnical Parameters
+            # ---------------------------
+            "Load Bearing Capacity": None,
+            "Skin Shear Strength": None,
+            "Relative Compaction": None,
+            "Rate of Consolidation": None,
+            "Nature of Construction": None,
+            # ---------------------------
+            # Earth Engine Data
+            # ---------------------------
+            "Soil Profile": {                # SoilGrids (multi-parameter)
+            "Clay": None,                # e.g. % clay at 200 cm
+            "Sand": None,                # % sand
+            "Silt": None,                # % silt
+            "OrganicCarbon": None,       # % organic carbon
+            "pH": None                   # soil pH if available
+            },
+            "Topo Data": None,               # Avg elevation (SRTM DEM)
+            "Seismic Data": None,            # PGA/g (GEM hazard)
+            "Flood Data": None,              # JRC Surface Water occurrence
+            "Environmental Data": {          # Landcover, vegetation, urban, etc.
+            "Landcover Stats": None,     # histogram by class
+            "Forest Loss": None,         # future add: Hansen dataset
+            "Urban Fraction": None       # optional calc from landcover
+            },
+            "Weather Data": {                # daily/monthly climate summaries
+            "Rainfall": None,
+            "Temperature": None,
+            "Humidity": None
+            },
+            "Atmospheric Data": {            # optional: pollution, aerosols
+            "AerosolOpticalDepth": None,
+            "NO2": None,
+            "CO": None
+            },
+            # ---------------------------
+            # Map & Visualization
+            # ---------------------------
+            "map_snapshot": None,
+            # ---------------------------
+            # AI / Reporting
+            # ---------------------------
+            "chat_history": [],
+            "classifier_inputs": {},
+            "classifier_decision": None,
+            "report_convo_state": 0,
+            "report_missing_fields": [],
+            "report_answers": {}
+             })
+        
 
 if "active_site" not in st.session_state:
     st.session_state["active_site"] = 0
@@ -711,49 +744,82 @@ with st.sidebar:
             idx = len(st.session_state["sites"])
             #idx = len(st.session_state["sites"]) + 1
             st.session_state["sites"].append({
-                "Site Name": new_site_name.strip(),
-                "Project Name": "Project - " + new_site_name.strip(),
-                "Site ID": idx,
-                "Soil Class": None,
-                "Soil Recognizer Confidence": None,
-                "Coordinates": "",
-                "lat": None,
-                "lon": None,
-                "Project Description": "",
-                # Site Characterization
-                "Topography": None,              # manual / descriptive topo entry
-                "Drainage": None,                # manual drainage notes
-                "Current Land Use": None,        # can be linked to Environmental Data
-                "Regional Geology": None,        # manual geology notes
-                # Investigations & Lab
-                "Field Investigation": [],
-                "Laboratory Results": [],
-                "GSD": None,
-                "USCS": None,
-                "AASHTO": None,
-                "GI": None,
-                # Geotechnical Parameters
-                "Load Bearing Capacity": None,
-                "Skin Shear Strength": None,
-                "Relative Compaction": None,
-                "Rate of Consolidation": None,
-                "Nature of Construction": None,
-                # Earth Engine Data
-                "Soil Profile": None,            # SoilGrids (clay/sand/silt etc.)
-                "Flood Data": None,              # JRC Global Surface Water
-                "Seismic Data": None,            # GSHAP Seismic hazard
-                "Environmental Data": None,      # Landcover, forest loss, urban
-                "Topo Data": None,               # SRTM DEM elevation
-                # Map & Visualization
-                "map_snapshot": None,
-                # AI / Reporting
-                "chat_history": [],
-                "classifier_inputs": {},
-                "classifier_decision": None,
-                "report_convo_state": 0,
-                "report_missing_fields": [],
-                "report_answers": {}
-            })
+            "Site Name": new_site_name.strip(),
+            "Project Name": "Project - " + new_site_name.strip(),
+            "Site ID": idx,
+            "Soil Class": None,
+            "Soil Recognizer Confidence": None,
+            "Coordinates": "",
+            "lat": None,
+            "lon": None,
+            "Project Description": "",
+            # ---------------------------
+            # Site Characterization
+            # ---------------------------
+            "Topography": None,              # manual topo entry
+            "Drainage": None,                # manual drainage notes
+            "Current Land Use": None,        # can be linked to Environmental Data
+            "Regional Geology": None,        # manual geology notes
+            # ---------------------------
+            # Investigations & Lab
+            # ---------------------------
+            "Field Investigation": [],
+            "Laboratory Results": [],
+            "GSD": None,
+            "USCS": None,
+            "AASHTO": None,
+            "GI": None,
+            # ---------------------------
+            # Geotechnical Parameters
+            # ---------------------------
+            "Load Bearing Capacity": None,
+            "Skin Shear Strength": None,
+            "Relative Compaction": None,
+            "Rate of Consolidation": None,
+            "Nature of Construction": None,
+            # ---------------------------
+            # Earth Engine Data
+            # ---------------------------
+            "Soil Profile": {                # SoilGrids (multi-parameter)
+            "Clay": None,                # e.g. % clay at 200 cm
+            "Sand": None,                # % sand
+            "Silt": None,                # % silt
+            "OrganicCarbon": None,       # % organic carbon
+            "pH": None                   # soil pH if available
+            },
+            "Topo Data": None,               # Avg elevation (SRTM DEM)
+            "Seismic Data": None,            # PGA/g (GEM hazard)
+            "Flood Data": None,              # JRC Surface Water occurrence
+            "Environmental Data": {          # Landcover, vegetation, urban, etc.
+            "Landcover Stats": None,     # histogram by class
+            "Forest Loss": None,         # future add: Hansen dataset
+            "Urban Fraction": None       # optional calc from landcover
+            },
+            "Weather Data": {                # daily/monthly climate summaries
+            "Rainfall": None,
+            "Temperature": None,
+            "Humidity": None
+            },
+            "Atmospheric Data": {            # optional: pollution, aerosols
+            "AerosolOpticalDepth": None,
+            "NO2": None,
+            "CO": None
+            },
+            # ---------------------------
+            # Map & Visualization
+            # ---------------------------
+            "map_snapshot": None,
+            # ---------------------------
+            # AI / Reporting
+            # ---------------------------
+            "chat_history": [],
+            "classifier_inputs": {},
+            "classifier_decision": None,
+            "report_convo_state": 0,
+            "report_missing_fields": [],
+            "report_answers": {}
+             })
+
 
             st.success(f"Site '{new_site_name.strip()}' created.")
             st.session_state["active_site"] = idx
@@ -1006,18 +1072,35 @@ def ocr_page():
         else:
             st.warning("OCR not available in this deployment.")
 # Locator Page (with Earth Engine auth at top)
+
 import os
+import json
 import streamlit as st
 import geemap.foliumap as geemap
 import ee
 import matplotlib.pyplot as plt
+from datetime import datetime
+from io import BytesIO
+import base64
 
-# ----------------------------
-# ----------------------------
 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
+    """
+
+    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."
+    )
+
     # ----------------------------
-    # Earth Engine Initialization (service account or interactive)
-    # ----------------------------
+    # Use your existing EE init function if present
     EARTHENGINE_TOKEN = os.getenv("EARTHENGINE_TOKEN")
     SERVICE_ACCOUNT = os.getenv("SERVICE_ACCOUNT")  # optional: service account email
 
@@ -1056,89 +1139,117 @@ def locator_page():
         st.stop()
 
     # ----------------------------
-    # Helper functions
+    # 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
+
+    # ----------------------------
+    # Helper: safe reducers + caching
     # ----------------------------
-    def safe_get_reduce(region, image, band: str, scale: int, default=None, max_pixels=1e9):
+    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:
-            res = image.reduceRegion(
+            rr = image.reduceRegion(
                 reducer=ee.Reducer.mean(),
                 geometry=region,
-                scale=scale,
+                scale=int(scale),
                 maxPixels=int(max_pixels)
             )
-            val = res.get(band)
+            val = rr.get(band)
             if val is None:
+                cache[cache_key] = default
                 return default
-            return float(val.getInfo())
-        except Exception:
+            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 default
 
-    def safe_reduce_histogram(region, image, band: str, scale: int, max_pixels=1e9):
+    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:
-            hist = image.reduceRegion(
+            rr = image.reduceRegion(
                 reducer=ee.Reducer.frequencyHistogram(),
                 geometry=region,
-                scale=scale,
+                scale=int(scale),
                 maxPixels=int(max_pixels)
-            ).get(band)
+            )
+            val = rr.get(band)
+            if val is None:
+                cache[cache_key] = {}
+                return {}
+            hist = val.getInfo()
             if hist is None:
-                return None
-            return hist.getInfo()
-        except Exception:
-            return 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] = {}
+            return {}
 
-    def get_roi_from_map(m: geemap.Map):
-        """Try multiple ways to extract the ROI from the drawn shapes."""
-        candidates = [
-            getattr(m, "user_roi", None),
-            getattr(m, "last_drawn_geojson", None),
-            getattr(m, "draw_last_feature", None),
-            getattr(m, "draw_features", None),
-            getattr(m, "user_drawn_features", None),
-            getattr(m, "drawn_features", None),
-        ]
-        for c in candidates:
-            if c:
-                if isinstance(c, ee.Geometry):
-                    return c
-                try:
-                    if isinstance(c, dict):
-                        return ee.Geometry(c)
-                    if isinstance(c, list) and len(c) > 0 and isinstance(c[0], dict):
-                        return ee.Geometry(c[0])
-                except Exception:
-                    pass
+    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:
-            s = getattr(m, "draw_last_feature", None)
-            if s:
-                import json
-                if isinstance(s, str):
-                    return ee.Geometry(json.loads(s))
-        except Exception:
-            pass
-        return None
-
-    # ----------------------------
-    # Page title
-    # ----------------------------
-    st.title("🌍 GeoMate Interactive Earth Explorer")
-    st.markdown(
-        "Draw a polygon or rectangle on the map (use the drawing tool), then the app will compute "
-        "regional summaries (soil clay, elevation, seismic, flood occurrence, landcover distribution)."
-    )
+            # 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)
+                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 = []
+            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))
+            return []
 
     # ----------------------------
     # Map setup
     # ----------------------------
-    m = geemap.Map(center=[28.0, 72.0], zoom=4, draw_export=True)
+    m = geemap.Map(center=[28.0, 72.0], zoom=5, draw_export=True)
 
+    # enriched basemaps list (many options; geemap will ignore unknown)
     basemaps = [
         "HYBRID", "ROADMAP", "TERRAIN", "SATELLITE",
         "Esri.WorldImagery", "Esri.WorldTopoMap", "Esri.WorldShadedRelief",
         "Esri.NatGeoWorldMap", "Esri.OceanBasemap",
         "CartoDB.Positron", "CartoDB.DarkMatter",
         "Stamen.Terrain", "Stamen.Watercolor",
-        "OpenStreetMap",
+        "OpenStreetMap", "Esri.WorldGrayCanvas", "Esri.WorldStreetMap"
     ]
     for b in basemaps:
         try:
@@ -1147,128 +1258,389 @@ def locator_page():
             pass
 
     # ----------------------------
-    # Datasets
+    # Datasets (choose stable EE catalog IDs)
+    # Terrain (DEM) -> prefer NASADEM then SRTM fallback
     # ----------------------------
-    soil = ee.Image("OpenLandMap/SOL/SOL_CLAY-WFRACTION_USDA-4B1C_M/v01").select("b200")
-    soil_vis = {"min": 0, "max": 60, "palette": ["yellow", "brown", "red"]}
-    m.addLayer(soil, soil_vis, "Soil Clay (200cm)")
-
-    dem = ee.Image("USGS/SRTMGL1_003")
-    dem_vis = {"min": 0, "max": 4000, "palette": ["blue", "green", "brown", "white"]}
-    m.addLayer(dem, dem_vis, "Topography (SRTM DEM)")
-
-    seismic = ee.Image("GEM/2015/GlobalSeismicHazard").select("b0")
-    m.addLayer(seismic, {"min": 0, "max": 1, "palette": ["white", "red"]}, "Seismic Hazard")
-
-    water = ee.Image("JRC/GSW1_4/GlobalSurfaceWater").select("occurrence")
-    flood_vis = {"min": 0, "max": 100, "palette": ["white", "blue"]}
-    m.addLayer(water, flood_vis, "Flood Hazard")
-
-    landcover = ee.Image("ESA/WorldCover/v200/2021")
-    landcover_vis = {
-        "bands": ["Map"], "min": 10, "max": 100,
-        "palette": [
-            "006400", "ffbb22", "ffff4c", "f096ff", "fa0000",
-            "b4b4b4", "f0f0f0", "0064c8", "0096a0", "00cf75"
-        ]
-    }
-    m.addLayer(landcover, landcover_vis, "Landcover 2021")
+    # Try NASADEM (higher quality), fallback to SRTM:
+    try:
+        dem = ee.Image("NASA/NASADEM_HGT/001")  # NASADEM if available
+        dem_band_name = "elevation"
+    except Exception:
+        dem = ee.Image("USGS/SRTMGL1_003")
+        dem_band_name = "elevation"
 
-    # Boundaries & grid
-    countries = ee.FeatureCollection("USDOS/LSIB_SIMPLE/2017")
-    m.addLayer(
-        countries.style(**{"color": "black", "fillColor": "00000000", "width": 1}),
-        {}, "Country Boundaries"
-    )
-    states = ee.FeatureCollection("FAO/GAUL_SIMPLIFIED_500m/2015/level1")
-    m.addLayer(
-        states.style(**{"color": "purple", "fillColor": "00000000", "width": 0.5}),
-        {}, "State/Province Boundaries"
-    )
-    graticule = geemap.latlon_grid(5.0, region=ee.Geometry.Rectangle([-180, -90, 180, 90]))
-    m.addLayer(graticule.style(**{"color": "gray", "width": 0.5}), {}, "Lat/Lon Grid")
+    # ----------------------------
+    # Soil -> use OpenLandMap clay fraction (v02) which provides multiple bands like b0,b10,b30,... and is available
+    # (fallback to SoilGrids if OpenLandMap missing)
+    # ----------------------------
+    soil_img = None
+    soil_band = "b200"  # default deep band
+    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.
+    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"
+        except Exception:
+            soil_img = None
 
-    # Drawing tools
-    m.add_draw_control(polyline=False, circle=False, circlemarker=False, rectangle=True, polygon=True)
-    m.to_streamlit(height=700, responsive=True)
-    st.markdown("👉 Use the map drawing tool to select a polygon/rectangle.")
+    # ----------------------------
+    # Seismic -> attempt SEDAC GSHAP, then GEM
+    # ----------------------------
+    seismic_img = None
+    try:
+        seismic_img = ee.Image("SEDAC/GSHAPSeismicHazard")  # band "gshap"
+        seismic_band = "gshap"
+    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
 
     # ----------------------------
-    # ROI extraction
+    # Flood -> JRC Global Surface Water
     # ----------------------------
-    roi = get_roi_from_map(m)
-    if roi is None:
-        st.warning("⚠️ No polygon selected yet.")
-        return
+    try:
+        water = ee.Image("JRC/GSW1_4/GlobalSurfaceWater")
+        water_band = "occurrence"
+    except Exception:
+        water = None
+        water_band = None
 
+    # ----------------------------
+    # Landcover -> ESA WorldCover v200 (10 m) - "Map" band
+    # ----------------------------
     try:
-        if not isinstance(roi, ee.Geometry):
-            roi = ee.Geometry(roi)
+        landcover = ee.Image("ESA/WorldCover/v200")
+        lc_band = "Map"
     except Exception:
-        st.error("👎 Could not parse the drawn ROI into an Earth Engine geometry.")
-        return
+        landcover = None
+        lc_band = None
 
-    st.success("✅ Polygon selected! Computing regional summaries...")
+    # ----------------------------
+    # NDVI collection (MODIS 1km as robust global product)
+    # ----------------------------
+    try:
+        ndvi_col = ee.ImageCollection("MODIS/061/MOD13A2").select("NDVI")
+    except Exception:
+        ndvi_col = None
 
     # ----------------------------
-    # Compute stats
+    # Add layers to map (visuals)
     # ----------------------------
-    soil_val = safe_get_reduce(roi, soil, "b200", scale=1000, default=None)
-    elev_val = safe_get_reduce(roi, dem, "elevation", scale=1000, default=None)
-    seismic_val = safe_get_reduce(roi, seismic, "b0", scale=5000, default=None)
-    flood_val = safe_get_reduce(roi, water, "occurrence", scale=30, default=None)
-    lc_stats = safe_reduce_histogram(roi, landcover, "Map", scale=30)
-
-    def safe_display(x):
-        return "N/A" if x is None else round(x, 2)
-
-    st.subheader("📊 Regional Data Summary")
-    st.write(f"**Average Clay (200cm):** {safe_display(soil_val)} %")
-    st.write(f"**Average Elevation:** {safe_display(elev_val)} m")
-    st.write(f"**Seismic Hazard (PGA):** {safe_display(seismic_val)} g")
-    st.write(f"**Flood Occurrence Probability:** {safe_display(flood_val)} %")
-
-    if lc_stats:
-        labels = [str(k) for k in lc_stats.keys()]
-        values = list(lc_stats.values())
-        fig1, ax1 = plt.subplots(figsize=(6, 4))
-        ax1.pie(values, labels=labels, autopct="%1.1f%%", startangle=90)
-        ax1.set_title("Landcover Distribution")
-        st.pyplot(fig1)
+    # 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:
+        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})")
+        except Exception:
+            pass
+
+    # Seismic
+    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")
+        except Exception:
+            pass
 
+    # Flood
+    if water is not None:
+        try:
+            m.addLayer(water.select(water_band), {"min":0,"max":100,"palette":["white","blue"]}, "Water Occurrence (JRC)")
+        except Exception:
+            pass
+
+    # Landcover
+    if landcover is not None:
+        try:
+            m.addLayer(landcover, {"min":10,"max":100,"palette":["#006400","#ffbb22","#ffff4c","#f096ff","#fa0000","#b4b4b4","#f0f0f0","#0064c8","#0096a0","#00cf75"]}, "Landcover (WorldCover)")
+        except Exception:
+            pass
+
+    # Add country boundaries & graticule
     try:
-        soil_hist = soil.reduceRegion(
-            reducer=ee.Reducer.histogram(maxBuckets=10),
-            geometry=roi,
-            scale=1000,
-            maxPixels=1e9
-        ).get("b200").getInfo()
+        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")
+    except Exception:
+        pass
+
+    # Enable drawing
+    m.add_draw_control(polyline=False, circle=False, circlemarker=False, rectangle=True, polygon=True)
+    m.to_streamlit(height=700, responsive=True)
+    st.markdown("👉 Draw a polygon/rectangle on the map (draw tool). After drawing click **Compute Summaries**.")
+
+    # Button to compute summaries (we'll fetch ROI from map object)
+    if "compute_button" not in st.session_state:
+        st.session_state["compute_button"] = False
+    if st.button("Compute Summaries"):
+        st.session_state["compute_button"] = True
+
+    # get ROI helper (try multiple attributes)
+    def get_roi_from_map(m):
+        # preferred property
+        candidates = [
+            getattr(m, "user_roi", None),
+            getattr(m, "last_drawn_geojson", None),
+            getattr(m, "draw_last_feature", None),
+            getattr(m, "draw_features", None),
+            getattr(m, "user_drawn_features", None),
+            getattr(m, "drawn_features", None),
+        ]
+        for c in candidates:
+            if c:
+                # if it's already an ee.Geometry
+                if isinstance(c, ee.Geometry):
+                    return c
+                # if it's a GeoJSON dict
+                try:
+                    if isinstance(c, dict):
+                        return ee.Geometry(c)
+                    # sometimes geemap keeps features list
+                    if isinstance(c, list) and len(c) > 0 and isinstance(c[0], dict):
+                        return ee.Geometry(c[0])
+                    # string that is GeoJSON
+                    if isinstance(c, str):
+                        import json
+                        js = json.loads(c)
+                        if isinstance(js, dict):
+                            return ee.Geometry(js)
+                except Exception:
+                    pass
+        # try Map.draw_last_feature property
+        try:
+            s = getattr(m, "draw_last_feature", None)
+            if s:
+                import json
+                if isinstance(s, str):
+                    return ee.Geometry(json.loads(s))
+        except Exception:
+            pass
+        return None
+
+    # If user pressed compute, extract ROI and compute
+    if st.session_state.get("compute_button", False):
+        roi = get_roi_from_map(m)
+        if roi is None:
+            st.error("No drawn ROI found. Please draw a polygon/rectangle on the map using the draw tool and press Compute Summaries again.")
+            return
+
+        # ensure ROI is ee.Geometry
+        try:
+            if not isinstance(roi, ee.Geometry):
+                roi = ee.Geometry(roi)
+        except Exception:
+            st.error("Failed to parse ROI as Earth Engine geometry.")
+            return
+
+        st.success("Polygon found — computing (this may take a few seconds)...")
+
+        # choose soil depth via UI (0-200cm). If soil_img is OpenLandMap provide depth selection; if SoilGrids, show its bands
+        chosen_soil_band = None
+        if soil_img is not None:
+            try:
+                bands = soil_img.bandNames().getInfo()
+                # if OpenLandMap bands like b0,b10,... show friendly selector
+                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
+
+        # compute using safe helpers with conservative maxPixels and reasonable scales
+        # scales: soil 250-1000m, dem 90-1000m, seismic coarse 5000m, flood 30-250m, landcover 30m
+        soil_val = None
+        if soil_img is not None and chosen_soil_band is not None:
+            soil_val = safe_get_reduce(roi, soil_img.select(chosen_soil_band), chosen_soil_band, scale=1000, default=None, max_pixels=int(5e7))
+
+        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 = None
+        if seismic_img is not None and seismic_band is not None:
+            seismic_val = safe_get_reduce(roi, seismic_img, seismic_band, scale=5000, default=None, max_pixels=int(5e7))
+
+        flood_val = None
+        if water is not None and water_band is not None:
+            flood_val = safe_get_reduce(roi, water.select(water_band), water_band, scale=30, default=None, max_pixels=int(5e7))
+
+        # landcover histogram
+        lc_stats = {}
+        if landcover is not None and lc_band is not None:
+            lc_stats = safe_reduce_histogram(roi, landcover, lc_band, scale=30, max_pixels=int(5e7))
+
+        # NDVI timeseries (last 2 years) — provide small chart
+        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))
+
+        # ----------------------------
+        # 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
+        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
 
-    if soil_hist and isinstance(soil_hist, dict) and "bucketMeans" in soil_hist:
-        fig2, ax2 = plt.subplots(figsize=(6, 4))
-        ax2.bar(soil_hist["bucketMeans"], soil_hist["histogram"],
-                width=2, color="brown", alpha=0.7)
-        ax2.set_xlabel("Clay fraction (%)")
-        ax2.set_ylabel("Pixel count")
-        ax2.set_title("Soil Clay Distribution")
-        st.pyplot(fig2)
+    # end of Compute Summaries block
 
-    # ----------------------------
-    # Save for reports
-    # ----------------------------
-    if "soil_json" not in st.session_state:
-        st.session_state["soil_json"] = {}
-
-    st.session_state["soil_json"].update({
-        "Soil": f"{safe_display(soil_val)} %",
-        "Elevation": f"{safe_display(elev_val)} m",
-        "Seismic Hazard": f"{safe_display(seismic_val)} g",
-        "Flood Probability": f"{safe_display(flood_val)} %",
-        "Landcover Stats": lc_stats if lc_stats else {}
-    })
-    st.success("📑 Data saved to `soil_json` for report integration!")
+# end locator_page()
 
 # GeoMate Ask (RAG) — simple chat with memory per site and auto-extract numeric values
 def rag_page():