Update app.py

app.py

@@ -1,80 +1,92 @@
 # app.py
-import re
-import json
+import re, json, tempfile
 import cv2
-import tempfile
 import numpy as np
 import gradio as gr
 from ultralytics import YOLO
 from paddleocr import PaddleOCR
 
-# ─── 0) Patch for old np.int usage ─────────────────────────────────
+# ─── 0) np.int patch for older PaddleOCR calls
 np.int = int
 
-# ─── 1) Character map (exactly the one used for training) ──────────
-# Digits + uppercase letters + space
-MY_CHAR_LIST = list("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ")
+# ─── 1) Plate character set (digits + uppercase + space)
+CHAR_LIST = list("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ")
 
-# ─── 2) Load models ────────────────────────────────────────────────
-yolo = YOLO("models/best.pt")  # your YOLOv8 detector
+# ─── 2) Load YOLOv8 detector
+yolo = YOLO("models/best.pt")
 
+# ─── 3) Init PaddleOCR recognition-only, override ALL params in-code
 ocr = PaddleOCR(
-    det=False,                   # disable PaddleOCR detector on crops
-    rec=True,                    # enable recognition
+    det=False,                   # disable det on plate crops
+    rec=True,                    # recognition-only
     rec_model_dir="models/ocr_model",
-    use_angle_cls=True,          # angle classifier
-    cls=True,                    # v3.x flag
-    use_space_char=True          # allow space in output
+    rec_image_shape="3,32,128",  # must match your training
+    cls=True,                    # angle classifier
+    use_angle_cls=True,
+    use_space_char=True
 )
-# Override the internal character list so it matches your training:
-ocr.text_recognizer.character = MY_CHAR_LIST
+# Force our exact char map (no dict file needed)
+ocr.text_recognizer.character = CHAR_LIST
+
+# ─── 4) Normalize & format OCR output
+def normalize_ocr(recs):
+    """
+    recs might be:
+      - []                                    → no read
+      - [["ABC123", 0.82]]                    → default det=False
+      - [["ABC123", 0.82], ...]               → (unlikely here)
+      - [[box,…], ("ABC123",0.82)]            → old det=True style
+    return text:str, score:float
+    """
+    if not recs:
+        return "", 0.0
+    first = recs[0]
+    # case: ["TXT",score]
+    if isinstance(first, (list,tuple)) and len(first)==2 and isinstance(first[0], str):
+        return first[0], float(first[1])
+    # case: [<box>, (<txt>,score)] or [<box>, [txt,score]]
+    if isinstance(first, (list,tuple)) and len(first)==2 and isinstance(first[1], (list,tuple)):
+        return first[1][0], float(first[1][1])
+    return "", 0.0
 
-# ─── 3) Plate formatting ───────────────────────────────────────────
 def format_plate(s: str) -> str:
-    """Normalize raw OCR-> 'DD AAA DDDD' or 'Unknown'."""
+    """‘DD AAA DDDD’  veya Unknown"""
     s = re.sub(r'[^A-Z0-9]', '', s.upper())
     m = re.match(r'^(\d{2})([A-Z]{1,3})(\d{2,4})$', s)
     return f"{m.group(1)} {m.group(2)} {m.group(3)}" if m else "Unknown"
 
-# ─── 4) OCR helper ────────────────────────────────────────────────
-def recognize_plate(crop):
-    """
-    Run OCR on a 128×32 crop; return (text, confidence).
-    """
-    recs = ocr.ocr(crop, det=False, cls=True)
-    if not recs or len(recs[0]) < 2:
-        return "", 0.0
-    text, score = recs[0][1]
-    return text, float(score)
-
-# ─── 5) Single-image inference ────────────────────────────────────
+# ─── 5) Single-image inference
 def run_image(img, conf=0.25):
-    # YOLO expects BGR
+    # YOLO wants BGR
     bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-    results = yolo(bgr, conf=conf)[0]
+    res = yolo(bgr, conf=conf)[0]
     out = bgr.copy()
 
-    for box in results.boxes.xyxy.cpu().numpy().astype(int):
+    for box in res.boxes.xyxy.cpu().numpy().astype(int):
         x1,y1,x2,y2 = box
         crop = out[y1:y2, x1:x2]
         if crop.size == 0:
             continue
 
-        # resize to match your OCR training size
-        plate_img = cv2.resize(crop, (128, 32))
-        text, score = recognize_plate(plate_img)
-        plate = format_plate(text)
+        # resize to OCR input
+        plate_img = cv2.resize(crop, (128,32))
+        # safe OCR
+        try:
+            recs = ocr.ocr(plate_img, det=False, cls=True)
+        except Exception:
+            recs = []
+        txt, score = normalize_ocr(recs)
+        plate = format_plate(txt)
         label = f"{plate} ({score:.2f})"
 
         # draw
-        cv2.rectangle(out, (x1,y1), (x2,y2), (0,255,0), 2)
+        cv2.rectangle(out, (x1,y1),(x2,y2), (0,255,0), 2)
         cv2.putText(out, label, (x1, y1-8),
                     cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
 
-    # back to RGB
-    return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(results.boxes)} plate(s) detected"
+    return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(res.boxes)} plate(s) detected"
 
-# ─── 6) Video inference ────────────────────────────────────────────
+# ─── 6) Video inference
 def run_video(video_file, conf=0.25):
     cap = cv2.VideoCapture(video_file)
     fps = cap.get(cv2.CAP_PROP_FPS) or 30
@@ -82,52 +94,43 @@ def run_video(video_file, conf=0.25):
     h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
     out_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
-    writer = cv2.VideoWriter(
-        out_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w,h)
-    )
-    records = []
-    frame_idx = 0
+    writer = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w,h))
+    records, idx = [], 0
 
     while True:
         ret, frame = cap.read()
-        if not ret:
-            break
-        frame_idx += 1
-        t = frame_idx / fps
+        if not ret: break
+        idx += 1; t = idx/fps
 
-        results = yolo(frame, conf=conf)[0]
-        for box in results.boxes.xyxy.cpu().numpy().astype(int):
+        res = yolo(frame, conf=conf)[0]
+        for box in res.boxes.xyxy.cpu().numpy().astype(int):
             x1,y1,x2,y2 = box
             crop = frame[y1:y2, x1:x2]
-            if crop.size == 0:
-                continue
+            if crop.size == 0: continue
 
-            plate_img = cv2.resize(crop, (128, 32))
-            text, score = recognize_plate(plate_img)
-            plate = format_plate(text)
+            plate_img = cv2.resize(crop, (128,32))
+            try:
+                recs = ocr.ocr(plate_img, det=False, cls=True)
+            except:
+                recs = []
+            txt, score = normalize_ocr(recs)
+            plate = format_plate(txt)
 
             if plate != "Unknown":
-                records.append({
-                    "time_s": round(t, 2),
-                    "plate": plate,
-                    "conf": round(score, 3)
-                })
+                records.append({"time_s":round(t,2),"plate":plate,"conf":round(score,3)})
 
-            cv2.rectangle(frame, (x1,y1), (x2,y2), (0,255,0), 2)
+            cv2.rectangle(frame, (x1,y1),(x2,y2), (0,255,0), 2)
             cv2.putText(frame, plate, (x1, y1-8),
                         cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
 
         writer.write(frame)
 
-    cap.release()
-    writer.release()
-
+    cap.release(); writer.release()
     with open("output.json","w") as f:
         json.dump(records, f, indent=2)
-
     return out_path, "Done"
 
-# ─── 7) Gradio UI ─────────────────────────────────────────────────
+# ─── 7) Gradio UI
 with gr.Blocks() as demo:
     gr.Markdown("## 🚗 License Plate Detection + Recognition")
 
@@ -135,7 +138,7 @@ with gr.Blocks() as demo:
         with gr.Column():
             img_in = gr.Image(type="numpy", label="Upload Image")
             vid_in = gr.File(label="Upload Video (.mp4)")
-            conf   = gr.Slider(0.0, 1.0, 0.25, 0.01, label="YOLO Confidence")
+            conf   = gr.Slider(0.0,1.0,0.25,0.01, label="YOLO Confidence")
             btn_i  = gr.Button("Run Image")
             btn_v  = gr.Button("Run Video")
         with gr.Column():