Update baigiang.py

baigiang.py

@@ -1,242 +1,432 @@
+import cv2
+import numpy as np
+import imutils
+from imutils.contours import sort_contours
 import json
-import google.generativeai as genai
-import re # Thêm thư viện Regex để xử lý chuỗi
-
-# --- CẤU HÌNH HEADLESS ---
-import matplotlib
-matplotlib.use('Agg')
-import matplotlib.pyplot as plt
-
-from pptx import Presentation
-from pptx.util import Inches, Pt
-from pptx.dml.color import RGBColor
-from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
-from pptx.enum.shapes import MSO_SHAPE
-from pptx.oxml import parse_xml
-from io import BytesIO
-
-# --- CẤU HÌNH ---
-THEME_COLOR = RGBColor(0, 112, 192)
-TEXT_COLOR = RGBColor(30, 30, 30)
-BG_COLOR = RGBColor(255, 255, 255)
-
-# --- HÀM 1: RENDER CÔNG THỨC TOÁN THÀNH ẢNH ---
-def render_math_to_image(latex_str):
+import base64
+import logging
+import os
+import uuid
+from fastapi import APIRouter, File, UploadFile, Form
+from supabase import create_client, Client
+
+# Cấu hình Log
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/omr", tags=["ChamThiOMR"])
+
+# --- KẾT NỐI SUPABASE ---
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+supabase: Client = None
+
+if SUPABASE_URL and SUPABASE_KEY:
     try:
-        # Xóa các ký tự thừa nếu AI lỡ thêm vào
-        clean_latex = latex_str.replace("`", "").strip()
-        
-        fig = plt.figure(figsize=(8, 0.8), dpi=200) # Giảm chiều cao xuống 0.8 để gọn hơn
-        fig.patch.set_alpha(0)
-        
-        # Vẽ công thức
-        # Dùng r"..." để tránh lỗi escape character
-        text_obj = fig.text(0.01, 0.5, f"${clean_latex}$", fontsize=22, 
-                           ha='left', va='center', color='#333333', fontname='DejaVu Sans')
-        
-        img_buffer = BytesIO()
-        plt.savefig(img_buffer, format='png', bbox_inches='tight', pad_inches=0.05)
-        plt.close(fig)
-        img_buffer.seek(0)
-        return img_buffer
+        supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+        logger.info("✅ OMR Module: Đã kết nối Supabase")
     except Exception as e:
-        print(f"Lỗi render math: {e}")
-        return None
+        logger.error(f"❌ OMR Module: Lỗi kết nối Supabase: {e}")
+
+# --- BIẾN TOÀN CỤC (CACHE RAM) ---
+sessions = {}
 
-# --- HÀM 2: GỬI GEMINI (PROMPT CHẶT CHẼ HƠN) ---
-async def generate_lesson_plan(api_keys: list, images_data: list, subject: str, grade: str, duration: int, style: str):
-    if not api_keys: raise ValueError("Thiếu API Key")
-    MODEL_NAME = "gemini-2.5-flash"
+# --- CÁC HÀM XỬ LÝ ẢNH ---
 
-    prompt = f"""
-    Đóng vai trò giáo viên {subject} lớp {grade}. Soạn bài giảng slide ({duration} phút).
+def order_points(pts):
+    """Sắp xếp 4 điểm góc theo thứ tự: trên-trái, trên-phải, dưới-phải, dưới-trái"""
+    rect = np.zeros((4, 2), dtype="float32")
+    s = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(s)]
+    rect[2] = pts[np.argmax(s)]
+    diff = np.diff(pts, axis=1)
+    rect[1] = pts[np.argmin(diff)]
+    rect[3] = pts[np.argmax(diff)]
+    return rect
+
+def four_point_transform(image, pts):
+    """Biến đổi phối cảnh (warp) để làm phẳng tờ phiếu"""
+    rect = order_points(pts)
+    (tl, tr, br, bl) = rect
+    maxWidth = max(int(np.linalg.norm(br - bl)), int(np.linalg.norm(tr - tl)))
+    maxHeight = max(int(np.linalg.norm(tr - br)), int(np.linalg.norm(tl - bl)))
+    dst = np.array([[0, 0],[maxWidth - 1, 0],[maxWidth - 1, maxHeight - 1],[0, maxHeight - 1]], dtype="float32")
+    M = cv2.getPerspectiveTransform(rect, dst)
+    return cv2.warpPerspective(image, M, (maxWidth, maxHeight))
+
+def read_bubbles(roi, cols, rows, draw_on_me=None, offset=(0,0), bubble_thresh=100):
+    """
+    Hàm đọc bong bóng đa năng.
+    roi: Vùng ảnh chứa bong bóng
+    cols: Số lượng cột dọc cần đọc
+    rows: Số lượng hàng ngang (số bong bóng trong 1 cột)
+    bubble_thresh: Ngưỡng pixel (đã giảm xuống 100 để nhạy hơn)
+    """
+    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+    # Dùng Threshold Otsu để tách đen trắng
+    thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
     
-    QUY TẮC TUYỆT ĐỐI VỀ CÔNG THỨC TOÁN (BẮT BUỘC TUÂN THỦ):
-    1. KHÔNG VIẾT CÔNG THỨC CHUNG DÒNG VỚI VĂN BẢN.
-    2. Muốn viết công thức, PHẢI XUỐNG DÒNG RIÊNG.
-    3. Bắt đầu dòng công thức bằng `[MATH]`.
+    cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cnts = imutils.grab_contours(cnts)
+    bubbles = []
     
-    SAI: "Ta có phương trình [MATH] x^2 + 1 = 0"
-    ĐÚNG:
-    "Ta có phương trình sau:"
-    "[MATH] x^2 + 1 = 0"
+    h_img, w_img = roi.shape[:2]
+    # Kích thước tối thiểu của bong bóng (để lọc nhiễu)
+    # [TWEAK] Giảm kích thước tối thiểu để bắt được bong bóng nhỏ
+    min_w = w_img // (cols * 6) 
     
-    QUY TẮC BỐ CỤC CHỐNG TRÀN:
-    - Mỗi slide tối đa 4 ý chính.
-    - Mỗi ý viết NGẮN GỌN (tối đa 15 từ). KHÔNG viết đoạn văn dài.
+    for c in cnts:
+        (x, y, w, h) = cv2.boundingRect(c)
+        ar = w / float(h)
+        # [TWEAK] Nới lỏng tỷ lệ khung hình (0.5 - 1.5) để chấp nhận ô bị méo
+        if w >= min_w and 0.5 <= ar <= 1.5:
+            bubbles.append(c)
     
-    Output JSON:
-    {{
-      "title": "TÊN BÀI HỌC",
-      "slides": [
-        {{ "layout": "title", "title": "TÊN BÀI", "subtitle": "GV AI | Lớp {grade}" }},
-        {{
-          "layout": "content",
-          "title": "1. Tiêu đề mục",
-          "content": [
-            "Định nghĩa tập hợp là:",
-            "[MATH] A = \\{{1; 2; 3\\}}",
-            "Ký hiệu thuộc là:",
-            "[MATH] x \\in A"
-          ],
-          "highlight": "Ghi nhớ" 
-        }}
-      ]
-    }}
-    """
+    if not bubbles: return None
 
-    for index, key in enumerate(api_keys):
-        key = key.strip()
-        if not key: continue
-        print(f"🔄 Thử Key {index+1}...")
-        try:
-            genai.configure(api_key=key)
-            model = genai.GenerativeModel(MODEL_NAME)
+    try:
+        # 1. Sắp xếp tất cả bong bóng từ TRÁI sang PHẢI để phân thành các cột
+        bubbles = sort_contours(bubbles, method="left-to-right")[0]
+        columns = []
+        current_col = []
+        prev_x = -1000
+        
+        # Thuật toán gom nhóm các bong bóng thẳng hàng dọc thành cột
+        for c in bubbles:
+            (x, y, w, h) = cv2.boundingRect(c)
+            # Nếu khoảng cách x nhảy vọt -> sang cột mới
+            if x - prev_x > w:
+                if current_col: 
+                    # Sắp xếp cột hiện tại từ TRÊN xuống DƯỚI (0 -> 9)
+                    current_col = sort_contours(current_col, method="top-to-bottom")[0]
+                    columns.append(current_col)
+                current_col = [c]
+                prev_x = x + w/2 # Cập nhật tâm x mới
+            else:
+                current_col.append(c)
+                
+        if current_col: 
+            current_col = sort_contours(current_col, method="top-to-bottom")[0]
+            columns.append(current_col)
             
-            request_contents = [prompt]
-            request_contents.extend(images_data)
+        # Chỉ lấy đúng số cột cần thiết (tránh nhiễu bên ngoài)
+        if len(columns) > cols: columns = columns[:cols]
+        
+        result_str = ""
+        
+        for col in columns:
+            filled_idx = -1
+            max_pixel = 0
             
-            response = model.generate_content(request_contents)
-            txt = response.text
+            # Duyệt từng bong bóng trong cột (0-9)
+            for i, c in enumerate(col):
+                mask = np.zeros(thresh.shape, dtype="uint8")
+                cv2.drawContours(mask, [c], -1, 255, -1)
+                mask = cv2.bitwise_and(thresh, thresh, mask=mask)
+                total = cv2.countNonZero(mask) # Đếm số pixel trắng (đã tô)
+                
+                # Debug: Vẽ khung xanh quanh bong bóng tìm thấy
+                if draw_on_me is not None:
+                    (x, y, w, h) = cv2.boundingRect(c)
+                    cv2.rectangle(draw_on_me, (x+offset[0], y+offset[1]), (x+w+offset[0], y+h+offset[1]), (0, 255, 0), 1)
+
+                if total > max_pixel:
+                    max_pixel = total
+                    filled_idx = i
             
-            if "```json" in txt: 
-                txt = txt.split("```json")[1].split("```")[0]
-            elif "```" in txt: 
-                txt = txt.split("```")[1].split("```")[0]
+            # Kiểm tra ngưỡng tô (threshold)
+            if max_pixel > bubble_thresh:
+                result_str += str(filled_idx) if filled_idx < 10 else "?"
+                # Debug: Vẽ chấm đỏ vào ô được chọn
+                if draw_on_me is not None and filled_idx != -1 and filled_idx < len(col):
+                    c = col[filled_idx]
+                    (x, y, w, h) = cv2.boundingRect(c)
+                    cv2.circle(draw_on_me, (int(x+w/2+offset[0]), int(y+h/2+offset[1])), int(w/2), (0, 0, 255), 3)
+            else:
+                result_str += "?" # Không tô hoặc tô quá mờ
+                
+        return result_str
+
+    except Exception as e:
+        logger.error(f"Sort Error: {e}")
+        return None
+
+def process_omr(image_bytes, all_keys):
+    try:
+        nparr = np.frombuffer(image_bytes, np.uint8)
+        image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        
+        if image.shape[1] > 1600: image = imutils.resize(image, width=1600)
+        
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+        edged = cv2.Canny(blurred, 75, 200)
+
+        cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        cnts = imutils.grab_contours(cnts)
+        
+        docCnt = None
+        if len(cnts) > 0:
+            cnts = sorted(cnts, key=cv2.contourArea, reverse=True)
+            for c in cnts:
+                peri = cv2.arcLength(c, True)
+                approx = cv2.approxPolyDP(c, 0.02 * peri, True)
+                if len(approx) == 4: 
+                    docCnt = approx
+                    break
+        
+        if docCnt is not None:
+            warped = four_point_transform(image, docCnt.reshape(4, 2))
+        else:
+            warped = image
+
+        h, w = warped.shape[:2]
+        draw_img = warped.copy()
+
+        # === CẤU HÌNH VÙNG CẮT MỚI (UPDATE QUAN TRỌNG) ===
+        # Thay vì cắt dọc (Trái/Phải), ta cắt ngang (Trên/Dưới) để phù hợp layout mới
+        
+        # 1. XỬ LÝ ID (SBD + MÃ ĐỀ) - Nằm ở phần trên (Khoảng 18% đến 38% chiều cao trang)
+        # ID nằm lệch trái nên ta lấy 70% chiều rộng bên trái
+        id_y_start = int(h * 0.18)
+        id_y_end = int(h * 0.38) 
+        id_x_end = int(w * 0.75) # Lấy rộng ra chút để bao trọn cả Mã đề
+        
+        id_roi = warped[id_y_start:id_y_end, 0:id_x_end]
+        
+        # Đọc 10 cột (6 SBD + 4 Mã đề)
+        id_result = read_bubbles(id_roi, 10, 10, draw_on_me=draw_img, offset=(0, id_y_start), bubble_thresh=100)
+        
+        sbd = "AI_READ"
+        code = "DEFAULT"
+        
+        if id_result and len(id_result) >= 6:
+            sbd = id_result[:6].replace("?", "")
+            if len(id_result) >= 10:
+                code = id_result[6:10].replace("?", "")
+            elif len(id_result) >= 9:
+                 code = id_result[6:].replace("?", "")
+        
+        # 2. XỬ LÝ CÂU HỎI - Nằm ở phần dưới (Từ 38% trở xuống)
+        # Quét toàn bộ chiều rộng (0 đến w) vì câu hỏi dàn đều 4 cột
+        ans_y_start = int(h * 0.38)
+        ans_roi_y = ans_y_start # Lưu mốc Y để vẽ debug cho đúng
+        
+        # Logic chọn Key
+        avail_codes = list(all_keys.keys())
+        if code not in avail_codes and avail_codes: 
+            if "DEFAULT" in avail_codes: code = "DEFAULT"
+            else: code = str(avail_codes[0])
             
-            print(f"✅ Key {index+1} OK")
-            return json.loads(txt.strip())
+        key_data = all_keys.get(code, {})
+        total_q = len(key_data)
+        
+        num_cols_page = 4 if total_q > 30 else 3 
+        
+        # Tính chiều rộng mỗi cột câu hỏi (Chia đều toàn bộ chiều rộng trang)
+        # Trừ đi lề trái phải một chút (khoảng 5% mỗi bên)
+        margin_x = int(w * 0.05)
+        eff_w = w - (2 * margin_x)
+        col_width = eff_w // num_cols_page
+        
+        score = 0
+        correct_count = 0
+        
+        for c_idx in range(num_cols_page):
+            c_x_start = margin_x + c_idx * col_width
             
-        except Exception as e:
-            print(f"❌ Lỗi Key {index+1}: {e}")
-            if "429" in str(e) or "quota" in str(e).lower(): continue
-            continue
-
-    return {"title": "Lỗi", "slides": [{"layout": "content", "title": "Lỗi Hệ Thống", "content": ["Tất cả API Key đều hết hạn."]}]}
-
-# --- HÀM 3: SLIDE TRANSITION ---
-def set_slide_transition(slide):
-    xml = """
-      <p:transition xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main" spd="med">
-        <p:fade/>
-      </p:transition>
-    """
-    transition_element = parse_xml(xml)
-    found_cSld = False
-    for i, child in enumerate(slide.element):
-        if "cSld" in child.tag:
-            slide.element.insert(i + 1, transition_element)
-            found_cSld = True
-            break
-    if not found_cSld:
-        slide.element.append(transition_element)
-
-def add_header(slide, title_text, slide_num):
-    shape = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0), Inches(0), Inches(10), Inches(1.2))
-    shape.fill.solid()
-    shape.fill.fore_color.rgb = THEME_COLOR
-    shape.line.fill.background()
-    
-    tf = shape.text_frame
-    tf.text = title_text.upper()
-    p = tf.paragraphs[0]
-    p.font.bold = True
-    p.font.size = Pt(30) # Giảm xíu cho gọn
-    p.font.color.rgb = RGBColor(255,255,255)
-    p.alignment = PP_ALIGN.LEFT
-    p.margin_left = Inches(0.5)
-
-    footer = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(9), Inches(7), Inches(1), Inches(0.5))
-    footer.fill.background()
-    footer.line.fill.background()
-    footer.text_frame.text = str(slide_num)
-    footer.text_frame.paragraphs[0].alignment = PP_ALIGN.RIGHT
-    footer.text_frame.paragraphs[0].font.color.rgb = RGBColor(150,150,150)
-
-# --- HÀM CHÍNH: TẠO FILE PPTX ---
-def create_pptx_file(slide_data):
-    prs = Presentation()
-    
-    for idx, slide_info in enumerate(slide_data.get("slides", [])):
-        if slide_info.get("layout") == "title":
-            slide = prs.slides.add_slide(prs.slide_layouts[6])
-            set_slide_transition(slide)
+            # Cắt vùng ảnh của cột câu hỏi (Lấy hết chiều cao còn lại)
+            c_roi = warped[ans_y_start:h-50, c_x_start : c_x_start + col_width]
             
-            bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0), Inches(0), Inches(10), Inches(7.5))
-            bg.fill.solid()
-            bg.fill.fore_color.rgb = THEME_COLOR
+            gray_c = cv2.cvtColor(c_roi, cv2.COLOR_BGR2GRAY)
+            thresh_c = cv2.threshold(gray_c, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
+            cnts_c = cv2.findContours(thresh_c, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            cnts_c = imutils.grab_contours(cnts_c)
             
-            tb = slide.shapes.add_textbox(Inches(0.5), Inches(2.5), Inches(9), Inches(2.5))
-            p = tb.text_frame.paragraphs[0]
-            p.text = slide_info.get("title", "").upper()
-            p.font.size = Pt(48)
-            p.font.bold = True
-            p.font.color.rgb = RGBColor(255,255,255)
-            p.alignment = PP_ALIGN.CENTER
+            bubbles_c = []
+            for b in cnts_c:
+                (bx, by, bw, bh) = cv2.boundingRect(b)
+                # Lọc kích thước bong bóng
+                if bw > 10 and bw < 60: bubbles_c.append(b)
+                
+            if not bubbles_c: continue
             
-            tb2 = slide.shapes.add_textbox(Inches(1), Inches(5), Inches(8), Inches(1))
-            p2 = tb2.text_frame.paragraphs[0]
-            p2.text = slide_info.get("subtitle", "")
-            p2.font.size = Pt(24)
-            p2.font.color.rgb = RGBColor(230,230,230)
-            p2.alignment = PP_ALIGN.CENTER
-
-        else:
-            slide = prs.slides.add_slide(prs.slide_layouts[6])
-            set_slide_transition(slide)
-            add_header(slide, slide_info.get("title", ""), idx + 1)
+            try:
+                bubbles_c = sort_contours(bubbles_c, method="top-to-bottom")[0]
+            except: continue
             
-            # Điều chỉnh vị trí bắt đầu và khoảng cách
-            current_top = Inches(1.4) 
-            left_margin = Inches(0.5)
+            rows = []
+            temp_row = []
+            prev_y = -1000
             
-            content_list = slide_info.get("content", [])
-            if isinstance(content_list, list):
-                for item in content_list:
-                    # Kiểm tra [MATH] (Linh hoạt hơn chút: strip khoảng trắng)
-                    clean_item = item.strip()
+            for b in bubbles_c:
+                (bx, by, bw, bh) = cv2.boundingRect(b)
+                if by - prev_y > bh * 0.8:
+                    if temp_row:
+                        if len(temp_row) == 4:
+                            temp_row = sort_contours(temp_row, method="left-to-right")[0]
+                            rows.append(temp_row)
+                    temp_row = [b]
+                    prev_y = by + bh/2
+                else:
+                    temp_row.append(b)
+            if len(temp_row) == 4: 
+                temp_row = sort_contours(temp_row, method="left-to-right")[0]
+                rows.append(temp_row)
+                
+            for r_idx, row in enumerate(rows):
+                questions_per_col = 10 
+                q_num = c_idx * questions_per_col + r_idx + 1
+                
+                if q_num > total_q: break
+                
+                filled_opt = -1
+                max_p = 0
+                
+                for o_idx, b in enumerate(row):
+                    mask = np.zeros(thresh_c.shape, dtype="uint8")
+                    cv2.drawContours(mask, [b], -1, 255, -1)
+                    mask = cv2.bitwise_and(thresh_c, thresh_c, mask=mask)
+                    total = cv2.countNonZero(mask)
                     
-                    if clean_item.startswith("[MATH]"):
-                        latex_code = clean_item.replace("[MATH]", "").strip()
-                        img_stream = render_math_to_image(latex_code)
-                        
-                        if img_stream:
-                            # Chèn ảnh công thức
-                            pic = slide.shapes.add_picture(img_stream, left_margin + Inches(0.5), current_top, height=Inches(0.6))
-                            current_top += Inches(0.8) # Dịch xuống ít hơn (0.8 inch)
+                    # Debug khung
+                    (bx, by, bw, bh) = cv2.boundingRect(b)
+                    gx, gy = c_x_start + bx, ans_roi_y + by
+                    cv2.rectangle(draw_img, (gx, gy), (gx+bw, gy+bh), (0, 255, 0), 1)
                     
-                    else:
-                        # Chèn Text thường
-                        # Tính chiều cao ước lượng dựa trên độ dài text
-                        text_height = Inches(0.6)
-                        if len(clean_item) > 80: text_height = Inches(1.0) # Nếu dài quá thì ô to hơn
-                        
-                        tb = slide.shapes.add_textbox(left_margin, current_top, Inches(9), text_height)
-                        p = tb.text_frame.paragraphs[0]
-                        p.text = "• " + clean_item
-                        p.font.size = Pt(24) # GIẢM CỠ CHỮ XUỐNG 24pt
-                        p.font.name = "Arial"
-                        p.font.color.rgb = TEXT_COLOR
-                        p.line_spacing = 1.0 # Giãn dòng đơn
-                        
-                        # Cộng dồn vị trí dựa trên chiều cao thực tế
-                        current_top += text_height + Inches(0.1) 
-
-            if "highlight" in slide_info and slide_info["highlight"]:
-                # Đẩy highlight xuống sát đáy
-                hl_box = slide.shapes.add_shape(MSO_SHAPE.ROUNDED_RECTANGLE, Inches(1), Inches(6.5), Inches(8), Inches(0.8))
-                hl_box.fill.solid()
-                hl_box.fill.fore_color.rgb = RGBColor(255, 255, 204)
-                hl_box.line.color.rgb = RGBColor(255, 204, 0)
+                    if total > max_p:
+                        max_p = total
+                        filled_opt = o_idx
+                
+                correct_char = key_data.get(q_num, key_data.get(str(q_num))) 
                 
-                tf_hl = hl_box.text_frame
-                p_hl = tf_hl.paragraphs[0]
-                p_hl.text = "💡 " + slide_info["highlight"]
-                p_hl.font.size = Pt(18)
-                p_hl.font.color.rgb = RGBColor(100, 100, 0)
-                p_hl.alignment = PP_ALIGN.CENTER
-
-    output = BytesIO()
-    prs.save(output)
-    output.seek(0)
-    return output
+                if correct_char:
+                    correct_idx = ord(correct_char) - 65 
+                    
+                    # [TWEAK] Giảm ngưỡng xác nhận tô xuống 100
+                    if max_p > 100:
+                        b = row[filled_opt]
+                        (bx, by, bw, bh) = cv2.boundingRect(b)
+                        gx, gy = c_x_start + bx, ans_roi_y + by
+                        
+                        if filled_opt == correct_idx:
+                            correct_count += 1
+                            cv2.circle(draw_img, (gx+bw//2, gy+bh//2), bw//2, (0, 255, 0), -1) 
+                        else:
+                            cv2.circle(draw_img, (gx+bw//2, gy+bh//2), bw//2, (0, 0, 255), -1) 
+                            
+                            if correct_idx < len(row):
+                                b_correct = row[correct_idx]
+                                (bx_c, by_c, bw_c, bh_c) = cv2.boundingRect(b_correct)
+                                gx_c, gy_c = c_x_start + bx_c, ans_roi_y + by_c
+                                cv2.circle(draw_img, (gx_c+bw_c//2, gy_c+bh_c//2), 5, (255, 0, 0), -1)
+
+        if total_q > 0:
+            score = round((correct_count / total_q) * 10, 2)
+
+        cv2.rectangle(draw_img, (0, 0), (w, 100), (255, 255, 255), -1)
+        cv2.putText(draw_img, f"SBD: {sbd} | CODE: {code}", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 2)
+        cv2.putText(draw_img, f"DIEM: {score} ({correct_count}/{total_q})", (20, 90), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0,0,255), 3)
+
+        _, buffer = cv2.imencode('.jpg', draw_img)
+        b64 = base64.b64encode(buffer).decode('utf-8')
+        
+        return {
+            "student_id": sbd, "exam_code": code, "score": score,
+            "correct_count": correct_count, "total_questions": total_q,
+            "wrong_count": total_q - correct_count, "image_base64": b64,
+            "status": "success"
+        }
+
+    except Exception as e:
+        logger.error(f"OMR Error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {"score": 0, "error": str(e)}
+
+# --- DB HELPERS & API (GIỮ NGUYÊN) ---
+def save_result_to_db(data, filename, session_id):
+    if not supabase: return
+    try:
+        payload = {
+            "session_id": session_id,
+            "student_id": data.get("student_id"),
+            "exam_code": data.get("exam_code"),
+            "score": data.get("score"),
+            "correct_count": data.get("correct_count"),
+            "wrong_count": data.get("wrong_count"),
+            "total_questions": data.get("total_questions"),
+            "filename": filename
+        }
+        supabase.table("omr_results").insert(payload).execute()
+    except Exception as e:
+        logger.error(f"DB Save Error: {e}")
+
+def get_key_from_db(session_id):
+    if not supabase: return {}
+    try:
+        res = supabase.table("omr_sessions").select("answer_key_json").eq("session_id", session_id).execute()
+        if res.data:
+            return json.loads(res.data[0]['answer_key_json'])
+    except: pass
+    return {}
+
+@router.post("/create_session")
+async def create_session(name: str = Form(...), answer_key_json: str = Form(...)):
+    session_id = str(uuid.uuid4())[:8].upper()
+    try: all_keys = json.loads(answer_key_json)
+    except: all_keys = {}
+    sessions[session_id] = {"keys": all_keys, "results": []}
+    if supabase:
+        try:
+            supabase.table("omr_sessions").insert({
+                "session_id": session_id, "session_name": name, "answer_key_json": answer_key_json
+            }).execute()
+        except Exception as e:
+            logger.error(f"Create Session DB Error: {e}")
+    return {"session_id": session_id, "name": name}
+
+@router.post("/grade")
+async def grade_exam(file: UploadFile = File(...), answer_key_json: str = Form(...)):
+    try: all_keys = json.loads(answer_key_json)
+    except: return {"error": "JSON Error"}
+    content = await file.read()
+    result = process_omr(content, all_keys)
+    save_result_to_db(result, file.filename, "Direct_Upload")
+    return result
+
+@router.post("/grade_mobile")
+async def grade_mobile(session_id: str = Form(...), file: UploadFile = File(...)):
+    if session_id not in sessions:
+        db_keys = get_key_from_db(session_id)
+        if db_keys: sessions[session_id] = {"keys": db_keys, "results": []}
+        else: return {"error": "Session not found"}
+    content = await file.read()
+    result = process_omr(content, sessions[session_id]["keys"])
+    result["filename"] = file.filename
+    sessions[session_id]["results"].append(result)
+    save_result_to_db(result, file.filename, session_id)
+    return result
+
+@router.get("/poll_results/{session_id}")
+async def poll_results(session_id: str):
+    if session_id not in sessions: return []
+    res = sessions[session_id]["results"]
+    sessions[session_id]["results"] = [] 
+    return res
+
+@router.get("/history")
+def get_history():
+    if not supabase: return []
+    try: return supabase.table("omr_sessions").select("*").order("created_at", desc=True).execute().data
+    except: return []
+
+@router.get("/history/{session_id}")
+def get_history_detail(session_id: str):
+    if not supabase: return []
+    try: return supabase.table("omr_results").select("*").eq("session_id", session_id).order("created_at", desc=True).execute().data
+    except: return []
+
+@router.post("/init_session")
+async def init_session(answer_key_json: str = Form(...)):
+    return await create_session(name="Quick Session", answer_key_json=answer_key_json)