Update app.py

app.py

@@ -1,1095 +1,102 @@
-# app.py
-"""
-GeoMate - Final integrated Gradio application
-Features:
-- USCS & AASHTO classification using your exact CLI logic
-- Soil recognition (PyTorch model 'soil_model.pth' if present)
-- Sieve Analysis (plot PSD on semi-log, find D60,D30,D10 via interpolation)
-- Problem solvers (bearing capacity, slope stability, consolidation, seepage, compaction)
-- LLM Geotech expert conclusion (uses GROQ_API_l_KEY env var if provided)
-- Styled PDF export with GeoMate logo, orange/black/red borders, decision path in PDF
-- Multi-tab futuristic GUI (icons, martian background option)
-"""
+""" GeoMate: Soil Engineering Toolkit 🌍
 
-# ---- SECTION: Imports ----
-import os
-import math
-from math import floor
-import datetime
-import tempfile
-from io import BytesIO
-import base64
+A complete geotechnical engineering assistant for soil classification, analysis, and design.
 
-import numpy as np
-import matplotlib
-matplotlib.use('Agg')
-import matplotlib.pyplot as plt
+===================== 🚀 Features =====================
 
-import torch
-import torch.nn as nn
-import torchvision.transforms as transforms
-import torchvision.models as models
-from PIL import Image
+📷 Soil Type Classifier — Upload image to identify soil type via PyTorch model
 
-import gradio as gr
-from reportlab.pdfgen import canvas
-from reportlab.lib.pagesizes import A4
-from reportlab.lib.colors import HexColor
-from reportlab.lib.utils import ImageReader
+🤖 Ask GeoMate — AI-based chat powered by Groq (LLaMA 70B)
 
-# ---- SECTION: Environment / LLM config ----
-import os
-import torch
-import torch.nn as nn
-import torchvision.models as models
-import torchvision.transforms as transforms
+🧪 Soil Classification — USCS and AASHTO classification systems
 
-# Using HF secret key stored under name "Shah"
-GROQ_API_KEY = os.environ.get("Shah")
-GROQ_MODEL_NAME = "llama-3.3-70b-versatile"
+🏗️ Engineering Calculators: • Bearing Capacity • Slope Stability • Consolidation Settlement • Seepage Flow • Compaction Density
 
-client = None
-if GROQ_API_KEY:
-    try:
-        from groq import Groq
-        client = Groq(api_key=GROQ_API_KEY)
-        print("Groq LLM client initialized successfully.")
-    except Exception as e:
-        client = None
-        print("Groq init failed:", e)
-else:
-    print("No API key found for 'Shah'. LLM features will be disabled.")
+📄 PDF Generator — Download summary reports
 
-# ---- SECTION: Soil Image Model setup ----
-class SoilClassifierNet(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.base_model = models.resnet18(weights=None)
-        num_f = self.base_model.fc.in_features
-        self.base_model.fc = nn.Linear(num_f, 1)
 
-    def forward(self, x):
-        return self.base_model(x)
+===================== 🔧 Tech Stack =====================
 
-soil_model = None
-transform = transforms.Compose([
-    transforms.Resize((224, 224)),
-    transforms.ToTensor(),
-    transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
-])
+Gradio (UI)
 
-try:
-    if os.path.exists("soil_model.pth"):
-        soil_model = SoilClassifierNet()
-        soil_model.load_state_dict(torch.load("soil_model.pth", map_location="cpu"))
-        soil_model.eval()
-        print("Loaded soil_model.pth successfully.")
-    else:
-        print("soil_model.pth not found — image recognition disabled.")
-except Exception as e:
-    soil_model = None
-    print("Error loading soil model:", e)
-# ---- SECTION: Global SESSION storage ----
-SESSION = {
-    "choice": None,
-    "uscs": {
-        "opt_organic": None, "P2": None, "P4": None, "enter_Dvals": None,
-        "D60": None, "D30": None, "D10": None,
-        "LL": None, "PL": None, "nDS": None, "nDIL": None, "nTG": None,
-        "result": None, "path": []
-    },
-    "aashto": {
-        "P2": None, "P4": None, "LL": None, "PL": None, "P1": None,
-        "result": None, "GI": None, "path": []
-    },
-    "solver_outputs": {},
-    "chat_history": [],
-    "sieve": {
-        "sieve_sizes": None,  # mm
-        "percent_finer": None,
-        "D10": None, "D30": None, "D60": None,
-        "Cu": None, "Cc": None
-    }
-}
+PyTorch (Image Classifier)
 
-# ---- SECTION: Utility helpers ----
-def parse_float_label(label, v, allow_empty=False, minimum=None, maximum=None):
-    if v is None or (isinstance(v,str) and v.strip()==""):
-        if allow_empty:
-            return None, None
-        return None, f"{label} required."
-    try:
-        num = float(v)
-    except Exception:
-        return None, f"{label} must be numeric."
-    if minimum is not None and num < minimum:
-        return None, f"{label} must be >= {minimum}."
-    if maximum is not None and num > maximum:
-        return None, f"{label} must be <= {maximum}."
-    return num, None
+Groq API (AI Chat)
 
-def split_text(text, chars=95):
-    words = str(text).split()
-    lines = []
-    cur = ""
-    for w in words:
-        if len(cur) + len(w) + 1 <= chars:
-            cur = (cur + " " + w).strip()
-        else:
-            lines.append(cur)
-            cur = w
-    if cur:
-        lines.append(cur)
-    return lines
+ReportLab (PDF Export)
 
-# ---- SECTION: SOIL DESCRIPTIONS (relevant items only) ----
-SOIL_DESCRIPTIONS = {
-    "GW": {"name":"GW — Well-graded gravel","desc":"Well-graded gravel. Excellent drainage, high shear strength.","notes":"High bearing capacity; minimal settlement; good for subbase/drainage."},
-    "GP": {"name":"GP — Poorly-graded gravel","desc":"Uniform gravel with poorer gradation.","notes":"Good drainage but lower interlock; careful compaction required."},
-    "GM": {"name":"GM — Silty gravel","desc":"Gravel with silt-sized fines.","notes":"Lower permeability; may need stabilization."},
-    "GC": {"name":"GC — Clayey gravel","desc":"Gravel with clay fines.","notes":"Poor drainage; plasticity concerns."},
-    "SW": {"name":"SW — Well-graded sand","desc":"Well-graded sand.","notes":"Good drainage and bearing; possible liquefaction if loose & saturated."},
-    "SP": {"name":"SP — Poorly-graded sand","desc":"Uniform sand.","notes":"Lower interlock; erosion concerns."},
-    "SM": {"name":"SM — Silty sand","desc":"Sand with silt.","notes":"Lower drainage; frost-susceptible."},
-    "SC": {"name":"SC — Clayey sand","desc":"Sand with clay fines.","notes":"May show plastic behavior; treat before use."},
-    "ML": {"name":"ML — Inorganic silt","desc":"Fine silt low plasticity.","notes":"Low strength; frost-susceptible."},
-    "OL": {"name":"OL — Organic silt","desc":"Organic fines.","notes":"Highly compressible; avoid for foundations."},
-    "CL": {"name":"CL — Lean clay","desc":"Low to medium plasticity clay.","notes":"Moderate compressibility; some swell-shrink."},
-    "CH": {"name":"CH — Fat clay","desc":"High plasticity clay.","notes":"Low bearing capacity; high settlement."},
-    "MH": {"name":"MH — Organic silts (high PI)","desc":"High-plasticity organic silts.","notes":"Problematic for foundations."},
-    "OH": {"name":"OH — Organic clays (high PI)","desc":"Organic clays.","notes":"Very compressible."},
-    "Pt": {"name":"Pt — Peat","desc":"Highly organic peat.","notes":"Very compressible; extensive ground improvement needed."},
-    "A-1-a": {"name":"A-1-a","desc":"Clean sands & gravels.","notes":"Excellent subgrade material."},
-    "A-1-b": {"name":"A-1-b","desc":"Sands & gravels with some fines.","notes":"Generally acceptable with compaction control."},
-    "A-2-4": {"name":"A-2-4","desc":"Sands & gravels with some fines","notes":"Acceptable with care."},
-    "A-2-5": {"name":"A-2-5","desc":"Sands & gravels with higher LL fines","notes":"May need attention."},
-    "A-2-6": {"name":"A-2-6","desc":"Sands with PI≥11","notes":"Variable behaviour."},
-    "A-2-7": {"name":"A-2-7","desc":"Sands with high PI fines","notes":"Less desirable."},
-    "A-3": {"name":"A-3","desc":"Fine sands","notes":"Compaction required."},
-    "A-4": {"name":"A-4","desc":"Silts - low plasticity","notes":"Frost-susceptible."},
-    "A-5": {"name":"A-5","desc":"Silts - higher LL","notes":"Moisture sensitive."},
-    "A-6": {"name":"A-6","desc":"Clays low plasticity","notes":"Moderate strength."},
-    "A-7-5": {"name":"A-7-5","desc":"High plasticity clays, GI condition","notes":"Poor subgrade unless treated."},
-    "A-7-6": {"name":"A-7-6","desc":"High plasticity clays, worse behaviour","notes":"Often requires stabilization."}
-}
 
-# ---- SECTION: Exact CLI logic (USCS & AASHTO) - kept identical to your corrected logic ----
-def classify_uscs_from_session(uscs):
-    path = []
-    opt = uscs["opt_organic"]
-    if opt is None:
-        path.append("Organic check not provided.")
-        return None, path
-    if str(opt).lower() == 'y':
-        path.append("Organic contents detected → Pt")
-        return "Pt", path
+===================== ✅ Hugging Face Deployment =====================
 
-    P2 = uscs["P2"]
-    if P2 is None:
-        path.append("P2 missing.")
-        return None, path
-    path.append(f"P2 = {P2}%")
+1. Create a new Space on https://huggingface.co/spaces
 
-    if P2 <= 50:
-        P4 = uscs["P4"]
-        if P4 is None:
-            path.append("P4 missing.")
-            return None, path
-        path.append(f"P4 = {P4}%")
 
-        op = uscs.get("enter_Dvals", "n")
-        if op and str(op).lower() == 'y':
-            if uscs["D60"] is None or uscs["D30"] is None or uscs["D10"] is None:
-                path.append("D60/D30/D10 required but missing.")
-                return None, path
-            D60 = uscs["D60"]; D30 = uscs["D30"]; D10 = uscs["D10"]
-            path.append(f"D60={D60}, D30={D30}, D10={D10}")
-        else:
-            D60 = uscs["D60"] or 0
-            D30 = uscs["D30"] or 0
-            D10 = uscs["D10"] or 0
-            path.append("D values not entered by user (treated as 0).")
+2. Choose Gradio SDK
 
-        LL = uscs["LL"]; PL = uscs["PL"]
-        if LL is None or PL is None:
-            path.append("LL/PL missing.")
-            return None, path
-        PI = LL - PL
-        path.append(f"LL={LL}, PL={PL}, PI={PI}")
 
-        if D60 != 0 and D30 != 0 and D10 != 0:
-            Cu = D60 / D10 if D10!=0 else float('inf')
-            Cc = (D30 ** 2) / (D10 * D60) if (D10*D60)!=0 else float('inf')
-        else:
-            Cu = 0; Cc = 0
-        path.append(f"Cu={Cu}, Cc={Cc}")
+3. Upload:
 
-        if P4 <= 50:
-            path.append("Gravel branch (P4 <= 50).")
-            if Cu != 0 and Cc != 0:
-                if Cu >= 4 and 1 <= Cc <= 3:
-                    path.append("Cu >= 4 and 1 <= Cc <= 3 → GW")
-                    return "GW", path
-                elif (Cu < 4 and 1 <= Cc <= 3) == False:
-                    path.append("(Cu < 4 and 1 <= Cc <= 3) == False → GP")
-                    return "GP", path
-            if PI < 4 or PI < 0.73 * (LL - 20):
-                path.append("PI < 4 or PI < 0.73*(LL-20) → GM")
-                return "GM", path
-            elif PI > 7 and PI > 0.73 * (LL - 20):
-                path.append("PI > 7 and PI > 0.73*(LL-20) → GC")
-                return "GC", path
-            else:
-                path.append("Else → GM-GC")
-                return "GM-GC", path
-        else:
-            path.append("Sand branch (P4 > 50).")
-            if Cu != 0 and Cc != 0:
-                if Cu >= 6 and 1 <= Cc <= 3:
-                    path.append("Cu >= 6 and 1 <= Cc <= 3 → SW")
-                    return "SW", path
-                elif (Cu < 6 and 1 <= Cc <= 3) == False:
-                    path.append("(Cu < 6 and 1 <= Cc <= 3) == False → SP")
-                    return "SP", path
-            if PI < 4 or PI <= 0.73 * (LL - 20):
-                path.append("PI < 4 or PI <= 0.73*(LL-20) → SM")
-                return "SM", path
-            elif PI > 7 and PI > 0.73 * (LL - 20):
-                path.append("PI > 7 and PI > 0.73*(LL-20) → SC")
-                return "SC", path
-            else:
-                path.append("Else → SM-SC")
-                return "SM-SC", path
-    else:
-        LL = uscs["LL"]; PL = uscs["PL"]
-        if LL is None or PL is None:
-            path.append("LL/PL missing for fine-grained branch.")
-            return None, path
-        PI = LL - PL
-        path.append(f"Fine branch: LL={LL}, PL={PL}, PI={PI}")
-        nDS = uscs["nDS"]; nDIL = uscs["nDIL"]; nTG = uscs["nTG"]
-        if nDS is None or nDIL is None or nTG is None:
-            path.append("nDS/nDIL/nTG missing.")
-            return None, path
-        path.append(f"nDS={nDS}, nDIL={nDIL}, nTG={nTG}")
+app.py
 
-        if LL < 50:
-            path.append("LL < 50 → Low plasticity fines.")
-            if 20 <= LL < 50 and PI <= 0.73 * (LL - 20):
-                path.append("20 ≤ LL < 50 and PI ≤ 0.73*(LL-20)")
-                if nDS == 1 or nDIL == 3 or nTG == 3:
-                    path.append("→ ML"); return "ML", path
-                elif nDS == 3 or nDIL == 3 or nTG == 3:
-                    path.append("→ OL"); return "OL", path
-                else:
-                    path.append("→ ML-OL"); return "ML-OL", path
-            elif 10 <= LL <= 30 and 4 <= PI <= 7 and PI > 0.72 * (LL - 20):
-                path.append("10 ≤ LL ≤ 30 and 4 ≤ PI ≤ 7 and PI > 0.72*(LL-20)")
-                if nDS == 1 or nDIL == 1 or nTG == 1:
-                    path.append("→ ML"); return "ML", path
-                elif nDS == 2 or nDIL == 2 or nTG == 2:
-                    path.append("→ CL"); return "CL", path
-                else:
-                    path.append("→ ML-CL"); return "ML-CL", path
-            else:
-                path.append("Else → CL"); return "CL", path
-        else:
-            path.append("LL ≥ 50 → High plasticity fines.")
-            if PI < 0.73 * (LL - 20):
-                path.append("PI < 0.73*(LL-20)")
-                if nDS == 3 or nDIL == 4 or nTG == 4:
-                    path.append("→ MH"); return "MH", path
-                elif nDS == 2 or nDIL == 2 or nTG == 4:
-                    path.append("→ OH"); return "OH", path
-                else:
-                    path.append("→ MH-OH"); return "MH-OH", path
-            else:
-                path.append("Else → CH"); return "CH", path
+requirements.txt
 
-def classify_aashto_from_inputs(P2, P4, LL, PL, P1=None):
-    path = []
-    PI = LL - PL
-    path.append(f"P200={P2}%, P40={P4}%, LL={LL}, PL={PL} → PI={PI}")
+README.md
 
-    Result = None
-    if P2 <= 35:
-        path.append("P200 ≤ 35 → Granular materials.")
-        if P2 <= 15 and P4 <= 30 and PI <= 6:
-            path.append("P200 ≤15 and P40 ≤30 and PI ≤6 → Candidate A-1-a.")
-            if P1 is None:
-                path.append("P1 necessary for A-1-a decision (missing).")
-                return None, path
-            if P1 <= 50:
-                Result = "A-1-a"; path.append(f"P1={P1} ≤ 50 → A-1-a")
-            else:
-                path.append("P1 > 50 → inconsistent for A-1-a."); return None, path
-        elif P2 <= 25 and P4 <= 50 and PI <= 6:
-            Result = "A-1-b"; path.append("P200 ≤25 and P40 ≤50 and PI ≤6 → A-1-b")
-        elif P2 <= 35 and P4 > 0:
-            path.append("P200 ≤35 and P40 > 0 → A-2 subgroup.")
-            if LL <= 40 and PI <= 10:
-                Result = "A-2-4"; path.append("LL ≤ 40 and PI ≤10 → A-2-4")
-            elif LL >= 41 and PI <= 10:
-                Result = "A-2-5"; path.append("LL ≥41 and PI ≤10 → A-2-5")
-            elif LL <= 40 and PI >= 11:
-                Result = "A-2-6"; path.append("LL ≤40 and PI ≥11 → A-2-6")
-            elif LL >= 41 and PI >= 11:
-                Result = "A-2-7"; path.append("LL ≥41 and PI ≥11 → A-2-7")
-        else:
-            Result = "A-3"; path.append("Else → A-3")
-    else:
-        path.append("P200 > 35 → Silt-Clay branch.")
-        if LL <= 40 and PI <= 10:
-            Result = "A-4"; path.append("LL ≤40 and PI ≤10 → A-4")
-        elif LL >= 41 and PI <= 10:
-            Result = "A-5"; path.append("LL ≥41 and PI ≤10 → A-5")
-        elif LL <= 40 and PI >= 11:
-            Result = "A-6"; path.append("LL ≤40 and PI ≥11 → A-6")
-        else:
-            if PI <= (LL - 30):
-                Result = "A-7-5"; path.append("PI ≤ LL-30 → A-7-5")
-            elif PI > (LL - 30):
-                Result = "A-7-6"; path.append("PI > LL-30 → A-7-6")
-            else:
-                path.append("Error in inputs."); return None, path
+soil_model.pth
 
-    # Group Index as provided
-    a = P2 - 35
-    if a <= 40 and a >= 0:
-        a = a
-    elif a < 0:
-        a = 0
-    else:
-        a = 40
 
-    b = P2 - 15
-    if b <= 40 and b >= 0:
-        b = b
-    elif b < 0:
-        b = 0
-    else:
-        b = 40
 
-    c = LL - 40
-    if c <= 20 and c >= 0:
-        c = c
-    elif c < 0:
-        c = 0
-    else:
-        c = 20
+4. Add Secret Key: GROQ_API_KEY
 
-    d = PI - 10
-    if d <= 20 and d >= 0:
-        d = d
-    elif d < 0:
-        d = 0
-    else:
-        d = 20
 
-    GI = floor(0.2*a + 0.005*a*c + 0.01*b*d)
-    path.append(f"Group Index calculation: a={a},b={b},c={c},d={d} → GI={GI}")
-    Result_with_GI = f"{Result} ({GI})"
-    path.append(f"Final AASHTO: {Result_with_GI}")
-    return Result_with_GI, path
 
-# ---- SECTION: LLM wrapper for short geotech conclusion (≤150 words) ----
-def get_geotech_expert_conclusion(context_text):
-    if client is None:
-        return "LLM unavailable (set environment variable GROQ_API_l_KEY to enable expert conclusions)."
-    prompt = (
-        "You are GeoMate, a professional geotechnical engineer. "
-        "Given the following soil data, classification results and solver outputs, "
-        "write a concise geotechnical conclusion (no more than 150 words) with practical recommendations and critical cautions.\n\n"
-        f"Context:\n{context_text}\n\nConclusion:"
-    )
-    try:
-        resp = client.chat.completions.create(
-            model=GROQ_MODEL_NAME,
-            messages=[{"role":"user","content":prompt}]
-        )
-        ans = resp.choices[0].message.content.strip()
-        # limit to ~150 words
-        words = ans.split()
-        if len(words) > 160:
-            ans = " ".join(words[:160]) + " ..."
-        return ans
-    except Exception as e:
-        return f"LLM call failed: {e}"
+Use AI for smarter soil engineering 💡 """
 
-# ---- SECTION: Problem solvers (same as earlier) ----
-def bearing_capacity_solver(q, unit, Nq, B):
-    try:
-        qv = float(q)
-        if unit == "psf":
-            q_conv = qv * 0.04788
-        else:
-            q_conv = qv
-        res = q_conv * float(Nq) * float(B)
-        out = f"Ultimate bearing capacity (approx): {round(res,2)} kN/m² (q converted: {round(q_conv,3)} kN/m²)"
-        SESSION["solver_outputs"]["bearing_capacity"] = out
-        return out
-    except Exception as e:
-        return f"Error: {e}"
+import os import gradio as gr import torch import torchvision.transforms as transforms from PIL import Image from groq import Groq from reportlab.lib.pagesizes import A4 from reportlab.pdfgen import canvas import tempfile
 
-def slope_stability_solver(c, phi, gamma, height):
-    try:
-        phi_r = math.radians(float(phi))
-        fs = (float(c) + float(gamma)*float(height)*math.tan(phi_r)) / (float(gamma)*float(height))
-        out = f"Factor of Safety (approx): {round(fs,3)}"
-        SESSION["solver_outputs"]["slope_stability"] = out
-        return out
-    except Exception as e:
-        return f"Error: {e}"
+Load model
 
-def consolidation_solver(delta_sigma, mv, H):
-    try:
-        settlement = float(mv) * float(delta_sigma) * float(H)
-        out = f"Estimated consolidation settlement: {round(settlement,3)} m"
-        SESSION["solver_outputs"]["consolidation"] = out
-        return out
-    except Exception as e:
-        return f"Error: {e}"
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = torch.load("soil_model.pth", map_location=device) model.eval()
 
-def seepage_solver(k, i, A):
-    try:
-        q = float(k)*float(i)*float(A)
-        out = f"Seepage discharge: {round(q,6)} m³/s"
-        SESSION["solver_outputs"]["seepage"] = out
-        return out
-    except Exception as e:
-        return f"Error: {e}"
+transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), ])
 
-def compaction_solver(W, V):
-    try:
-        dry_density = float(W)/float(V)
-        out = f"Dry density: {round(dry_density,3)} kN/m³"
-        SESSION["solver_outputs"]["compaction"] = out
-        return out
-    except Exception as e:
-        return f"Error: {e}"
+classes = ['Clay', 'Silt', 'Sand', 'Gravel']
 
-# ---- SECTION: Sieve analysis utilities (plotting & interpolation) ----
-def parse_sieve_input(text_or_csv):
-    """
-    Accepts CSV-like text with two columns: sieve_size_mm, percent_finer
-    Returns numpy arrays sorted by size descending (for plotting)
-    """
-    lines = [ln.strip() for ln in text_or_csv.strip().splitlines() if ln.strip()]
-    sizes = []
-    perc = []
-    for ln in lines:
-        parts = [p for p in ln.replace(",", " ").split() if p]
-        if len(parts) < 2: continue
-        try:
-            s = float(parts[0])
-            p = float(parts[1])
-        except:
-            continue
-        sizes.append(s)
-        perc.append(p)
-    if not sizes:
-        return None, None
-    arr = np.array(sizes), np.array(perc)
-    # sort by sieve size descending
-    idx = np.argsort(arr[0])[::-1]
-    return arr[0][idx], arr[1][idx]
+def classify_image(img): image = transform(img).unsqueeze(0).to(device) with torch.no_grad(): output = model(image) _, predicted = torch.max(output, 1) return classes[predicted.item()]
 
-def compute_D_values(sizes_mm, perc_finer):
-    """
-    Sizes: descending array (mm), perc_finer: same shape
-    Interpolate to find D10,D30,D60 (phi vs log size)
-    We'll interpolate percent finer vs log(size) using linear interpolation.
-    """
-    # avoid zeros or duplicates, ensure positive sizes
-    mask = sizes_mm > 0
-    sizes = sizes_mm[mask]
-    perc = perc_finer[mask]
-    if len(sizes) < 2:
-        return None, None, None
-    # transform to log10(size)
-    logd = np.log10(sizes)
-    # interpolation function perc -> logd (we need size at certain percent finer)
-    # But perc is % finer (0-100), not monotonic necessarily — ensure monotonic by interpolation over perc
-    # For interpolation, perc should be increasing with decreasing size (since sizes descending)
-    # We'll create arrays sorted by perc ascending
-    order = np.argsort(perc)
-    perc_sort = perc[order]
-    logd_sort = logd[order]
-    # if duplicates in perc_sort, use unique with average logd
-    perc_unique, idx_first = np.unique(perc_sort, return_index=True)
-    # If perc_unique too small, fallback to linear interp on original
-    try:
-        D10_log = np.interp(10.0, perc_sort, logd_sort)
-        D30_log = np.interp(30.0, perc_sort, logd_sort)
-        D60_log = np.interp(60.0, perc_sort, logd_sort)
-    except Exception:
-        return None, None, None
-    D10 = 10 ** D10_log
-    D30 = 10 ** D30_log
-    D60 = 10 ** D60_log
-    return D10, D30, D60
+Groq AI Chat
 
-def plot_sieve_curve(sizes_mm, perc_finer):
-    """
-    Create PSD plot (percent finer vs particle size) with x axis log scale.
-    Return PNG bytes.
-    """
-    fig, ax = plt.subplots(figsize=(6,3.5))
-    ax.semilogx(sizes_mm, perc_finer, marker='o', linestyle='-', linewidth=1.5)
-    ax.set_xlabel("Particle size (mm) - log scale")
-    ax.set_ylabel("% Passing (finer)")
-    ax.set_title("Particle Size Distribution (PSD)")
-    ax.grid(which='both', linestyle='--', linewidth=0.5)
-    ax.set_xlim(max(sizes_mm)*1.1, min(sizes_mm)*0.001)  # show descending
-    ax.set_ylim(-5,105)
-    # invert x for conventional left-to-right large->small
-    ax.invert_xaxis()
-    buf = BytesIO()
-    plt.tight_layout()
-    fig.savefig(buf, format='png', dpi=150)
-    plt.close(fig)
-    buf.seek(0)
-    return buf.getvalue()
+groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
 
-# ---- SECTION: PDF generator ----
-def generate_report_pdf(logo_bytes=None):
-    ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=f"_GeoMate_Report_{ts}.pdf")
-    path = tmp.name
-    tmp.close()
+def ask_geomate(prompt): chat_completion = groq_client.chat.completions.create( messages=[{"role": "user", "content": prompt}], model="llama3-70b-8192" ) return chat_completion.choices[0].message.content
 
-    c = canvas.Canvas(path, pagesize=A4)
-    w, h = A4
-    orange = HexColor("#ff6600")
-    black = HexColor("#000000")
-    red = HexColor("#cc0000")
-    margin = 20
+Soil classification
 
-    # outer orange border
-    c.setStrokeColor(orange); c.setLineWidth(3)
-    c.rect(margin/2, margin/2, w - margin, h - margin, stroke=1, fill=0)
-    # inner black border
-    c.setStrokeColor(black); c.setLineWidth(1.2)
-    c.rect(margin+6, margin+6, w - 2*(margin+6), h - 2*(margin+6), stroke=1, fill=0)
+def classify_uscs(symbol, fines_percent): if symbol.startswith("G"): if fines_percent < 5: return "Well-graded Gravel (GW)" if "W" in symbol else "Poorly-graded Gravel (GP)" elif 5 <= fines_percent <= 12: return "Gravel with Fines (GW-GM or GW-GC)" else: return "Silty or Clayey Gravel (GM/GC)" elif symbol.startswith("S"): if fines_percent < 5: return "Well-graded Sand (SW)" if "W" in symbol else "Poorly-graded Sand (SP)" elif 5 <= fines_percent <= 12: return "Sand with Fines (SW-SM or SW-SC)" else: return "Silty or Clayey Sand (SM/SC)" elif symbol.startswith("M"): return "Silt (ML)" elif symbol.startswith("C"): return "Clay (CL)" return "Check symbol"
 
-    y = h - 50
-    # logo if provided
-    if logo_bytes:
-        try:
-            logo = Image.open(BytesIO(logo_bytes))
-            lw = 70
-            lh = int((logo.size[1]/logo.size[0]) * lw)
-            logo = logo.resize((lw, lh))
-            buf = BytesIO(); logo.save(buf, format="PNG"); buf.seek(0)
-            c.drawImage(ImageReader(buf), margin + 10, y - lh, width=lw, height=lh)
-        except Exception:
-            pass
+def classify_aashto(percent_passing_no200): if percent_passing_no200 < 35: return "Granular Soil (A-1 to A-3)" else: return "Silty-Clay Soil (A-4 to A-7)"
 
-    c.setFont("Helvetica-Bold", 18); c.setFillColor(black)
-    c.drawString(margin + 100, y - 8, "GeoMate - Soil Classification Report")
-    c.setFont("Helvetica", 9); c.drawString(margin + 100, y - 26, f"Generated: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    y -= 70
+Calculators
 
-    # Selected systems
-    c.setFont("Helvetica-Bold", 12); c.drawString(margin + 10, y, "Selected System(s):")
-    c.setFont("Helvetica", 11); c.drawString(margin + 150, y, str(SESSION.get("choice")))
-    y -= 22
+def bearing_capacity(q, Nq, sc, dc, ic): return q * Nq * sc * dc * ic
 
-    # USCS result
-    if SESSION["uscs"]["result"]:
-        res = SESSION["uscs"]["result"]
-        c.setFont("Helvetica-Bold", 12); c.drawString(margin + 10, y, "USCS Classification:")
-        c.setFont("Helvetica", 11); c.drawString(margin + 150, y, res); y -= 18
-        info = SOIL_DESCRIPTIONS.get(res)
-        if info:
-            c.setFont("Helvetica-Bold", 11); c.drawString(margin + 10, y, "Relevant USCS Notes:")
-            y -= 14
-            c.setFont("Helvetica", 10)
-            txt = info.get("desc","") + " " + info.get("notes","")
-            for line in split_text(txt, 95):
-                c.drawString(margin + 12, y, line); y -= 12
-            y -= 6
+def slope_stability(factor_safety, slope_angle): return "Stable" if factor_safety > 1.5 else "Unstable"
 
-    # AASHTO result
-    if SESSION["aashto"]["result"]:
-        ares = SESSION["aashto"]["result"]
-        c.setFont("Helvetica-Bold", 12); c.drawString(margin + 10, y, "AASHTO Classification:")
-        c.setFont("Helvetica", 11); c.drawString(margin + 150, y, ares); y -= 18
-        code = ares.split()[0]
-        info = SOIL_DESCRIPTIONS.get(code)
-        if info:
-            c.setFont("Helvetica-Bold", 11); c.drawString(margin + 10, y, "Relevant AASHTO Notes:")
-            y -= 14
-            c.setFont("Helvetica", 10)
-            txt = info.get("desc","") + " " + info.get("notes","")
-            for line in split_text(txt, 95):
-                c.drawString(margin + 12, y, line); y -= 12
-            y -= 6
+def consolidation_settlement(H, Cv, t): return (Cv * t) / (H**2)
 
-    # Sieve outputs
-    s = SESSION["sieve"]
-    if s.get("D10") is not None:
-        c.setFont("Helvetica-Bold", 12); c.drawString(margin + 10, y, "Sieve Analysis:")
-        y -= 16
-        c.setFont("Helvetica", 10)
-        c.drawString(margin + 12, y, f"D10={round(s['D10'],5)} mm, D30={round(s['D30'],5)} mm, D60={round(s['D60'],5)} mm")
-        y -= 14
-        c.drawString(margin + 12, y, f"Cu={round(s['Cu'],3)}, Cc={round(s['Cc'],3)}")
-        y -= 18
+def seepage_flow(K, H, L): return K * H / L
 
-    # Problem solver outputs
-    if SESSION["solver_outputs"]:
-        c.setFont("Helvetica-Bold", 12); c.drawString(margin + 10, y, "Problem Solver Outputs:")
-        y -= 16
-        c.setFont("Helvetica", 10)
-        for k, v in SESSION["solver_outputs"].items():
-            for line in split_text(f"{k.replace('_',' ').title()}: {v}", 95):
-                c.drawString(margin + 12, y, line); y -= 12
-            y -= 6
+def compaction_density(W, V): return W / V
 
-    # Build LLM context
-    ctx = []
-    ctx.append(f"Selected systems: {SESSION.get('choice')}")
-    if SESSION["uscs"]["result"]:
-        ctx.append(f"USCS: {SESSION['uscs']['result']}")
-    if SESSION["aashto"]["result"]:
-        ctx.append(f"AASHTO: {SESSION['aashto']['result']}")
-    us = SESSION["uscs"]; aa = SESSION["aashto"]
-    ctx.append(f"USCS inputs: P2={us.get('P2')}, P4={us.get('P4')}, LL={us.get('LL')}, PL={us.get('PL')}, D60={us.get('D60')}, D30={us.get('D30')}, D10={us.get('D10')}, nDS={us.get('nDS')}, nDIL={us.get('nDIL')}, nTG={us.get('nTG')}")
-    ctx.append(f"AASHTO inputs: P2={aa.get('P2')}, P4={aa.get('P4')}, LL={aa.get('LL')}, PL={aa.get('PL')}, P1={aa.get('P1')}")
-    if SESSION["solver_outputs"]:
-        ctx.append("Solver outputs:")
-        for k,v in SESSION["solver_outputs"].items():
-            ctx.append(f"{k}: {v}")
-    context_text = "\n".join(ctx)
+PDF Generator
 
-    # LLM conclusion
-    c.setFont("Helvetica-Bold", 12); c.drawString(margin + 10, y, "Geotech Expert Conclusion:")
-    y -= 16
-    conclusion = get_geotech_expert_conclusion(context_text) if client is not None else "LLM unavailable. Set env var GROQ_API_l_KEY to enable."
-    c.setFont("Helvetica", 10)
-    for line in split_text(conclusion, 95):
-        c.drawString(margin + 12, y, line); y -= 12
-    y -= 8
+def generate_pdf(text): with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp: c = canvas.Canvas(tmp.name, pagesize=A4) width, height = A4 text_obj = c.beginText(40, height - 50) text_obj.setFont("Helvetica", 12) for line in text.split("\n"): text_obj.textLine(line) c.drawText(text_obj) c.showPage() c.save() return tmp.name
 
-    # Decision path (small font) at bottom
-    c.setFont("Helvetica-Bold", 10); c.drawString(margin + 10, 110, "Decision Path (internal):")
-    ypos = 96
-    c.setFont("Helvetica", 8)
-    for step in SESSION["aashto"]["path"]:
-        for line in split_text(step, 120):
-            c.drawString(margin + 12, ypos, "- " + line); ypos -= 8
-            if ypos < 20:
-                c.showPage(); ypos = h - 40
-    for step in SESSION["uscs"]["path"]:
-        for line in split_text(step, 120):
-            c.drawString(margin + 12, ypos, "- " + line); ypos -= 8
-            if ypos < 20:
-                c.showPage(); ypos = h - 40
+Gradio Interface
 
-    c.save()
-    return path
+tab1 = gr.Interface(fn=classify_image, inputs=gr.Image(type="pil"), outputs="text", title="Soil Image Classifier") tab2 = gr.Interface(fn=ask_geomate, inputs=gr.Textbox(), outputs="text", title="Ask GeoMate") tab3 = gr.Interface(fn=classify_uscs, inputs=[gr.Textbox(label="USCS Symbol"), gr.Number(label="% Fines")], outputs="text", title="USCS Classification") tab4 = gr.Interface(fn=classify_aashto, inputs=gr.Number(label="% Passing No. 200"), outputs="text", title="AASHTO Classification") tab5 = gr.Interface(fn=bearing_capacity, inputs=[gr.Number(), gr.Number(), gr.Number(), gr.Number(), gr.Number()], outputs="number", title="Bearing Capacity") tab6 = gr.Interface(fn=slope_stability, inputs=[gr.Number(), gr.Number()], outputs="text", title="Slope Stability") tab7 = gr.Interface(fn=consolidation_settlement, inputs=[gr.Number(), gr.Number(), gr.Number()], outputs="number", title="Consolidation Settlement") tab8 = gr.Interface(fn=seepage_flow, inputs=[gr.Number(), gr.Number(), gr.Number()], outputs="number", title="Seepage Flow") tab9 = gr.Interface(fn=compaction_density, inputs=[gr.Number(), gr.Number()], outputs="number", title="Compaction Density") tab10 = gr.Interface(fn=generate_pdf, inputs=gr.Textbox(lines=10, placeholder="Paste your summary here"), outputs="file", title="📄 Generate PDF Report")
 
-# ---- SECTION: Wizard flow helpers for Gradio classification tab ----
-DRY_STRENGTH_OPTIONS = ["1. Non-Slight","2. Med-high","3. Slight-Med","4. High-V.high","5. Null"]
-DILATANCY_OPTIONS = ["1. Quick-slow","2. None-V.slow","3. Slow","4. Slow-none","5. None","6. Null"]
-TOUGHNESS_OPTIONS = ["1. None","2. Med","3. Slight","4. Slight-Med","5. High","6. Null"]
+demo = gr.TabbedInterface([tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8, tab9, tab10], tab_names=["Image Classifier", "Ask GeoMate", "USCS", "AASHTO", "Bearing", "Slope", "Consolidation", "Seepage", "Compaction", "📄 Generate PDF"])
 
-def wizard_start(choice):
-    SESSION["choice"] = choice
-    SESSION["uscs"]["path"] = []
-    SESSION["uscs"]["result"] = None
-    SESSION["aashto"]["path"] = []
-    SESSION["aashto"]["result"] = None
-    SESSION["solver_outputs"] = {}
-    return "uscs_org", "Does the soil contain organic contents, feels spongy or has odour? (enter 'y' or 'n')", ""
+demo.launch()
 
-def wizard_next(prompt_id, value):
-    us = SESSION["uscs"]; aa = SESSION["aashto"]
-    # replicate the CLI flow; return (next_prompt_id, prompt_text, status_message, finished_bool)
-    if prompt_id == "uscs_org":
-        ans = str(value).strip().lower() if value is not None else ""
-        if ans not in ("y","n"): return "uscs_org", "Enter 'y' or 'n' please.", "Invalid input.", False
-        us["opt_organic"] = ans; us["path"].append(f"Organic: {ans}")
-        if ans == 'y':
-            us["result"] = "Pt"; us["path"].append("→ Pt")
-            if SESSION["choice"] == "Both":
-                return "aashto_P2", "% Passing sieve no. 200 (P2) for AASHTO:", "USCS Pt done; continue AASHTO.", False
-            return None, None, "USCS classification: Pt (Peat).", True
-        else:
-            return "uscs_P2", "% Passing sieve no. 200 (P2):", "", False
-
-    if prompt_id == "uscs_P2":
-        num, err = parse_float_label("P2", value, False, 0, 100)
-        if err: return "uscs_P2", "% Passing sieve no. 200 (P2):", err, False
-        us["P2"] = num; us["path"].append(f"P2={num}%")
-        if num <= 50:
-            return "uscs_P4", "% Passing sieve no. 4 (P4):", "", False
-        else:
-            return "uscs_fine_LL", "Liquid limit (LL):", "", False
-
-    if prompt_id == "uscs_P4":
-        num, err = parse_float_label("P4", value, False, 0, 100)
-        if err: return "uscs_P4", "% Passing sieve no. 4 (P4):", err, False
-        us["P4"] = num; us["path"].append(f"P4={num}%"); return "uscs_op_D", "Enter D? (y/n):", "", False
-
-    if prompt_id == "uscs_op_D":
-        ans = str(value).strip().lower() if value is not None else ""
-        if ans not in ("y","n"): return "uscs_op_D", "Enter 'y' or 'n':", "Invalid", False
-        us["enter_Dvals"] = ans; us["path"].append(f"enter_Dvals={ans}")
-        if ans == 'y':
-            return "uscs_D60", "Enter D60 (mm):", "", False
-        else:
-            us["D60"] = 0; us["D30"] = 0; us["D10"] = 0; us["path"].append("D-values set to 0")
-            return "uscs_LL", "Enter liquid limit (LL):", "", False
-
-    if prompt_id == "uscs_D60":
-        num, err = parse_float_label("D60", value, False, 0.0, None)
-        if err: return "uscs_D60", "D60 (mm):", err, False
-        us["D60"] = num; us["path"].append(f"D60={num}mm"); return "uscs_D30", "Enter D30 (mm):", "", False
-
-    if prompt_id == "uscs_D30":
-        num, err = parse_float_label("D30", value, False, 0.0, None)
-        if err: return "uscs_D30", "D30 (mm):", err, False
-        us["D30"] = num; us["path"].append(f"D30={num}mm"); return "uscs_D10", "Enter D10 (mm):", "", False
-
-    if prompt_id == "uscs_D10":
-        num, err = parse_float_label("D10", value, False, 0.0, None)
-        if err: return "uscs_D10", "D10 (mm):", err, False
-        us["D10"] = num; us["path"].append(f"D10={num}mm"); return "uscs_LL", "Enter liquid limit (LL):", "", False
-
-    if prompt_id == "uscs_LL":
-        num, err = parse_float_label("LL", value, False, 0.0, None)
-        if err: return "uscs_LL", "Liquid limit (LL):", err, False
-        us["LL"] = num; us["path"].append(f"LL={num}"); return "uscs_PL", "Enter plastic limit (PL):", "", False
-
-    if prompt_id == "uscs_PL":
-        num, err = parse_float_label("PL", value, False, 0.0, None)
-        if err: return "uscs_PL", "Plastic limit (PL):", err, False
-        us["PL"] = num; us["path"].append(f"PL={num}")
-        # classify
-        res, path = classify_uscs_from_session(us)
-        if res is None:
-            us["path"].extend(path)
-            return None, None, "USCS classification incomplete: " + "; ".join(path), False
-        us["result"] = res; us["path"].extend(path)
-        if SESSION["choice"] == "Both":
-            return "aashto_P2", "% Passing sieve no. 200 (P2) for AASHTO:", f"USCS done: {res}. Continue AASHTO.", False
-        return None, None, f"USCS classification completed: {res}", True
-
-    # fine branch prompts
-    if prompt_id == "uscs_fine_LL":
-        num, err = parse_float_label("LL", value, False, 0.0, None)
-        if err: return "uscs_fine_LL", "LL:", err, False
-        us["LL"] = num; us["path"].append(f"LL={num}"); return "uscs_fine_PL", "PL:", "", False
-
-    if prompt_id == "uscs_fine_PL":
-        num, err = parse_float_label("PL", value, False, 0.0, None)
-        if err: return "uscs_fine_PL", "PL:", err, False
-        us["PL"] = num; us["path"].append(f"PL={num}"); return "uscs_fine_nDS", "Select Dry Strength (nDS):", "", False
-
-    if prompt_id == "uscs_fine_nDS":
-        try:
-            n = int(str(value).split(".")[0]) if isinstance(value, str) else int(value)
-        except:
-            return "uscs_fine_nDS", "Select nDS:", "Invalid selection", False
-        if not (1 <= n <= 5): return "uscs_fine_nDS", "Select nDS:", "Invalid", False
-        us["nDS"] = n; us["path"].append(f"nDS={n}"); return "uscs_fine_nDIL", "Select Dilatancy (nDIL):", "", False
-
-    if prompt_id == "uscs_fine_nDIL":
-        try:
-            n = int(str(value).split(".")[0]) if isinstance(value, str) else int(value)
-        except:
-            return "uscs_fine_nDIL", "Select nDIL:", "Invalid selection", False
-        if not (1 <= n <= 6): return "uscs_fine_nDIL", "Select nDIL:", "Invalid", False
-        us["nDIL"] = n; us["path"].append(f"nDIL={n}"); return "uscs_fine_nTG", "Select Toughness (nTG):", "", False
-
-    if prompt_id == "uscs_fine_nTG":
-        try:
-            n = int(str(value).split(".")[0]) if isinstance(value, str) else int(value)
-        except:
-            return "uscs_fine_nTG", "Select nTG:", "Invalid selection", False
-        if not (1 <= n <= 6): return "uscs_fine_nTG", "Select nTG:", "Invalid", False
-        us["nTG"] = n; us["path"].append(f"nTG={n}")
-        res, path = classify_uscs_from_session(us)
-        if res is None:
-            us["path"].extend(path)
-            return None, None, "USCS classification incomplete: " + "; ".join(path), False
-        us["result"] = res; us["path"].extend(path)
-        if SESSION["choice"] == "Both":
-            return "aashto_P2", "% Passing sieve no. 200 (P2) for AASHTO:", f"USCS done: {res}. Continue AASHTO.", False
-        return None, None, f"USCS classification completed: {res}", True
-
-    # AASHTO branch
-    if prompt_id == "aashto_P2":
-        num, err = parse_float_label("P2", value, False, 0, 100)
-        if err: return "aashto_P2", "% Passing sieve no. 200 (P2):", err, False
-        aa["P2"] = num; aa["path"] = [f"P2={num}%"]; return "aashto_P4", "% Passing sieve no. 40 (P4) (0 if none):", "", False
-
-    if prompt_id == "aashto_P4":
-        num, err = parse_float_label("P4", value, True, 0, 100)
-        if err: return "aashto_P4", "% Passing sieve no. 40 (P4):", err, False
-        aa["P4"] = 0 if num is None else num; aa["path"].append(f"P4={aa['P4']}%"); return "aashto_LL", "LL:", "", False
-
-    if prompt_id == "aashto_LL":
-        num, err = parse_float_label("LL", value, False, 0, None)
-        if err: return "aashto_LL", "LL:", err, False
-        aa["LL"] = num; aa["path"].append(f"LL={num}"); return "aashto_PL", "PL:", "", False
-
-    if prompt_id == "aashto_PL":
-        num, err = parse_float_label("PL", value, False, 0, None)
-        if err: return "aashto_PL", "PL:", err, False
-        aa["PL"] = num; aa["path"].append(f"PL={num}")
-        result, path = classify_aashto_from_inputs(aa["P2"], aa["P4"], aa["LL"], aa["PL"], aa.get("P1"))
-        if result is None:
-            aa["path"].extend(path)
-            if any("A-1-a" in p or "Candidate A-1-a" in p for p in path):
-                return "aashto_P1", "% Passing sieve no. 10 (P1) required:", "", False
-            return None, None, "AASHTO classification incomplete: " + "; ".join(path), False
-        aa["result"] = result; aa["path"].extend(path)
-        try:
-            aa["GI"] = int(result.split("(")[-1].split(")")[0])
-        except:
-            aa["GI"] = None
-        return None, None, f"AASHTO classification completed: {result}", True
-
-    if prompt_id == "aashto_P1":
-        num, err = parse_float_label("P1", value, False, 0, 100)
-        if err: return "aashto_P1", "% Passing sieve no. 10 (P1):", err, False
-        aa["P1"] = num; aa["path"].append(f"P1={num}%")
-        result, path = classify_aashto_from_inputs(aa["P2"], aa["P4"], aa["LL"], aa["PL"], aa["P1"])
-        if result is None:
-            aa["path"].extend(path); return None, None, "AASHTO classification incomplete: " + "; ".join(path), False
-        aa["result"] = result; aa["path"].extend(path)
-        try: aa["GI"] = int(result.split("(")[-1].split(")")[0])
-        except: aa["GI"] = None
-        return None, None, f"AASHTO classification completed: {result}", True
-
-    return None, None, "Unhandled state; restart wizard.", False
-
-# ---- SECTION: Gradio UI ----
-# We will create a multi-tab futuristic interface with icons.
-with gr.Blocks(title="GeoMate 🌍 - Soil Engineering Toolkit") as demo:
-    # style: black background with accent colors via HTML/CSS
-    css = """
-    body { background-color: #0b0b0b; color: #ffffff; }
-    .gm-title { text-align:center; font-size:26px; font-weight:700; color:#ff6600; margin-bottom:6px; }
-    .gm-sub { text-align:center; color:#ffb199; margin-bottom:18px; }
-    .tab-btn { background: linear-gradient(90deg, rgba(255,102,0,0.12), rgba(204,0,0,0.06)); border-radius:8px; padding:8px; }
-    """
-    gr.HTML(f"<style>{css}</style>")
-    gr.Markdown("<div class='gm-title'>🌍 GeoMate - Soil Engineering Toolkit</div>", elem_id="title")
-    gr.Markdown("<div class='gm-sub'>Futuristic interface • Black – Orange – Red theme • Martian background optional</div>")
-
-    # Tabs
-    with gr.Tab("🏠 Home"):
-        gr.Markdown("### Welcome to GeoMate")
-        gr.Markdown("Use the tabs to navigate: Soil Recognition, Classification, Sieve Analysis, Problem Solvers, LLM Expert, Report.")
-        gr.Markdown("Tip: Set environment variable `GROQ_API_l_KEY` to enable LLM expert (Report will include a concise expert conclusion).")
-
-    with gr.Tab("📷 Soil Recognition"):
-        gr.Markdown("Upload soil image; model (soil_model.pth) will predict. If model not present, this is disabled.")
-        img_in = gr.Image(type="pil", label="Upload Soil Image")
-        img_pred = gr.Textbox(label="Image Model Output", interactive=False)
-        def do_image_pred(img):
-            if img is None:
-                return "No image."
-            if soil_model is None:
-                return "Image model not configured (soil_model.pth missing)."
-            try:
-                im = img.convert("RGB")
-                t = transform(im).unsqueeze(0)
-                with torch.no_grad():
-                    out = soil_model(t)
-                    raw = float(out.item()); prob = float(torch.sigmoid(out).item())
-                SESSION["chat_history"].append(("Image prediction", f"raw={raw:.4f}, prob={prob:.4f}"))
-                return f"Raw={raw:.4f}, Sigmoid={prob:.4f}"
-            except Exception as e:
-                return f"Image prediction error: {e}"
-        img_in.change(do_image_pred, inputs=[img_in], outputs=[img_pred])
-
-    with gr.Tab("🧪 Soil Classification"):
-        gr.Markdown("Step-by-step wizard for USCS & AASHTO. Use Next to proceed; previous answers are retained.")
-        choice = gr.Dropdown(["USCS","AASHTO","Both"], label="Choose classification system", value="USCS")
-        start = gr.Button("Start / Reset Wizard")
-        prompt_text = gr.Markdown("")
-        answer = gr.Textbox(label="Answer (or numeric input)", placeholder="Type answer here (or select dropdown below if shown)")
-        ds_dd = gr.Dropdown(choices=DRY_STRENGTH_OPTIONS, label="Dry Strength (nDS)", visible=False)
-        dil_dd = gr.Dropdown(choices=DILATANCY_OPTIONS, label="Dilatancy (nDIL)", visible=False)
-        tg_dd = gr.Dropdown(choices=TOUGHNESS_OPTIONS, label="Toughness (nTG)", visible=False)
-        next_btn = gr.Button("Next")
-        status = gr.Textbox(label="Status / Messages", interactive=False)
-        final_result = gr.Textbox(label="Final classification(s)", interactive=False)
-
-        state = gr.State(value=None)
-
-        def on_start_system(ch):
-            pid, ptext, _ = wizard_start(ch)
-            # hide all dropdowns initially
-            return ptext, "", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), "", pid
-
-        start.click(on_start_system, inputs=[choice], outputs=[prompt_text, status, ds_dd, dil_dd, tg_dd, final_result, state])
-
-        def on_next(pid, txt, ds_val, dil_val, tg_val, ch):
-            # decide which input to use based on pid
-            if pid is None:
-                return gr.update(value=""), "No active prompt: click Start", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), "", None
-            use_val = None
-            if pid == "uscs_fine_nDS": use_val = ds_val
-            elif pid == "uscs_fine_nDIL": use_val = dil_val
-            elif pid == "uscs_fine_nTG": use_val = tg_val
-            else: use_val = txt
-            next_pid, next_prompt, msg, finished = wizard_next(pid, use_val)
-            # show appropriate dropdowns
-            show_ds = next_pid in ("uscs_fine_nDS",)
-            show_dil = next_pid in ("uscs_fine_nDIL",)
-            show_tg = next_pid in ("uscs_fine_nTG",)
-            # update final result display
-            res_display = []
-            if SESSION["uscs"]["result"]:
-                res_display.append(f"USCS: {SESSION['uscs']['result']}")
-            if SESSION["aashto"]["result"]:
-                res_display.append(f"AASHTO: {SESSION['aashto']['result']}")
-            return (next_prompt or ""), msg, gr.update(visible=show_ds), gr.update(visible=show_dil), gr.update(visible=show_tg), " | ".join(res_display), next_pid
-
-        next_btn.click(on_next, inputs=[state, answer, ds_dd, dil_dd, tg_dd, choice],
-                       outputs=[prompt_text, status, ds_dd, dil_dd, tg_dd, final_result, state])
-
-    with gr.Tab("🧾 Sieve Analysis"):
-        gr.Markdown("Upload CSV or paste two-column data (sieve_size_mm, percent_finer). Example:\n`19 100\n9.5 95\n4.75 85\n2.36 65\n0.425 10`")
-        sieve_input = gr.Textbox(label="Paste sieve data (size_mm percent_finer) or upload CSV", lines=6, placeholder="size_mm percent_finer")
-        sieve_upload = gr.File(label="Upload CSV file (optional)", file_types=['.csv'])
-        run_sieve = gr.Button("Run Sieve Analysis")
-        sieve_plot = gr.Image(label="PSD Plot")
-        dvals_box = gr.Textbox(label="D10, D30, D60 and Cu, Cc", interactive=False)
-
-        def on_sieve_run(text, csv_file):
-            data_text = text
-            if csv_file:
-                try:
-                    with open(csv_file.name, "r") as f:
-                        data_text = f.read()
-                except Exception:
-                    pass
-            if not data_text or data_text.strip()=="":
-                return None, "No data provided."
-            sizes, perc = parse_sieve_input(data_text)
-            if sizes is None:
-                return None, "No valid numeric data found. Ensure two columns: size_mm percent_finer."
-            # compute D-values
-            D10, D30, D60 = compute_D_values(sizes, perc)
-            if D10 is None:
-                return None, "Could not compute D10/D30/D60 from given data."
-            Cu = D60 / D10 if D10 != 0 else None
-            Cc = (D30 ** 2) / (D10 * D60) if (D10*D60) != 0 else None
-            # store in SESSION
-            SESSION["sieve"]["sieve_sizes"] = sizes.tolist()
-            SESSION["sieve"]["percent_finer"] = perc.tolist()
-            SESSION["sieve"]["D10"] = D10; SESSION["sieve"]["D30"] = D30; SESSION["sieve"]["D60"] = D60
-            SESSION["sieve"]["Cu"] = Cu; SESSION["sieve"]["Cc"] = Cc
-            # generate plot
-            img_bytes = plot_sieve_curve(sizes, perc)
-            info = f"D10={D10:.6f} mm, D30={D30:.6f} mm, D60={D60:.6f} mm\nCu={Cu:.3f}, Cc={Cc:.3f}"
-            return (img_bytes, info)
-
-        run_sieve.click(on_sieve_run, inputs=[sieve_input, sieve_upload], outputs=[sieve_plot, dvals_box])
-
-    with gr.Tab("🧮 Problem Solvers"):
-        gr.Markdown("Use these to compute engineering values; results are appended to the report context.")
-        with gr.Group():
-            gr.Markdown("#### Bearing Capacity")
-            bc_q = gr.Number(label="Overburden q")
-            bc_unit = gr.Dropdown(["kN/m²","psf","kPa"], value="kN/m²")
-            bc_Nq = gr.Number(label="Nq", value=10)
-            bc_B = gr.Number(label="Width B (m)", value=1.0)
-            bc_btn = gr.Button("Compute")
-            bc_out = gr.Textbox(interactive=False)
-            bc_btn.click(bearing_capacity_solver, inputs=[bc_q, bc_unit, bc_Nq, bc_B], outputs=[bc_out])
-
-            gr.Markdown("#### Slope Stability")
-            s_c = gr.Number(label="C (kN/m²)")
-            s_phi = gr.Number(label="phi (deg)")
-            s_gamma = gr.Number(label="gamma (kN/m³)")
-            s_h = gr.Number(label="height (m)")
-            s_btn = gr.Button("Compute")
-            s_out = gr.Textbox(interactive=False)
-            s_btn.click(slope_stability_solver, inputs=[s_c, s_phi, s_gamma, s_h], outputs=[s_out])
-
-            gr.Markdown("#### Consolidation")
-            ds_ds = gr.Number(label="Δσ (kN/m²)")
-            ds_mv = gr.Number(label="mv (m²/kN)")
-            ds_H = gr.Number(label="H (m)")
-            ds_btn = gr.Button("Compute")
-            ds_out = gr.Textbox(interactive=False)
-            ds_btn.click(consolidation_solver, inputs=[ds_ds, ds_mv, ds_H], outputs=[ds_out])
-
-            gr.Markdown("#### Seepage")
-            sp_k = gr.Number(label="k (m/s)")
-            sp_i = gr.Number(label="i")
-            sp_A = gr.Number(label="A (m²)")
-            sp_btn = gr.Button("Compute")
-            sp_out = gr.Textbox(interactive=False)
-            sp_btn.click(seepage_solver, inputs=[sp_k, sp_i, sp_A], outputs=[sp_out])
-
-            gr.Markdown("#### Compaction")
-            cp_W = gr.Number(label="W (kN)")
-            cp_V = gr.Number(label="V (m³)")
-            cp_btn = gr.Button("Compute")
-            cp_out = gr.Textbox(interactive=False)
-            cp_btn.click(compaction_solver, inputs=[cp_W, cp_V], outputs=[cp_out])
-
-    with gr.Tab("🤖 GeoMate LLM Expert"):
-        gr.Markdown("LLM assistant. Requires env var `GROQ_API_l_KEY`. If not set, LLM features are disabled.")
-        qbox = gr.Textbox(label="Ask GeoMate", lines=4, placeholder="e.g., Recommend foundation type for CL soil under water table")
-        ask_btn = gr.Button("Ask")
-        ans_box = gr.Textbox(label="Geotech Expert (LLM) answer", lines=8, interactive=False)
-
-        def ask_llm(q):
-            if client is None:
-                return "LLM unavailable. Set environment variable GROQ_API_l_KEY to enable."
-            prompt = f"You are GeoMate, an expert geotechnical engineer. Answer concisely.\nQuery: {q}"
-            try:
-                r = client.chat.completions.create(model=GROQ_MODEL_NAME, messages=[{"role":"user","content":prompt}])
-                ans = r.choices[0].message.content
-                SESSION["chat_history"].append((q, ans))
-                return ans
-            except Exception as e:
-                return f"LLM call failed: {e}"
-
-        ask_btn.click(ask_llm, inputs=[qbox], outputs=[ans_box])
-
-    with gr.Tab("📄 Report & Export"):
-        gr.Markdown("Generate final PDF report. The decision path is only included in the PDF (not the UI).")
-        logo_file = gr.File(label="Upload GeoMate logo (PNG/JPG) - optional", file_types=[".png",".jpg",".jpeg"])
-        gen_btn = gr.Button("Generate PDF Report")
-        pdf_out = gr.File(label="Download PDF")
-        def on_generate(logo):
-            logo_bytes = None
-            if logo:
-                try:
-                    with open(logo.name, "rb") as f:
-                        logo_bytes = f.read()
-                except:
-                    logo_bytes = None
-            p = generate_report_pdf(logo_bytes)
-            return p
-        gen_btn.click(on_generate, inputs=[logo_file], outputs=[pdf_out])
-
-    with gr.Tab("✉️ Feedback"):
-        feedback = gr.Textbox(label="Feedback / Bug report", lines=4)
-        fb_btn = gr.Button("Send Feedback (saves locally)")
-        fb_out = gr.Textbox(interactive=False)
-        def save_feedback(txt):
-            try:
-                ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-                fname = f"feedback_{ts}.txt"
-                with open(fname, "w") as f:
-                    f.write(txt)
-                return f"Saved feedback to {fname}"
-            except Exception as e:
-                return f"Error saving feedback: {e}"
-        fb_btn.click(save_feedback, inputs=[feedback], outputs=[fb_out])
-
-# ---- SECTION: Launch app ----
-if __name__ == "__main__":
-    demo.launch(share=False)