files upload

app/api/main.py

@@ -0,0 +1,45 @@
+# main.py
+
+from fastapi import FastAPI, UploadFile, File
+import shutil
+import os
+from src.services.inference import detect_license_plate
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI()
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+UPLOAD_DIR = os.path.join(BASE_DIR, "temp")
+
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # for development
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+app.mount("/temp", StaticFiles(directory=UPLOAD_DIR), name="temp")
+
+@app.post("/detect")
+async def detect(file: UploadFile = File(...)):
+    file_path = os.path.join(UPLOAD_DIR, file.filename)
+
+    # Save uploaded file
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+
+    # Run inference
+    detections, output_path = detect_license_plate(file_path)
+
+    # return ONLY filename
+    output_filename = os.path.basename(output_path)
+
+    return {
+        "filename": file.filename,
+        "detections": detections,
+        "output_image": output_filename
+    }

app/models/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e458f1e9a5a077e954e3adbc964f4416a3ebbcb9bff24e7883c3fd4d527694af
+size 22542250

app/models/last.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:080592f1c43e63cadfc39202c7aa82838aad5868a8805e1bb5ba0ea5c4c722f9
+size 22542250

app/services/inference.py

@@ -0,0 +1,377 @@
+# # inference.py
+
+# from ultralytics import YOLO
+# import os
+# import cv2
+# import easyocr
+# import numpy as np
+
+
+
+# # Load model once (global)
+# MODEL_PATH = os.path.join("src", "models", "best.pt")
+# model = YOLO(MODEL_PATH)
+
+# reader= easyocr.Reader(
+#     ['en'],
+#     gpu=True,
+#     )
+
+# # Plate characters only — kills J→] Z→z O→0 confusion
+# PLATE_ALLOWLIST = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 '
+
+# CONF_THRESHOLD= 0.3
+
+
+# def preprocess_plate(crop: np.ndarray) -> np.ndarray:
+#     """
+#     Clean up a plate crop before passing to OCR.
+#     Steps: upscale if small → grayscale → denoise → sharpen → adaptive threshold
+#     """
+#     h, w = crop.shape[:2]
+ 
+#     # 1. Upscale only if the crop is genuinely small
+#     #    Target: at least 100px tall so characters are readable
+#     if h < 100:
+#         scale = 100 / h
+#         crop = cv2.resize(crop, None, fx=scale, fy=scale,
+#                           interpolation=cv2.INTER_CUBIC)
+#     elif h < 200:
+#         # Modest 1.5x for medium crops
+#         crop = cv2.resize(crop, None, fx=1.5, fy=1.5,
+#                           interpolation=cv2.INTER_CUBIC)
+#     # If already large enough, don't upscale — it can blur
+ 
+#     # 2. Grayscale
+#     gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
+ 
+#     # 3. Denoise (fastNlMeans: removes sensor noise without destroying edges)
+#     gray = cv2.fastNlMeansDenoising(gray, h=15, templateWindowSize=7, searchWindowSize=21)
+ 
+#     # 4. Sharpen — unsharp mask style
+#     blurred = cv2.GaussianBlur(gray, (0, 0), 2)
+#     gray = cv2.addWeighted(gray, 1.8, blurred, -0.8, 0)
+ 
+#     # 5. Adaptive threshold → clean black-on-white binary image
+#     #    Works much better than global threshold for varying lighting
+#     binary = cv2.adaptiveThreshold(
+#         gray, 255,
+#         cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+#         cv2.THRESH_BINARY,
+#         blockSize=15,
+#         C=8
+#     )
+ 
+#     # 6. Add a small white border — prevents edge characters from being clipped
+#     binary = cv2.copyMakeBorder(binary, 10, 10, 10, 10,
+#                                  cv2.BORDER_CONSTANT, value=255)
+ 
+#     return binary
+
+
+
+
+
+# def read_plate_text(crop: np.ndarray) -> tuple[str, float]:
+#     """
+#     Run OCR on a plate crop. Returns (text, ocr_confidence).
+#     Tries preprocessed binary first; falls back to color crop if no result.
+#     """
+#     processed = preprocess_plate(crop)
+ 
+#     results = reader.readtext(
+#         processed,
+#         detail=1,
+#         paragraph=False,      # treat each text region independently
+#         decoder='beamsearch',  # more accurate than greedy
+#         beamWidth=10,
+#         batch_size=1,
+#         allowlist=PLATE_ALLOWLIST,
+#         # EasyOCR hint: plate text is usually 1-2 lines, wide aspect
+#         width_ths=0.8,        # merge nearby text boxes horizontally
+#         contrast_ths=0.05,
+#         adjust_contrast=0.7,
+#         text_threshold=0.6,
+#         low_text=0.3,
+#     )
+ 
+#     if not results:
+#         # Fallback: try on the raw color crop
+#         results = reader.readtext(
+#             crop,
+#             detail=1,
+#             allowlist=PLATE_ALLOWLIST,
+#             decoder='beamsearch',
+#             beamWidth=10,
+#         )
+ 
+#     if not results:
+#         return "", 0.0
+ 
+#     # Sort by confidence descending, take best
+#     results.sort(key=lambda x: x[2], reverse=True)
+#     best = results[0]
+#     text = best[1].upper().strip()
+#     conf = float(best[2])
+ 
+#     # If multiple boxes detected, try joining them in left-to-right order
+#     # (handles split plates like "KV67" + "HUJ" as separate regions)
+#     if len(results) > 1:
+#         # Sort all boxes by their x-coordinate (left edge of bbox)
+#         sorted_by_x = sorted(results, key=lambda x: x[0][0][0])
+#         joined = " ".join(r[1].upper().strip() for r in sorted_by_x)
+#         avg_conf = sum(r[2] for r in sorted_by_x) / len(sorted_by_x)
+#         # Use joined version only if average confidence is decent
+#         if avg_conf >= 0.5:
+#             text = joined
+#             conf = avg_conf
+ 
+#     return text, round(conf, 3)
+
+
+
+
+# def detect_license_plate(image_path):
+#     results= model(image_path)
+#     image= cv2.imread(image_path)
+
+#     detections= []
+
+#     for result in results:
+#         for box in result.boxes:
+#             x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
+#             conf = float(box.conf[0])
+
+
+#             if conf < CONF_THRESHOLD:
+#                 continue
+
+
+# # CROPPING 
+#             # Crop with a small margin to avoid clipping plate edges
+#             margin = 4
+#             h_img, w_img = image.shape[:2]
+#             cx1 = max(0, x1 - margin)
+#             cy1 = max(0, y1 - margin)
+#             cx2 = min(w_img, x2 + margin)
+#             cy2 = min(h_img, y2 + margin)
+ 
+#             plate_crop = image[cy1:cy2, cx1:cx2]
+ 
+#             plate_text, ocr_conf = read_plate_text(plate_crop)
+ 
+#             # Draw bounding box
+#             cv2.rectangle(image, (x1, y1), (x2, y2), (0, 0, 220), 2)
+
+
+#             # Label: text + detection confidence
+#             label = f"{plate_text}  ({round(conf, 2)})" if plate_text else f"({round(conf, 2)})"
+#             (lw, lh), baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.55, 2)
+
+
+#             # Background rect for label so it's always readable
+#             cv2.rectangle(image, (x1, y1 - lh - baseline - 6), (x1 + lw + 4, y1), (0, 0, 220), -1)
+#             cv2.putText(
+#                 image, label,
+#                 (x1 + 2, y1 - baseline - 2),
+#                 cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+#                 (255, 255, 255), 2
+#             )
+ 
+
+#             detections.append({
+#                 "bbox": {
+#                     "x1": int(x1),
+#                     "y1": int(y1),
+#                     "x2": int(x2),
+#                     "y2": int(y2)
+#                 },
+#                 "confidence": round(conf, 3),
+#                 "text": plate_text,
+#                 "ocr_confidence": round(ocr_conf, 3) if ocr_conf else None,
+#             })
+
+#     # output image
+#     name, ext= os.path.splitext(image_path)
+#     output_path= f"{name}_output{ext}"
+#     cv2.imwrite(output_path, image)
+
+
+#     return detections, output_path
+
+
+
+
+
+
+
+
+from ultralytics import YOLO
+import os
+import cv2
+import numpy as np
+import easyocr
+import re
+from fast_plate_ocr import LicensePlateRecognizer
+
+# ── Init ──────────────────────────────────────────────────────────────────────
+MODEL_PATH = os.path.join("src", "models", "best.pt")
+model = YOLO(MODEL_PATH)
+# reader = easyocr.Reader(['en'], gpu=True)
+
+ocr= LicensePlateRecognizer("cct-s-v2-global-model")
+
+CONF_THRESHOLD = 0.255
+PLATE_ALLOWLIST = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 '
+
+# ── Preprocessing ─────────────────────────────────────────────────────────────
+
+# def preprocess_plate(crop: np.ndarray) -> list[np.ndarray]:
+#     """
+#     Returns multiple processed versions of the crop.
+#     OCR is run on all of them and best result is picked.
+#     """
+#     h, w = crop.shape[:2]
+
+#     # Upscale only if genuinely small — target 80px height minimum
+#     scale = max(1.0, 80 / h)
+#     if scale > 1.0:
+#         crop = cv2.resize(crop, None, fx=scale, fy=scale,
+#                           interpolation=cv2.INTER_CUBIC)
+
+#     gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
+
+#     # Version 1: CLAHE — improves local contrast without over-brightening
+#     clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(4, 4))
+#     v1 = clahe.apply(gray)
+
+#     # Version 2: Otsu threshold — works well on clean plates
+#     _, v2 = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+#     # Version 3: Inverted Otsu — for dark-on-light plates
+#     v3 = cv2.bitwise_not(v2)
+
+#     # Version 4: Sharpened grayscale — good for slightly blurry crops
+#     blurred = cv2.GaussianBlur(gray, (0, 0), 1.5)
+#     v4 = cv2.addWeighted(gray, 2.0, blurred, -1.0, 0)
+
+#     # Add white padding to all versions so edge chars aren't clipped
+#     pad = lambda img: cv2.copyMakeBorder(img, 12, 12, 12, 12,
+#                                           cv2.BORDER_CONSTANT, value=255)
+#     return [pad(v) for v in [v1, v2, v3, v4]]
+
+
+# def clean_text(text: str) -> str:
+#     """Strip non-plate characters and normalize spacing."""
+#     text = text.upper().strip()
+#     # Remove anything that's not A-Z, 0-9, or space
+#     text = re.sub(r'[^A-Z0-9 ]', '', text)
+#     # Collapse multiple spaces
+#     text = re.sub(r' +', ' ', text).strip()
+#     return text
+
+
+# def run_ocr_on_versions(versions: list[np.ndarray]) -> tuple[str, float]:
+#     """
+#     Run OCR on each preprocessed version, collect all results,
+#     return the highest-confidence clean result.
+#     """
+#     candidates = []
+
+#     for img in versions:
+#         try:
+#             results = reader.readtext(
+#                 img,
+#                 detail=1,
+#                 allowlist=PLATE_ALLOWLIST,
+#                 paragraph=True,       # merge into one line — avoids multi-box noise
+#                 decoder='greedy',     # greedy is actually more stable for short strings
+#                 text_threshold=0.5,
+#                 low_text=0.3,
+#                 width_ths=1.0,        # aggressive merge: treat plate as single region
+#                 mag_ratio=1.0,
+#             )
+
+#             for (_, text, conf) in results:
+#                 cleaned = clean_text(text)
+#                 if len(cleaned) >= 4:  # ignore single chars / noise
+#                     candidates.append((cleaned, float(conf)))
+
+#         except Exception:
+#             continue
+
+#     if not candidates:
+#         return "", 0.0
+
+#     # Pick highest confidence
+#     candidates.sort(key=lambda x: x[1], reverse=True)
+#     return candidates[0]
+
+
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+def detect_license_plate(image_path: str):
+    results = model(image_path)
+    image = cv2.imread(image_path)
+    h_img, w_img = image.shape[:2]
+
+    detections = []
+
+    for result in results:
+        for box in result.boxes:
+            x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
+            conf = float(box.conf[0])
+
+            if conf < CONF_THRESHOLD:
+                continue
+
+            # Small margin to avoid clipping plate edges
+            margin = 4
+            cx1 = max(0, x1 - margin)
+            cy1 = max(0, y1 - margin)
+            cx2 = min(w_img, x2 + margin)
+            cy2 = min(h_img, y2 + margin)
+
+            plate_crop = image[cy1:cy2, cx1:cx2]
+            # versions = preprocess_plate(plate_crop)
+            # plate_text, ocr_conf = run_ocr_on_versions(versions)
+
+
+
+            # fast-plate-ocr expects BGR numpy array — no preprocessing needed
+            result_ocr = ocr.run(plate_crop)
+
+            # run() returns a list of predictions, one per image — take first
+            plate_text = result_ocr[0].plate if result_ocr else ""
+            
+            
+            # Draw bounding box
+            cv2.rectangle(image, (x1, y1), (x2, y2), (255, 218, 105), 2)
+
+            label = f"{plate_text} ({round(conf, 2)})" if plate_text else f"({round(conf, 2)})"
+            (lw, lh), baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.55, 2)
+
+            # Solid background behind label for readability
+            # cv2.rectangle(image,
+            #               (x1, y1 - lh - baseline - 6),
+            #               (x1 + lw + 6, y1),
+            #               (0, 0, 220), -1)
+            # cv2.putText(image, label,
+            #             (x1 + 3, y1 - baseline - 2),
+            #             cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+            #             (255, 255, 255), 2)
+
+            detections.append({
+                "bbox": {"x1": x1, "y1": y1, "x2": x2, "y2": y2},
+                "confidence": round(conf, 3),
+                "text": plate_text,
+                # "ocr_confidence": round(ocr_conf, 3) if ocr_conf else None,
+            })
+
+    name, ext = os.path.splitext(image_path)
+    output_path = f"{name}_output{ext}"
+    cv2.imwrite(output_path, image)
+
+    return detections, output_path

app/training/train.py

@@ -0,0 +1,104 @@
+import os
+from ultralytics import YOLO
+import torch
+import mlflow
+
+
+
+device= 0 if torch.cuda.is_available() else "cpu"
+if device==0:
+    print("GPU")
+else:
+    print("CPU")
+
+
+def train():
+    # Project root
+    ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../"))
+    data_path = os.path.join(ROOT_DIR, "data/raw/data.yaml")
+
+
+    # Output directory (YOLO saves here)
+    project_name= "experiments"
+    run_name= "yolov8s_768_v2_run"
+
+    output_dir= os.path.join(ROOT_DIR, project_name, run_name)
+
+
+    # MLflow Setup
+    mlflow.set_tracking_uri("sqlite:///mlflow.db")
+    mlflow.set_experiment("license-plate-detection")
+
+
+    # Training Config
+    params= {
+        "model": "yolov8s",
+        "epochs": 40,
+        "imgsz": 768,
+        "batch": 6,
+        "optimizer": "auto",
+        "mosaic": 0.3,
+        "device": device,
+    }
+
+
+    # Start MLflow run
+    with mlflow.start_run(run_name=run_name):
+
+        # log parameters
+        mlflow.log_params(params)
+
+
+        # load model
+        model = YOLO("yolov8s.pt")
+
+        # train
+        results= model.train(
+            data=data_path,
+            epochs=params["epochs"],
+            imgsz=params["imgsz"],
+            device=params["device"],
+            batch=params["batch"],
+            cache=False,
+            workers=0,
+            patience=10,
+            mosaic=params["mosaic"],
+            project=project_name,
+            name=run_name
+        )
+
+        # log metrics
+        metrics = results.results_dict
+
+        mlflow.log_metric("mAP50", metrics.get("metrics/mAP50(B)", 0))
+        mlflow.log_metric("mAP50-95", metrics.get("metrics/mAP50-95(B)", 0))
+        mlflow.log_metric("precision", metrics.get("metrics/precision(B)", 0))
+        mlflow.log_metric("recall", metrics.get("metrics/recall(B)", 0))
+
+
+        # log artifacts
+        # -------------
+
+        # 1. Best model
+        best_model_path= os.path.join(output_dir, "weights/best.pt")
+        if os.path.exists(best_model_path):
+            mlflow.log_artifact(best_model_path, artifact_path="model")
+
+        
+        # 2. Training results csv
+        results_csv= os.path.join(output_dir, "results.csv")
+        if os.path.exists(results_csv):
+            mlflow.log_artifact(results_csv, artifact_path="metrics")
+
+
+        # 3. labels plot / confusion matrix (if generated)
+        labels_img= os.path.join(output_dir, "labels.jpg")
+        if os.path.exists(labels_img):
+            mlflow.log_artifact(labels_img, artifact_path="plots")
+
+
+        print("Training + MLflow logging completed")
+
+
+if __name__ == "__main__":
+    train()

app/training/yolo26n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b09cc8bf347f0fc8a5f7657480587f25db09b34bf33b0652110fb03a8ad4fef
+size 5544453

app/training/yolov8n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f59b3d833e2ff32e194b5bb8e08d211dc7c5bdf144b90d2c8412c47ccfc83b36
+size 6549796

app/training/yolov8s.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f47a78bf100391c2a140b7ac73a1caae18c32779be7d310658112f7ac9aa78a
+size 22588772