Update app.py

app.py

@@ -8,180 +8,145 @@ import psutil
 from ultralytics import YOLO
 from paddleocr import PaddleOCR
 
-# ─── 0) np.int patch for older PaddleOCR calls
-np.int = int
+np.int = int  # For backward compatibility
 
-# ─── 1) Plate character set (digits + uppercase + space)
 CHAR_LIST = list("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ")
-
-# ─── 2) Load YOLOv8 detector
 yolo = YOLO("models/best.pt")
 
-# ─── 3) Init PaddleOCR recognition-only, override ALL params in-code
-ocr = PaddleOCR(
-    det=False,                   # disable det on plate crops
-    rec=True,                    # recognition-only
-    rec_model_dir="models/ocr_model",
-    rec_image_shape="3,32,128",  # must match your training
-    cls=True,                    # angle classifier
-    use_angle_cls=True,
-    use_space_char=True
-)
-# Force our exact char map (no dict file needed)
-ocr.text_recognizer.character = CHAR_LIST
 def print_mem_usage(tag=""):
     mem = psutil.virtual_memory()
     print(f"[{tag}] RAM usage: {mem.used / 1024**2:.2f} MB / {mem.total / 1024**2:.2f} MB ({mem.percent}%)")
 
-
-# ─── 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):
+    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)):
+    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
 
-# Plaka format kontrolü (Türk plakası değilse orijinal yazı korunur)
 def format_plate(s: str) -> str:
     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 f"RAW: {s}" if s else "Unknown"
 
-# Perspektif düzeltme (tek sıra plaka kenarı düz olmayan durumlar için)
 def correct_perspective(image, box):
     x1, y1, x2, y2 = box
     h, w = image.shape[:2]
-    margin = 5  # biraz dışarıdan al
-
+    margin = 5
     x1 = max(0, x1 - margin)
     y1 = max(0, y1 - margin)
     x2 = min(w, x2 + margin)
     y2 = min(h, y2 + margin)
-
     crop = image[y1:y2, x1:x2]
-    if crop.size == 0: return None
-
-    # OCR input boyutuna perspektif düzeltme
-    src_pts = np.float32([
-        [0, 0], [crop.shape[1], 0],
-        [crop.shape[1], crop.shape[0]], [0, crop.shape[0]]
-    ])
-    dst_pts = np.float32([
-        [0, 0], [128, 0],
-        [128, 32], [0, 32]
-    ])
+    if crop.size == 0:
+        return None
+    src_pts = np.float32([[0, 0], [crop.shape[1], 0], [crop.shape[1], crop.shape[0]], [0, crop.shape[0]]])
+    dst_pts = np.float32([[0, 0], [128, 0], [128, 32], [0, 32]])
     M = cv2.getPerspectiveTransform(src_pts, dst_pts)
     warped = cv2.warpPerspective(crop, M, (128, 32))
     return warped
 
-# Güncellenmiş image fonksiyonu
+def create_ocr():
+    ocr = PaddleOCR(
+        det=False,
+        rec=True,
+        rec_model_dir="models/ocr_model",
+        rec_image_shape="3,32,128",
+        cls=True,
+        use_angle_cls=True,
+        use_space_char=True
+    )
+    ocr.text_recognizer.character = CHAR_LIST
+    return ocr
+
 def run_image(img, conf=0.25):
+    ocr = create_ocr()
     bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
     res = yolo(bgr, conf=conf)[0]
     out = bgr.copy()
 
     for box in res.boxes.xyxy.cpu().numpy().astype(int):
         warped = correct_perspective(out, box)
-        if warped is None: continue
-
+        if warped is None:
+            continue
         try:
             recs = ocr.ocr(warped, det=False, cls=True)
-            # After OCR call:
-            gc.collect()
-            print_mem_usage("After OCR")
         except:
             recs = []
+        gc.collect()
+        print_mem_usage("After OCR")
         txt, score = normalize_ocr(recs)
         plate = format_plate(txt)
         label = f"{plate} ({score:.2f})"
-
         x1, y1, x2, y2 = box
-        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)
+        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)
 
     return cv2.cvtColor(out, cv2.COLOR_BGR2RGB), f"{len(res.boxes)} plate(s) detected"
 
-# Güncellenmiş video fonksiyonu
 def run_video(video_file, conf=0.25):
+    ocr = create_ocr()
     cap = cv2.VideoCapture(video_file)
     fps = cap.get(cv2.CAP_PROP_FPS) or 30
     w, h = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), 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))
+    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
-        idx += 1; t = idx/fps
+        if not ret:
+            break
+        idx += 1
+        t = idx / fps
         res = yolo(frame, conf=conf)[0]
 
         for box in res.boxes.xyxy.cpu().numpy().astype(int):
             warped = correct_perspective(frame, box)
-            if warped is None: continue
-
+            if warped is None:
+                continue
             try:
                 recs = ocr.ocr(warped, det=False, cls=True)
-                 # After OCR call:
-                gc.collect()
-                print_mem_usage("After OCR")
             except:
                 recs = []
+            gc.collect()
+            print_mem_usage("After OCR")
             txt, score = normalize_ocr(recs)
             plate = format_plate(txt)
-            if plate.startswith("RAW:"):
-                raw_txt = plate[5:]
-            else:
-                raw_txt = plate
-
+            raw_txt = plate[5:] if plate.startswith("RAW:") else plate
             if raw_txt != "Unknown":
-                records.append({"time_s":round(t,2),"plate":raw_txt,"conf":round(score,3)})
-
+                records.append({"time_s": round(t, 2), "plate": raw_txt, "conf": round(score, 3)})
             x1, y1, x2, y2 = box
-            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)
+            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:
+    cap.release()
+    writer.release()
+    with open("output.json", "w") as f:
         json.dump(records, f, indent=2)
     return out_path, "Done"
 
-
-# ─── 7) Gradio 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)")
-            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")
+            conf = gr.Slider(0.0, 1.0, value=0.25, step=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")
+            status = gr.Textbox(label="Status / JSON Path")
+
+    btn_i.click(run_image, [img_in, conf], [img_out, status])
+    btn_v.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__":
     demo.launch()