Benchmark framework implementation and 3 models added:

* benchmark framework: benchmarks based on configs

* added impl and benchmark for YuNet (face detection)

* added impl and benchmark for DB (text detection)

* added impl and benchmark for CRNN (text recognition)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Shiqi Yu <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,22 @@
+# YuNet
+
+YuNet is a light-weight, fast and accurate face detection model, which achieves 0.834(AP_easy), 0.824(AP_medium), 0.708(AP_hard) on the WIDER Face validation set.
+
+## Demo
+
+Run the following command to try the demo:
+```shell
+# detect on camera input
+python demo.py
+# detect on an image
+python demo.py --input /path/to/image
+```
+
+## License
+
+All files in this directory are licensed under [MIT License](./LICENSE).
+
+## Reference
+
+- https://github.com/ShiqiYu/libfacedetection
+- https://github.com/ShiqiYu/libfacedetection.train

demo.py

@@ -0,0 +1,122 @@
+# This file is part of OpenCV Zoo project.
+# It is subject to the license terms in the LICENSE file found in the same directory.
+#
+# Copyright (C) 2021, Shenzhen Institute of Artificial Intelligence and Robotics for Society, all rights reserved.
+# Third party copyrights are property of their respective owners.
+
+import argparse
+
+import numpy as np
+import cv2 as cv
+
+from yunet import YuNet
+
+def str2bool(v):
+    if v.lower() in ['on', 'yes', 'true', 'y', 't']:
+        return True
+    elif v.lower() in ['off', 'no', 'false', 'n', 'f']:
+        return False
+    else:
+        raise NotImplementedError
+
+parser = argparse.ArgumentParser(description='YuNet: A Fast and Accurate CNN-based Face Detector (https://github.com/ShiqiYu/libfacedetection).')
+parser.add_argument('--input', '-i', type=str, help='Path to the input image. Omit for using default camera.')
+parser.add_argument('--model', '-m', type=str, default='face_detection_yunet.onnx', help='Path to the model.')
+parser.add_argument('--conf_threshold', type=float, default=0.9, help='Filter out faces of confidence < conf_threshold.')
+parser.add_argument('--nms_threshold', type=float, default=0.3, help='Suppress bounding boxes of iou >= nms_threshold.')
+parser.add_argument('--top_k', type=int, default=5000, help='Keep top_k bounding boxes before NMS.')
+parser.add_argument('--keep_top_k', type=int, default=750, help='Keep keep_top_k bounding boxes after NMS.')
+parser.add_argument('--save', '-s', type=str, default=False, help='Set true to save results. This flag is invalid when using camera.')
+parser.add_argument('--vis', '-v', type=str2bool, default=True, help='Set true to open a window for result visualization. This flag is invalid when using camera.')
+args = parser.parse_args()
+
+def visualize(image, results, box_color=(0, 255, 0), text_color=(0, 0, 255), fps=None):
+    output = image.copy()
+    landmark_color = [
+        (255,   0,   0), # right eye
+        (  0,   0, 255), # left eye
+        (  0, 255,   0), # nose tip
+        (255,   0, 255), # right mouth corner
+        (  0, 255, 255)  # left mouth corner
+    ]
+
+    if fps is not None:
+        cv.putText(output, 'FPS: {:.2f}'.format(fps), (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, text_color)
+
+    for det in results:
+        bbox = det[0:4].astype(np.int32)
+        cv.rectangle(output, (bbox[0], bbox[1]), (bbox[0]+bbox[2], bbox[1]+bbox[3]), box_color, 2)
+
+        conf = det[-1]
+        cv.putText(output, '{:.4f}'.format(conf), (bbox[0], bbox[1]+12), cv.FONT_HERSHEY_DUPLEX, 0.5, text_color)
+
+        landmarks = det[4:14].astype(np.int32).reshape((5,2))
+        for idx, landmark in enumerate(landmarks):
+            cv.circle(output, landmark, 2, landmark_color[idx], 2)
+
+    return output
+
+if __name__ == '__main__':
+    # Instantiate YuNet
+    model = YuNet(modelPath=args.model,
+                  inputSize=[320, 320],
+                  confThreshold=args.conf_threshold,
+                  nmsThreshold=args.nms_threshold,
+                  topK=args.top_k,
+                  keepTopK=args.keep_top_k)
+
+    # If input is an image
+    if args.input is not None:
+        image = cv.imread(args.input)
+        h, w, _ = image.shape
+
+        # Inference
+        model.setInputSize([w, h])
+        results = model.infer(image)
+
+        # Print results
+        print('{} faces detected.'.format(results.shape[0]))
+        for idx, det in enumerate(results):
+            print('{}: [{:.0f}, {:.0f}] [{:.0f}, {:.0f}], {:.2f}'.format(
+                idx, det[0], det[1], det[2], det[3], det[-1])
+            )
+
+        # Draw results on the input image
+        image = visualize(image, results)
+
+        # Save results if save is true
+        if args.save:
+            print('Resutls saved to result.jpg\n')
+            cv.imwrite('result.jpg', image)
+
+        # Visualize results in a new window
+        if args.vis:
+            cv.namedWindow(args.input, cv.WINDOW_AUTOSIZE)
+            cv.imshow(args.input, image)
+            cv.waitKey(0)
+    else: # Omit input to call default camera
+        deviceId = 0
+        cap = cv.VideoCapture(deviceId)
+        w = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+        h = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+        model.setInputSize([w, h])
+
+        tm = cv.TickMeter()
+        while cv.waitKey(1) < 0:
+            hasFrame, frame = cap.read()
+            if not hasFrame:
+                print('No frames grabbed!')
+                break
+
+            # Inference
+            tm.start()
+            results = model.infer(frame) # results is a tuple
+            tm.stop()
+
+            # Draw results on the input image
+            frame = visualize(frame, results, fps=tm.getFPS())
+
+            # Visualize results in a new Window
+            cv.imshow('YuNet Demo', frame)
+
+            tm.reset()

yunet.py

@@ -0,0 +1,149 @@
+# This file is part of OpenCV Zoo project.
+# It is subject to the license terms in the LICENSE file found in the same directory.
+#
+# Copyright (C) 2021, Shenzhen Institute of Artificial Intelligence and Robotics for Society, all rights reserved.
+# Third party copyrights are property of their respective owners.
+
+from itertools import product
+
+import numpy as np
+import cv2 as cv
+
+class YuNet:
+    def __init__(self, modelPath, inputSize=[320, 320], confThreshold=0.6, nmsThreshold=0.3, topK=5000, keepTopK=750):
+        self._modelPath = modelPath
+        self._model = cv.dnn.readNet(self._modelPath)
+
+        self._inputNames = ''
+        self._outputNames = ['loc', 'conf', 'iou']
+        self._inputSize = inputSize # [w, h]
+        self._confThreshold = confThreshold
+        self._nmsThreshold = nmsThreshold
+        self._topK = topK
+        self._keepTopK = keepTopK
+
+        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]
+
+        # Generate priors
+        self._priorGen()
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def setBackend(self, backend):
+        self._model.setPreferableBackend(backend)
+
+    def setTarget(self, target):
+        self._model.setPreferableTarget(target)
+
+    def setInputSize(self, input_size):
+        self._inputSize = input_size # [w, h]
+
+        # Regenerate priors
+        self._priorGen()
+
+    def _preprocess(self, image):
+        return cv.dnn.blobFromImage(image)
+
+    def infer(self, image):
+        assert image.shape[0] == self._inputSize[1], '{} (height of input image) != {} (preset height)'.format(image.shape[0], self._inputSize[1])
+        assert image.shape[1] == self._inputSize[0], '{} (width of input image) != {} (preset width)'.format(image.shape[1], self._inputSize[0])
+
+        # Preprocess
+        inputBlob = self._preprocess(image)
+
+        # Forward
+        self._model.setInput(inputBlob, self._inputNames)
+        outputBlob = self._model.forward(self._outputNames)
+
+        # Postprocess
+        results = self._postprocess(outputBlob)
+
+        return results
+
+    def _postprocess(self, outputBlob):
+        # Decode
+        dets = self._decode(outputBlob)
+
+        # NMS
+        keepIdx = cv.dnn.NMSBoxes(
+            bboxes=dets[:, 0:4].tolist(),
+            scores=dets[:, -1].tolist(),
+            score_threshold=self._confThreshold,
+            nms_threshold=self._nmsThreshold,
+            top_k=self._topK
+        ) # box_num x class_num
+        if len(keepIdx) > 0:
+            dets = dets[keepIdx]
+            dets = np.squeeze(dets, axis=1)
+            return dets[:self._keepTopK]
+        else:
+            return np.empty(shape=(0, 15))
+
+    def _priorGen(self):
+        w, h = self._inputSize
+        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, outputBlob):
+        loc, conf, iou = outputBlob
+        # 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 = np.array(self._inputSize)
+
+        # get bboxes
+        bboxes = np.hstack((
+            (self.priors[:, 0:2] + loc[:, 0:2] * self._variance[0] * self.priors[:, 2:4]) * scale,
+            (self.priors[:, 2:4] * np.exp(loc[:, 2:4] * self._variance)) * scale
+        ))
+        # (x_c, y_c, w, h) -> (x1, y1, w, h)
+        bboxes[:, 0:2] -= bboxes[:, 2:4] / 2
+
+        # get landmarks
+        landmarks = 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[:,  8:10] * 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, landmarks, scores))
+        return dets