pivoted from onnx to opencv 5

efficientdet-d0/README.md

@@ -33,22 +33,19 @@ net = cv2.dnn.readNet("efficientdet-d0_2026jul.onnx")
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module (default engine — no ONNX Runtime
+needed). Adjust the OpenCV paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
 OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model efficientdet-d0_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

efficientdet-d0/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <algorithm>
@@ -36,40 +36,23 @@ int main(int argc, char** argv)
     resize(rgb, rgb, Size(sz, sz));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t nout = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_str;
-    for (size_t i = 0; i < nout; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_str.push_back(out_holders.back().get());
-    }
-    std::vector<const char*> out_names;
-    for (auto& s : out_str) out_names.push_back(s.c_str());
-
-    std::array<int64_t, 4> shape = {1, sz, sz, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, (size_t)sz * sz * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, sz, sz, 3};
+    Mat blob(4, blobShape, CV_8U, rgb.data);
+    dnn::Net net = dnn::readNetFromONNX(model);
+    net.setInput(blob);
+    std::vector<Mat> outs;
+    net.forward(outs, net.getUnconnectedOutLayersNames());
 
     const float* boxp = nullptr;
     const float* clsp = nullptr;
     int n = 0, nc = 0;
     for (size_t i = 0; i < outs.size(); ++i)
     {
-        auto os = outs[i].GetTensorTypeAndShapeInfo().GetShape();
-        const float* p = outs[i].GetTensorMutableData<float>();
-        if (os.back() == 4) { boxp = p; n = (int)os[os.size() - 2]; }
-        else { clsp = p; nc = (int)os.back(); }
+        const Mat& o = outs[i];
+        const float* p = (const float*)o.data;
+        int last = o.size[o.dims - 1];
+        if (last == 4) { boxp = p; n = o.size[o.dims - 2]; }
+        else { clsp = p; nc = last; }
     }
 
     std::vector<std::array<float, 2>> baseWH;

efficientdet-d0/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 sz = 512
@@ -53,9 +52,10 @@ def main():
     anchors = build_anchors()
     acx, acy, aw, ah = anchors[:, 0], anchors[:, 1], anchors[:, 2], anchors[:, 3]
 
-    sess = ort.InferenceSession(model, providers=["CPUExecutionProvider"])
+    net = cv.dnn.readNetFromONNX(model)
     inp = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (sz, sz))
-    res = sess.run(None, {sess.get_inputs()[0].name: inp[None].astype(np.uint8)})
+    net.setInput(inp[None].astype(np.uint8))
+    res = net.forward(net.getUnconnectedOutLayersNames())
     box = next(a for a in res if a.shape[-1] == 4).reshape(-1, 4)
     cls = next(a for a in res if a.shape[-1] != 4).reshape(box.shape[0], -1)
 

faster_rcnn_inception_v2_coco_2018_01_28/README.md

@@ -3,7 +3,7 @@
 Object detection with the Faster-RCNN meta-architecture and an Inception v2 backbone,
 trained on the COCO dataset. The model was originally distributed as a frozen TensorFlow
 graph (`faster_rcnn_inception_v2_coco_2018_01_28.pb`) from the TensorFlow Object Detection
-API and converted to ONNX for inference with ONNX Runtime.
+API and converted to ONNX for inference with OpenCV's DNN module (ONNX Runtime engine).
 
 ## Model Details
 - **Architecture**: Faster-RCNN with an Inception v2 backbone
@@ -20,22 +20,20 @@ python demo.py --model faster_rcnn_inception_v2_coco_2018_01_28_2026jul.onnx --i
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module using its ONNX Runtime engine
+(`ENGINE_ORT`), so OpenCV must be built with `-DWITH_ONNXRUNTIME=ON`. Adjust the OpenCV
+paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
-OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (built with -DWITH_ONNXRUNTIME=ON)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model faster_rcnn_inception_v2_coco_2018_01_28_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

faster_rcnn_inception_v2_coco_2018_01_28/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <array>
@@ -34,38 +34,21 @@ int main(int argc, char** argv)
     cv::resize(rgb, rgb, cv::Size(W, H));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t nout = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_strs;
-    for (size_t i = 0; i < nout; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_strs.push_back(out_holders.back().get());
-    }
-    std::vector<const char*> out_names;
-    for (auto& s : out_strs) out_names.push_back(s.c_str());
-
-    std::array<int64_t, 4> shape = {1, H, W, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, (size_t)H * W * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, H, W, 3};
+    cv::Mat blob(4, blobShape, CV_8U, rgb.data);
+    cv::dnn::Net net = cv::dnn::readNetFromONNX(model, cv::dnn::ENGINE_ORT);
+    net.setInput(blob);
+    std::vector<cv::String> out_strs = {"detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"};
+    std::vector<cv::Mat> outs;
+    net.forward(outs, out_strs);
 
     float* boxes = nullptr;
     float* scores = nullptr;
     float* classes = nullptr;
     float* numd = nullptr;
-    for (size_t i = 0; i < nout; ++i)
+    for (size_t i = 0; i < out_strs.size(); ++i)
     {
-        float* p = outs[i].GetTensorMutableData<float>();
+        float* p = (float*)outs[i].data;
         const std::string& n = out_strs[i];
         if (n.find("detection_boxes") != std::string::npos) boxes = p;
         else if (n.find("detection_scores") != std::string::npos) scores = p;

faster_rcnn_inception_v2_coco_2018_01_28/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -23,9 +22,10 @@ def main():
         raise SystemExit("could not read image: %s" % args.image)
 
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (800, 600))
-    sess = ort.InferenceSession(model, providers=["CPUExecutionProvider"])
-    res = sess.run(None, {sess.get_inputs()[0].name: rgb[None].astype(np.uint8)})
-    onames = [o.name for o in sess.get_outputs()]
+    net = cv.dnn.readNetFromONNX(model, cv.dnn.ENGINE_ORT)
+    onames = ["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"]
+    net.setInput(rgb[None].astype(np.uint8))
+    res = net.forward(onames)
     boxes = res[[i for i, n in enumerate(onames) if "detection_boxes" in n][0]].reshape(-1, 4)
     scores = res[[i for i, n in enumerate(onames) if "detection_scores" in n][0]].reshape(-1)
     classes = res[[i for i, n in enumerate(onames) if "detection_classes" in n][0]].reshape(-1)

faster_rcnn_resnet50_coco_2018_01_28/README.md

@@ -3,7 +3,7 @@
 Object detection with the Faster-RCNN meta-architecture and a ResNet-50 backbone,
 trained on the COCO dataset. The model was originally distributed as a frozen TensorFlow
 graph (`faster_rcnn_resnet50_coco_2018_01_28.pb`) from the TensorFlow Object Detection
-API and converted to ONNX for inference with ONNX Runtime.
+API and converted to ONNX for inference with OpenCV's DNN module (ONNX Runtime engine).
 
 ## Model Details
 - **Architecture**: Faster-RCNN with a ResNet-50 backbone
@@ -20,22 +20,20 @@ python demo.py --model faster_rcnn_resnet50_coco_2018_01_28_2026jul.onnx --image
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module using its ONNX Runtime engine
+(`ENGINE_ORT`), so OpenCV must be built with `-DWITH_ONNXRUNTIME=ON`. Adjust the OpenCV
+paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
-OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (built with -DWITH_ONNXRUNTIME=ON)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model faster_rcnn_resnet50_coco_2018_01_28_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

faster_rcnn_resnet50_coco_2018_01_28/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <array>
@@ -34,38 +34,21 @@ int main(int argc, char** argv)
     cv::resize(rgb, rgb, cv::Size(W, H));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t nout = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_strs;
-    for (size_t i = 0; i < nout; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_strs.push_back(out_holders.back().get());
-    }
-    std::vector<const char*> out_names;
-    for (auto& s : out_strs) out_names.push_back(s.c_str());
-
-    std::array<int64_t, 4> shape = {1, H, W, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, (size_t)H * W * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, H, W, 3};
+    cv::Mat blob(4, blobShape, CV_8U, rgb.data);
+    cv::dnn::Net net = cv::dnn::readNetFromONNX(model, cv::dnn::ENGINE_ORT);
+    net.setInput(blob);
+    std::vector<cv::String> out_strs = {"detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"};
+    std::vector<cv::Mat> outs;
+    net.forward(outs, out_strs);
 
     float* boxes = nullptr;
     float* scores = nullptr;
     float* classes = nullptr;
     float* numd = nullptr;
-    for (size_t i = 0; i < nout; ++i)
+    for (size_t i = 0; i < out_strs.size(); ++i)
     {
-        float* p = outs[i].GetTensorMutableData<float>();
+        float* p = (float*)outs[i].data;
         const std::string& n = out_strs[i];
         if (n.find("detection_boxes") != std::string::npos) boxes = p;
         else if (n.find("detection_scores") != std::string::npos) scores = p;

faster_rcnn_resnet50_coco_2018_01_28/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -23,9 +22,10 @@ def main():
         raise SystemExit("could not read image: %s" % args.image)
 
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (800, 600))
-    sess = ort.InferenceSession(model, providers=["CPUExecutionProvider"])
-    res = sess.run(None, {sess.get_inputs()[0].name: rgb[None].astype(np.uint8)})
-    onames = [o.name for o in sess.get_outputs()]
+    net = cv.dnn.readNetFromONNX(model, cv.dnn.ENGINE_ORT)
+    onames = ["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"]
+    net.setInput(rgb[None].astype(np.uint8))
+    res = net.forward(onames)
     boxes = res[[i for i, n in enumerate(onames) if "detection_boxes" in n][0]].reshape(-1, 4)
     scores = res[[i for i, n in enumerate(onames) if "detection_scores" in n][0]].reshape(-1)
     classes = res[[i for i, n in enumerate(onames) if "detection_classes" in n][0]].reshape(-1)

mask_rcnn_inception_v2_coco_2018_01_28/README.md

@@ -3,7 +3,7 @@
 Instance segmentation with the Mask-RCNN Inception v2 network trained on the COCO dataset.
 The model was originally distributed as a frozen TensorFlow graph
 (`mask_rcnn_inception_v2_coco_2018_01_28.pb`) from the TensorFlow Object Detection API
-and converted to ONNX for use with ONNX Runtime.
+and converted to ONNX for use with OpenCV's DNN module (ONNX Runtime engine).
 
 ## Model Details
 - **Architecture**: Mask-RCNN with an Inception v2 backbone
@@ -22,22 +22,20 @@ python demo.py --model mask_rcnn_inception_v2_coco_2018_01_28_2026jul.onnx --ima
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module using its ONNX Runtime engine
+(`ENGINE_ORT`), so OpenCV must be built with `-DWITH_ONNXRUNTIME=ON`. Adjust the OpenCV
+paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
-OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (built with -DWITH_ONNXRUNTIME=ON)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model mask_rcnn_inception_v2_coco_2018_01_28_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

mask_rcnn_inception_v2_coco_2018_01_28/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <algorithm>
@@ -35,39 +35,22 @@ int main(int argc, char** argv)
     cv::resize(rgb, rgb, cv::Size(W, H));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t nout = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_strs;
-    for (size_t i = 0; i < nout; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_strs.push_back(out_holders.back().get());
-    }
-    std::vector<const char*> out_names;
-    for (auto& s : out_strs) out_names.push_back(s.c_str());
-
-    std::array<int64_t, 4> shape = {1, H, W, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, (size_t)H * W * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, H, W, 3};
+    cv::Mat blob(4, blobShape, CV_8U, rgb.data);
+    cv::dnn::Net net = cv::dnn::readNetFromONNX(model, cv::dnn::ENGINE_ORT);
+    net.setInput(blob);
+    std::vector<cv::String> out_strs = {"num_detections:0", "detection_boxes:0", "detection_scores:0", "detection_classes:0", "detection_masks:0"};
+    std::vector<cv::Mat> outs;
+    net.forward(outs, out_strs);
 
     float* boxes = nullptr;
     float* scores = nullptr;
     float* classes = nullptr;
     float* numd = nullptr;
     float* masks = nullptr;
-    for (size_t i = 0; i < nout; ++i)
+    for (size_t i = 0; i < out_strs.size(); ++i)
     {
-        float* p = outs[i].GetTensorMutableData<float>();
+        float* p = (float*)outs[i].data;
         const std::string& n = out_strs[i];
         if (n.find("detection_boxes") != std::string::npos) boxes = p;
         else if (n.find("detection_scores") != std::string::npos) scores = p;

mask_rcnn_inception_v2_coco_2018_01_28/demo.py

@@ -4,13 +4,12 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Mask-RCNN Inception v2 COCO (ONNX Runtime) detection + mask demo")
+    parser = argparse.ArgumentParser(description="Mask-RCNN Inception v2 COCO (OpenCV DNN) detection + mask demo")
     found = glob.glob(os.path.join(here, "*.onnx"))
     parser.add_argument("--model", default=found[0] if found else None)
     parser.add_argument("--image", default=os.path.join(here, "example_outputs", "input_image.png"))
@@ -22,10 +21,11 @@ def main():
     if img is None:
         raise SystemExit("could not read image: %s" % args.image)
 
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
+    net = cv.dnn.readNetFromONNX(args.model, cv.dnn.ENGINE_ORT)
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (800, 800))
-    res = sess.run(None, {sess.get_inputs()[0].name: rgb[None].astype(np.uint8)})
-    onames = [o.name for o in sess.get_outputs()]
+    onames = ["num_detections:0", "detection_boxes:0", "detection_scores:0", "detection_classes:0", "detection_masks:0"]
+    net.setInput(rgb[None].astype(np.uint8))
+    res = net.forward(onames)
     boxes = res[[i for i, n in enumerate(onames) if "detection_boxes" in n][0]].reshape(-1, 4)
     scores = res[[i for i, n in enumerate(onames) if "detection_scores" in n][0]].reshape(-1)
     classes = res[[i for i, n in enumerate(onames) if "detection_classes" in n][0]].reshape(-1)

opencv_face_detector_uint8/README.md

@@ -2,7 +2,7 @@
 
 Single-shot face detection with the OpenCV SSD ResNet-10 network. The model ships in the
 OpenCV project as a quantized frozen TensorFlow graph (`opencv_face_detector_uint8.pb`) and is
-converted here to ONNX for use with OpenCV's DNN module and onnxruntime. Only the backbone is
+converted here to ONNX for use with OpenCV's DNN module. Only the backbone is
 exported — PriorBox generation, the confidence softmax, variance decode, score threshold and NMS
 are run in host code (see `demo.py` / `demo.cpp`).
 
@@ -36,22 +36,19 @@ net = cv2.dnn.readNet("opencv_face_detector_uint8_2026jul.onnx")
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module (default engine — no ONNX Runtime
+needed). Adjust the OpenCV paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
 OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model opencv_face_detector_uint8_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

opencv_face_detector_uint8/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <algorithm>
@@ -40,39 +40,20 @@ int main(int argc, char** argv)
     subtract(inp, Scalar(104, 177, 123), inp);
     if (!inp.isContinuous()) inp = inp.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t nout = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_str;
-    for (size_t i = 0; i < nout; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_str.push_back(out_holders.back().get());
-    }
-    std::vector<const char*> out_names;
-    for (auto& s : out_str) out_names.push_back(s.c_str());
-
-    std::array<int64_t, 4> shape = {1, sz, sz, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<float>(mem, (float*)inp.data, (size_t)sz * sz * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, sz, sz, 3};
+    Mat blob(4, blobShape, CV_32F, inp.data);
+    dnn::Net net = dnn::readNetFromONNX(model);
+    net.setInput(blob);
+    std::vector<Mat> outs;
+    net.forward(outs, net.getUnconnectedOutLayersNames());
 
     const float* loc = nullptr;
     const float* conf = nullptr;
     for (size_t i = 0; i < outs.size(); ++i)
     {
-        auto os = outs[i].GetTensorTypeAndShapeInfo().GetShape();
-        size_t tot = 1;
-        for (auto d : os) tot *= (size_t)d;
-        const float* p = outs[i].GetTensorMutableData<float>();
+        const Mat& o = outs[i];
+        size_t tot = o.total();
+        const float* p = (const float*)o.data;
         if (tot == 35568) loc = p;
         else if (tot == 17784) conf = p;
     }

opencv_face_detector_uint8/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -57,9 +56,10 @@ def main():
 
     inp = cv.resize(img, (sz, sz)).astype(np.float32) - np.array([104.0, 177.0, 123.0], np.float32)
 
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
-    res = sess.run(None, {sess.get_inputs()[0].name: inp[None]})
-    onames = [o.name for o in sess.get_outputs()]
+    net = cv.dnn.readNetFromONNX(args.model)
+    onames = net.getUnconnectedOutLayersNames()
+    net.setInput(inp[None])
+    res = net.forward(onames)
     loc = res[[i for i, n in enumerate(onames) if "mbox_loc" in n][0]].reshape(-1, 4)
     conf = res[[i for i, n in enumerate(onames) if "mbox_conf" in n][0]].reshape(-1, 2)
 

ssd_inception_v2_coco_2017_11_17/README.md

@@ -19,22 +19,20 @@ python demo.py --model ssd_inception_v2_coco_2017_11_17_2026jul.onnx --image exa
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module using its ONNX Runtime engine
+(`ENGINE_ORT`), so OpenCV must be built with `-DWITH_ONNXRUNTIME=ON`. Adjust the OpenCV
+paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
-OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (built with -DWITH_ONNXRUNTIME=ON)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model ssd_inception_v2_coco_2017_11_17_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

ssd_inception_v2_coco_2017_11_17/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <array>
@@ -35,39 +35,22 @@ int main(int argc, char** argv)
     resize(rgb, rgb, Size(300, 300));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t out_count = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_str;
-    std::vector<const char*> out_names;
-    for (size_t i = 0; i < out_count; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_str.push_back(out_holders.back().get());
-        out_names.push_back(out_str.back().c_str());
-    }
-
-    std::array<int64_t, 4> shape = {1, 300, 300, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, 300 * 300 * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, 300, 300, 3};
+    Mat blob(4, blobShape, CV_8U, rgb.data);
+    dnn::Net net = dnn::readNetFromONNX(model, dnn::ENGINE_ORT);
+    net.setInput(blob);
+    std::vector<String> out_str = {"detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"};
+    std::vector<Mat> outs;
+    net.forward(outs, out_str);
 
     const float *boxes = 0, *scores = 0, *classes = 0, *num = 0;
-    for (size_t i = 0; i < out_count; ++i)
+    for (size_t i = 0; i < out_str.size(); ++i)
     {
         const std::string& n = out_str[i];
-        if (n.find("detection_boxes") != std::string::npos) boxes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_scores") != std::string::npos) scores = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_classes") != std::string::npos) classes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("num_detections") != std::string::npos) num = outs[i].GetTensorMutableData<float>();
+        if (n.find("detection_boxes") != std::string::npos) boxes = (const float*)outs[i].data;
+        else if (n.find("detection_scores") != std::string::npos) scores = (const float*)outs[i].data;
+        else if (n.find("detection_classes") != std::string::npos) classes = (const float*)outs[i].data;
+        else if (n.find("num_detections") != std::string::npos) num = (const float*)outs[i].data;
     }
     if (!boxes || !scores || !classes || !num)
     {

ssd_inception_v2_coco_2017_11_17/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -23,9 +22,10 @@ def main():
 
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (300, 300))
 
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
-    res = sess.run(None, {sess.get_inputs()[0].name: rgb[None].astype(np.uint8)})
-    onames = [o.name for o in sess.get_outputs()]
+    net = cv.dnn.readNetFromONNX(args.model, cv.dnn.ENGINE_ORT)
+    onames = ["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"]
+    net.setInput(rgb[None].astype(np.uint8))
+    res = net.forward(onames)
     boxes = res[[i for i, n in enumerate(onames) if "detection_boxes" in n][0]].reshape(-1, 4)
     scores = res[[i for i, n in enumerate(onames) if "detection_scores" in n][0]].reshape(-1)
     classes = res[[i for i, n in enumerate(onames) if "detection_classes" in n][0]].reshape(-1)

ssd_mobilenet_v1_coco_2017_11_17/README.md

@@ -19,22 +19,20 @@ python demo.py --model ssd_mobilenet_v1_coco_2017_11_17_2026jul.onnx --image exa
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module using its ONNX Runtime engine
+(`ENGINE_ORT`), so OpenCV must be built with `-DWITH_ONNXRUNTIME=ON`. Adjust the OpenCV
+paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
-OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (built with -DWITH_ONNXRUNTIME=ON)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model ssd_mobilenet_v1_coco_2017_11_17_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

ssd_mobilenet_v1_coco_2017_11_17/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <array>
@@ -35,39 +35,22 @@ int main(int argc, char** argv)
     resize(rgb, rgb, Size(300, 300));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t out_count = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_str;
-    std::vector<const char*> out_names;
-    for (size_t i = 0; i < out_count; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_str.push_back(out_holders.back().get());
-        out_names.push_back(out_str.back().c_str());
-    }
-
-    std::array<int64_t, 4> shape = {1, 300, 300, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, 300 * 300 * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, 300, 300, 3};
+    Mat blob(4, blobShape, CV_8U, rgb.data);
+    dnn::Net net = dnn::readNetFromONNX(model, dnn::ENGINE_ORT);
+    net.setInput(blob);
+    std::vector<String> out_str = {"detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"};
+    std::vector<Mat> outs;
+    net.forward(outs, out_str);
 
     const float *boxes = 0, *scores = 0, *classes = 0, *num = 0;
-    for (size_t i = 0; i < out_count; ++i)
+    for (size_t i = 0; i < out_str.size(); ++i)
     {
         const std::string& n = out_str[i];
-        if (n.find("detection_boxes") != std::string::npos) boxes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_scores") != std::string::npos) scores = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_classes") != std::string::npos) classes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("num_detections") != std::string::npos) num = outs[i].GetTensorMutableData<float>();
+        if (n.find("detection_boxes") != std::string::npos) boxes = (const float*)outs[i].data;
+        else if (n.find("detection_scores") != std::string::npos) scores = (const float*)outs[i].data;
+        else if (n.find("detection_classes") != std::string::npos) classes = (const float*)outs[i].data;
+        else if (n.find("num_detections") != std::string::npos) num = (const float*)outs[i].data;
     }
     if (!boxes || !scores || !classes || !num)
     {

ssd_mobilenet_v1_coco_2017_11_17/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -23,9 +22,10 @@ def main():
 
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (300, 300))
 
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
-    res = sess.run(None, {sess.get_inputs()[0].name: rgb[None].astype(np.uint8)})
-    onames = [o.name for o in sess.get_outputs()]
+    net = cv.dnn.readNetFromONNX(args.model, cv.dnn.ENGINE_ORT)
+    onames = ["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"]
+    net.setInput(rgb[None].astype(np.uint8))
+    res = net.forward(onames)
     boxes = res[[i for i, n in enumerate(onames) if "detection_boxes" in n][0]].reshape(-1, 4)
     scores = res[[i for i, n in enumerate(onames) if "detection_scores" in n][0]].reshape(-1)
     classes = res[[i for i, n in enumerate(onames) if "detection_classes" in n][0]].reshape(-1)

ssd_mobilenet_v1_ppn_coco/README.md

@@ -20,22 +20,20 @@ python demo.py --model ssd_mobilenet_v1_ppn_coco_2026jul.onnx --image example_ou
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module using its ONNX Runtime engine
+(`ENGINE_ORT`), so OpenCV must be built with `-DWITH_ONNXRUNTIME=ON`. Adjust the OpenCV
+paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
-OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (built with -DWITH_ONNXRUNTIME=ON)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model ssd_mobilenet_v1_ppn_coco_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

ssd_mobilenet_v1_ppn_coco/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <array>
@@ -35,39 +35,22 @@ int main(int argc, char** argv)
     resize(rgb, rgb, Size(300, 300));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t out_count = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_str;
-    std::vector<const char*> out_names;
-    for (size_t i = 0; i < out_count; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_str.push_back(out_holders.back().get());
-        out_names.push_back(out_str.back().c_str());
-    }
-
-    std::array<int64_t, 4> shape = {1, 300, 300, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, 300 * 300 * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, 300, 300, 3};
+    Mat blob(4, blobShape, CV_8U, rgb.data);
+    dnn::Net net = dnn::readNetFromONNX(model, dnn::ENGINE_ORT);
+    net.setInput(blob);
+    std::vector<String> out_str = {"detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"};
+    std::vector<Mat> outs;
+    net.forward(outs, out_str);
 
     const float *boxes = 0, *scores = 0, *classes = 0, *num = 0;
-    for (size_t i = 0; i < out_count; ++i)
+    for (size_t i = 0; i < out_str.size(); ++i)
     {
         const std::string& n = out_str[i];
-        if (n.find("detection_boxes") != std::string::npos) boxes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_scores") != std::string::npos) scores = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_classes") != std::string::npos) classes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("num_detections") != std::string::npos) num = outs[i].GetTensorMutableData<float>();
+        if (n.find("detection_boxes") != std::string::npos) boxes = (const float*)outs[i].data;
+        else if (n.find("detection_scores") != std::string::npos) scores = (const float*)outs[i].data;
+        else if (n.find("detection_classes") != std::string::npos) classes = (const float*)outs[i].data;
+        else if (n.find("num_detections") != std::string::npos) num = (const float*)outs[i].data;
     }
     if (!boxes || !scores || !classes || !num)
     {

ssd_mobilenet_v1_ppn_coco/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -23,9 +22,10 @@ def main():
 
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (300, 300))
 
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
-    res = sess.run(None, {sess.get_inputs()[0].name: rgb[None].astype(np.uint8)})
-    onames = [o.name for o in sess.get_outputs()]
+    net = cv.dnn.readNetFromONNX(args.model, cv.dnn.ENGINE_ORT)
+    onames = ["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"]
+    net.setInput(rgb[None].astype(np.uint8))
+    res = net.forward(onames)
     boxes = res[[i for i, n in enumerate(onames) if "detection_boxes" in n][0]].reshape(-1, 4)
     scores = res[[i for i, n in enumerate(onames) if "detection_scores" in n][0]].reshape(-1)
     classes = res[[i for i, n in enumerate(onames) if "detection_classes" in n][0]].reshape(-1)

ssd_mobilenet_v2_coco_2018_03_29/README.md

@@ -19,22 +19,20 @@ python demo.py --model ssd_mobilenet_v2_coco_2018_03_29_2026jul.onnx --image exa
 ```
 
 ### C++
-The C++ demo runs inference with ONNX Runtime (C++ API) and uses OpenCV only for image I/O.
-Install ONNX Runtime (C++) from https://github.com/microsoft/onnxruntime/releases — this build
-uses `onnxruntime-linux-x64-1.25.0` — and adjust the ONNX Runtime and OpenCV paths to your setup:
+The C++ demo runs inference with OpenCV's DNN module using its ONNX Runtime engine
+(`ENGINE_ORT`), so OpenCV must be built with `-DWITH_ONNXRUNTIME=ON`. Adjust the OpenCV
+paths to your setup:
 ```bash
-ORT=/path/to/onnxruntime-linux-x64-1.25.0    # ONNX Runtime release dir (contains include/ and lib/)
 OCV=/path/to/opencv                          # OpenCV source tree
-OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (built with -DWITH_ONNXRUNTIME=ON)
 g++ -std=c++17 demo.cpp -o demo \
-  -I$ORT/include \
   -I$OCV/include \
   -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
   -I$OCV/modules/imgproc/include \
   -I$OCV/modules/imgcodecs/include \
   -I$OCVBUILD \
-  -L$ORT/lib -Wl,-rpath,$ORT/lib -lonnxruntime \
-  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
 ./demo --model ssd_mobilenet_v2_coco_2018_03_29_2026jul.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png
 ```
 

ssd_mobilenet_v2_coco_2018_03_29/demo.cpp

@@ -1,4 +1,4 @@
-#include <onnxruntime_cxx_api.h>
+#include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <array>
@@ -35,39 +35,22 @@ int main(int argc, char** argv)
     resize(rgb, rgb, Size(300, 300));
     if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "demo");
-    Ort::SessionOptions so;
-    Ort::Session session(env, model.c_str(), so);
-    Ort::AllocatorWithDefaultOptions alloc;
-
-    auto in_name = session.GetInputNameAllocated(0, alloc);
-    const char* in_names[] = {in_name.get()};
-
-    size_t out_count = session.GetOutputCount();
-    std::vector<Ort::AllocatedStringPtr> out_holders;
-    std::vector<std::string> out_str;
-    std::vector<const char*> out_names;
-    for (size_t i = 0; i < out_count; ++i)
-    {
-        out_holders.push_back(session.GetOutputNameAllocated(i, alloc));
-        out_str.push_back(out_holders.back().get());
-        out_names.push_back(out_str.back().c_str());
-    }
-
-    std::array<int64_t, 4> shape = {1, 300, 300, 3};
-    auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-    Ort::Value input = Ort::Value::CreateTensor<uint8_t>(mem, rgb.data, 300 * 300 * 3, shape.data(), shape.size());
-
-    auto outs = session.Run(Ort::RunOptions{nullptr}, in_names, &input, 1, out_names.data(), out_names.size());
+    int blobShape[] = {1, 300, 300, 3};
+    Mat blob(4, blobShape, CV_8U, rgb.data);
+    dnn::Net net = dnn::readNetFromONNX(model, dnn::ENGINE_ORT);
+    net.setInput(blob);
+    std::vector<String> out_str = {"detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"};
+    std::vector<Mat> outs;
+    net.forward(outs, out_str);
 
     const float *boxes = 0, *scores = 0, *classes = 0, *num = 0;
-    for (size_t i = 0; i < out_count; ++i)
+    for (size_t i = 0; i < out_str.size(); ++i)
     {
         const std::string& n = out_str[i];
-        if (n.find("detection_boxes") != std::string::npos) boxes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_scores") != std::string::npos) scores = outs[i].GetTensorMutableData<float>();
-        else if (n.find("detection_classes") != std::string::npos) classes = outs[i].GetTensorMutableData<float>();
-        else if (n.find("num_detections") != std::string::npos) num = outs[i].GetTensorMutableData<float>();
+        if (n.find("detection_boxes") != std::string::npos) boxes = (const float*)outs[i].data;
+        else if (n.find("detection_scores") != std::string::npos) scores = (const float*)outs[i].data;
+        else if (n.find("detection_classes") != std::string::npos) classes = (const float*)outs[i].data;
+        else if (n.find("num_detections") != std::string::npos) num = (const float*)outs[i].data;
     }
     if (!boxes || !scores || !classes || !num)
     {

ssd_mobilenet_v2_coco_2018_03_29/demo.py

@@ -4,7 +4,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -23,9 +22,10 @@ def main():
 
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (300, 300))
 
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
-    res = sess.run(None, {sess.get_inputs()[0].name: rgb[None].astype(np.uint8)})
-    onames = [o.name for o in sess.get_outputs()]
+    net = cv.dnn.readNetFromONNX(args.model, cv.dnn.ENGINE_ORT)
+    onames = ["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"]
+    net.setInput(rgb[None].astype(np.uint8))
+    res = net.forward(onames)
     boxes = res[[i for i, n in enumerate(onames) if "detection_boxes" in n][0]].reshape(-1, 4)
     scores = res[[i for i, n in enumerate(onames) if "detection_scores" in n][0]].reshape(-1)
     classes = res[[i for i, n in enumerate(onames) if "detection_classes" in n][0]].reshape(-1)

tensorflow_inception_graph/README.md

@@ -27,9 +27,20 @@ net = cv2.dnn.readNet("tensorflow_inception_graph_2026jul.onnx")
 ```
 
 ### C++
+The C++ demo runs inference with OpenCV's DNN module (default engine — no ONNX Runtime
+needed). Adjust the OpenCV paths to your setup:
 ```bash
-cmake -B build && cmake --build build
-./build/demo --model tensorflow_inception_graph_2026jul.onnx --image example_outputs/input_image.png
+OCV=/path/to/opencv                          # OpenCV source tree
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+g++ -std=c++17 demo.cpp -o demo \
+  -I$OCV/include \
+  -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
+  -I$OCV/modules/imgproc/include \
+  -I$OCV/modules/imgcodecs/include \
+  -I$OCVBUILD \
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+./demo --model tensorflow_inception_graph_2026jul.onnx --image example_outputs/input_image.png
 ```
 
 ## Conversion

tensorflow_inception_graph/demo.cpp

@@ -1,13 +1,13 @@
 #include <opencv2/dnn.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
+#include <algorithm>
+#include <array>
 #include <fstream>
 #include <iostream>
 #include <string>
 #include <vector>
 
-using namespace cv;
-
 static std::string argVal(int argc, char** argv, const std::string& key, const std::string& def)
 {
     for (int i = 1; i + 1 < argc; ++i)
@@ -22,45 +22,44 @@ int main(int argc, char** argv)
     std::string output = argVal(argc, argv, "--output", "example_outputs/output_image.png");
     std::string labels = argVal(argc, argv, "--labels", "");
 
-    Mat img = imread(image);
+    cv::Mat img = cv::imread(image);
     if (img.empty())
     {
         std::cerr << "could not read image: " << image << std::endl;
         return 1;
     }
 
-    Mat rgb;
-    cvtColor(img, rgb, COLOR_BGR2RGB);
-    resize(rgb, rgb, Size(224, 224));
+    cv::Mat rgb;
+    cv::cvtColor(img, rgb, cv::COLOR_BGR2RGB);
+    cv::resize(rgb, rgb, cv::Size(224, 224));
     rgb.convertTo(rgb, CV_32F);
+    if (!rgb.isContinuous()) rgb = rgb.clone();
 
-    int dims[] = {1, 224, 224, 3};
-    Mat blob(4, dims, CV_32F, rgb.data);
-
-    dnn::Net net = dnn::readNet(model);
+    int blobShape[] = {1, 224, 224, 3};
+    cv::Mat blob(4, blobShape, CV_32F, rgb.data);
+    cv::dnn::Net net = cv::dnn::readNetFromONNX(model);
     net.setInput(blob);
-    Mat scores = net.forward().reshape(1, 1);
+    cv::Mat scoresMat = net.forward();
+    float* scores = (float*)scoresMat.data;
+    int n = (int)scoresMat.total();
+    int top = (int)(std::max_element(scores, scores + n) - scores);
+    float conf = scores[top];
 
-    Point classId;
-    double conf;
-    minMaxLoc(scores, 0, &conf, 0, &classId);
-
-    std::string label = std::to_string(classId.x);
+    std::string label = std::to_string(top);
     if (!labels.empty())
     {
         std::ifstream f(labels);
         std::vector<std::string> names;
         std::string line;
         while (std::getline(f, line)) names.push_back(line);
-        if (classId.x < (int)names.size()) label = names[classId.x];
+        if (top < (int)names.size()) label = names[top];
     }
+    std::cout << "class " << top << " " << label << " confidence " << conf << std::endl;
 
-    std::cout << "class " << classId.x << " " << label << " confidence " << conf << std::endl;
-
-    Mat out = img.clone();
-    putText(out, format("%s (%.2f)", label.c_str(), conf), Point(10, 30),
-            FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 255, 0), 2);
-    imwrite(output, out);
+    cv::Mat out = img.clone();
+    cv::putText(out, cv::format("%s (%.2f)", label.c_str(), conf), cv::Point(10, 30),
+                cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(0, 255, 0), 2);
+    cv::imwrite(output, out);
     std::cout << "wrote " << output << std::endl;
     return 0;
 }

tensorflow_inception_graph/demo.py

@@ -3,7 +3,6 @@ import os
 
 import cv2 as cv
 import numpy as np
-import onnxruntime as ort
 
 here = os.path.dirname(os.path.abspath(__file__))
 
@@ -22,8 +21,9 @@ def main():
 
     rgb = cv.resize(cv.cvtColor(img, cv.COLOR_BGR2RGB), (224, 224)).astype(np.float32)
 
-    sess = ort.InferenceSession(args.model, providers=["CPUExecutionProvider"])
-    scores = sess.run(None, {sess.get_inputs()[0].name: rgb[None]})[0].ravel()
+    net = cv.dnn.readNetFromONNX(args.model)
+    net.setInput(rgb[None])
+    scores = net.forward().ravel()
 
     top = int(np.argmax(scores))
     conf = float(scores[top])