devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

opencv+yolov8实现监控画面报警功能_利用opencv实时获取图像并识别文字发送报警信息

作者：Cpp五条 | 2024-02-12 15:08:02

赞

踩

利用opencv实时获取图像并识别文字发送报警信息

项目背景

最近停在门前的车被人开走了，虽然有监控，但是看监控太麻烦了，于是想着框选一个区域用yolov8直接检测闯入到这个区域的所有目标，这样1ms一帧，很快就可以跑完一天的视频

用到的技术

  1. C++
  2. OpenCV
  3. Yolov8 + OnnxRuntime

yolov8介绍

  • YOLOv8支持Pose和Segment,在使用TensorRT可以跑到1-2ms一帧
  • YOLOv8提供了一个全新的SOTA模型，包括P5 640和P6 1280分辨率的目标检测网络和基于YOLACT的实例分割模型。
  • YOLOv8和YOLOv5一样，基于缩放系数也提供了N/S/M/L/X尺度的不同大小模型，用于满足不同场景需求。
  • YOLOv8骨干网络和Neck部分可能参考了YOLOv7 ELAN设计思想，将YOLOv5的C3结构换成了梯度流更丰富的C2f结构，并对不同尺度模型调整了不同的通道数。
  • YOLOv8 Head部分相比YOLOv5改动较大，换成了目前主流的解耦头结构，将分类和检测头分离，同时也从Anchor-Based换成了Anchor-Free。
  • YOLOv8 Loss计算方面采用了TaskAlignedAssigner正样本分配策略，并引入了Distribution Focal Loss。
  • YOLOv8训练的数据增强部分引入了YOLOX中的最后10 epoch关闭Mosiac增强的操作，可以有效地提升精度。

实现步骤

  1. 首先打开视频第一帧，框选区域，我们直接使用opencv实现这个功能
  2. 加载模型检测画面中的所有对象
  3. 计算IOU，如果有重合就保存这一帧具体信息
  4. 跟踪闯入画面的目标，否则会重复保存信息

使用opencv打开视频，并框选区域

  1. #include <opencv2/opencv.hpp>
  2. #include "inference.h"
  3.  
  4. using namespace cv;
  5.  
  6. // 定义一个全局变量，用于存放鼠标框选的矩形区域
  7. Rect g_rect;
  8. // 定义一个全局变量，用于标记鼠标是否按下
  9. bool g_bDrawingBox = false;
  10.  
  11. // 定义一个回调函数，用于处理鼠标事件
  12. void on_MouseHandle(int event, int x, int y, int flags, void* param)
  13. {
  14.     // 将param转换为Mat类型的指针
  15.     Mat& image = *(Mat*) param;
  16.     // 根据不同的鼠标事件进行处理
  17.     switch (event)
  18.     {
  19.         // 鼠标左键按下事件
  20.         case EVENT_LBUTTONDOWN:
  21.         {
  22.             // 标记鼠标已按下
  23.             g_bDrawingBox = true;
  24.             // 记录矩形框的起始点
  25.             g_rect.x = x;
  26.             g_rect.y = y;
  27.             break;
  28.         }
  29.         // 鼠标移动事件
  30.         case EVENT_MOUSEMOVE:
  31.         {
  32.             // 如果鼠标已按下，更新矩形框的宽度和高度
  33.             if (g_bDrawingBox)
  34.             {
  35.                 g_rect.width = x - g_rect.x;
  36.                 g_rect.height = y - g_rect.y;
  37.             }
  38.             break;
  39.         }
  40.         // 鼠标左键松开事件
  41.         case EVENT_LBUTTONUP:
  42.         {
  43.             // 标记鼠标已松开
  44.             g_bDrawingBox = false;
  45.             // 如果矩形框的宽度和高度为正，绘制矩形框到图像上
  46.             if (g_rect.width > 0 && g_rect.height > 0)
  47.             {
  48.                 rectangle(image, g_rect, Scalar(0, 255, 0));
  49.             }
  50.             break;
  51.         }
  52.     }
  53. }
  54.  
  55. int main(int argc, char* argv[])
  56. {
  57.     // 读取视频文件
  58.     cv::VideoCapture vc;
  59.     vc.open(argv[1]);
  60.     
  61.     if(vc.isOpened()){
  62.         cv::Mat frame;
  63.         vc >> frame;
  64.         if(!frame.empty()){
  65.             // 创建一个副本图像，用于显示框选过程
  66.             Mat temp;
  67.             frame.copyTo(temp);
  68.             // 创建一个窗口，显示图像
  69.             namedWindow("image");
  70.             // 设置鼠标回调函数，传入副本图像作为参数
  71.             setMouseCallback("image", on_MouseHandle, (void*)&temp);
  72.             while (1)
  73.             {
  74.                 // 如果鼠标正在框选，绘制一个虚线矩形框到副本图像上，并显示框的大小和坐标
  75.                 if (g_bDrawingBox)
  76.                 {
  77.                     temp.copyTo(frame);
  78.                     rectangle(frame, g_rect, Scalar(0, 255, 0), 1, LINE_AA);
  79.                     char text[32];
  80.                     sprintf(text, "w=%d, h=%d", g_rect.width, g_rect.height);
  81.                     putText(frame, text, Point(g_rect.x + 5, g_rect.y - 5), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
  82.                 }
  83.                 // 显示副本图像
  84.                 imshow("image", frame);
  85.                 // 等待按键，如果按下ESC键，退出循环
  86.                 if (waitKey(10) == 27)
  87.                 {
  88.                     break;
  89.                 }
  90.             }
  91.  
  92.             while(!frame.empty()){
  93.                 cv::imshow("image", frame);
  94.                 cv::waitKey(1);
  95.  
  96.                 vc >> frame;
  97.             }
  98.         }
  99.     }
  100.     
  101.     return 0;
  102. }

使用YoloV8检测目标

inference.h

  1. #pragma once
  2.  
  3. #define    RET_OK nullptr
  4.  
  5. #ifdef _WIN32
  6. #include <Windows.h>
  7. #include <direct.h>
  8. #include <io.h>
  9. #endif
  10.  
  11. #include <string>
  12. #include <vector>
  13. #include <cstdio>
  14. #include <opencv2/opencv.hpp>
  15. #include "onnxruntime_cxx_api.h"
  16.  
  17. #ifdef USE_CUDA
  18. #include <cuda_fp16.h>
  19. #endif
  20.  
  21.  
  22. enum MODEL_TYPE {
  23.     //FLOAT32 MODEL
  24.     YOLO_ORIGIN_V5 = 0,
  25.     YOLO_ORIGIN_V8 = 1,//only support v8 detector currently
  26.     YOLO_POSE_V8 = 2,
  27.     YOLO_CLS_V8 = 3,
  28.     YOLO_ORIGIN_V8_HALF = 4,
  29.     YOLO_POSE_V8_HALF = 5,
  30.     YOLO_CLS_V8_HALF = 6
  31. };
  32.  
  33.  
  34. typedef struct _DCSP_INIT_PARAM {
  35.     std::string ModelPath;
  36.     MODEL_TYPE ModelType = YOLO_ORIGIN_V8;
  37.     std::vector<int> imgSize = {640, 640};
  38.     float RectConfidenceThreshold = 0.6;
  39.     float iouThreshold = 0.5;
  40.     bool CudaEnable = false;
  41.     int LogSeverityLevel = 3;
  42.     int IntraOpNumThreads = 1;
  43. } DCSP_INIT_PARAM;
  44.  
  45.  
  46. typedef struct _DCSP_RESULT {
  47.     int classId;
  48.     float confidence;
  49.     cv::Rect box;
  50. } DCSP_RESULT;
  51.  
  52.  
  53. class DCSP_CORE {
  54. public:
  55.     DCSP_CORE();
  56.  
  57.     ~DCSP_CORE();
  58.  
  59. public:
  60.     char *CreateSession(DCSP_INIT_PARAM &iParams);
  61.  
  62.     char *RunSession(cv::Mat &iImg, std::vector<DCSP_RESULT> &oResult);
  63.  
  64.     char *WarmUpSession();
  65.  
  66.     template<typename N>
  67.     char *TensorProcess(clock_t &starttime_1, cv::Mat &iImg, N &blob, std::vector<int64_t> &inputNodeDims,
  68.                         std::vector<DCSP_RESULT> &oResult);
  69.  
  70.     std::vector<std::string> classes{};
  71.  
  72. private:
  73.     Ort::Env env;
  74.     Ort::Session *session;
  75.     bool cudaEnable;
  76.     Ort::RunOptions options;
  77.     std::vector<const char *> inputNodeNames;
  78.     std::vector<const char *> outputNodeNames;
  79.  
  80.     MODEL_TYPE modelType;
  81.     std::vector<int> imgSize;
  82.     float rectConfidenceThreshold;
  83.     float iouThreshold;
  84. };

inference.cpp

  1. #include "inference.h"
  2. #include <regex>
  3.  
  4. #define benchmark
  5.  
  6. DCSP_CORE::DCSP_CORE() {
  7.  
  8. }
  9.  
  10.  
  11. DCSP_CORE::~DCSP_CORE() {
  12.     delete session;
  13. }
  14.  
  15. #ifdef USE_CUDA
  16. namespace Ort
  17. {
  18.     template<>
  19.     struct TypeToTensorType<half> { static constexpr ONNXTensorElementDataType type = ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT16; };
  20. }
  21. #endif
  22.  
  23.  
  24. template<typename T>
  25. char *BlobFromImage(cv::Mat &iImg, T &iBlob) {
  26.     int channels = iImg.channels();
  27.     int imgHeight = iImg.rows;
  28.     int imgWidth = iImg.cols;
  29.  
  30.     for (int c = 0; c < channels; c++) {
  31.         for (int h = 0; h < imgHeight; h++) {
  32.             for (int w = 0; w < imgWidth; w++) {
  33.                 iBlob[c * imgWidth * imgHeight + h * imgWidth + w] = typename std::remove_pointer<T>::type(
  34.                         (iImg.at<cv::Vec3b>(h, w)[c]) / 255.0f);
  35.             }
  36.         }
  37.     }
  38.     return RET_OK;
  39. }
  40.  
  41.  
  42. char *PostProcess(cv::Mat &iImg, std::vector<int> iImgSize, cv::Mat &oImg) {
  43.     cv::Mat img = iImg.clone();
  44.     cv::resize(iImg, oImg, cv::Size(iImgSize.at(0), iImgSize.at(1)));
  45.     if (img.channels() == 1) {
  46.         cv::cvtColor(oImg, oImg, cv::COLOR_GRAY2BGR);
  47.     }
  48.     cv::cvtColor(oImg, oImg, cv::COLOR_BGR2RGB);
  49.     return RET_OK;
  50. }
  51.  
  52.  
  53. char *DCSP_CORE::CreateSession(DCSP_INIT_PARAM &iParams) {
  54.     char *Ret = RET_OK;
  55.     std::regex pattern("[\u4e00-\u9fa5]");
  56.     bool result = std::regex_search(iParams.ModelPath, pattern);
  57.     if (result) {
  58.         Ret = "[DCSP_ONNX]:Model path error.Change your model path without chinese characters.";
  59.         std::cout << Ret << std::endl;
  60.         return Ret;
  61.     }
  62.     try {
  63.         rectConfidenceThreshold = iParams.RectConfidenceThreshold;
  64.         iouThreshold = iParams.iouThreshold;
  65.         imgSize = iParams.imgSize;
  66.         modelType = iParams.ModelType;
  67.         env = Ort::Env(ORT_LOGGING_LEVEL_WARNING, "Yolo");
  68.         Ort::SessionOptions sessionOption;
  69.         if (iParams.CudaEnable) {
  70.             cudaEnable = iParams.CudaEnable;
  71.             OrtCUDAProviderOptions cudaOption;
  72.             cudaOption.device_id = 0;
  73.             sessionOption.AppendExecutionProvider_CUDA(cudaOption);
  74.         }
  75.         sessionOption.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);
  76.         sessionOption.SetIntraOpNumThreads(iParams.IntraOpNumThreads);
  77.         sessionOption.SetLogSeverityLevel(iParams.LogSeverityLevel);
  78.  
  79. #ifdef _WIN32
  80.         int ModelPathSize = MultiByteToWideChar(CP_UTF8, 0, iParams.ModelPath.c_str(), static_cast<int>(iParams.ModelPath.length()), nullptr, 0);
  81.         wchar_t* wide_cstr = new wchar_t[ModelPathSize + 1];
  82.         MultiByteToWideChar(CP_UTF8, 0, iParams.ModelPath.c_str(), static_cast<int>(iParams.ModelPath.length()), wide_cstr, ModelPathSize);
  83.         wide_cstr[ModelPathSize] = L'\0';
  84.         const wchar_t* modelPath = wide_cstr;
  85. #else
  86.         const char *modelPath = iParams.ModelPath.c_str();
  87. #endif // _WIN32
  88.  
  89.         session = new Ort::Session(env, modelPath, sessionOption);
  90.         Ort::AllocatorWithDefaultOptions allocator;
  91.         size_t inputNodesNum = session->GetInputCount();
  92.         for (size_t i = 0; i < inputNodesNum; i++) {
  93.             Ort::AllocatedStringPtr input_node_name = session->GetInputNameAllocated(i, allocator);
  94.             char *temp_buf = new char[50];
  95.             strcpy(temp_buf, input_node_name.get());
  96.             inputNodeNames.push_back(temp_buf);
  97.         }
  98.         size_t OutputNodesNum = session->GetOutputCount();
  99.         for (size_t i = 0; i < OutputNodesNum; i++) {
  100.             Ort::AllocatedStringPtr output_node_name = session->GetOutputNameAllocated(i, allocator);
  101.             char *temp_buf = new char[10];
  102.             strcpy(temp_buf, output_node_name.get());
  103.             outputNodeNames.push_back(temp_buf);
  104.         }
  105.         options = Ort::RunOptions{nullptr};
  106.         WarmUpSession();
  107.         return RET_OK;
  108.     }
  109.     catch (const std::exception &e) {
  110.         const char *str1 = "[DCSP_ONNX]:";
  111.         const char *str2 = e.what();
  112.         std::string result = std::string(str1) + std::string(str2);
  113.         char *merged = new char[result.length() + 1];
  114.         std::strcpy(merged, result.c_str());
  115.         std::cout << merged << std::endl;
  116.         delete[] merged;
  117.         return "[DCSP_ONNX]:Create session failed.";
  118.     }
  119.  
  120. }
  121.  
  122.  
  123. char *DCSP_CORE::RunSession(cv::Mat &iImg, std::vector<DCSP_RESULT> &oResult) {
  124. #ifdef benchmark
  125.     clock_t starttime_1 = clock();
  126. #endif // benchmark
  127.  
  128.     char *Ret = RET_OK;
  129.     cv::Mat processedImg;
  130.     PostProcess(iImg, imgSize, processedImg);
  131.     if (modelType < 4) {
  132.         float *blob = new float[processedImg.total() * 3];
  133.         BlobFromImage(processedImg, blob);
  134.         std::vector<int64_t> inputNodeDims = {1, 3, imgSize.at(0), imgSize.at(1)};
  135.         TensorProcess(starttime_1, iImg, blob, inputNodeDims, oResult);
  136.     } else {
  137. #ifdef USE_CUDA
  138.         half* blob = new half[processedImg.total() * 3];
  139.         BlobFromImage(processedImg, blob);
  140.         std::vector<int64_t> inputNodeDims = { 1,3,imgSize.at(0),imgSize.at(1) };
  141.         TensorProcess(starttime_1, iImg, blob, inputNodeDims, oResult);
  142. #endif
  143.     }
  144.  
  145.     return Ret;
  146. }
  147.  
  148.  
  149. template<typename N>
  150. char *DCSP_CORE::TensorProcess(clock_t &starttime_1, cv::Mat &iImg, N &blob, std::vector<int64_t> &inputNodeDims,
  151.                                std::vector<DCSP_RESULT> &oResult) {
  152.     Ort::Value inputTensor = Ort::Value::CreateTensor<typename std::remove_pointer<N>::type>(
  153.             Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU), blob, 3 * imgSize.at(0) * imgSize.at(1),
  154.             inputNodeDims.data(), inputNodeDims.size());
  155. #ifdef benchmark
  156.     clock_t starttime_2 = clock();
  157. #endif // benchmark
  158.     auto outputTensor = session->Run(options, inputNodeNames.data(), &inputTensor, 1, outputNodeNames.data(),
  159.                                      outputNodeNames.size());
  160. #ifdef benchmark
  161.     clock_t starttime_3 = clock();
  162. #endif // benchmark
  163.  
  164.     Ort::TypeInfo typeInfo = outputTensor.front().GetTypeInfo();
  165.     auto tensor_info = typeInfo.GetTensorTypeAndShapeInfo();
  166.     std::vector<int64_t> outputNodeDims = tensor_info.GetShape();
  167.     auto output = outputTensor.front().GetTensorMutableData<typename std::remove_pointer<N>::type>();
  168.     delete blob;
  169.     switch (modelType) {
  170.         case 1://V8_ORIGIN_FP32
  171.         case 4://V8_ORIGIN_FP16
  172.         {
  173.             int strideNum = outputNodeDims[2];
  174.             int signalResultNum = outputNodeDims[1];
  175.             std::vector<int> class_ids;
  176.             std::vector<float> confidences;
  177.             std::vector<cv::Rect> boxes;
  178.  
  179.             cv::Mat rawData;
  180.             if (modelType == 1) {
  181.                 // FP32
  182.                 rawData = cv::Mat(signalResultNum, strideNum, CV_32F, output);
  183.             } else {
  184.                 // FP16
  185.                 rawData = cv::Mat(signalResultNum, strideNum, CV_16F, output);
  186.                 rawData.convertTo(rawData, CV_32F);
  187.             }
  188.             rawData = rawData.t();
  189.             float *data = (float *) rawData.data;
  190.  
  191.             float x_factor = iImg.cols / 640.;
  192.             float y_factor = iImg.rows / 640.;
  193.             for (int i = 0; i < strideNum; ++i) {
  194.                 float *classesScores = data + 4;
  195.                 cv::Mat scores(1, this->classes.size(), CV_32FC1, classesScores);
  196.                 cv::Point class_id;
  197.                 double maxClassScore;
  198.                 cv::minMaxLoc(scores, 0, &maxClassScore, 0, &class_id);
  199.                 if (maxClassScore > rectConfidenceThreshold) {
  200.                     confidences.push_back(maxClassScore);
  201.                     class_ids.push_back(class_id.x);
  202.  
  203.                     float x = data[0];
  204.                     float y = data[1];
  205.                     float w = data[2];
  206.                     float h = data[3];
  207.  
  208.                     int left = int((x - 0.5 * w) * x_factor);
  209.                     int top = int((y - 0.5 * h) * y_factor);
  210.  
  211.                     int width = int(w * x_factor);
  212.                     int height = int(h * y_factor);
  213.  
  214.                     boxes.emplace_back(left, top, width, height);
  215.                 }
  216.                 data += signalResultNum;
  217.             }
  218.  
  219.             std::vector<int> nmsResult;
  220.             cv::dnn::NMSBoxes(boxes, confidences, rectConfidenceThreshold, iouThreshold, nmsResult);
  221.  
  222.             for (int i = 0; i < nmsResult.size(); ++i) {
  223.                 int idx = nmsResult[i];
  224.                 DCSP_RESULT result;
  225.                 result.classId = class_ids[idx];
  226.                 result.confidence = confidences[idx];
  227.                 result.box = boxes[idx];
  228.                 oResult.push_back(result);
  229.             }
  230.  
  231.  
  232. #ifdef benchmark
  233.             clock_t starttime_4 = clock();
  234.             double pre_process_time = (double) (starttime_2 - starttime_1) / CLOCKS_PER_SEC * 1000;
  235.             double process_time = (double) (starttime_3 - starttime_2) / CLOCKS_PER_SEC * 1000;
  236.             double post_process_time = (double) (starttime_4 - starttime_3) / CLOCKS_PER_SEC * 1000;
  237.             if (cudaEnable) {
  238.                 std::cout << "[DCSP_ONNX(CUDA)]: " << pre_process_time << "ms pre-process, " << process_time
  239.                           << "ms inference, " << post_process_time << "ms post-process." << std::endl;
  240.             } else {
  241.                 std::cout << "[DCSP_ONNX(CPU)]: " << pre_process_time << "ms pre-process, " << process_time
  242.                           << "ms inference, " << post_process_time << "ms post-process." << std::endl;
  243.             }
  244. #endif // benchmark
  245.  
  246.             break;
  247.         }
  248.     }
  249.     return RET_OK;
  250. }
  251.  
  252.  
  253. char *DCSP_CORE::WarmUpSession() {
  254.     clock_t starttime_1 = clock();
  255.     cv::Mat iImg = cv::Mat(cv::Size(imgSize.at(0), imgSize.at(1)), CV_8UC3);
  256.     cv::Mat processedImg;
  257.     PostProcess(iImg, imgSize, processedImg);
  258.     if (modelType < 4) {
  259.         float *blob = new float[iImg.total() * 3];
  260.         BlobFromImage(processedImg, blob);
  261.         std::vector<int64_t> YOLO_input_node_dims = {1, 3, imgSize.at(0), imgSize.at(1)};
  262.         Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
  263.                 Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU), blob, 3 * imgSize.at(0) * imgSize.at(1),
  264.                 YOLO_input_node_dims.data(), YOLO_input_node_dims.size());
  265.         auto output_tensors = session->Run(options, inputNodeNames.data(), &input_tensor, 1, outputNodeNames.data(),
  266.                                            outputNodeNames.size());
  267.         delete[] blob;
  268.         clock_t starttime_4 = clock();
  269.         double post_process_time = (double) (starttime_4 - starttime_1) / CLOCKS_PER_SEC * 1000;
  270.         if (cudaEnable) {
  271.             std::cout << "[DCSP_ONNX(CUDA)]: " << "Cuda warm-up cost " << post_process_time << " ms. " << std::endl;
  272.         }
  273.     } else {
  274. #ifdef USE_CUDA
  275.         half* blob = new half[iImg.total() * 3];
  276.         BlobFromImage(processedImg, blob);
  277.         std::vector<int64_t> YOLO_input_node_dims = { 1,3,imgSize.at(0),imgSize.at(1) };
  278.         Ort::Value input_tensor = Ort::Value::CreateTensor<half>(Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU), blob, 3 * imgSize.at(0) * imgSize.at(1), YOLO_input_node_dims.data(), YOLO_input_node_dims.size());
  279.         auto output_tensors = session->Run(options, inputNodeNames.data(), &input_tensor, 1, outputNodeNames.data(), outputNodeNames.size());
  280.         delete[] blob;
  281.         clock_t starttime_4 = clock();
  282.         double post_process_time = (double)(starttime_4 - starttime_1) / CLOCKS_PER_SEC * 1000;
  283.         if (cudaEnable)
  284.         {
  285.             std::cout << "[DCSP_ONNX(CUDA)]: " << "Cuda warm-up cost " << post_process_time << " ms. " << std::endl;
  286.         }
  287. #endif
  288.     }
  289.     return RET_OK;
  290. }

main.cpp

  1. int read_coco_yaml(DCSP_CORE *&p) {
  2.     // Open the YAML file
  3.     std::ifstream file("coco.yaml");
  4.     if (!file.is_open()) {
  5.         std::cerr << "Failed to open file" << std::endl;
  6.         return 1;
  7.     }
  8.  
  9.     // Read the file line by line
  10.     std::string line;
  11.     std::vector<std::string> lines;
  12.     while (std::getline(file, line)) {
  13.         lines.push_back(line);
  14.     }
  15.  
  16.     // Find the start and end of the names section
  17.     std::size_t start = 0;
  18.     std::size_t end = 0;
  19.     for (std::size_t i = 0; i < lines.size(); i++) {
  20.         if (lines[i].find("names:") != std::string::npos) {
  21.             start = i + 1;
  22.         } else if (start > 0 && lines[i].find(':') == std::string::npos) {
  23.             end = i;
  24.             break;
  25.         }
  26.     }
  27.  
  28.     // Extract the names
  29.     std::vector<std::string> names;
  30.     for (std::size_t i = start; i < end; i++) {
  31.         std::stringstream ss(lines[i]);
  32.         std::string name;
  33.         std::getline(ss, name, ':'); // Extract the number before the delimiter
  34.         std::getline(ss, name); // Extract the string after the delimiter
  35.         names.push_back(name);
  36.     }
  37.  
  38.     p->classes = names;
  39.     return 0;
  40. }
  41.  
  42. int main(int argc, char* argv[])
  43. {
  44.     DCSP_CORE *yoloDetector = new DCSP_CORE;
  45.     //std::string model_path = "yolov8n.onnx";
  46.     std::string model_path = argv[1];
  47.     read_coco_yaml(yoloDetector);
  48.     #ifdef USE_CUDA
  49.     // GPU FP32 inference
  50.     DCSP_INIT_PARAM params{ model_path, YOLO_ORIGIN_V8, {640, 640},  0.1, 0.5, true };
  51.     // GPU FP16 inference
  52.     // DCSP_INIT_PARAM params{ model_path, YOLO_ORIGIN_V8_HALF, {640, 640},  0.1, 0.5, true };
  53.     #else
  54.     // CPU inference
  55.     DCSP_INIT_PARAM params{model_path, YOLO_ORIGIN_V8, {640, 640}, 0.1, 0.5, false};
  56.     #endif
  57.     yoloDetector->CreateSession(params);
  58.     
  59.     cv::VideoCapture vc;
  60.     vc.open(argv[2]);
  61.     
  62.     if(vc.isOpened()){
  63.     cv::Mat frame;
  64.     vc >> frame;
  65.             while(!frame.empty()){
  66.                 std::vector<DCSP_RESULT> res;
  67.                 yoloDetector->RunSession(frame, res);
  68.  
  69.                 for (int i = 0; i < res.size(); ++i)
  70.                 {
  71.                     DCSP_RESULT detection = res[i];
  72.  
  73.                     cv::Rect box = detection.box;
  74.                     cv::RNG rng(cv::getTickCount());
  75.                     cv::Scalar color(rng.uniform(0, 256), rng.uniform(0, 256), rng.uniform(0, 256));;
  76.  
  77.                     // Detection box
  78.                     cv::rectangle(frame, box, color, 2);
  79.  
  80.                     // Detection box text
  81.                     std::string classString = yoloDetector->classes[detection.classId] + ' ' + std::to_string(detection.confidence).substr(0, 4);
  82.                     cv::Size textSize = cv::getTextSize(classString, cv::FONT_HERSHEY_DUPLEX, 1, 2, 0);
  83.                     cv::Rect textBox(box.x, box.y - 40, textSize.width + 10, textSize.height + 20);
  84.  
  85.                     cv::rectangle(frame, textBox, color, cv::FILLED);
  86.                     cv::putText(frame, classString, cv::Point(box.x + 5, box.y - 10), cv::FONT_HERSHEY_DUPLEX, 1, cv::Scalar(0, 0, 0), 2, 0);
  87.                 }
  88.                 cv::rectangle(frame, g_rect, Scalar(0, 255, 0), 3, cv::LINE_AA);
  89.  
  90.                 cv::imshow("image", frame);
  91.                 cv::waitKey(1);
  92.  
  93.                 vc >> frame;
  94.           }
  95.         }
  96. }

opencv的框选区域和yolov8检测目标框融合

  1. #include <opencv2/opencv.hpp>
  2. #include <fstream>
  3. #include "inference.h"
  4.  
  5. using namespace cv;
  6.  
  7. // 定义一个全局变量，用于存放鼠标框选的矩形区域
  8. Rect g_rect;
  9. // 定义一个全局变量，用于标记鼠标是否按下
  10. bool g_bDrawingBox = false;
  11.  
  12. // 定义一个回调函数，用于处理鼠标事件
  13. void on_MouseHandle(int event, int x, int y, int flags, void* param)
  14. {
  15.     // 将param转换为Mat类型的指针
  16.     Mat& image = *(Mat*) param;
  17.     // 根据不同的鼠标事件进行处理
  18.     switch (event)
  19.     {
  20.         // 鼠标左键按下事件
  21.         case EVENT_LBUTTONDOWN:
  22.         {
  23.             // 标记鼠标已按下
  24.             g_bDrawingBox = true;
  25.             // 记录矩形框的起始点
  26.             g_rect.x = x;
  27.             g_rect.y = y;
  28.             break;
  29.         }
  30.         // 鼠标移动事件
  31.         case EVENT_MOUSEMOVE:
  32.         {
  33.             // 如果鼠标已按下，更新矩形框的宽度和高度
  34.             if (g_bDrawingBox)
  35.             {
  36.                 g_rect.width = x - g_rect.x;
  37.                 g_rect.height = y - g_rect.y;
  38.             }
  39.             break;
  40.         }
  41.         // 鼠标左键松开事件
  42.         case EVENT_LBUTTONUP:
  43.         {
  44.             // 标记鼠标已松开
  45.             g_bDrawingBox = false;
  46.             // 如果矩形框的宽度和高度为正，绘制矩形框到图像上
  47.             if (g_rect.width > 0 && g_rect.height > 0)
  48.             {
  49.                 rectangle(image, g_rect, Scalar(0, 255, 0));
  50.             }
  51.             break;
  52.         }
  53.     }
  54. }
  55.  
  56. int read_coco_yaml(DCSP_CORE *&p) {
  57.     // Open the YAML file
  58.     std::ifstream file("coco.yaml");
  59.     if (!file.is_open()) {
  60.         std::cerr << "Failed to open file" << std::endl;
  61.         return 1;
  62.     }
  63.  
  64.     // Read the file line by line
  65.     std::string line;
  66.     std::vector<std::string> lines;
  67.     while (std::getline(file, line)) {
  68.         lines.push_back(line);
  69.     }
  70.  
  71.     // Find the start and end of the names section
  72.     std::size_t start = 0;
  73.     std::size_t end = 0;
  74.     for (std::size_t i = 0; i < lines.size(); i++) {
  75.         if (lines[i].find("names:") != std::string::npos) {
  76.             start = i + 1;
  77.         } else if (start > 0 && lines[i].find(':') == std::string::npos) {
  78.             end = i;
  79.             break;
  80.         }
  81.     }
  82.  
  83.     // Extract the names
  84.     std::vector<std::string> names;
  85.     for (std::size_t i = start; i < end; i++) {
  86.         std::stringstream ss(lines[i]);
  87.         std::string name;
  88.         std::getline(ss, name, ':'); // Extract the number before the delimiter
  89.         std::getline(ss, name); // Extract the string after the delimiter
  90.         names.push_back(name);
  91.     }
  92.  
  93.     p->classes = names;
  94.     return 0;
  95. }
  96.  
  97. int main(int argc, char* argv[])
  98. {
  99.     // 读取原始图像
  100.     // Mat src = imread(argv[1]);
  101.  
  102.     DCSP_CORE *yoloDetector = new DCSP_CORE;
  103.     //std::string model_path = "yolov8n.onnx";
  104.     std::string model_path = argv[1];
  105.     read_coco_yaml(yoloDetector);
  106. #ifdef USE_CUDA
  107.     // GPU FP32 inference
  108.     DCSP_INIT_PARAM params{ model_path, YOLO_ORIGIN_V8, {640, 640},  0.1, 0.5, true };
  109.     // GPU FP16 inference
  110.     // DCSP_INIT_PARAM params{ model_path, YOLO_ORIGIN_V8_HALF, {640, 640},  0.1, 0.5, true };
  111. #else
  112.     // CPU inference
  113.     DCSP_INIT_PARAM params{model_path, YOLO_ORIGIN_V8, {640, 640}, 0.1, 0.5, false};
  114. #endif
  115.     yoloDetector->CreateSession(params);
  116.  
  117.     cv::VideoCapture vc;
  118.     vc.open(argv[2]);
  119.     
  120.     if(vc.isOpened()){
  121.         cv::Mat frame;
  122.         vc >> frame;
  123.         if(!frame.empty()){
  124.             // 创建一个副本图像，用于显示框选过程
  125.             Mat temp;
  126.             frame.copyTo(temp);
  127.             // 创建一个窗口，显示图像
  128.             namedWindow("image");
  129.             // 设置鼠标回调函数，传入副本图像作为参数
  130.             setMouseCallback("image", on_MouseHandle, (void*)&temp);
  131.             while (1)
  132.             {
  133.                 // 如果鼠标正在框选，绘制一个虚线矩形框到副本图像上，并显示框的大小和坐标
  134.                 if (g_bDrawingBox)
  135.                 {
  136.                     temp.copyTo(frame);
  137.                     rectangle(frame, g_rect, Scalar(0, 255, 0), 1, LINE_AA);
  138.                     char text[32];
  139.                     sprintf(text, "w=%d, h=%d", g_rect.width, g_rect.height);
  140.                     putText(frame, text, Point(g_rect.x + 5, g_rect.y - 5), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
  141.                 }
  142.                 // 显示副本图像
  143.                 imshow("image", frame);
  144.                 // 等待按键，如果按下ESC键，退出循环
  145.                 if (waitKey(10) == 27)
  146.                 {
  147.                     break;
  148.                 }
  149.             }
  150.  
  151.             while(!frame.empty()){
  152.                 std::vector<DCSP_RESULT> res;
  153.                 yoloDetector->RunSession(frame, res);
  154.  
  155.                 for (int i = 0; i < res.size(); ++i)
  156.                 {
  157.                     DCSP_RESULT detection = res[i];
  158.  
  159.                     cv::Rect box = detection.box;
  160.                     cv::RNG rng(cv::getTickCount());
  161.                     cv::Scalar color(rng.uniform(0, 256), rng.uniform(0, 256), rng.uniform(0, 256));;
  162.  
  163.                     // Detection box
  164.                     cv::rectangle(frame, box, color, 2);
  165.  
  166.                     // Detection box text
  167.                     std::string classString = yoloDetector->classes[detection.classId] + ' ' + std::to_string(detection.confidence).substr(0, 4);
  168.                     cv::Size textSize = cv::getTextSize(classString, cv::FONT_HERSHEY_DUPLEX, 1, 2, 0);
  169.                     cv::Rect textBox(box.x, box.y - 40, textSize.width + 10, textSize.height + 20);
  170.  
  171.                     cv::rectangle(frame, textBox, color, cv::FILLED);
  172.                     cv::putText(frame, classString, cv::Point(box.x + 5, box.y - 10), cv::FONT_HERSHEY_DUPLEX, 1, cv::Scalar(0, 0, 0), 2, 0);
  173.                 }
  174.                 cv::rectangle(frame, g_rect, Scalar(0, 255, 0), 3, cv::LINE_AA);
  175.  
  176.                 cv::imshow("image", frame);
  177.                 cv::waitKey(1);
  178.  
  179.                 vc >> frame;
  180.             }
  181.         }
  182.     }
  183.     
  184.     return 0;
  185. }

计算预警区域和目标框重合度

  1. double calIou(const cv::Rect& rc1, const cv::Rect& rc2)
  2. {
  3.     cv::Rect intersection = rc1 & rc2;
  4.     
  5.     if (!intersection.empty()) {
  6.         double intersectionArea = intersection.width * intersection.height;
  7.         double rect1Area = rc1.width * rc1.height;
  8.         double rect2Area = rc2.width * rc2.height;
  9.         
  10.         // 计算IOU
  11.         double iou = intersectionArea / (rect1Area + rect2Area - intersectionArea);
  12.         return iou;
  13.     } else {
  14.         // 没有重叠，IOU为0
  15.         return 0.0;
  16.     }
  17. }

跟踪实现

不断的去循环激活的目标，来过滤掉重复的代码，这块以后实现

完整代码

  1. #include <opencv2/opencv.hpp>
  2. #include <fstream>
  3. #include "inference.h"
  4.  
  5. using namespace cv;
  6.  
  7. // 定义一个全局变量，用于存放鼠标框选的矩形区域
  8. Rect g_rect;
  9. // 定义一个全局变量，用于标记鼠标是否按下
  10. bool g_bDrawingBox = false;
  11.  
  12. // 定义一个回调函数，用于处理鼠标事件
  13. void on_MouseHandle(int event, int x, int y, int flags, void* param)
  14. {
  15.     // 将param转换为Mat类型的指针
  16.     Mat& image = *(Mat*) param;
  17.     // 根据不同的鼠标事件进行处理
  18.     switch (event)
  19.     {
  20.         // 鼠标左键按下事件
  21.         case EVENT_LBUTTONDOWN:
  22.         {
  23.             // 标记鼠标已按下
  24.             g_bDrawingBox = true;
  25.             // 记录矩形框的起始点
  26.             g_rect.x = x;
  27.             g_rect.y = y;
  28.             break;
  29.         }
  30.         // 鼠标移动事件
  31.         case EVENT_MOUSEMOVE:
  32.         {
  33.             // 如果鼠标已按下，更新矩形框的宽度和高度
  34.             if (g_bDrawingBox)
  35.             {
  36.                 g_rect.width = x - g_rect.x;
  37.                 g_rect.height = y - g_rect.y;
  38.             }
  39.             break;
  40.         }
  41.         // 鼠标左键松开事件
  42.         case EVENT_LBUTTONUP:
  43.         {
  44.             // 标记鼠标已松开
  45.             g_bDrawingBox = false;
  46.             // 如果矩形框的宽度和高度为正，绘制矩形框到图像上
  47.             if (g_rect.width > 0 && g_rect.height > 0)
  48.             {
  49.                 rectangle(image, g_rect, Scalar(0, 255, 0));
  50.             }
  51.             break;
  52.         }
  53.     }
  54. }
  55.  
  56. int read_coco_yaml(DCSP_CORE *&p) {
  57.     // Open the YAML file
  58.     std::ifstream file("coco.yaml");
  59.     if (!file.is_open()) {
  60.         std::cerr << "Failed to open file" << std::endl;
  61.         return 1;
  62.     }
  63.  
  64.     // Read the file line by line
  65.     std::string line;
  66.     std::vector<std::string> lines;
  67.     while (std::getline(file, line)) {
  68.         lines.push_back(line);
  69.     }
  70.  
  71.     // Find the start and end of the names section
  72.     std::size_t start = 0;
  73.     std::size_t end = 0;
  74.     for (std::size_t i = 0; i < lines.size(); i++) {
  75.         if (lines[i].find("names:") != std::string::npos) {
  76.             start = i + 1;
  77.         } else if (start > 0 && lines[i].find(':') == std::string::npos) {
  78.             end = i;
  79.             break;
  80.         }
  81.     }
  82.  
  83.     // Extract the names
  84.     std::vector<std::string> names;
  85.     for (std::size_t i = start; i < end; i++) {
  86.         std::stringstream ss(lines[i]);
  87.         std::string name;
  88.         std::getline(ss, name, ':'); // Extract the number before the delimiter
  89.         std::getline(ss, name); // Extract the string after the delimiter
  90.         names.push_back(name);
  91.     }
  92.  
  93.     p->classes = names;
  94.     return 0;
  95. }
  96.  
  97. double calIou(const cv::Rect& rc1, const cv::Rect& rc2)
  98. {
  99.     cv::Rect intersection = rc1 & rc2;
  100.     
  101.     if (!intersection.empty()) {
  102.         double intersectionArea = intersection.width * intersection.height;
  103.         double rect1Area = rc1.width * rc1.height;
  104.         double rect2Area = rc2.width * rc2.height;
  105.         
  106.         // 计算IOU
  107.         double iou = intersectionArea / (rect1Area + rect2Area - intersectionArea);
  108.         return iou;
  109.     } else {
  110.         // 没有重叠，IOU为0
  111.         return 0.0;
  112.     }
  113. }
  114.  
  115. int main(int argc, char* argv[])
  116. {
  117.     // 读取原始图像
  118.     // Mat src = imread(argv[1]);
  119.  
  120.     DCSP_CORE *yoloDetector = new DCSP_CORE;
  121.     //std::string model_path = "yolov8n.onnx";
  122.     std::string model_path = argv[1];
  123.     read_coco_yaml(yoloDetector);
  124. #ifdef USE_CUDA
  125.     // GPU FP32 inference
  126.     DCSP_INIT_PARAM params{ model_path, YOLO_ORIGIN_V8, {640, 640},  0.1, 0.5, true };
  127.     // GPU FP16 inference
  128.     // DCSP_INIT_PARAM params{ model_path, YOLO_ORIGIN_V8_HALF, {640, 640},  0.1, 0.5, true };
  129. #else
  130.     // CPU inference
  131.     DCSP_INIT_PARAM params{model_path, YOLO_ORIGIN_V8, {640, 640}, 0.1, 0.5, false};
  132. #endif
  133.     yoloDetector->CreateSession(params);
  134.  
  135.     cv::VideoCapture vc;
  136.     vc.open(argv[2]);
  137.     
  138.     if(vc.isOpened()){
  139.         cv::Mat frame;
  140.         vc >> frame;
  141.         if(!frame.empty()){
  142.             // 创建一个副本图像，用于显示框选过程
  143.             Mat temp;
  144.             frame.copyTo(temp);
  145.             // 创建一个窗口，显示图像
  146.             namedWindow("image");
  147.             // 设置鼠标回调函数，传入副本图像作为参数
  148.             setMouseCallback("image", on_MouseHandle, (void*)&temp);
  149.             while (1)
  150.             {
  151.                 // 如果鼠标正在框选，绘制一个虚线矩形框到副本图像上，并显示框的大小和坐标
  152.                 if (g_bDrawingBox)
  153.                 {
  154.                     temp.copyTo(frame);
  155.                     rectangle(frame, g_rect, Scalar(0, 255, 0), 1, LINE_AA);
  156.                     char text[32];
  157.                     sprintf(text, "w=%d, h=%d", g_rect.width, g_rect.height);
  158.                     putText(frame, text, Point(g_rect.x + 5, g_rect.y - 5), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
  159.                 }
  160.                 // 显示副本图像
  161.                 imshow("image", frame);
  162.                 // 等待按键，如果按下ESC键，退出循环
  163.                 if (waitKey(10) == 27)
  164.                 {
  165.                     break;
  166.                 }
  167.             }
  168.  
  169.             while(!frame.empty()){
  170.                 std::vector<DCSP_RESULT> res;
  171.                 yoloDetector->RunSession(frame, res);
  172.  
  173.                 for (int i = 0; i < res.size(); ++i)
  174.                 {
  175.                     DCSP_RESULT detection = res[i];
  176.  
  177.                     cv::Rect box = detection.box;
  178.                     cv::RNG rng(cv::getTickCount());
  179.                     cv::Scalar color(rng.uniform(0, 256), rng.uniform(0, 256), rng.uniform(0, 256));;
  180.  
  181.                     // Detection box
  182.                     cv::rectangle(frame, box, color, 2);
  183.  
  184.                     // Detection box text
  185.                     std::string classString = yoloDetector->classes[detection.classId] + ' ' + std::to_string(detection.confidence).substr(0, 4);
  186.                     cv::Size textSize = cv::getTextSize(classString, cv::FONT_HERSHEY_DUPLEX, 1, 2, 0);
  187.                     cv::Rect textBox(box.x, box.y - 40, textSize.width + 10, textSize.height + 20);
  188.  
  189.                     cv::rectangle(frame, textBox, color, cv::FILLED);
  190.                     cv::putText(frame, classString, cv::Point(box.x + 5, box.y - 10), cv::FONT_HERSHEY_DUPLEX, 1, cv::Scalar(0, 0, 0), 2, 0);
  191.  
  192.                     double iou = calIou(g_rect, box);
  193.                     if(iou > 0)
  194.                         std::cout << "iou:" << iou << std::endl;
  195.                 }
  196.                 cv::rectangle(frame, g_rect, Scalar(0, 255, 0), 3, cv::LINE_AA);
  197.  
  198.                 cv::imshow("image", frame);
  199.                 cv::waitKey(1);
  200.  
  201.                 vc >> frame;
  202.             }
  203.         }
  204.     }
  205.     
  206.     return 0;
  207. }

参考

yolov8

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/77952
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号