Update app.py

app.py

@@ -1,7 +1,6 @@
 # app.py
 import cv2, json, tempfile, re
 import numpy as np
-np.int = int  # work around numpy 2.0 deprecations
 import gradio as gr
 from ultralytics import YOLO
 from paddleocr import PaddleOCR
@@ -9,120 +8,124 @@ from paddleocr import PaddleOCR
 # ─── 1) Load models ───────────────────────────────────────────────
 yolo = YOLO("models/best.pt")
 ocr  = PaddleOCR(
-    det=False,                # no built-in detection
-    rec=True,                 # recognition only
-    rec_model_dir="models/ocr_model",
-    cls=False,                # no angle classification
+    det=False,                                # turn off detection
+    rec=True,                                 # recognition only
+    text_recognition_model_dir="models/ocr_model",
+    cls=False                                 # no angle classification
 )
 
 # ─── 2) Turkish plate formatter ────────────────────────────────────
 def format_turkish_plate(s: str) -> str:
-    m = re.match(r"^(\d{2})([A-Z]{1,3})(\d{2,4})$", s.replace(" ",""))
+    # Matches e.g. "06NE944" → "06 NE 944"
+    m = re.match(r"^(\d{2})([A-Z]{1,3})(\d{2,4})$", s.replace(" ", ""))
     return f"{m[1]} {m[2]} {m[3]}" if m else "Unknown"
 
 # ─── 3) Single‐image pipeline ─────────────────────────────────────
 def run_image(img, conf=0.25):
+    # Convert RGB→BGR for YOLO
     bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
     res = yolo(bgr, conf=conf)[0]
     out = bgr.copy()
 
+    # Loop over each detected box
     for box, yolo_score in zip(res.boxes.xyxy.cpu().numpy(),
                                res.boxes.conf.cpu().numpy()):
-        x1,y1,x2,y2 = box.astype(int)
+        x1, y1, x2, y2 = box.astype(int)
         roi = out[y1:y2, x1:x2]
-        if roi.size == 0: 
+        if roi.size == 0:
             continue
 
-        plate_img = cv2.resize(roi, (128,32))
+        # Resize to your OCR input shape
+        plate_img = cv2.resize(roi, (128, 32))
         ocr_result = ocr.ocr(plate_img, cls=True)
 
-        if not ocr_result or not ocr_result[0]:
-            detected_text = ""
-            ocr_score = 0.0
+        # Safely unpack [ [poly], (text,score) ] or yield empty
+        if ocr_result and ocr_result[0]:
+            _, (raw_text, ocr_score) = ocr_result[0]
         else:
-            detected_text = ocr_result[0][0]
-            ocr_score     = ocr_result[0][1]
+            raw_text, ocr_score = "", 0.0
 
-        label_text = format_turkish_plate(detected_text)
+        # Format & draw
+        label_text = format_turkish_plate(raw_text)
         label = f"{label_text} ({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)
 
-        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)
-
-    return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(res.boxes)} plate(s)"
-
+    # Convert BGR→RGB for display
+    return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(res.boxes)} plate(s) detected"
 
 # ─── 4) Video pipeline ───────────────────────────────────────────
 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))
+    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))
+    writer = cv2.VideoWriter(outfp, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
 
     records = []
-    idx = 0
+    frame_i = 0
 
     while True:
         ret, frame = cap.read()
-        if not ret: 
+        if not ret:
             break
-        idx += 1
-        t = idx / fps
+        frame_i += 1
+        t = frame_i / 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):
             roi = frame[y1:y2, x1:x2]
-            if roi.size == 0: 
+            if roi.size == 0:
                 continue
 
-            plate_img = cv2.resize(roi, (128,32))
-            rec = ocr.ocr(plate_img, cls=True)[0]
-
-            if rec:
-                text, ocr_score = rec
+            plate_img = cv2.resize(roi, (128, 32))
+            ocr_result = ocr.ocr(plate_img, cls=True)
+            if ocr_result and ocr_result[0]:
+                _, (raw_text, ocr_score) = ocr_result[0]
             else:
-                text, ocr_score = "", 0.0
+                raw_text, ocr_score = "", 0.0
 
-            label_text = format_turkish_plate(text)
+            label_text = format_turkish_plate(raw_text)
             if label_text != "Unknown":
                 records.append({
-                    "time_s": round(t,2),
+                    "time_s": round(t, 2),
                     "plate": label_text,
-                    "conf": round(ocr_score,3)
+                    "conf": round(ocr_score, 3)
                 })
 
-            cv2.rectangle(frame, (x1,y1), (x2,y2), (0,255,0), 2)
-            cv2.putText(frame, label_text, (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, label_text, (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:
+    # Dump JSON timeline
+    with open("output.json", "w") as f:
         json.dump(records, f, indent=2)
     return outfp
 
-# ─── 5) Gradio UI ─────────────────────────────────────────────────
+# ─── 5) Gradio Web UI ──────────────────────────────────────────────
 with gr.Blocks() as demo:
     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)")
-            slider = gr.Slider(0,1,0.25,0.01, label="YOLO Confidence")
-            btn1   = gr.Button("Run Image")
-            btn2   = gr.Button("Run Video")
+            img_in  = gr.Image(type="numpy", label="Upload Image")
+            vid_in  = gr.File(label="Upload Video (.mp4)")
+            slider  = gr.Slider(0, 1, 0.25, 0.01, label="YOLO Confidence")
+            btn_img = gr.Button("Run Image")
+            btn_vid = gr.Button("Run Video")
         with gr.Column():
             img_out = gr.Image(type="numpy", label="Annotated Image")
             vid_out = gr.Video(label="Annotated Video")
             txt_out = gr.Textbox(label="Status / JSON Path")
 
-    btn1.click(run_image, [img_in, slider], [img_out, txt_out])
-    btn2.click(run_video, [vid_in, slider], [vid_out, txt_out])
+    btn_img.click(run_image, [img_in, slider], [img_out, txt_out])
+    btn_vid.click(run_video, [vid_in, slider], [vid_out, txt_out])
 
 if __name__ == "__main__":
     demo.launch()