Update app.po

app.po

@@ -534,40 +534,124 @@ def soil_recognizer_ui():
 # Soil Classifier
 # -------------------------------------------------------
 
-# Helpers for USCS + AASHTO classification logic
+# -------------------------------------------------------
+# Soil Classifier (Chatbot Style, with OCR + LLM)
+# -------------------------------------------------------
+import pytesseract
+import tempfile
+from PIL import Image
+from typing import Dict, Any, Tuple
+
+# ---------- Utilities ----------
+def run_ocr_on_image(uploaded_file) -> Dict[str, float]:
+    """Run OCR on uploaded soil problem sheet to extract LL, PL, sieve %s."""
+    img = Image.open(uploaded_file).convert("L")
+    text = pytesseract.image_to_string(img)
+    extracted = {}
+
+    # Very naive parsing – refine later
+    for line in text.splitlines():
+        if "LL" in line.upper():
+            try: extracted["LL"] = float([s for s in line.split() if s.replace('.','',1).isdigit()][0])
+            except: pass
+        if "PL" in line.upper():
+            try: extracted["PL"] = float([s for s in line.split() if s.replace('.','',1).isdigit()][0])
+            except: pass
+        if "#200" in line or "200" in line:
+            try: extracted["P200"] = float([s for s in line.split() if s.replace('.','',1).isdigit()][0])
+            except: pass
+        if "#40" in line or "40" in line:
+            try: extracted["P40"] = float([s for s in line.split() if s.replace('.','',1).isdigit()][0])
+            except: pass
+    return extracted
+
+
+# ---------- Classification Logic ----------
+def classify_aashto(inputs: Dict[str, Any]) -> Tuple[str, str, str]:
+    """Full AASHTO logic + Group Index + explanation."""
+    from math import floor
+    P2 = inputs.get("P200", 0.0)
+    P4 = inputs.get("P40", 0.0)
+    LL = inputs.get("LL", 0.0)
+    PL = inputs.get("PL", 0.0)
+    PI = LL - PL
+    result = "A-0"
+    desc = ""
+    GI = 0
+
+    if P2 <= 35:
+        if P2 <= 15 and P4 <= 30 and PI <= 6:
+            P1 = inputs.get("P10", 0.0)
+            if P1 <= 50:
+                result = "A-1-a"; desc = "Granular soil, excellent subgrade."
+            else:
+                result = "A-1-b"; desc = "Granular soil with fines, still good subgrade."
+        elif P2 <= 25 and P4 <= 50 and PI <= 6:
+            result = "A-1-b"; desc = "Granular soil with more fines, fair performance."
+        elif P2 <= 35:
+            if LL <= 40 and PI <= 10: result = "A-2-4"; desc = "Granular soil with silt, fair subgrade."
+            elif LL >= 41 and PI <= 10: result = "A-2-5"; desc = "Granular soil, high LL silt content."
+            elif LL <= 40 and PI >= 11: result = "A-2-6"; desc = "Granular soil with clayey fines."
+            else: result = "A-2-7"; desc = "Granular soil, poor clayey fines."
+        else:
+            result = "A-3"; desc = "Clean sands, excellent highway subgrade."
+    else:
+        if LL <= 40 and PI <= 10: result = "A-4"; desc = "Silt, fair to poor subgrade."
+        elif LL >= 41 and PI <= 10: result = "A-5"; desc = "Elastic silt, very poor subgrade."
+        elif LL <= 40 and PI >= 11: result = "A-6"; desc = "Clay of low plasticity, poor subgrade."
+        else:
+            if PI <= (LL-30): result = "A-7-5"; desc = "Clay, high LL, fair plasticity."
+            else: result = "A-7-6"; desc = "Clay, high plasticity, very poor subgrade."
+
+    # Group Index
+    a = min(max(P2 - 35, 0), 40)
+    b = min(max(P2 - 15, 0), 40)
+    c = min(max(LL - 40, 0), 20)
+    d = min(max(PI - 10, 0), 20)
+    GI = floor(0.2*a + 0.005*a*c + 0.01*b*d)
+
+    return result, desc, str(GI)
+
+
 def classify_uscs(inputs: Dict[str, Any]) -> Tuple[str, str]:
-    """
-    Verbatim simplified USCS logic based on % fines, D10/30/60, LL, PL, and observations.
-    Returns (code, description).
-    """
-    # Very simplified placeholder (expand with full decision tree)
-    fines = inputs.get("P200", 0.0)
+    """Full USCS logic with Cu, Cc, PI, DS/DIL/TG."""
+    P2 = inputs.get("P200", 0.0)
     if inputs.get("organic", False):
         return "Pt", "Peat / Organic soil — compressible, poor engineering properties."
-    if fines < 5:
-        return "GW", "Well-graded gravel with excellent load-bearing capacity."
-    if fines > 50:
-        LL = inputs.get("LL", 0)
+
+    if P2 <= 50:  # Coarse
+        P4 = inputs.get("P4", 0.0)
+        D60, D30, D10 = inputs.get("D60", 0.0), inputs.get("D30", 0.0), inputs.get("D10", 0.0)
+        LL, PL = inputs.get("LL", 0.0), inputs.get("PL", 0.0)
+        PI = LL - PL
+        Cu, Cc = 0, 0
+        if all([D60, D30, D10]):
+            Cu = D60/D10 if D10 else 0
+            Cc = (D30**2)/(D10*D60) if D10*D60 else 0
+
+        if P4 <= 50:  # Gravels
+            if Cu >= 4 and 1 <= Cc <= 3: return "GW", "Well-graded gravel, excellent foundation material."
+            elif PI <= 7: return "GM", "Silty gravel, moderate quality."
+            else: return "GC", "Clayey gravel, reduced drainage."
+        else:  # Sands
+            if Cu >= 6 and 1 <= Cc <= 3: return "SW", "Well-graded sand, excellent engineering soil."
+            elif PI <= 7: return "SM", "Silty sand, fair to moderate."
+            else: return "SC", "Clayey sand, reduced strength."
+    else:  # Fine
+        LL, PL = inputs.get("LL", 0.0), inputs.get("PL", 0.0)
+        PI = LL - PL
         if LL < 50:
-            return "CL", "Low plasticity clay."
+            if PI <= 7: return "ML", "Low plasticity silt."
+            elif PI > 7: return "CL", "Low plasticity clay."
         else:
-            return "CH", "High plasticity clay."
-    return "SM", "Silty sand with moderate engineering quality."
+            if PI < 0.73*(LL-20): return "MH", "Elastic silt."
+            else: return "CH", "High plasticity clay, compressible, weak foundation soil."
+    return "ML", "Default: Low plasticity silt."
 
-def classify_aashto(inputs: Dict[str, Any]) -> Tuple[str, str]:
-    """
-    Simplified AASHTO classification logic.
-    """
-    fines = inputs.get("P200", 0.0)
-    if inputs.get("organic", False):
-        return "A-8", "Organic soils (special handling required)."
-    if fines < 35:
-        return "A-1-a", "Granular material with excellent performance."
-    else:
-        return "A-7-6", "Clayey soils with poor performance unless stabilized."
 
+# ---------- Main Chatbot ----------
 def soil_classifier_ui():
-    st.header("🤖 Soil Classifier (Chatbot Style)")
+    st.header("🤖 Soil Classifier (Chatbot + OCR + LLM)")
     site = get_active_site()
 
     if "classifier_state" not in site:
@@ -582,7 +666,7 @@ def soil_classifier_ui():
     def add_user(msg: str):
         chat.append(["user", msg])
 
-    # Chat rendering
+    # Render chat
     for role, msg in chat:
         bubble_color = THEME["bubble_bg"] if role=="bot" else "#1f2a44"
         border = f"2px solid {THEME['accent']}" if role=="bot" else "1px solid #333"
@@ -593,85 +677,94 @@ def soil_classifier_ui():
         </div>
         """, unsafe_allow_html=True)
 
-    # State machine
     state = site["classifier_state"]
     inputs = site["classifier_inputs"]
 
-    def ask(question: str):
-        add_bot(question)
-        site["classifier_state"] += 1
-        save_active_site(site)
-        st.rerun()
+    # OCR Upload
+    uploaded = st.file_uploader("📄 Upload soil test sheet (OCR)", type=["jpg","png","jpeg"])
+    if uploaded:
+        ocr_data = run_ocr_on_image(uploaded)
+        inputs.update(ocr_data)
+        add_bot(f"OCR detected values: {ocr_data}")
 
-    # Initial Q
+    # Initial
     if state == 0 and not chat:
-        ask("Hello — I am the GeoMate Soil Classifier. Is the soil organic (spongy, dark, odorous)? (y/n)")
+        add_bot("Hello 👋 I am GeoMate Soil Classifier. Let's begin. Is the soil organic (spongy, dark, odorous)? (y/n)")
+        site["classifier_state"] = 1
+        save_active_site(site)
 
-    # User input
+    # User Input
     user_in = st.text_input("Your answer:", key=f"classifier_input_{state}")
-    if st.button("➡️ Submit", key=f"classifier_submit_{state}"):
+    if st.button("➡️", key=f"classifier_submit_{state}"):
         if user_in.strip():
             add_user(user_in.strip())
-            # Logic branch
-            if state == 1:  # organic q
+
+            # Logic branches
+            if state == 1:
                 if user_in.lower().startswith("y"):
                     inputs["organic"] = True
-                    site["USCS"], desc1 = classify_uscs(inputs)
-                    site["AASHTO"], desc2 = classify_aashto(inputs)
-                    add_bot(f"Classification complete: USCS={site['USCS']} ({desc1}), AASHTO={site['AASHTO']} ({desc2})")
+                    uscs, desc1 = classify_uscs(inputs)
+                    aashto, desc2, gi = classify_aashto(inputs)
+                    add_bot(f"Classification complete ✅ USCS={uscs} ({desc1}), AASHTO={aashto} (GI={gi}, {desc2})")
+                    # Expand with LLM
+                    full_report = query_llm_for_soil(uscs, aashto, desc1, desc2, gi)
+                    add_bot(full_report)
                     site["classifier_state"] = -1
                 else:
                     inputs["organic"] = False
-                    ask("What is the % passing the #200 sieve (0.075 mm)?")
+                    add_bot("What is % passing #200 sieve?")
+                    site["classifier_state"] = 2
             elif state == 2:
-                try:
-                    inputs["P200"] = float(user_in)
+                try: inputs["P200"] = float(user_in)
                 except: inputs["P200"] = 0.0
-                if inputs["P200"] < 5:
-                    ask("What is the % passing the sieve no. 4 (4.75 mm)?")
-                else:
-                    ask("What is the Liquid Limit (LL)?")
+                add_bot("What is % passing #40 sieve?")
+                site["classifier_state"] = 3
             elif state == 3:
-                try:
-                    inputs["P4"] = float(user_in)
-                except: inputs["P4"] = 0.0
-                ask("Do you know the D10, D30, D60 values? (y/n)")
+                try: inputs["P40"] = float(user_in)
+                except: inputs["P40"] = 0.0
+                add_bot("Enter Liquid Limit (LL):")
+                site["classifier_state"] = 4
             elif state == 4:
-                if user_in.lower().startswith("y"):
-                    ask("Enter D60 (mm):")
-                else:
-                    ask("Enter Liquid Limit (LL):")
-            elif state == 5:
-                try: inputs["D60"] = float(user_in)
-                except: inputs["D60"] = 0.0
-                ask("Enter D30 (mm):")
-            elif state == 6:
-                try: inputs["D30"] = float(user_in)
-                except: inputs["D30"] = 0.0
-                ask("Enter D10 (mm):")
-            elif state == 7:
-                try: inputs["D10"] = float(user_in)
-                except: inputs["D10"] = 0.0
-                ask("Enter Liquid Limit (LL):")
-            elif state == 8:
                 try: inputs["LL"] = float(user_in)
                 except: inputs["LL"] = 0.0
-                ask("Enter Plastic Limit (PL):")
-            elif state == 9:
+                add_bot("Enter Plastic Limit (PL):")
+                site["classifier_state"] = 5
+            elif state == 5:
                 try: inputs["PL"] = float(user_in)
                 except: inputs["PL"] = 0.0
-                # classify now
-                site["USCS"], desc1 = classify_uscs(inputs)
-                site["AASHTO"], desc2 = classify_aashto(inputs)
-                add_bot(f"Classification complete: USCS={site['USCS']} ({desc1}), AASHTO={site['AASHTO']} ({desc2})")
+                uscs, desc1 = classify_uscs(inputs)
+                aashto, desc2, gi = classify_aashto(inputs)
+                add_bot(f"Classification complete ✅ USCS={uscs} ({desc1}), AASHTO={aashto} (GI={gi}, {desc2})")
+                full_report = query_llm_for_soil(uscs, aashto, desc1, desc2, gi)
+                add_bot(full_report)
                 site["classifier_state"] = -1
+
             save_active_site(site)
             st.rerun()
 
     if site["classifier_state"] == -1:
         if st.button("📄 Export Classification Report"):
-            st.success("Report export will be in Reports page.")
+            site["classification_report"] = chat
+            st.success("Report saved. Generate full report in Reports Page.")
 
+
+# ---------- LLM Expansion ----------
+def query_llm_for_soil(uscs_code, aashto_code, desc1, desc2, gi):
+    """Ask Groq LLM to expand classification into detailed engineering report."""
+    prompt = f"""
+    Soil Classification Results:
+    - USCS: {uscs_code} ({desc1})
+    - AASHTO: {aashto_code} ({desc2}), Group Index={gi}
+
+    Provide:
+    1. Engineering characteristics (compressibility, permeability, shear strength, settlement, frost susceptibility).
+    2. Construction applications (foundations, embankments, pavements).
+    3. Typical stabilization or improvement methods.
+    4. Warnings or limitations.
+
+    Be detailed but concise, use professional engineering language.
+    """
+    return groq_chat(prompt)  # assumes you have groq_chat() wrapper
 # -------------------------------------------------------
 # GSD Curve Page
 # -------------------------------------------------------