Update app.py

app.py

@@ -515,4 +515,410 @@ def soil_classifier_ui():
             sel = st.selectbox("", DILATANCY_OPTIONS, index=0)
             if st.button("Submit dilatancy"):
                 ans = sel
-        elif key == "tou
+        elif key == "toughness":
+            sel = st.selectbox("", TOUGHNESS_OPTIONS, index=0)
+            if st.button("Submit toughness"):
+                ans = sel
+        elif key == "confirm":
+            if st.button("Classify now"):
+                ans = "go"
+
+        # process answer if provided
+        if ans is not None:
+            # save chat turn
+            site.setdefault("classifier_chat", []).append(("bot", qtext))
+            site["classifier_chat"].append(("user", str(ans)))
+            # map answers
+            if key == "organic_check":
+                site["classifier_inputs"]["opt"] = "y" if ans == "y" else "n"
+                site["classifier_state"] += 1
+            elif key in ("p2","p4","d60","d30","d10","ll","pl"):
+                # number input: get current value from widget
+                val = float(st.session_state.get(f"num_{key}", ans))
+                site["classifier_inputs"][key.upper() if key in ("p2","p4") else key.upper()] = val
+                # normalize keys consistent with uscs function: P2, P4, D60, D30, D10, LL, PL
+                # store lower-case keys also
+                if key == "p2":
+                    site["classifier_inputs"]["P2"] = val
+                elif key == "p4":
+                    site["classifier_inputs"]["P4"] = val
+                elif key == "d60":
+                    site["classifier_inputs"]["D60"] = val
+                elif key == "d30":
+                    site["classifier_inputs"]["D30"] = val
+                elif key == "d10":
+                    site["classifier_inputs"]["D10"] = val
+                elif key == "ll":
+                    site["classifier_inputs"]["LL"] = val
+                elif key == "pl":
+                    site["classifier_inputs"]["PL"] = val
+                site["classifier_state"] += 1
+            elif key == "d_values_known":
+                if ans == "yes":
+                    site["classifier_state"] += 1  # will ask D60 next
+                else:
+                    # redirect user to GSD curve page to upload/plot
+                    st.success("Please go to GSD Curve page to upload or paste your sieve analysis. After saving D10/D30/D60 there, return here and continue.")
+                    site["classifier_state"] += 3  # skip D60/D30/D10 questions for now
+            elif key == "dry_strength":
+                site["classifier_inputs"]["nDS"] = DRY_STRENGTH_MAP.get(ans, 5)
+                site["classifier_state"] += 1
+            elif key == "dilatancy":
+                site["classifier_inputs"]["nDIL"] = DILATANCY_MAP.get(ans, 6)
+                site["classifier_state"] += 1
+            elif key == "toughness":
+                site["classifier_inputs"]["nTG"] = TOUGHNESS_MAP.get(ans, 6)
+                site["classifier_state"] += 1
+            elif key == "confirm":
+                # classification step
+                # adapt keys to uscs function names
+                inps = {
+                    "opt": site["classifier_inputs"].get("opt","n"),
+                    "P2": site["classifier_inputs"].get("P2",0.0),
+                    "P4": site["classifier_inputs"].get("P4",0.0),
+                    "D60": site["classifier_inputs"].get("D60",0.0),
+                    "D30": site["classifier_inputs"].get("D30",0.0),
+                    "D10": site["classifier_inputs"].get("D10",0.0),
+                    "LL": site["classifier_inputs"].get("LL",0.0),
+                    "PL": site["classifier_inputs"].get("PL",0.0),
+                    "nDS": site["classifier_inputs"].get("nDS",5),
+                    "nDIL": site["classifier_inputs"].get("nDIL",6),
+                    "nTG": site["classifier_inputs"].get("nTG",6)
+                }
+                try:
+                    res_text, uscs, aashto, GI, expl, chars = uscs_aashto_logic(inps)
+                    site["USCS"] = uscs
+                    site["AASHTO"] = aashto
+                    site["GI"] = GI
+                    site["classifier_decision_path"] = res_text
+                    site["classifier_inputs"].update(inps)
+                    # Save classification to shared dict for quick access
+                    ss.soil_classifications[site.get("Site Name","Site")] = {
+                        "USCS": uscs, "AASHTO": aashto, "GI": GI, "inputs": inps, "decision_path": res_text
+                    }
+                    st.success("Classification complete. Results saved to site.")
+                    st.markdown("**Results**")
+                    st.markdown(res_text)
+                except Exception as e:
+                    st.error(f"Classification failed: {e}")
+                site["classifier_state"] = len(questions)  # finish
+            save_active_site(site)
+    else:
+        st.markdown("🟢 Classification flow completed. See saved results in the Results tab or site JSON.")
+
+# -----------------------------
+# --- GSD Curve UI
+# -----------------------------
+def gsd_curve_ui():
+    st.header("📊 Grain Size Distribution (GSD) Curve")
+    site = get_active_site()
+    if not site:
+        st.info("Create/select a site first.")
+        return
+    st.markdown("You can paste a comma-separated list of sieve diameters (mm) and corresponding % passing, or upload a CSV with two columns: diameter_mm, percent_passing.")
+    diameters_text = st.text_area("Diameters (mm) comma-separated (descending preferred)", value=site.get("GSD",{}).get("diameters_str","75,50,37.5,25,19,12.5,9.5,4.75,2,0.85,0.425,0.25,0.18,0.15,0.075"))
+    passing_text = st.text_area("% Passing comma-separated", value=site.get("GSD",{}).get("passing_str","100,98,96,90,85,78,72,65,55,45,35,25,18,14,8"))
+    uploaded = st.file_uploader("Or upload CSV (diameter_mm,percent_passing)", type=["csv"])
+    if uploaded:
+        try:
+            import pandas as pd
+            df = pd.read_csv(uploaded)
+            d = df.iloc[:,0].astype(float).tolist()
+            p = df.iloc[:,1].astype(float).tolist()
+        except Exception as e:
+            st.error(f"CSV parse failed: {e}")
+            return
+    else:
+        try:
+            d = [float(x.strip()) for x in diameters_text.split(",") if x.strip()]
+            p = [float(x.strip()) for x in passing_text.split(",") if x.strip()]
+        except Exception as e:
+            st.error(f"Parse error: {e}")
+            return
+    if len(d) != len(p):
+        st.error("Diameters and passing values must have same length.")
+        return
+    try:
+        # compute D10,D30,D60
+        D10 = interpolate_D_from_gsd(d,p,10.0)
+        D30 = interpolate_D_from_gsd(d,p,30.0)
+        D60 = interpolate_D_from_gsd(d,p,60.0)
+        Cu = D60 / D10 if D10>0 else 0
+        Cc = (D30**2) / (D10*D60) if (D10>0 and D60>0) else 0
+
+        # plot
+        fig, ax = plt.subplots(figsize=(6,4))
+        ax.semilogx(d, p, marker='o')
+        ax.set_xlabel("Particle size (mm) - log scale")
+        ax.set_ylabel("% Passing")
+        ax.set_title("Grain Size Distribution")
+        ax.grid(True, which='both', linestyle='--', linewidth=0.5)
+        # annotate D-values
+        ax.axhline(10, color='gray', linewidth=0.6, linestyle=':')
+        ax.axhline(30, color='gray', linewidth=0.6, linestyle=':')
+        ax.axhline(60, color='gray', linewidth=0.6, linestyle=':')
+        ax.annotate(f"D10={D10:.4g} mm", xy=(D10,10), xytext=(D10,15))
+        ax.annotate(f"D30={D30:.4g} mm", xy=(D30,30), xytext=(D30,40))
+        ax.annotate(f"D60={D60:.4g} mm", xy=(D60,60), xytext=(D60,70))
+        st.pyplot(fig)
+
+        if st.button("Save D-values to active site"):
+            site["GSD"] = {
+                "diameters": d, "passing": p,
+                "D10": D10, "D30": D30, "D60": D60,
+                "Cu": Cu, "Cc": Cc,
+                "diameters_str": diameters_text, "passing_str": passing_text
+            }
+            # also save D values into classifier inputs (if present)
+            site.setdefault("classifier_inputs", {})["D10"] = D10
+            site["classifier_inputs"]["D30"] = D30
+            site["classifier_inputs"]["D60"] = D60
+            save_active_site(site)
+            st.success("Saved D-values and GSD to site.")
+        st.markdown(f"D10 = {D10:.5g} mm, D30 = {D30:.5g} mm, D60 = {D60:.5g} mm, Cu = {Cu:.3g}, Cc = {Cc:.3g}")
+    except Exception as e:
+        st.error(f"GSD error: {e}")
+
+# -----------------------------
+# --- Locator UI (simple, EE optional)
+# -----------------------------
+def try_initialize_ee():
+    # attempt to initialize Earth Engine if secrets present
+    global EE_READY
+    if not EE_AVAILABLE:
+        return False
+    try:
+        import ee, geemap
+        key_json = st.secrets["EE_PRIVATE_KEY"]
+        service_account = st.secrets["SERVICE_ACCOUNT"]
+        # attempt init using ServiceAccountCredentials
+        try:
+            creds = ee.ServiceAccountCredentials(service_account, key_json)
+            ee.Initialize(creds)
+            EE_READY = True
+            return True
+        except Exception as e:
+            # try alternate (if key_json is a filepath)
+            try:
+                ee.Initialize()
+                EE_READY = True
+                return True
+            except Exception:
+                EE_READY = False
+                return False
+    except Exception:
+        EE_READY = False
+        return False
+
+def locator_ui():
+    st.header("🌍 Locator (chatbot + map)")
+    site = get_active_site()
+    if not site:
+        st.info("Create/select a site first.")
+        return
+    # Initialize EE if possible (lazy)
+    if ss.secrets_status.get("ee_key_found", False) and not EE_READY:
+        try_initialize_ee()
+
+    st.markdown("GeoMate: Please provide the site's center coordinates or paste a GeoJSON polygon in the box below.")
+    cols = st.columns(2)
+    lat = cols[0].number_input("Latitude", value=site.get("lat") or 0.0, format="%.6f")
+    lon = cols[1].number_input("Longitude", value=site.get("lon") or 0.0, format="%.6f")
+    geojson = st.text_area("Optional: Paste GeoJSON polygon for boundary", value="")
+    if st.button("Save coordinates & fetch data"):
+        # save coords
+        site["lat"] = lat
+        site["lon"] = lon
+        site["Site Coordinates"] = f"{lat:.6f}, {lon:.6f}"
+        save_active_site(site)
+        st.success("Coordinates saved to site.")
+        # fetch EE data if available
+        if EE_READY:
+            st.info("Fetching Earth Engine data (this may take a moment)...")
+            try:
+                import ee, geemap
+                # placeholder: set site fields
+                site["Soil Profile"] = f"EE soil profile placeholder at {lat},{lon}"
+                site["Flood Data"] = f"EE flood summary placeholder (20-year history)"
+                site["Seismic Data"] = f"EE seismic summary placeholder"
+                site["Topography"] = f"Elevation approx. {int(100+lat)%400} m (EE placeholder)"
+                # attempt to get a quick map snapshot via geemap (if supported)
+                try:
+                    m = geemap.Map(center=[lat, lon], zoom=10)
+                    # add a marker (geemap uses ipyleaflet/folium depending); to avoid complex saving, we'll capture a PNG via to_image if available
+                    try:
+                        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+                            m.to_image(outfile=tmp.name)
+                            site["map_snapshot"] = tmp.name
+                    except Exception:
+                        site["map_snapshot"] = None
+                except Exception:
+                    site["map_snapshot"] = None
+                save_active_site(site)
+                st.success("Earth Engine data saved to site.")
+            except Exception as e:
+                st.error(f"Earth Engine fetch failed: {e}")
+        else:
+            # fallback: save simple placeholders and create a simple static map image
+            site["Soil Profile"] = f"Sample soil summary at {lat},{lon}"
+            site["Flood Data"] = "Flood history: not available (EE not configured)."
+            site["Seismic Data"] = "Seismic data: not available (EE not configured)."
+            # create a simple static map-like image with a marker using matplotlib
+            fig, ax = plt.subplots(figsize=(6,3))
+            ax.text(0.5, 0.6, f"Map placeholder\n{site['Site Name']}\n{lat:.6f}, {lon:.6f}", ha='center', va='center', fontsize=12)
+            ax.axis("off")
+            tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+            fig.savefig(tmp.name, bbox_inches='tight', dpi=150)
+            plt.close(fig)
+            site["map_snapshot"] = tmp.name
+            save_active_site(site)
+            st.info("Map snapshot saved (placeholder).")
+
+# -----------------------------
+# --- Reports UI & PDF builder
+# -----------------------------
+def build_full_report_pdf(site: Dict[str,Any]) -> bytes:
+    """
+    Build a professional PDF using ReportLab, returns bytes.
+    """
+    buf = io.BytesIO()
+    doc = SimpleDocTemplate(buf, pagesize=A4, leftMargin=20*mm, rightMargin=20*mm, topMargin=20*mm, bottomMargin=15*mm)
+    styles = getSampleStyleSheet()
+    title_style = ParagraphStyle("title", parent=styles["Title"], fontSize=20, alignment=1, textColor=colors.HexColor("#FF7A00"))
+    h1 = ParagraphStyle("h1", parent=styles["Heading1"], fontSize=14, textColor=colors.HexColor("#1F4E79"))
+    body = ParagraphStyle("body", parent=styles["BodyText"], fontSize=10, leading=12)
+
+    elems = []
+    # cover
+    elems.append(Spacer(1,12))
+    elems.append(Paragraph("GEOTECHNICAL INVESTIGATION REPORT", title_style))
+    elems.append(Spacer(1,12))
+    info_data = [
+        ["Project", site.get("Site Name","-")],
+        ["Coordinates", site.get("Site Coordinates","-")],
+        ["Date", datetime.today().strftime("%Y-%m-%d")],
+    ]
+    t = Table(info_data, colWidths=[60*mm, 100*mm])
+    t.setStyle(TableStyle([("GRID",(0,0),(-1,-1),0.5,colors.grey)]))
+    elems.append(t)
+    elems.append(Spacer(1,12))
+
+    # Summary (dummy narrative assembled from site dict)
+    elems.append(Paragraph("SUMMARY", h1))
+    summary_lines = []
+    summary_lines.append(f"The site '{site.get('Site Name')}' was investigated using GeoMate V2 tools and available data.")
+    if site.get("USCS"):
+        summary_lines.append(f"Classification: USCS = {site.get('USCS')}, AASHTO = {site.get('AASHTO')} (GI = {site.get('GI')}).")
+    if site.get("Load Bearing Capacity"):
+        summary_lines.append(f"Reported bearing capacity: {site.get('Load Bearing Capacity')}.")
+    if site.get("Soil Profile"):
+        summary_lines.append(f"Soil profile summary: {site.get('Soil Profile')}")
+    for ln in summary_lines:
+        elems.append(Paragraph(ln, body))
+    elems.append(Spacer(1,8))
+
+    # Field & Lab table placeholders
+    elems.append(Paragraph("FIELD INVESTIGATION AND LABORATORY TESTING", h1))
+    elems.append(Paragraph("Field observations and laboratory test results are summarized below.", body))
+    lab_rows = []
+    # try to extract some lab-like info from site
+    if site.get("GSD"):
+        g = site["GSD"]
+        lab_rows.append(["GSD D10 (mm)", f"{g.get('D10', '-'):.5g}" if g.get('D10') else "-"])
+        lab_rows.append(["GSD D30 (mm)", f"{g.get('D30', '-'):.5g}" if g.get('D30') else "-"])
+        lab_rows.append(["GSD D60 (mm)", f"{g.get('D60', '-'):.5g}" if g.get('D60') else "-"])
+    # create table
+    if lab_rows:
+        t2 = Table([["Test","Value"]] + lab_rows, colWidths=[70*mm,80*mm])
+        t2.setStyle(TableStyle([("GRID",(0,0),(-1,-1),0.5,colors.grey),("BACKGROUND",(0,0),(-1,0),colors.HexColor("#1F4E79")),("TEXTCOLOR",(0,0),(-1,0),colors.white)]))
+        elems.append(t2)
+        elems.append(Spacer(1,8))
+
+    # Earth Engine section
+    elems.append(Paragraph("EARTH ENGINE / SITE DATA", h1))
+    elems.append(Paragraph(f"Soil profile: {site.get('Soil Profile','Not available')}", body))
+    elems.append(Paragraph(f"Flood data: {site.get('Flood Data','Not available')}", body))
+    elems.append(Paragraph(f"Seismic data: {site.get('Seismic Data','Not available')}", body))
+    elems.append(Paragraph(f"Topography: {site.get('Topography','Not available')}", body))
+    elems.append(Spacer(1,8))
+
+    # Insert map snapshot if present
+    if site.get("map_snapshot"):
+        try:
+            elems.append(Paragraph("Site Map", h1))
+            from reportlab.platypus import Image as RLImage
+            img_path = site["map_snapshot"]
+            im = RLImage(img_path, width=160*mm, height=90*mm)
+            elems.append(im)
+            elems.append(Spacer(1,8))
+        except Exception:
+            pass
+
+    # Evaluation & Recommendations (dummy, to be replaced by LLM if available)
+    elems.append(Paragraph("EVALUATION OF GEOTECHNICAL PROPERTIES", h1))
+    eval_text = site.get("classifier_decision_path","Detailed classification not available.")
+    elems.append(Paragraph(eval_text, body))
+    elems.append(Paragraph("RECOMMENDATIONS", h1))
+    recs = [
+        "Remove unconsolidated fill beneath foundation footprints.",
+        "Provide positive drainage away from structures.",
+        "Consider shallow foundations where competent soil is available at shallow depth; otherwise consider piled solutions."
+    ]
+    for r in recs:
+        elems.append(Paragraph(f"- {r}", body))
+
+    elems.append(PageBreak())
+    # appendices placeholder
+    elems.append(Paragraph("APPENDICES", h1))
+    elems.append(Paragraph("Borehole logs, laboratory tables and GSD curves are included in the appendices when available.", body))
+
+    doc.build(elems)
+    pdf_bytes = buf.getvalue()
+    buf.close()
+    return pdf_bytes
+
+def reports_ui():
+    st.header("📑 Reports")
+    site = get_active_site()
+    if not site:
+        st.info("Create/select a site first.")
+        return
+
+    st.markdown("GeoMate will ask a few final questions (chat-style) before generating the full geotechnical report.")
+    # simple chat-driven data collection
+    questions = [
+        ("Load Bearing Capacity","Please provide the design bearing capacity (e.g., '200 kPa' or '2000 psf')."),
+        ("Skin Shear Strength","What is the skin shear strength (if known)?"),
+        ("Relative Compaction","What relative % compaction should be used for imported fill? (e.g., 95%)"),
+        ("Rate of Consolidation","Provide the approximate consolidation rate (if known)."),
+        ("Nature of Construction","Describe nature of construction (Residential, Commercial, Road, Dam, etc.)")
+    ]
+    state = site.get("report_convo_state",0)
+    # display chat bubbles
+    if "report_chat" not in site:
+        site["report_chat"] = []
+    for sender, msg in site["report_chat"]:
+        if sender == "bot":
+            st.markdown(f"<div style='background:#111;padding:8px;border-radius:8px;color:#FF8C00;'>🤖 {msg}</div>", unsafe_allow_html=True)
+        else:
+            st.markdown(f"<div style='background:#0b0b0b;padding:8px;border-radius:8px;color:#9fd3ff;text-align:right'>👤 {msg}</div>", unsafe_allow_html=True)
+
+    if state < len(questions):
+        key, qtext = questions[state]
+        st.markdown(f"**GeoMate:** {qtext}")
+        ans = st.text_input("", key=f"report_input_{state}")
+        if st.button("Submit answer", key=f"report_submit_{state}"):
+            # save if not skip/dk
+            if ans.strip().lower() not in ["", "don't know", "dk", "skip", "n/a"]:
+                site[key] = ans.strip()
+            site.setdefault("report_chat", []).append(("bot", qtext))
+            site["report_chat"].append(("user", ans.strip()))
+            site["report_convo_state"] = state + 1
+            save_active_site(site)
+            st.experimental_rerun()
+    else:
+        st.success("All questions complete for report generation.")
+        if st.button("Generate Full Geotechnical Report (PDF)"):
+            with st.spinner("Building PDF..."):
+                pdf_bytes = build_full_report_pdf(site)
+            st.download_button("Download Report PDF", data=pdf_bytes, file_name=f"GeoMate_FullReport_{site.get('Site Name','site')}.pdf", mime="application/pdf")