Added license plate detection to opencv spaces

README.md

@@ -7,6 +7,12 @@ sdk: gradio
 sdk_version: 5.34.2
 app_file: app.py
 pinned: false
+short_description: License plate detection with yunet using OpenCV
+tags:
+  - opencv
+  - license-plate-detection
+  - yunet
+  - LPD-yunet
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,57 @@
+import cv2 as cv
+import numpy as np
+import gradio as gr
+from lpd_yunet import LPD_YuNet
+from huggingface_hub import hf_hub_download
+
+# Download ONNX model from Hugging Face
+model_path = hf_hub_download(
+    repo_id="opencv/license_plate_detection_yunet",
+    filename="license_plate_detection_lpd_yunet_2023mar.onnx"
+)
+
+# Initialize LPD-YuNet model
+model = LPD_YuNet(
+    modelPath=model_path,
+    confThreshold=0.9,
+    nmsThreshold=0.3,
+    topK=5000,
+    keepTopK=750,
+    backendId=cv.dnn.DNN_BACKEND_OPENCV,
+    targetId=cv.dnn.DNN_TARGET_CPU
+)
+
+def visualize(image, dets, line_color=(0, 255, 0), text_color=(0, 0, 255)):
+    output = image.copy()
+    for det in dets:
+        bbox = det[:-1].astype(np.int32)
+        x1, y1, x2, y2, x3, y3, x4, y4 = bbox
+        cv.line(output, (x1, y1), (x2, y2), line_color, 2)
+        cv.line(output, (x2, y2), (x3, y3), line_color, 2)
+        cv.line(output, (x3, y3), (x4, y4), line_color, 2)
+        cv.line(output, (x4, y4), (x1, y1), line_color, 2)
+    return output
+
+def detect_license_plates(input_image):
+    input_image = cv.cvtColor(input_image, cv.COLOR_RGB2BGR)
+    h, w, _ = input_image.shape
+    model.setInputSize([w, h])
+    results = model.infer(input_image)
+    if results is None or len(results) == 0:
+        return cv.cvtColor(input_image, cv.COLOR_BGR2RGB)
+    output = visualize(input_image, results)
+    output = cv.cvtColor(output, cv.COLOR_BGR2RGB)
+    return output
+
+# Gradio Interface
+demo = gr.Interface(
+    fn=detect_license_plates,
+    inputs=gr.Image(type="numpy", label="Upload Vehicle Image"),
+    outputs=gr.Image(type="numpy", label="Detected License Plates"),
+    title="License Plate Detection (LPD-YuNet)",
+    allow_flagging="never",
+    description="Upload a vehicle image to detect license plates using OpenCV's ONNX-based LPD-YuNet model."
+)
+
+if __name__ == "__main__":
+    demo.launch()

lpd_yunet.py

@@ -0,0 +1,136 @@
+from itertools import product
+
+import numpy as np
+import cv2 as cv
+
+class LPD_YuNet:
+    def __init__(self, modelPath, inputSize=[320, 240], confThreshold=0.8, nmsThreshold=0.3, topK=5000, keepTopK=750, backendId=0, targetId=0):
+        self.model_path = modelPath
+        self.input_size = np.array(inputSize)
+        self.confidence_threshold=confThreshold
+        self.nms_threshold = nmsThreshold
+        self.top_k = topK
+        self.keep_top_k = keepTopK
+        self.backend_id = backendId
+        self.target_id = targetId
+
+        self.output_names = ['loc', 'conf', 'iou']
+        self.min_sizes = [[10, 16, 24], [32, 48], [64, 96], [128, 192, 256]]
+        self.steps = [8, 16, 32, 64]
+        self.variance = [0.1, 0.2]
+
+        # load model
+        self.model = cv.dnn.readNet(self.model_path)
+        # set backend and target
+        self.model.setPreferableBackend(self.backend_id)
+        self.model.setPreferableTarget(self.target_id)
+        # generate anchors/priorboxes
+        self._priorGen()
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def setBackendAndTarget(self, backendId, targetId):
+        self.backend_id = backendId
+        self.target_id = targetId
+        self.model.setPreferableBackend(self.backend_id)
+        self.model.setPreferableTarget(self.target_id)
+
+    def setInputSize(self, inputSize):
+        self.input_size = inputSize
+        # re-generate anchors/priorboxes
+        self._priorGen()
+
+    def _preprocess(self, image):
+        return cv.dnn.blobFromImage(image)
+
+    def infer(self, image):
+        assert image.shape[0] == self.input_size[1], '{} (height of input image) != {} (preset height)'.format(image.shape[0], self.input_size[1])
+        assert image.shape[1] == self.input_size[0], '{} (width of input image) != {} (preset width)'.format(image.shape[1], self.input_size[0])
+
+        # Preprocess
+        inputBlob = self._preprocess(image)
+
+        # Forward
+        self.model.setInput(inputBlob)
+        outputBlob = self.model.forward(self.output_names)
+
+        # Postprocess
+        results = self._postprocess(outputBlob)
+
+        return results
+
+    def _postprocess(self, blob):
+        # Decode
+        dets = self._decode(blob)
+
+        # NMS
+        keepIdx = cv.dnn.NMSBoxes(
+            bboxes=dets[:, 0:4].tolist(),
+            scores=dets[:, -1].tolist(),
+            score_threshold=self.confidence_threshold,
+            nms_threshold=self.nms_threshold,
+            top_k=self.top_k
+        ) # box_num x class_num
+        if len(keepIdx) > 0:
+            dets = dets[keepIdx]
+            return dets[:self.keep_top_k]
+        else:
+            return np.empty(shape=(0, 9))
+
+    def _priorGen(self):
+        w, h = self.input_size
+        feature_map_2th = [int(int((h + 1) / 2) / 2),
+                           int(int((w + 1) / 2) / 2)]
+        feature_map_3th = [int(feature_map_2th[0] / 2),
+                           int(feature_map_2th[1] / 2)]
+        feature_map_4th = [int(feature_map_3th[0] / 2),
+                           int(feature_map_3th[1] / 2)]
+        feature_map_5th = [int(feature_map_4th[0] / 2),
+                           int(feature_map_4th[1] / 2)]
+        feature_map_6th = [int(feature_map_5th[0] / 2),
+                           int(feature_map_5th[1] / 2)]
+
+        feature_maps = [feature_map_3th, feature_map_4th,
+                        feature_map_5th, feature_map_6th]
+
+        priors = []
+        for k, f in enumerate(feature_maps):
+            min_sizes = self.min_sizes[k]
+            for i, j in product(range(f[0]), range(f[1])): # i->h, j->w
+                for min_size in min_sizes:
+                    s_kx = min_size / w
+                    s_ky = min_size / h
+
+                    cx = (j + 0.5) * self.steps[k] / w
+                    cy = (i + 0.5) * self.steps[k] / h
+
+                    priors.append([cx, cy, s_kx, s_ky])
+        self.priors = np.array(priors, dtype=np.float32)
+
+    def _decode(self, blob):
+        loc, conf, iou = blob
+        # get score
+        cls_scores = conf[:, 1]
+        iou_scores = iou[:, 0]
+        # clamp
+        _idx = np.where(iou_scores < 0.)
+        iou_scores[_idx] = 0.
+        _idx = np.where(iou_scores > 1.)
+        iou_scores[_idx] = 1.
+        scores = np.sqrt(cls_scores * iou_scores)
+        scores = scores[:, np.newaxis]
+
+        scale = self.input_size
+
+        # get four corner points for bounding box
+        bboxes = np.hstack((
+            (self.priors[:, 0:2] + loc[:,  4: 6] * self.variance[0] * self.priors[:, 2:4]) * scale,
+            (self.priors[:, 0:2] + loc[:,  6: 8] * self.variance[0] * self.priors[:, 2:4]) * scale,
+            (self.priors[:, 0:2] + loc[:, 10:12] * self.variance[0] * self.priors[:, 2:4]) * scale,
+            (self.priors[:, 0:2] + loc[:, 12:14] * self.variance[0] * self.priors[:, 2:4]) * scale
+        ))
+
+        dets = np.hstack((bboxes, scores))
+        return dets

requirements.txt

@@ -0,0 +1,4 @@
+opencv-python
+gradio
+numpy
+huggingface_hub