Update app.py

app.py

@@ -1,383 +1,290 @@
-# app.py
-import streamlit as st
+import os
+import re
+import time
+from typing import Dict, Optional, Tuple
+
 import cv2
 import numpy as np
-import re
+import pandas as pd
+import requests
+import streamlit as st
+from paddleocr import PaddleOCR
 from PIL import Image
-import io
-import math
-
-# Try import PaddleOCR with graceful failure message inside app
-try:
-    from paddleocr import PaddleOCR
-except Exception:
-    PaddleOCR = None
-
-# -----------------------
-# CONFIG
-# -----------------------
-st.set_page_config(
-    page_title="Nutri-Grade Label Detection",
-    page_icon="🥗",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Session keys
-KEYS = {
-    "ocr_done": "ocr_done_v2",
-    "ocr_text": "ocr_text_v2",
-    "data": "data_v2",
-    "calc": "calc_v2",
-    "calculated": "calculated_v2",
-}
-
-# -----------------------
-# UTILITIES
-# -----------------------
-def safe_parse_number(s: str) -> float:
-    if s is None:
-        return 0.0
-    s = str(s).strip()
-    if s == "":
+
+# ---------------------------
+#  Konfigurasi / Constants
+# ---------------------------
+APP_TITLE = "🥗 Nutri-Grade Label Detection"
+APP_VERSION = "v2.1 (refactor)"
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+GRADE_ORDER = ["Grade A", "Grade B", "Grade C", "Grade D"]
+
+# ---------------------------
+#  Util / Helpers
+# ---------------------------
+def get_openrouter_api_key() -> Optional[str]:
+    """
+    Ambil API key dari environment variable atau dari Streamlit secrets.
+    Jangan meletakkan API key langsung di kode.
+    """
+    return os.environ.get("OPENROUTER_API_KEY") or st.secrets.get("OPENROUTER_API_KEY", None)
+
+
+def safe_float_from_text(txt: str) -> float:
+    """
+    Ambil angka dari teks (mengatasi koma desimal) dan konversi ke float.
+    Jika gagal, kembalikan 0.0.
+    """
+    if txt is None:
         return 0.0
-    is_negative = False
-    if s.startswith("(") and s.endswith(")"):
-        is_negative = True
-        s = s[1:-1].strip()
-    s = re.sub(r"[^\d\.,\-\/]", "", s)
-    if s == "" or s in ["-", ".", ","]:
+    s = str(txt).strip()
+    # ganti koma desimal jika ada
+    s = s.replace(",", ".")
+    # ambil simbol angka, titik, minus
+    cleaned = re.sub(r"[^\d\.\-]", "", s)
+    if cleaned in ("", ".", "-", "-.", ".-"):
         return 0.0
-    if "/" in s and not any(c.isalpha() for c in s):
-        try:
-            a, b = s.split("/", 1)
-            val = float(a) / float(b)
-            return -val if is_negative else val
-        except:
-            pass
-    if "." in s and "," in s:
-        if s.rfind(".") > s.rfind(","):
-            s = s.replace(",", "")
-        else:
-            s = s.replace(".", "").replace(",", ".")
-    else:
-        if "," in s and "." not in s:
-            parts = s.split(",")
-            if len(parts[-1]) in (1,2,3):
-                s = s.replace(",", ".")
-            else:
-                s = s.replace(",", "")
     try:
-        val = float(s)
-        return -val if is_negative else val
-    except:
-        m = re.search(r"-?\d+([.,]\d+)?", s)
-        if m:
-            return float(m.group(0).replace(",", "."))
-    return 0.0
-
-def preprocess_for_ocr(img: np.ndarray, max_dim=1600):
-    if len(img.shape) == 2:
-        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-    h, w = img.shape[:2]
-    if max(h, w) > max_dim:
-        scale = max_dim / max(h, w)
-        img = cv2.resize(img, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA)
+        return float(cleaned)
+    except ValueError:
+        return 0.0
+
+
+def get_grade_from_value(value: float, thresholds: Dict[str, float]) -> str:
+    """
+    Thresholds contoh: {"A": 1.0, "B": 5.0, "C": 10.0}
+    kembalikan "Grade X"
+    """
     try:
-        img = cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
+        if value <= thresholds["A"]:
+            return "Grade A"
+        if value <= thresholds["B"]:
+            return "Grade B"
+        if value <= thresholds["C"]:
+            return "Grade C"
+        return "Grade D"
     except Exception:
-        pass
-    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    return img_rgb
-
-def try_ocr_variants(ocr, img_rgb):
-    variants = []
-    rotations = [0, 90, 180, 270]
-    scales = [1.0, 1.5, 0.8]
-    for rot in rotations:
-        if rot != 0:
-            M = cv2.getRotationMatrix2D((img_rgb.shape[1]/2, img_rgb.shape[0]/2), rot, 1.0)
-            imgr = cv2.warpAffine(img_rgb, M, (img_rgb.shape[1], img_rgb.shape[0]), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
-        else:
-            imgr = img_rgb
-        for s in scales:
-            if s != 1.0:
-                imgrs = cv2.resize(imgr, (0,0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC)
-            else:
-                imgrs = imgr
-            try:
-                ocr_res = ocr.ocr(imgrs, cls=True)
-            except Exception:
-                try:
-                    ocr_res = ocr.ocr(imgrs)
-                except Exception:
-                    ocr_res = None
-            text_lines = []
-            conf_sum = 0.0
-            num_tokens = 0
-            if ocr_res:
-                flat = ocr_res
-                for item in flat:
-                    try:
-                        entry = item[1] if isinstance(item, (list, tuple)) and len(item) > 1 else item
-                        if isinstance(entry, (list, tuple)):
-                            txt = entry[0]
-                            prob = float(entry[1]) if len(entry) > 1 else 0.0
-                        elif isinstance(entry, dict):
-                            txt = entry.get("text", "")
-                            prob = float(entry.get("confidence", 0.0))
-                        else:
-                            txt = str(entry)
-                            prob = 0.0
-                    except Exception:
-                        txt = str(item)
-                        prob = 0.0
-                    text_lines.append(txt)
-                    try:
-                        conf_sum += float(prob)
-                    except:
-                        pass
-                    num_tokens += len(re.findall(r"[\d]+", txt))
-            joined = " ".join(text_lines)
-            score = num_tokens + conf_sum
-            variants.append({"rot": rot, "scale": s, "score": score, "text": joined, "raw": ocr_res})
-    variants = sorted(variants, key=lambda x: x["score"], reverse=True)
-    return variants[0] if variants else {"text": ""}
-
-def extract_nutrition_info(full_text: str) -> dict:
-    txt = (full_text or "").lower()
-    serving = None
-    serving_unit = None
-    m = re.search(r"(takaran saj(?:i|a)|serving size|serving)[^\d]{0,10}([-\d\.,\/ ]{1,20})", txt)
-    if m:
-        serving = m.group(2).strip()
-    else:
-        m2 = re.search(r"(\d{1,3}(?:[.,]\d+)?)(?:\s*)(ml|g)\b", txt)
-        if m2:
-            serving = m2.group(1)
-            serving_unit = m2.group(2)
-    sugar = None
-    sugar_unit = None
-    sugar_patterns = [
-        r"(gula|sugar)[^\d\-\,\.\d]{0,6}([-\d\.,\/ ]{1,20})",
-        r"sugars?[^\d]{0,6}([-\d\.,\/ ]{1,20})",
-    ]
-    for p in sugar_patterns:
-        m = re.search(p, txt)
-        if m:
-            sugar = m.group(2).strip()
-            break
-    fat = None
-    fat_unit = None
-    fat_patterns = [
-        r"(lemak jenuh|saturated fat|sat fat)[^\d\-\,\.\d]{0,6}([-\d\.,\/ ]{1,20})",
-        r"(lemak total|total fat)[^\d\-\,\.\d]{0,6}([-\d\.,\/ ]{1,20})"
-    ]
-    for p in fat_patterns:
-        m = re.search(p, txt)
-        if m:
-            fat = m.group(2).strip()
-            break
-    per100 = False
-    if re.search(r"(per 100|per 100g|per 100 ml|/100g|/100 ml|/100ml|/100g)", txt):
-        per100 = True
-    if not sugar or sugar == "":
-        nums = re.findall(r"[-+]?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d+)?", txt)
-        if nums:
-            for n in nums:
-                v = safe_parse_number(n)
-                if 0 <= v <= 100:
-                    sugar = n
-                    break
-    return {
-        "serving_raw": serving or "",
-        "serving_unit": serving_unit or "",
-        "sugar_raw": sugar or "",
-        "sugar_unit": sugar_unit or "",
-        "fat_raw": fat or "",
-        "fat_unit": fat_unit or "",
-        "values_are_per100": per100
-    }
+        return "Grade D"
 
-def normalize_to_per_100(value_raw: str, unit_raw: str, serving_size: float, values_are_per100: bool) -> float:
-    if value_raw is None or str(value_raw).strip() == "":
-        return 0.0
-    s = str(value_raw).lower()
-    s = re.sub(r"(g|mg|ml)\b", "", s)
-    val = safe_parse_number(s)
-    if values_are_per100:
-        return val
-    if serving_size and serving_size > 0:
-        try:
-            per100 = (val / serving_size) * 100.0
-            return per100
-        except Exception:
-            return val
-    return val
-
-def get_grade_from_value(value: float, thresholds: dict) -> str:
-    try:
-        v = float(value)
-    except:
-        v = 9999.0
-    if v <= thresholds.get("A", 0):
-        return "Grade A"
-    if v <= thresholds.get("B", float("inf")):
-        return "Grade B"
-    if v <= thresholds.get("C", float("inf")):
-        return "Grade C"
-    return "Grade D"
-
-def get_grade_color(grade: str):
+
+def get_grade_color(grade: str) -> Tuple[str, str]:
+    """
+    kembalikan (background_color, text_color)
+    """
     colors = {
         "Grade A": ("#2ecc71", "white"),
         "Grade B": ("#f1c40f", "black"),
         "Grade C": ("#e67e22", "white"),
-        "Grade D": ("#e74c3c", "white")
+        "Grade D": ("#e74c3c", "white"),
     }
     return colors.get(grade, ("#bdc3c7", "black"))
 
-def nutrition_advice_rule_based(final_grade: str, sugar_per100: float, fat_per100: float):
-    adv = []
-    if final_grade == "Grade A":
-        adv.append("Produk tergolong baik. Konsumsi sesuai porsi.")
-    elif final_grade == "Grade B":
-        adv.append("Cukup baik, perhatikan frekuensi konsumsi.")
-    elif final_grade == "Grade C":
-        adv.append("Perhatikan kandungan gula/lemak. Batasi konsumsi harian.")
-    else:
-        adv.append("Kandungan gula/lemak tinggi. Kurangi frekuensi, pilih alternatif lebih sehat.")
-    if sugar_per100 > 10:
-        adv.append("Gula per 100g cukup tinggi — hindari dikonsumsi berlebihan.")
-    elif sugar_per100 > 5:
-        adv.append("Perhatikan gula; hindari menambah gula lagi.")
-    if fat_per100 > 5:
-        adv.append("Lemak jenuh tinggi — perhatikan asupan harian dan coba variasi rendah lemak.")
-    return " ".join(adv)
-
-# -----------------------
-# INITIALIZE OCR (cached)
-# -----------------------
+
+def worse_grade(g1: str, g2: str) -> str:
+    """Pilih grade yang 'lebih buruk' menurut urutan Grade A..D"""
+    idx1 = GRADE_ORDER.index(g1) if g1 in GRADE_ORDER else len(GRADE_ORDER) - 1
+    idx2 = GRADE_ORDER.index(g2) if g2 in GRADE_ORDER else len(GRADE_ORDER) - 1
+    return g1 if idx1 > idx2 else g2
+
+
+# ---------------------------
+#  OCR Initialization
+# ---------------------------
 @st.cache_resource
-def init_ocr_model():
-    if PaddleOCR is None:
-        return None
+def init_paddleocr() -> Optional[PaddleOCR]:
+    """Inisialisasi PaddleOCR (cached)."""
     try:
-        return PaddleOCR(lang="en", use_angle_cls=True, use_gpu=False)
-    except Exception:
+        # Anda bisa tambahkan lang list sesuai kebutuhan, mis: ['en','id']
+        return PaddleOCR(lang="en", use_angle_cls=True)
+    except Exception as e:
+        st.error(f"Gagal inisialisasi PaddleOCR: {e}")
         return None
 
-ocr_model = init_ocr_model()
-
-# -----------------------
-# UI
-# -----------------------
-st.title("🥗 Nutri-Grade Detection & Grade Calculator (No AI Chatbot)")
-st.caption("Analisis gizi berdasarkan data pada label. Koreksi manual selalu disarankan.")
-
-with st.expander("📋 Petunjuk"):
-    st.markdown(
-        """
-        1. Upload gambar tabel gizi (jpg/png).  
-        2. Klik **Analisis OCR** (butuh PaddleOCR terinstall).  
-        3. Koreksi hasil jika perlu.  
-        4. Klik **Hitung Grade**.  
-        """
-    )
 
-if PaddleOCR is None:
-    st.error("PaddleOCR tidak ditemukan. Pastikan package `paddleocr` (dan `paddlepaddle`) telah terinstall di environment Anda.")
-    st.stop()
+# ---------------------------
+#  OCR & Parsing
+# ---------------------------
+def ocr_read_image(ocr_model: PaddleOCR, img_bgr: np.ndarray) -> str:
+    """
+    Jalankan OCR pada numpy BGR image dan kembalikan teks gabungan (lowercase).
+    Jika error, kembalikan string kosong.
+    """
+    try:
+        # PaddleOCR menerima image sebagai numpy array BGR/RGB — kami pakai seperti contoh awal
+        result = ocr_model.ocr(img_bgr, cls=True)
+        # result struktur: list of lists; ambil teks tiap baris
+        lines = []
+        for block in result:
+            for line in block:
+                if len(line) >= 2 and isinstance(line[1], (list, tuple)) is False:
+                    # fallback
+                    continue
+                text = line[1][0] if len(line) >= 2 and isinstance(line[1], (list, tuple)) else ""
+                lines.append(str(text))
+        return " ".join(lines).lower()
+    except Exception as e:
+        st.error(f"OCR gagal: {e}")
+        return ""
+
+
+def extract_nutri_from_text(text: str) -> Dict[str, str]:
+    """
+    Cari nilai serving, sugar, saturated fat dari teks OCR.
+    Mengembalikan dict string untuk diisi ulang oleh user jika perlu.
+    Pola regex dibuat toleran terhadap kata dalam Bahasa Indonesia & Inggris.
+    """
+    patterns = {
+        "serving": r"(takaran\s*saj(?:i|a)|serving\s*size)[^\d,\.]*([\d\.,]+)",
+        "sugar": r"(gula|sugar)[^\d,\.]*([\d\.,]+)",
+        "fat": r"(lemak\s*jenuh|saturated\s*fat)[^\d,\.]*([\d\.,]+)",
+    }
+    found = {}
+    for key, pat in patterns.items():
+        m = re.search(pat, text, flags=re.IGNORECASE)
+        if m:
+            found[key] = m.group(2)
+    return found
+
 
-if ocr_model is None:
-    st.error("Gagal inisialisasi model OCR. Jika di Spaces atau Docker, pastikan dependency paddle telah terpasang dengan benar.")
-    st.stop()
+# ---------------------------
+#  AI Advice (OpenRouter)
+# ---------------------------
+def get_nutrition_advice_openrouter(api_key: str, serving_size: float, sugar_norm: float, fat_norm: float,
+                                    sugar_grade: str, fat_grade: str, final_grade: str) -> str:
+    """
+    Panggil OpenRouter Chat Completions untuk meminta saran nutrisi singkat.
+    Pastikan API key tersedia (diperoleh dari env / secrets).
+    """
+    if not api_key:
+        return "OpenRouter API key tidak ditemukan. Silakan set OPENROUTER_API_KEY di environment atau streamlit secrets."
+    prompt = (
+        "Anda adalah ahli gizi dari Indonesia yang ramah.\n"
+        f"- Takaran Saji: {serving_size} g/ml\n"
+        f"- Gula (per 100): {sugar_norm:.2f} g (Grade {sugar_grade.replace('Grade ', '')})\n"
+        f"- Lemak Jenuh (per 100): {fat_norm:.2f} g (Grade {fat_grade.replace('Grade ', '')})\n"
+        f"- Grade Akhir: {final_grade.replace('Grade ', '')}\n\n"
+        "Berikan saran nutrisi singkat 50-80 kata, fokus pada dampak kesehatan dan tips praktis."
+    )
+    payload = {
+        "model": "mistralai/mistral-7b-instruct:free",
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 250,
+        "temperature": 0.7,
+    }
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    try:
+        r = requests.post(f"{OPENROUTER_BASE_URL}/chat/completions", json=payload, headers=headers, timeout=30)
+        r.raise_for_status()
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+    except Exception as e:
+        return f"Error saat meminta saran AI: {e}"
 
-st.header("1. Upload Gambar")
-uploaded = st.file_uploader("Pilih gambar (jpg, jpeg, png)", type=["jpg","jpeg","png"])
 
+# ---------------------------
+#  Streamlit App UI
+# ---------------------------
 def reset_state():
-    for v in KEYS.values():
-        if v in st.session_state:
-            del st.session_state[v]
-
-if uploaded:
-    file_bytes = np.asarray(bytearray(uploaded.read()), dtype=np.uint8)
-    img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
-    st.image(cv2.cvtColor(img, cv2.COLOR_BGR2RGB), caption="Preview", use_column_width=False, width=350)
-
-    if st.button("Analisis OCR"):
-        with st.spinner("Memproses gambar dan menjalankan OCR..."):
-            try:
-                img_rgb = preprocess_for_ocr(img)
-                best = try_ocr_variants(ocr_model, img_rgb)
-                extracted = extract_nutrition_info(best.get("text", ""))
-                st.session_state[KEYS["ocr_done"]] = True
-                st.session_state[KEYS["ocr_text"]] = best.get("text", "")
-                st.session_state[KEYS["data"]] = extracted
-                st.success("OCR selesai. Mohon periksa dan koreksi nilai-nilai yang terdeteksi.")
-            except Exception as e:
-                st.error(f"Gagal menjalankan OCR: {e}")
-
-if st.session_state.get(KEYS["ocr_done"], False):
-    st.header("2. Koreksi & Hitung Grade")
-    d = st.session_state.get(KEYS["data"], {})
-    with st.form("form_calc"):
-        serving_raw = st.text_input("Takaran Saji (mis. '100 g' atau '250 ml')", value=d.get("serving_raw", "100"))
-        sugar_raw = st.text_input("Nilai Gula (teks mentah dari OCR)", value=d.get("sugar_raw", ""))
-        fat_raw = st.text_input("Nilai Lemak Jenuh (teks mentah dari OCR)", value=d.get("fat_raw", ""))
-        values_are_per100 = st.checkbox("Nilai yang terdeteksi sudah per 100g/ml", value=d.get("values_are_per100", False))
-        submitted = st.form_submit_button("Hitung Grade")
-    if submitted:
-        m = re.search(r"(\d{1,4}(?:[.,]\d+)?)\s*(ml|g)?", serving_raw.lower())
-        serving_size = 0.0
-        serving_unit = ""
-        if m:
-            serving_size = safe_parse_number(m.group(1))
-            serving_unit = (m.group(2) or "").lower()
-        else:
-            serving_size = safe_parse_number(serving_raw)
-        sugar_per100 = normalize_to_per_100(sugar_raw, "", serving_size, values_are_per100)
-        fat_per100 = normalize_to_per_100(fat_raw, "", serving_size, values_are_per100)
-        st.session_state[KEYS["calc"]] = {"serving_size": serving_size, "serving_unit": serving_unit, "sugar_per100": sugar_per100, "fat_per100": fat_per100}
-        st.session_state[KEYS["calculated"]] = True
-
-if st.session_state.get(KEYS["calculated"], False):
-    st.header("3. Hasil Grading & Saran")
-    c = st.session_state[KEYS["calc"]]
-    sugar_thresholds = {"A": 5.0, "B": 12.5, "C": 22.5}
-    fat_thresholds = {"A": 1.0, "B": 3.0, "C": 5.0}
-    gs = get_grade_from_value(c["sugar_per100"], sugar_thresholds)
-    gf = get_grade_from_value(c["fat_per100"], fat_thresholds)
-    order = ["Grade A", "Grade B", "Grade C", "Grade D"]
-    final = max([gs, gf], key=lambda x: order.index(x))
-
-    cols = st.columns(3)
-    def show(col, title, value, unit, grade):
-        bg, tc = get_grade_color(grade)
-        col.markdown(
-            f"""
-            <div style="padding:12px;border-radius:8px;background:{bg};color:{tc};text-align:center;">
-              <strong style="font-size:18px;">{title}</strong>
-              <div style="font-size:24px;margin-top:6px;">{value:.2f} {unit}</div>
-              <div style="font-size:20px;margin-top:8px;"><strong>{grade}</strong></div>
-            </div>
-            """,
-            unsafe_allow_html=True
+    """Reset beberapa key di session state saat user upload file baru."""
+    for k in ("ocr_done", "ocr_text", "extracted", "calc", "calculated", "ai_advice"):
+        if k in st.session_state:
+            del st.session_state[k]
+
+
+def render_grade_box(col, title: str, value: float, unit: str, grade: str):
+    bg, txtc = get_grade_color(grade)
+    col.markdown(
+        f"<div style='background:{bg};padding:12px;border-radius:10px;text-align:center;color:{txtc};'>"
+        f"<strong>{title}</strong>"
+        f"<p style='font-size:18px;margin:6px 0'>{value:.2f} {unit}</p>"
+        f"<h4 style='margin:2px'>{grade}</h4></div>",
+        unsafe_allow_html=True,
+    )
+
+
+def main():
+    st.set_page_config(page_title=APP_TITLE, page_icon="🥗", layout="wide", initial_sidebar_state="collapsed")
+    st.title(APP_TITLE)
+    st.caption(f"Analisis gizi produk berdasarkan standar Nutri-Grade. {APP_VERSION}")
+
+    with st.expander("📋 Petunjuk Penggunaan"):
+        st.markdown(
+            "1. Upload gambar (JPG/PNG).\n"
+            "2. Klik **Analisis OCR**.\n"
+            "3. Koreksi hasil jika diperlukan.\n"
+            "4. Klik **Hitung Grade**."
         )
-    show(cols[0], "Gula (per 100g/ml)", c["sugar_per100"], "g/100", gs)
-    show(cols[1], "Lemak Jenuh (per 100g/ml)", c["fat_per100"], "g/100", gf)
-    show(cols[2], "Grade Akhir", 0.0, "", final)
-
-    st.markdown("---")
-    st.subheader("Saran Nutrisi (rule-based)")
-    advice = nutrition_advice_rule_based(final, c["sugar_per100"], c["fat_per100"])
-    st.info(advice)
-
-    st.markdown("**Catatan:** Hasil tergantung akurasi OCR dan input. Jika nilai terlihat aneh, koreksi secara manual pada langkah 2 lalu hitung ulang.")
-
-st.markdown("---")
-st.write("Nutri-Grade App (improved). Pastikan memeriksa manual hasil OCR sebelum mengambil keputusan.")
-if st.button("Reset Aplikasi"):
-    reset_state()
-    st.experimental_rerun()
+
+    ocr_model = init_paddleocr()
+    if ocr_model is None:
+        st.error("OCR model tidak tersedia. Pastikan PaddleOCR terinstal dengan benar.")
+        st.stop()
+
+    # --- Upload ---
+    st.header("1. Upload Gambar")
+    uploaded = st.file_uploader("Pilih gambar tabel gizi", type=["jpg", "jpeg", "png"], on_change=reset_state)
+    img_bgr = None
+    if uploaded:
+        # tampilkan preview
+        file_bytes = np.frombuffer(uploaded.read(), np.uint8)
+        img_bgr = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+        if img_bgr is None:
+            st.error("Gagal membaca gambar. Pastikan file gambar valid.")
+        else:
+            st.image(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB), width=320)
+
+    # tombol OCR
+    if uploaded and st.button("Analisis OCR"):
+        with st.spinner("Mendeteksi teks..."):
+            text = ocr_read_image(ocr_model, img_bgr)
+            st.session_state.ocr_text = text
+            st.session_state.extracted = extract_nutri_from_text(text)
+            st.session_state.ocr_done = True
+        st.success("OCR selesai — periksa hasil ekstraksi di langkah berikutnya.")
+
+    # --- Koreksi & Hitung ---
+    if st.session_state.get("ocr_done"):
+        st.header("2. Koreksi & Hitung Grade")
+        extracted = st.session_state.get("extracted", {})
+        default_serving = extracted.get("serving", "100")
+        default_sugar = extracted.get("sugar", "0")
+        default_fat = extracted.get("fat", "0")
+
+        with st.form("calc_form"):
+            serving_input = st.text_input("Takaran Saji (g/ml)", value=default_serving)
+            sugar_input = st.text_input("Gula (g) — total per serving", value=default_sugar)
+            fat_input = st.text_input("Lemak Jenuh (g) — total per serving", value=default_fat)
+            submitted = st.form_submit_button("Hitung Grade")
+
+        if submitted:
+            sv = safe_float_from_text(serving_input)
+            sugar = safe_float_from_text(sugar_input)
+            fat = safe_float_from_text(fat_input)
+
+            # normalisasi ke per 100 g / ml
+            sugar_per100 = (sugar / sv) * 100 if sv > 0 else 0.0
+            fat_per100 = (fat / sv) * 100 if sv > 0 else 0.0
+
+            st.session_state.calc = {"serving": sv, "sugar": sugar, "fat": fat,
+                                     "sugar_per100": sugar_per100, "fat_per100": fat_per100}
+            st.session_state.calculated = True
+
+    # --- Tampilkan Hasil ---
+    if st.session_state.get("calculated"):
+        st.header("3. Hasil Grading")
+        c = st.session_state["calc"]
+        # thresholds (contoh standar)
+        sugar_thresholds = {"A": 1.0, "B": 5.0, "C": 10.0}
+        fat_thresholds = {"A": 0.7, "B": 1.2, "C": 2.8}
+
+        sugar_grade = get_grade_from_value(c["sugar_per100"], sugar_thresholds)
+        fat_grade = get_grade_from_value(c["fat_per100"], fat_thresholds)
+        final = worse_grade(sugar_grade, fat_grade)
+
+        cols = st.columns(3, gap="large")
+        render_grade_box(cols[0], "Gula", c["sugar_per100"], "g/100", sugar_grade)
+        render_grade_box(cols[1], "Lemak Jenuh", c["fat_per100"], "g/100", fat_grade)
+        render_grade_box(cols[2], "Grade Akhir", 0.0, "", final)
+
+        st.markdown("---")
+        st.header("4.