Duplicate from opencv/object_detection_yolox

Co-authored-by: Abhishek Gola <abhishek-gola@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,26 @@
+
+# Caffe
+*.caffemodel filter=lfs diff=lfs merge=lfs -text
+
+# Tensorflow
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pbtxt filter=lfs diff=lfs merge=lfs -text
+
+# Torch
+*.t7 filter=lfs diff=lfs merge=lfs -text
+*.net filter=lfs diff=lfs merge=lfs -text
+
+# Darknet
+*.weights filter=lfs diff=lfs merge=lfs -text
+
+# ONNX
+*.onnx filter=lfs diff=lfs merge=lfs -text
+
+# NPY
+*.npy filter=lfs diff=lfs merge=lfs -text
+
+# Images
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+*.pyc
+**/__pycache__
+**/__pycache__/**
+
+.vscode
+
+build/
+**/build
+**/build/**

CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.24)
+set(project_name "opencv_zoo_object_detection_yolox")
+
+PROJECT (${project_name})
+
+set(OPENCV_VERSION "4.10.0")
+set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
+find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
+# Find OpenCV, you may need to set OpenCV_DIR variable
+# to the absolute path to the directory containing OpenCVConfig.cmake file
+# via the command line or GUI
+
+file(GLOB SourceFile
+    "demo.cpp")
+# If the package has been found, several variables will
+# be set, you can find the full list with descriptions
+# in the OpenCVConfig.cmake file.
+# Print some message showing some of them
+message(STATUS "OpenCV library status:")
+message(STATUS "    config: ${OpenCV_DIR}")
+message(STATUS "    version: ${OpenCV_VERSION}")
+message(STATUS "    libraries: ${OpenCV_LIBS}")
+message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
+
+# Declare the executable target built from your sources
+add_executable(${project_name} ${SourceFile})
+
+# Link your application with OpenCV libraries
+target_link_libraries(${project_name} PRIVATE ${OpenCV_LIBS})

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2021-2022 Megvii Inc. All rights reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,135 @@
+# YOLOX
+
+Nanodet: YOLOX is an anchor-free version of YOLO, with a simpler design but better performance! It aims to bridge the gap between research and industrial communities. YOLOX is a high-performing object detector, an improvement to the existing YOLO series. YOLO series are in constant exploration of techniques to improve the object detection techniques for optimal speed and accuracy trade-off for real-time applications.
+
+Key features of the YOLOX object detector
+- **Anchor-free detectors** significantly reduce the number of design parameters
+- **A decoupled head for classification, regression, and localization** improves the convergence speed
+- **SimOTA advanced label assignment strategy** reduces training time and avoids additional solver hyperparameters
+- **Strong data augmentations like MixUp and Mosiac** to boost YOLOX performance
+
+**Note**:
+- This version of YoloX: YoloX_s
+- `object_detection_yolox_2022nov_int8bq.onnx` represents the block-quantized version in int8 precision and is generated using [block_quantize.py](../../tools/quantize/block_quantize.py) with `block_size=64`.
+
+
+## Demo
+
+### Python
+
+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 -v
+```
+Note: 
+- image result saved as "result.jpg"
+- this model requires `opencv-python>=4.8.0`
+
+### C++
+
+Install latest OpenCV and CMake >= 3.24.0 to get started with:
+
+```shell
+# A typical and default installation path of OpenCV is /usr/local
+cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
+cmake --build build
+
+# detect on camera input
+./build/opencv_zoo_object_detection_yolox
+# detect on an image
+./build/opencv_zoo_object_detection_yolox -m=/path/to/model -i=/path/to/image -v
+# get help messages
+./build/opencv_zoo_object_detection_yolox -h
+```
+
+
+## Results
+
+Here are some of the sample results that were observed using the model (**yolox_s.onnx**),
+
+![1_res.jpg](./example_outputs/1_res.jpg)
+![2_res.jpg](./example_outputs/2_res.jpg)
+![3_res.jpg](./example_outputs/3_res.jpg)
+
+Check [benchmark/download_data.py](../../benchmark/download_data.py) for the original images.
+
+## Model metrics:
+
+The model is evaluated on [COCO 2017 val](https://cocodataset.org/#download). Results are showed below:
+
+<table>
+<tr><th>Average Precision </th><th>Average Recall</th></tr>
+<tr><td>
+
+|  area  |  IoU  |  Average Precision(AP)  |
+|:-------|:------|:------------------------|
+|  all  |  0.50:0.95  |  0.405  |
+|  all  |  0.50  |  0.593  |
+|  all  |  0.75  |  0.437  |
+|  small  |  0.50:0.95  |  0.232  |
+|  medium  |  0.50:0.95  |  0.448  |
+|  large  |  0.50:0.95  |  0.541  |
+
+ </td><td>
+
+|   area |  IoU  |  Average Recall(AR)  |
+|:-------|:------|:----------------|
+|  all  |  0.50:0.95  |  0.326  |
+|  all  |  0.50:0.95  |  0.531  |
+|  all  |  0.50:0.95 |  0.574  |
+|  small  |  0.50:0.95  |  0.365  |
+|  medium  |  0.50:0.95  |  0.634  |
+|  large  |  0.50:0.95  |  0.724  |
+</td></tr> </table>
+
+| class         | AP     | class        | AP     | class          | AP     |
+|:--------------|:-------|:-------------|:-------|:---------------|:-------|
+| person        | 54.109 | bicycle      | 31.580 | car            | 40.447 |
+| motorcycle    | 43.477 | airplane     | 66.070 | bus            | 64.183 |
+| train         | 64.483 | truck        | 35.110 | boat           | 24.681 |
+| traffic light | 25.068 | fire hydrant | 64.382 | stop sign      | 65.333 |
+| parking meter | 48.439 | bench        | 22.653 | bird           | 33.324 |
+| cat           | 66.394 | dog          | 60.096 | horse          | 58.080 |
+| sheep         | 49.456 | cow          | 53.596 | elephant       | 65.574 |
+| bear          | 70.541 | zebra        | 66.461 | giraffe        | 66.780 |
+| backpack      | 13.095 | umbrella     | 41.614 | handbag        | 12.865 |
+| tie           | 29.453 | suitcase     | 39.089 | frisbee        | 61.712 |
+| skis          | 21.623 | snowboard    | 31.326 | sports ball    | 39.820 |
+| kite          | 41.410 | baseball bat | 27.311 | baseball glove | 36.661 |
+| skateboard    | 49.374 | surfboard    | 35.524 | tennis racket  | 45.569 |
+| bottle        | 37.270 | wine glass   | 33.088 | cup            | 39.835 |
+| fork          | 31.620 | knife        | 15.265 | spoon          | 14.918 |
+| bowl          | 43.251 | banana       | 27.904 | apple          | 17.630 |
+| sandwich      | 32.789 | orange       | 29.388 | broccoli       | 23.187 |
+| carrot        | 23.114 | hot dog      | 33.716 | pizza          | 52.541 |
+| donut         | 47.980 | cake         | 36.160 | chair          | 29.707 |
+| couch         | 46.175 | potted plant | 24.781 | bed            | 44.323 |
+| dining table  | 30.022 | toilet       | 64.237 | tv             | 57.301 |
+| laptop        | 58.362 | mouse        | 57.774 | remote         | 24.271 |
+| keyboard      | 48.020 | cell phone   | 32.376 | microwave      | 57.220 |
+| oven          | 36.168 | toaster      | 28.735 | sink           | 38.159 |
+| refrigerator  | 52.876 | book         | 15.030 | clock          | 48.622 |
+| vase          | 37.013 | scissors     | 26.307 | teddy bear     | 45.676 |
+| hair drier    | 7.255  | toothbrush   | 19.374 |                |        |
+
+## License
+
+All files in this directory are licensed under [Apache 2.0 License](./LICENSE).
+
+#### Contributor Details
+
+- Google Summer of Code'22
+- Contributor: Sri Siddarth Chakaravarthy
+- Github Profile: https://github.com/Sidd1609
+- Organisation: OpenCV
+- Project: Lightweight object detection models using OpenCV 
+
+## Reference
+
+- YOLOX article: https://arxiv.org/abs/2107.08430
+- YOLOX weight and scripts for training: https://github.com/Megvii-BaseDetection/YOLOX
+- YOLOX blog: https://arshren.medium.com/yolox-new-improved-yolo-d430c0e4cf20
+- YOLOX-lite: https://github.com/TexasInstruments/edgeai-yolox

demo.cpp

@@ -0,0 +1,311 @@
+#include <vector>
+#include <string>
+#include <utility>
+
+#include <opencv2/opencv.hpp>
+
+using namespace std;
+using namespace cv;
+using namespace dnn;
+
+vector< pair<dnn::Backend, dnn::Target> > backendTargetPairs = {
+        std::make_pair<dnn::Backend, dnn::Target>(dnn::DNN_BACKEND_OPENCV, dnn::DNN_TARGET_CPU),
+        std::make_pair<dnn::Backend, dnn::Target>(dnn::DNN_BACKEND_CUDA, dnn::DNN_TARGET_CUDA),
+        std::make_pair<dnn::Backend, dnn::Target>(dnn::DNN_BACKEND_CUDA, dnn::DNN_TARGET_CUDA_FP16),
+        std::make_pair<dnn::Backend, dnn::Target>(dnn::DNN_BACKEND_TIMVX, dnn::DNN_TARGET_NPU),
+        std::make_pair<dnn::Backend, dnn::Target>(dnn::DNN_BACKEND_CANN, dnn::DNN_TARGET_NPU) };
+
+vector<string> labelYolox = {
+        "person", "bicycle", "car", "motorcycle", "airplane", "bus",
+        "train", "truck", "boat", "traffic light", "fire hydrant",
+        "stop sign", "parking meter", "bench", "bird", "cat", "dog",
+        "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe",
+        "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
+        "skis", "snowboard", "sports ball", "kite", "baseball bat",
+        "baseball glove", "skateboard", "surfboard", "tennis racket",
+        "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl",
+        "banana", "apple", "sandwich", "orange", "broccoli", "carrot",
+        "hot dog", "pizza", "donut", "cake", "chair", "couch",
+        "potted plant", "bed", "dining table", "toilet", "tv", "laptop",
+        "mouse", "remote", "keyboard", "cell phone", "microwave",
+        "oven", "toaster", "sink", "refrigerator", "book", "clock",
+        "vase", "scissors", "teddy bear", "hair drier", "toothbrush" };
+
+class YoloX {
+private:
+    Net net;
+    string modelPath;
+    Size inputSize;
+    float confThreshold;
+    float nmsThreshold;
+    float objThreshold;
+    dnn::Backend backendId;
+    dnn::Target targetId;
+    int num_classes;
+    vector<int> strides;
+    Mat expandedStrides;
+    Mat grids;
+
+public:
+    YoloX(string modPath, float confThresh = 0.35, float nmsThresh = 0.5, float objThresh = 0.5, dnn::Backend bId = DNN_BACKEND_DEFAULT, dnn::Target tId = DNN_TARGET_CPU) :
+        modelPath(modPath), confThreshold(confThresh),
+        nmsThreshold(nmsThresh), objThreshold(objThresh),
+        backendId(bId), targetId(tId)
+    {
+        this->num_classes = int(labelYolox.size());
+        this->net = readNet(modelPath);
+        this->inputSize = Size(640, 640);
+        this->strides = vector<int>{ 8, 16, 32 };
+        this->net.setPreferableBackend(this->backendId);
+        this->net.setPreferableTarget(this->targetId);
+        this->generateAnchors();
+    }
+
+    Mat preprocess(Mat img)
+    {
+        Mat blob;
+        Image2BlobParams paramYolox;
+        paramYolox.datalayout = DNN_LAYOUT_NCHW;
+        paramYolox.ddepth = CV_32F;
+        paramYolox.mean = Scalar::all(0);
+        paramYolox.scalefactor = Scalar::all(1);
+        paramYolox.size = Size(img.cols, img.rows);
+        paramYolox.swapRB = true;
+
+        blob = blobFromImageWithParams(img, paramYolox);
+        return blob;
+    }
+
+   Mat infer(Mat srcimg)
+    {
+        Mat inputBlob = this->preprocess(srcimg);
+
+        this->net.setInput(inputBlob);
+        vector<Mat> outs;
+        this->net.forward(outs, this->net.getUnconnectedOutLayersNames());
+
+        Mat predictions = this->postprocess(outs[0]);
+        return predictions;
+    }
+
+    Mat postprocess(Mat outputs)
+    {
+        Mat dets = outputs.reshape(0,outputs.size[1]);
+        Mat col01;
+        add(dets.colRange(0, 2), this->grids, col01);
+        Mat col23;
+        exp(dets.colRange(2, 4), col23);
+        vector<Mat> col = { col01, col23 };
+        Mat boxes;
+        hconcat(col, boxes);
+        float* ptr = this->expandedStrides.ptr<float>(0);
+        for (int r = 0; r < boxes.rows; r++, ptr++)
+        {
+            boxes.rowRange(r, r + 1) = *ptr * boxes.rowRange(r, r + 1);
+        }
+        // get boxes
+        Mat boxes_xyxy(boxes.rows, boxes.cols, CV_32FC1, Scalar(1));
+        Mat scores = dets.colRange(5, dets.cols).clone();
+        vector<float> maxScores(dets.rows);
+        vector<int> maxScoreIdx(dets.rows);
+        vector<Rect2d> boxesXYXY(dets.rows);
+
+        for (int r = 0; r < boxes_xyxy.rows; r++, ptr++)
+        {
+            boxes_xyxy.at<float>(r, 0) = boxes.at<float>(r, 0) - boxes.at<float>(r, 2) / 2.f;
+            boxes_xyxy.at<float>(r, 1) = boxes.at<float>(r, 1) - boxes.at<float>(r, 3) / 2.f;
+            boxes_xyxy.at<float>(r, 2) = boxes.at<float>(r, 0) + boxes.at<float>(r, 2) / 2.f;
+            boxes_xyxy.at<float>(r, 3) = boxes.at<float>(r, 1) + boxes.at<float>(r, 3) / 2.f;
+            // get scores and class indices
+            scores.rowRange(r, r + 1) = scores.rowRange(r, r + 1) * dets.at<float>(r, 4);
+            double minVal, maxVal;
+            Point maxIdx;
+            minMaxLoc(scores.rowRange(r, r+1), &minVal, &maxVal, nullptr, &maxIdx);
+            maxScoreIdx[r] = maxIdx.x;
+            maxScores[r] = float(maxVal);
+            boxesXYXY[r].x = boxes_xyxy.at<float>(r, 0);
+            boxesXYXY[r].y = boxes_xyxy.at<float>(r, 1);
+            boxesXYXY[r].width = boxes_xyxy.at<float>(r, 2);
+            boxesXYXY[r].height = boxes_xyxy.at<float>(r, 3);
+        }
+
+        vector<int> keep;
+        NMSBoxesBatched(boxesXYXY, maxScores, maxScoreIdx, this->confThreshold, this->nmsThreshold, keep);
+        Mat candidates(int(keep.size()), 6, CV_32FC1);
+        int row = 0;
+        for (auto idx : keep)
+        {
+            boxes_xyxy.rowRange(idx, idx + 1).copyTo(candidates(Rect(0, row, 4, 1)));
+            candidates.at<float>(row, 4) = maxScores[idx];
+            candidates.at<float>(row, 5) = float(maxScoreIdx[idx]);
+            row++;
+        }
+        if (keep.size() == 0)
+            return Mat();
+        return candidates;
+        
+    }
+
+
+    void generateAnchors()
+    {
+        vector< tuple<int, int, int> > nb;
+        int total = 0;
+
+        for (auto v : this->strides)
+        {
+            int w = this->inputSize.width / v;
+            int h = this->inputSize.height / v;
+            nb.push_back(tuple<int, int, int>(w * h, w, v));
+            total += w * h;
+        }
+        this->grids = Mat(total, 2, CV_32FC1);
+        this->expandedStrides = Mat(total, 1, CV_32FC1);
+        float* ptrGrids = this->grids.ptr<float>(0);
+        float* ptrStrides = this->expandedStrides.ptr<float>(0);
+        int pos = 0;
+        for (auto le : nb)
+        {
+            int r = get<1>(le);
+            for (int i = 0; i < get<0>(le); i++, pos++)
+            {
+                *ptrGrids++ = float(i % r);
+                *ptrGrids++ = float(i / r);
+                *ptrStrides++ = float((get<2>(le)));
+            }
+        }
+    }
+};
+
+std::string keys =
+"{ help  h          |                                               | Print help message. }"
+"{ model m          | object_detection_yolox_2022nov.onnx           | Usage: Path to the model, defaults to object_detection_yolox_2022nov.onnx  }"
+"{ input i          |                                               | Path to input image or video file. Skip this argument to capture frames from a camera.}"
+"{ confidence       | 0.5                                           | Class confidence }"
+"{ obj              | 0.5                                           | Enter object threshold }"
+"{ nms              | 0.5                                           | Enter nms IOU threshold }"
+"{ save s           | true                                          | Specify to save results. This flag is invalid when using camera. }"
+"{ vis v            | 1                                             | Specify to open a window for result visualization. This flag is invalid when using camera. }"
+"{ backend bt       | 0                                             | Choose one of computation backends: "
+"0: (default) OpenCV implementation + CPU, "
+"1: CUDA + GPU (CUDA), "
+"2: CUDA + GPU (CUDA FP16), "
+"3: TIM-VX + NPU, "
+"4: CANN + NPU}";
+
+pair<Mat, double> letterBox(Mat srcimg, Size targetSize = Size(640, 640))
+{
+    Mat paddedImg(targetSize.height, targetSize.width, CV_32FC3, Scalar::all(114.0));
+    Mat resizeImg;
+
+    double ratio = min(targetSize.height / double(srcimg.rows), targetSize.width / double(srcimg.cols));
+    resize(srcimg, resizeImg, Size(int(srcimg.cols * ratio), int(srcimg.rows * ratio)), INTER_LINEAR);
+    resizeImg.copyTo(paddedImg(Rect(0, 0, int(srcimg.cols * ratio), int(srcimg.rows * ratio))));
+    return pair<Mat, double>(paddedImg, ratio);
+}
+
+Mat unLetterBox(Mat bbox, double letterboxScale)
+{
+    return bbox / letterboxScale;
+}
+
+Mat visualize(Mat dets, Mat srcimg, double letterbox_scale, double fps = -1)
+{
+    Mat resImg = srcimg.clone();
+
+    if (fps > 0)
+        putText(resImg, format("FPS: %.2f", fps), Size(10, 25), FONT_HERSHEY_SIMPLEX, 1, Scalar(0, 0, 255), 2);
+
+    for (int row = 0; row < dets.rows; row++)
+    {
+        Mat boxF = unLetterBox(dets(Rect(0, row, 4, 1)), letterbox_scale);
+        Mat box;
+        boxF.convertTo(box, CV_32S);
+        float score = dets.at<float>(row, 4);
+        int clsId = int(dets.at<float>(row, 5));
+
+        int x0 = box.at<int>(0, 0);
+        int y0 = box.at<int>(0, 1);
+        int x1 = box.at<int>(0, 2);
+        int y1 = box.at<int>(0, 3);
+
+        string text = format("%s : %f", labelYolox[clsId].c_str(), score * 100);
+        int font = FONT_HERSHEY_SIMPLEX;
+        int baseLine = 0;
+        Size txtSize = getTextSize(text, font, 0.4, 1, &baseLine);
+        rectangle(resImg, Point(x0, y0), Point(x1, y1), Scalar(0, 255, 0), 2);
+        rectangle(resImg, Point(x0, y0 + 1), Point(x0 + txtSize.width + 1, y0 + int(1.5 * txtSize.height)), Scalar(255, 255, 255), -1);
+        putText(resImg, text, Point(x0, y0 + txtSize.height), font, 0.4, Scalar(0, 0, 0), 1);
+    }
+
+    return resImg;
+}
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+
+    parser.about("Use this script to run Yolox deep learning networks in opencv_zoo using OpenCV.");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    string model = parser.get<String>("model");
+    float confThreshold = parser.get<float>("confidence");
+    float objThreshold = parser.get<float>("obj");
+    float nmsThreshold = parser.get<float>("nms");
+    bool vis = parser.get<bool>("vis");
+    bool save = parser.get<bool>("save");
+    int backendTargetid = parser.get<int>("backend");
+
+    if (model.empty())
+    {
+        CV_Error(Error::StsError, "Model file " + model + " not found");
+    }
+
+    YoloX modelNet(model, confThreshold, nmsThreshold, objThreshold,
+        backendTargetPairs[backendTargetid].first, backendTargetPairs[backendTargetid].second);
+    //! [Open a video file or an image file or a camera stream]
+    VideoCapture cap;
+    if (parser.has("input"))
+        cap.open(samples::findFile(parser.get<String>("input")));
+    else
+        cap.open(0);
+    if (!cap.isOpened())
+        CV_Error(Error::StsError, "Cannot open video or file");
+    Mat frame, inputBlob;
+    double letterboxScale;
+
+    static const std::string kWinName = model;
+    int nbInference = 0;
+    while (waitKey(1) < 0)
+    {
+        cap >> frame;
+        if (frame.empty())
+        {
+            cout << "Frame is empty" << endl;
+            waitKey();
+            break;
+        }
+        pair<Mat, double> w = letterBox(frame);
+        inputBlob = get<0>(w);
+        letterboxScale  = get<1>(w);
+        TickMeter tm;
+        tm.start();
+        Mat predictions = modelNet.infer(inputBlob);
+        tm.stop();
+        cout << "Inference time: " << tm.getTimeMilli() << " ms\n";
+        Mat img = visualize(predictions, frame, letterboxScale, tm.getFPS());
+        if (save && parser.has("input"))
+        {
+            imwrite("result.jpg", img);
+        }
+        if (vis)
+        {
+            imshow(kWinName, img);
+        }
+    }
+    return 0;
+}

demo.py

@@ -0,0 +1,155 @@
+import numpy as np
+import cv2 as cv
+import argparse
+
+# Check OpenCV version
+opencv_python_version = lambda str_version: tuple(map(int, (str_version.split("."))))
+assert opencv_python_version(cv.__version__) >= opencv_python_version("4.10.0"), \
+       "Please install latest opencv-python for benchmark: python3 -m pip install --upgrade opencv-python"
+
+from yolox import YoloX
+
+# Valid combinations of backends and targets
+backend_target_pairs = [
+    [cv.dnn.DNN_BACKEND_OPENCV, cv.dnn.DNN_TARGET_CPU],
+    [cv.dnn.DNN_BACKEND_CUDA,   cv.dnn.DNN_TARGET_CUDA],
+    [cv.dnn.DNN_BACKEND_CUDA,   cv.dnn.DNN_TARGET_CUDA_FP16],
+    [cv.dnn.DNN_BACKEND_TIMVX,  cv.dnn.DNN_TARGET_NPU],
+    [cv.dnn.DNN_BACKEND_CANN,   cv.dnn.DNN_TARGET_NPU]
+]
+
+classes = ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
+           'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
+           'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
+           'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
+           'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
+           'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
+           'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
+           'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
+           'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
+           'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
+           'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
+           'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+           'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock',
+           'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush')
+
+def letterbox(srcimg, target_size=(640, 640)):
+    padded_img = np.ones((target_size[0], target_size[1], 3)).astype(np.float32) * 114.0
+    ratio = min(target_size[0] / srcimg.shape[0], target_size[1] / srcimg.shape[1])
+    resized_img = cv.resize(
+        srcimg, (int(srcimg.shape[1] * ratio), int(srcimg.shape[0] * ratio)), interpolation=cv.INTER_LINEAR
+    ).astype(np.float32)
+    padded_img[: int(srcimg.shape[0] * ratio), : int(srcimg.shape[1] * ratio)] = resized_img
+
+    return padded_img, ratio
+
+def unletterbox(bbox, letterbox_scale):
+    return bbox / letterbox_scale
+
+def vis(dets, srcimg, letterbox_scale, fps=None):
+    res_img = srcimg.copy()
+
+    if fps is not None:
+        fps_label = "FPS: %.2f" % fps
+        cv.putText(res_img, fps_label, (10, 25), cv.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+
+    for det in dets:
+        box = unletterbox(det[:4], letterbox_scale).astype(np.int32)
+        score = det[-2]
+        cls_id = int(det[-1])
+
+        x0, y0, x1, y1 = box
+
+        text = '{}:{:.1f}%'.format(classes[cls_id], score * 100)
+        font = cv.FONT_HERSHEY_SIMPLEX
+        txt_size = cv.getTextSize(text, font, 0.4, 1)[0]
+        cv.rectangle(res_img, (x0, y0), (x1, y1), (0, 255, 0), 2)
+        cv.rectangle(res_img, (x0, y0 + 1), (x0 + txt_size[0] + 1, y0 + int(1.5 * txt_size[1])), (255, 255, 255), -1)
+        cv.putText(res_img, text, (x0, y0 + txt_size[1]), font, 0.4, (0, 0, 0), thickness=1)
+
+    return res_img
+
+if __name__=='__main__':
+    parser = argparse.ArgumentParser(description='Nanodet inference using OpenCV an contribution by Sri Siddarth Chakaravarthy part of GSOC_2022')
+    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='object_detection_yolox_2022nov.onnx',
+                        help="Path to the model")
+    parser.add_argument('--backend_target', '-bt', type=int, default=0,
+                    help='''Choose one of the backend-target pair to run this demo:
+                        {:d}: (default) OpenCV implementation + CPU,
+                        {:d}: CUDA + GPU (CUDA),
+                        {:d}: CUDA + GPU (CUDA FP16),
+                        {:d}: TIM-VX + NPU,
+                        {:d}: CANN + NPU
+                    '''.format(*[x for x in range(len(backend_target_pairs))]))
+    parser.add_argument('--confidence', default=0.5, type=float,
+                        help='Class confidence')
+    parser.add_argument('--nms', default=0.5, type=float,
+                        help='Enter nms IOU threshold')
+    parser.add_argument('--obj', default=0.5, type=float,
+                        help='Enter object threshold')
+    parser.add_argument('--save', '-s', action='store_true',
+                        help='Specify to save results. This flag is invalid when using camera.')
+    parser.add_argument('--vis', '-v', action='store_true',
+                        help='Specify to open a window for result visualization. This flag is invalid when using camera.')
+    args = parser.parse_args()
+
+    backend_id = backend_target_pairs[args.backend_target][0]
+    target_id = backend_target_pairs[args.backend_target][1]
+
+    model_net = YoloX(modelPath= args.model,
+                      confThreshold=args.confidence,
+                      nmsThreshold=args.nms,
+                      objThreshold=args.obj,
+                      backendId=backend_id,
+                      targetId=target_id)
+
+    tm = cv.TickMeter()
+    tm.reset()
+    if args.input is not None:
+        image = cv.imread(args.input)
+        input_blob = cv.cvtColor(image, cv.COLOR_BGR2RGB)
+        input_blob, letterbox_scale = letterbox(input_blob)
+
+        # Inference
+        tm.start()
+        preds = model_net.infer(input_blob)
+        tm.stop()
+        print("Inference time: {:.2f} ms".format(tm.getTimeMilli()))
+
+        img = vis(preds, image, letterbox_scale)
+
+        if args.save:
+            print('Results saved to result.jpg\n')
+            cv.imwrite('result.jpg', img)
+
+        if args.vis:
+            cv.namedWindow(args.input, cv.WINDOW_AUTOSIZE)
+            cv.imshow(args.input, img)
+            cv.waitKey(0)
+
+    else:
+        print("Press any key to stop video capture")
+        deviceId = 0
+        cap = cv.VideoCapture(deviceId)
+
+        while cv.waitKey(1) < 0:
+            hasFrame, frame = cap.read()
+            if not hasFrame:
+                print('No frames grabbed!')
+                break
+
+            input_blob = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
+            input_blob, letterbox_scale = letterbox(input_blob)
+
+            # Inference
+            tm.start()
+            preds = model_net.infer(input_blob)
+            tm.stop()
+
+            img = vis(preds, frame, letterbox_scale, fps=tm.getFPS())
+
+            cv.imshow("YoloX Demo", img)
+
+            tm.reset()

object_detection_yolox_2022nov.onnx

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

object_detection_yolox_2022nov_int8.onnx

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

object_detection_yolox_2022nov_int8bq.onnx

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

yolox.py

@@ -0,0 +1,85 @@
+import numpy as np
+import cv2
+
+class YoloX:
+    def __init__(self, modelPath, confThreshold=0.35, nmsThreshold=0.5, objThreshold=0.5, backendId=0, targetId=0):
+        self.num_classes = 80
+        self.net = cv2.dnn.readNet(modelPath)
+        self.input_size = (640, 640)
+        self.mean = np.array([0.485, 0.456, 0.406], dtype=np.float32).reshape(1, 1, 3)
+        self.std = np.array([0.229, 0.224, 0.225], dtype=np.float32).reshape(1, 1, 3)
+        self.strides = [8, 16, 32]
+        self.confThreshold = confThreshold
+        self.nmsThreshold = nmsThreshold
+        self.objThreshold = objThreshold
+        self.backendId = backendId
+        self.targetId = targetId
+        self.net.setPreferableBackend(self.backendId)
+        self.net.setPreferableTarget(self.targetId)
+
+        self.generateAnchors()
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def setBackendAndTarget(self, backendId, targetId):
+        self.backendId = backendId
+        self.targetId = targetId
+        self.net.setPreferableBackend(self.backendId)
+        self.net.setPreferableTarget(self.targetId)
+
+    def preprocess(self, img):
+        blob = np.transpose(img, (2, 0, 1))
+        return blob[np.newaxis, :, :, :]
+
+    def infer(self, srcimg):
+        input_blob = self.preprocess(srcimg)
+
+        self.net.setInput(input_blob)
+        outs = self.net.forward(self.net.getUnconnectedOutLayersNames())
+
+        predictions = self.postprocess(outs[0])
+        return predictions
+
+    def postprocess(self, outputs):
+        dets = outputs[0]
+
+        dets[:, :2] = (dets[:, :2] + self.grids) * self.expanded_strides
+        dets[:, 2:4] = np.exp(dets[:, 2:4]) * self.expanded_strides
+
+        # get boxes
+        boxes = dets[:, :4]
+        boxes_xyxy = np.ones_like(boxes)
+        boxes_xyxy[:, 0] = boxes[:, 0] - boxes[:, 2] / 2.
+        boxes_xyxy[:, 1] = boxes[:, 1] - boxes[:, 3] / 2.
+        boxes_xyxy[:, 2] = boxes[:, 0] + boxes[:, 2] / 2.
+        boxes_xyxy[:, 3] = boxes[:, 1] + boxes[:, 3] / 2.
+
+        # get scores and class indices
+        scores = dets[:, 4:5] * dets[:, 5:]
+        max_scores = np.amax(scores, axis=1)
+        max_scores_idx = np.argmax(scores, axis=1)
+
+        keep = cv2.dnn.NMSBoxesBatched(boxes_xyxy.tolist(), max_scores.tolist(), max_scores_idx.tolist(), self.confThreshold, self.nmsThreshold)
+
+        candidates = np.concatenate([boxes_xyxy, max_scores[:, None], max_scores_idx[:, None]], axis=1)
+        if len(keep) == 0:
+            return np.array([])
+        return candidates[keep]
+
+    def generateAnchors(self):
+        self.grids = []
+        self.expanded_strides = []
+        hsizes = [self.input_size[0] // stride for stride in self.strides]
+        wsizes = [self.input_size[1] // stride for stride in self.strides]
+
+        for hsize, wsize, stride in zip(hsizes, wsizes, self.strides):
+            xv, yv = np.meshgrid(np.arange(hsize), np.arange(wsize))
+            grid = np.stack((xv, yv), 2).reshape(1, -1, 2)
+            self.grids.append(grid)
+            shape = grid.shape[:2]
+            self.expanded_strides.append(np.full((*shape, 1), stride))
+
+        self.grids = np.concatenate(self.grids, 1)
+        self.expanded_strides = np.concatenate(self.expanded_strides, 1)