Update app/services/inference.py

app/services/inference.py

@@ -1,216 +1,9 @@
-# # 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
-
-
-
-
-
-
-
+# inference.py
 
 from ultralytics import YOLO
 import os
 import cv2
 import numpy as np
-import easyocr
 import re
 from fast_plate_ocr import LicensePlateRecognizer
 
@@ -224,90 +17,6 @@ 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 ──────────────────────────────────────���───────────────────────────────
@@ -353,16 +62,7 @@ def detect_license_plate(image_path: str):
             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),