Update app.py

app.py

@@ -1,89 +1,93 @@
 # app.py
+import re
+import json
+import cv2
+import tempfile
 import numpy as np
-np.int = int   # patch for PaddleOCR’s old np.int calls
-
-import cv2, json, tempfile, re
 import gradio as gr
 from ultralytics import YOLO
 from paddleocr import PaddleOCR
 
-# ─── 1) Load models ───────────────────────────────────────────────
-yolo = YOLO("models/best.pt")
+# ─── 0) Patch for old np.int usage ─────────────────────────────────
+np.int = int
+
+# ─── 1) Character map (exactly the one used for training) ──────────
+# Digits + uppercase letters + space
+MY_CHAR_LIST = list("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ")
+
+# ─── 2) Load models ────────────────────────────────────────────────
+yolo = YOLO("models/best.pt")  # your YOLOv8 detector
 
-# Recognition-only PaddleOCR: no det_model_dir, so ocr.ocr() only runs the recognizer + cls
 ocr = PaddleOCR(
-    det_model_dir=None,               # disable PaddleOCR’s own detector entirely
-    rec_model_dir="models/ocr_model", # your trained CRNN weights
-    use_textline_orientation=False,
-    lang="en",
-    use_angle_cls=True,               # flip/rotation correction
-    use_space_char=True               # allow spaces
+    det=False,                   # disable PaddleOCR detector on crops
+    rec=True,                    # enable recognition
+    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
 )
+# Override the internal character list so it matches your training:
+ocr.text_recognizer.character = MY_CHAR_LIST
 
-# ─── 2) Turkish plate formatter ────────────────────────────────────
-def format_turkish_plate(s: str) -> str:
+# ─── 3) Plate formatting ───────────────────────────────────────────
+def format_plate(s: str) -> str:
+    """Normalize raw OCR-> 'DD AAA DDDD' or '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"
 
-# ─── 3) Flatten OCR result & pick min confidence ───────────────────
-def parse_ocr(recs):
+# ─── 4) OCR helper ────────────────────────────────────────────────
+def recognize_plate(crop):
     """
-    recs from ocr.ocr(crop, cls=True) comes back as:
-      [  # list per text-line
-        [ <coords>, (<text>, <score>) ],
-        [ <coords>, (<text>, <score>) ],
-        ...
-      ]
-    We join all <text> pieces, and take the min score across them.
+    Run OCR on a 128×32 crop; return (text, confidence).
     """
-    if not recs or not recs[0]:
+    recs = ocr.ocr(crop, det=False, cls=True)
+    if not recs or len(recs[0]) < 2:
         return "", 0.0
-    lines = recs[0]
-    texts  = [line[1][0] for line in lines]
-    scores = [line[1][1] for line in lines]
-    return "".join(texts), float(min(scores))
+    text, score = recs[0][1]
+    return text, float(score)
 
-# ─── 4) Single-image inference ─────────────────────────────────────
+# ─── 5) Single-image inference ────────────────────────────────────
 def run_image(img, conf=0.25):
-    # convert to BGR for YOLO
+    # YOLO expects BGR
     bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-    res = yolo(bgr, conf=conf)[0]      # detect plates
+    results = yolo(bgr, conf=conf)[0]
     out = bgr.copy()
 
-    for box in res.boxes.xyxy.cpu().numpy().astype(int):
+    for box in results.boxes.xyxy.cpu().numpy().astype(int):
         x1,y1,x2,y2 = box
         crop = out[y1:y2, x1:x2]
         if crop.size == 0:
             continue
 
-        # resize for CRNN
+        # resize to match your OCR training size
         plate_img = cv2.resize(crop, (128, 32))
-        # recognize only (no internal detection)
-        recs = ocr.ocr(plate_img, cls=True)
-
-        raw, score = parse_ocr(recs)
-        plate = format_turkish_plate(raw)
+        text, score = recognize_plate(plate_img)
+        plate = format_plate(text)
         label = f"{plate} ({score:.2f})"
 
-        # draw box + label
+        # draw
         cv2.rectangle(out, (x1,y1), (x2,y2), (0,255,0), 2)
-        cv2.putText(out, label, (x1, y1-5),
+        cv2.putText(out, label, (x1, y1-8),
                     cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
 
-    return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(res.boxes)} plate(s) detected"
+    # back to RGB
+    return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(results.boxes)} plate(s) detected"
 
-# ─── 5) 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)
-    w   = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    h   = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    outfp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
-    writer = cv2.VideoWriter(outfp, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w,h))
-
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    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
+
     while True:
         ret, frame = cap.read()
         if not ret:
@@ -91,37 +95,39 @@ def run_video(video_file, conf=0.25):
         frame_idx += 1
         t = frame_idx / fps
 
-        res = yolo(frame, conf=conf)[0]
-        for (x1,y1,x2,y2) in res.boxes.xyxy.cpu().numpy().astype(int):
+        results = yolo(frame, conf=conf)[0]
+        for box in results.boxes.xyxy.cpu().numpy().astype(int):
+            x1,y1,x2,y2 = box
             crop = frame[y1:y2, x1:x2]
             if crop.size == 0:
                 continue
 
-            plate_img = cv2.resize(crop, (128,32))
-            recs = ocr.ocr(plate_img, cls=True)
-            raw, score = parse_ocr(recs)
-            plate = format_turkish_plate(raw)
+            plate_img = cv2.resize(crop, (128, 32))
+            text, score = recognize_plate(plate_img)
+            plate = format_plate(text)
+
             if plate != "Unknown":
                 records.append({
-                    "time_s": round(t,2),
-                    "plate":  plate,
-                    "conf":   round(score,3)
+                    "time_s": round(t, 2),
+                    "plate": plate,
+                    "conf": round(score, 3)
                 })
 
-            cv2.rectangle(frame, (x1,y1),(x2,y2), (0,255,0), 2)
-            cv2.putText(frame, plate, (x1, y1-5),
+            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()
+
     with open("output.json","w") as f:
         json.dump(records, f, indent=2)
 
-    return outfp, "Done"
+    return out_path, "Done"
 
-# ─── 6) Gradio UI ──────────────────────────────────────────────────
+# ─── 7) Gradio UI ─────────────────────────────────────────────────
 with gr.Blocks() as demo:
     gr.Markdown("## 🚗 License Plate Detection + Recognition")
 
@@ -129,16 +135,16 @@ 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,1,0.25,0.01, label="YOLO Confidence")
-            b1     = gr.Button("Run Image")
-            b2     = gr.Button("Run Video")
+            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():
             img_out = gr.Image(type="numpy", label="Annotated Image")
             vid_out = gr.Video(label="Annotated Video")
             status  = gr.Textbox(label="Status / JSON Path")
 
-    b1.click(run_image, [img_in,conf], [img_out,status])
-    b2.click(run_video, [vid_in,conf], [vid_out,status])
+    btn_i.click(run_image, [img_in,conf], [img_out,status])
+    btn_v.click(run_video, [vid_in,conf], [vid_out,status])
 
-if __name__=="__main__":
+if __name__ == "__main__":
     demo.launch()