Update app.py

app.py

@@ -1005,7 +1005,270 @@ def ocr_page():
                 st.error(f"OCR failed: {e}")
         else:
             st.warning("OCR not available in this deployment.")
+# Locator Page (with Earth Engine auth at top)
+import os
+import streamlit as st
+import geemap.foliumap as geemap
+import ee
+import matplotlib.pyplot as plt
+
+# ----------------------------
+# ----------------------------
+def locator_page():
+    # ----------------------------
+    # Earth Engine Initialization (service account or interactive)
+    # ----------------------------
+    EARTHENGINE_TOKEN = os.getenv("EARTHENGINE_TOKEN")
+    SERVICE_ACCOUNT = os.getenv("SERVICE_ACCOUNT")  # optional: service account email
+
+    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
+                )
+                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...")
+
+        try:
+            ee.Initialize()
+            st.session_state["ee_initialized"] = True
+            return True
+        except Exception:
+            try:
+                ee.Authenticate()
+                ee.Initialize()
+                st.session_state["ee_initialized"] = True
+                return True
+            except Exception as e:
+                st.error(f"Earth Engine authentication failed: {e}")
+                return False
+
+    if not initialize_ee():
+        st.stop()
 
+    # ----------------------------
+    # Helper functions
+    # ----------------------------
+    def safe_get_reduce(region, image, band: str, scale: int, default=None, max_pixels=1e9):
+        try:
+            res = image.reduceRegion(
+                reducer=ee.Reducer.mean(),
+                geometry=region,
+                scale=scale,
+                maxPixels=int(max_pixels)
+            )
+            val = res.get(band)
+            if val is None:
+                return default
+            return float(val.getInfo())
+        except Exception:
+            return default
+
+    def safe_reduce_histogram(region, image, band: str, scale: int, max_pixels=1e9):
+        try:
+            hist = image.reduceRegion(
+                reducer=ee.Reducer.frequencyHistogram(),
+                geometry=region,
+                scale=scale,
+                maxPixels=int(max_pixels)
+            ).get(band)
+            if hist is None:
+                return None
+            return hist.getInfo()
+        except Exception:
+            return None
+
+    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
+        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)."
+    )
+
+    # ----------------------------
+    # Map setup
+    # ----------------------------
+    m = geemap.Map(center=[28.0, 72.0], zoom=4, draw_export=True)
+
+    basemaps = [
+        "HYBRID", "ROADMAP", "TERRAIN", "SATELLITE",
+        "Esri.WorldImagery", "Esri.WorldTopoMap", "Esri.WorldShadedRelief",
+        "Esri.NatGeoWorldMap", "Esri.OceanBasemap",
+        "CartoDB.Positron", "CartoDB.DarkMatter",
+        "Stamen.Terrain", "Stamen.Watercolor",
+        "OpenStreetMap",
+    ]
+    for b in basemaps:
+        try:
+            m.add_basemap(b)
+        except Exception:
+            pass
+
+    # ----------------------------
+    # Datasets
+    # ----------------------------
+    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")
+
+    # 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")
+
+    # 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.")
+
+    # ----------------------------
+    # ROI extraction
+    # ----------------------------
+    roi = get_roi_from_map(m)
+    if roi is None:
+        st.warning("⚠️ No polygon selected yet.")
+        return
+
+    try:
+        if not isinstance(roi, ee.Geometry):
+            roi = ee.Geometry(roi)
+    except Exception:
+        st.error("👎 Could not parse the drawn ROI into an Earth Engine geometry.")
+        return
+
+    st.success("✅ Polygon selected! Computing regional summaries...")
+
+    # ----------------------------
+    # Compute stats
+    # ----------------------------
+    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)
+
+    try:
+        soil_hist = soil.reduceRegion(
+            reducer=ee.Reducer.histogram(maxBuckets=10),
+            geometry=roi,
+            scale=1000,
+            maxPixels=1e9
+        ).get("b200").getInfo()
+    except Exception:
+        soil_hist = None
+
+    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)
+
+    # ----------------------------
+    # 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!")
 
 # GeoMate Ask (RAG) — simple chat with memory per site and auto-extract numeric values
 def rag_page():