Update app.py

app.py

@@ -1,125 +1,156 @@
 # app.py
+
 import numpy as np
 np.int = int   # patch for PaddleOCR’s old np.int calls
 
-import cv2, json, tempfile, re
+import cv2
+import json
+import tempfile
+import re
 import gradio as gr
 from ultralytics import YOLO
 from paddleocr import PaddleOCR
 
+# ─── 0) Character map ───────────────────────────────────────────────
+# Your plate charset: digits + uppercase + space
+MY_CHAR_LIST = list("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ")
+
 # ─── 1) Load models ───────────────────────────────────────────────
+# YOLO for detection
 yolo = YOLO("models/best.pt")
 
-# Use recognition‐only mode (no detector), with angle‐cls to handle simple flips
+# PaddleOCR for recognition only, with angle‐classify turned on
 ocr = PaddleOCR(
-    det=False,               # skip built‐in detection
-    rec=True,                # enable recognition
+    det=False,                   # no detector
+    rec=True,                    # recognition only
     rec_model_dir="models/ocr_model",
-    cls=True,                # turn on angle classification
-    use_angle_cls=True,      # v2.x flag
-    lang="en"                # our char dict is basic Latin+digits
+    cls=True,                    # turn on angle classifier
+    use_angle_cls=True,          # v2.x flag
+    use_space_char=True         # allow recognizing spaces
 )
+# Override the internal character list so it matches your plate labels exactly
+ocr.text_recognizer.character = MY_CHAR_LIST
+
 
 # ─── 2) Turkish plate formatter ────────────────────────────────────
 def format_turkish_plate(s: str) -> str:
+    # uppercase, strip any non-alnum, then regex into “AA 123 BB” style
     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"
+    if m:
+        return f"{m.group(1)} {m.group(2)} {m.group(3)}"
+    return "Unknown"
+
 
 # ─── 3) Single‐image inference ─────────────────────────────────────
 def run_image(img, conf=0.25):
+    # convert and detect
     bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
     res = yolo(bgr, conf=conf)[0]
     out = bgr.copy()
 
-    for box, yolo_score in zip(res.boxes.xyxy.cpu().numpy(),
-                               res.boxes.conf.cpu().numpy()):
-        x1,y1,x2,y2 = box.astype(int)
+    for box, score in zip(res.boxes.xyxy.cpu().numpy(),
+                          res.boxes.conf.cpu().numpy()):
+        x1, y1, x2, y2 = box.astype(int)
         crop = out[y1:y2, x1:x2]
         if crop.size == 0:
             continue
 
-        plate_img = cv2.resize(crop, (128,32))
-        # explicitly tell PaddleOCR: skip detection here
-        recs = ocr.ocr(plate_img, det=False, cls=False)
+        # resize to your OCR’s input
+        plate_img = cv2.resize(crop, (128, 32))
+        # run recognition + angle correction
+        recs = ocr.ocr(plate_img, cls=True)
 
+        # unpack or default
         if recs and recs[0]:
-            _, (raw, ocr_score) = recs[0]
+            raw_text, ocr_score = recs[0][1][0], recs[0][1][1]
         else:
-            raw, ocr_score = "", 0.0
+            raw_text, ocr_score = "", 0.0
 
-        plate = format_turkish_plate(raw)
+        plate = format_turkish_plate(raw_text)
         label = f"{plate} ({ocr_score:.2f})"
 
-        cv2.rectangle(out, (x1,y1),(x2,y2), (0,255,0), 2)
-        cv2.putText(out, label, (x1,y1-5),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
+        # draw
+        cv2.rectangle(out, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        cv2.putText(out, label, (x1, y1 - 5),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
 
+    # back to RGB for Gradio
     return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(res.boxes)} plate(s) detected"
 
-# ─── 4) Video inference (same pattern) ───────────────────────────
+
+# ─── 4) Video inference ───────────────────────────────────────────
 def run_video(video_file, conf=0.25):
     cap = cv2.VideoCapture(video_file)
     fps = cap.get(cv2.CAP_PROP_FPS)
-    w,h = int(cap.get(3)), int(cap.get(4))
-    outfp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
-    writer = cv2.VideoWriter(outfp, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w,h))
-    records, idx = [], 0
+    w, h = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    tmp_out = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
+    writer = cv2.VideoWriter(tmp_out, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
+    records = []
 
+    frame_idx = 0
     while True:
         ret, frame = cap.read()
         if not ret:
             break
-        idx += 1
-        t = idx / fps
+        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):
+        for (x1, y1, x2, y2) in res.boxes.xyxy.cpu().numpy().astype(int):
             crop = frame[y1:y2, x1:x2]
             if crop.size == 0:
                 continue
-
-            plate_img = cv2.resize(crop, (128,32))
-            recs = ocr.ocr(plate_img, det=False, cls=False)
+            plate_img = cv2.resize(crop, (128, 32))
+            recs = ocr.ocr(plate_img, cls=True)
 
             if recs and recs[0]:
-                _, (raw, ocr_score) = recs[0]
+                raw_text, ocr_score = recs[0][1][0], recs[0][1][1]
             else:
-                raw, ocr_score = "", 0.0
+                raw_text, ocr_score = "", 0.0
 
-            plate = format_turkish_plate(raw)
+            plate = format_turkish_plate(raw_text)
             if plate != "Unknown":
-                records.append({"time_s":round(t,2), "plate":plate, "conf":round(ocr_score,3)})
+                records.append({
+                    "time_s": round(t, 2),
+                    "plate": plate,
+                    "conf": round(ocr_score, 3)
+                })
 
-            cv2.rectangle(frame, (x1,y1),(x2,y2), (0,255,0), 2)
-            cv2.putText(frame, plate, (x1,y1-5),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
+            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            cv2.putText(frame, plate, (x1, y1 - 5),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
 
         writer.write(frame)
 
     cap.release()
     writer.release()
-    with open("output.json","w") as f:
+
+    # save JSON log
+    with open("output.json", "w") as f:
         json.dump(records, f, indent=2)
-    return outfp
+
+    return tmp_out, "Done"
+
 
 # ─── 5) Gradio UI ─────────────────────────────────────────────────
 with gr.Blocks() as demo:
-    gr.Markdown("## 🚗 License Plate Detection + Recognition")
+    gr.Markdown("## 🚗 License Plate Detection & Recognition")
+
     with gr.Row():
         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, 1, 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()