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

yolov5 obb旋转框 tensorrt8.4 生成dll供c# 调用。win10。vs2019_windows tensorrt yolov5_obb

作者：你好赵伟 | 2024-03-25 18:18:05

赞

踩

windows tensorrt yolov5_obb

1.首先生成自己的engine文件

yolov5 obb 旋转框 tensorrt 部署踩坑，c++,win10,cuda 11.7,tensorrt 8.4,opencv4.5.5_vokxchh的博客-CSDN博客https://blog.csdn.net/vokxchh/article/details/1307896192.修改文件yolov5_use.cpp。

  1. #include <iostream>
  2. #include <chrono>
  3. #include <cmath>
  4. #include "cuda_utils.h"
  5. #include "logging.h"
  6. #include "common.hpp"
  7. #include<string>
  8. #include "yolov5_obb_dll.h"
  9. #define USE_FP16  // set USE_INT8 or USE_FP16 or USE_FP32
  10. #define DEVICE 0  // GPU id
  11. #define NMS_THRESH 0.1
  12. #define CONF_THRESH 0.1
  13. #define objThreshold 0.1
  14. #define BATCH_SIZE 1
  15. #define MAX_IMAGE_INPUT_SIZE_THRESH 3000 * 3000 // ensure it exceed the maximum size in the input images !
  16. using namespace std;
  17. // stuff we know about the network and the input/output blobs
  18. static const int INPUT_H = Yolo::INPUT_H;
  19. static const int INPUT_W = Yolo::INPUT_W;
  20. static const int CLASS_NUM = Yolo::CLASS_NUM;
  21. static const int OUTPUT_SIZE = Yolo::MAX_OUTPUT_BBOX_COUNT * sizeof(Yolo::Detection) / sizeof(float) + 1;  // we assume the yololayer outputs no more than MAX_OUTPUT_BBOX_COUNT boxes that conf >= 0.1
  22. const char* INPUT_BLOB_NAME = "data";
  23. const char* OUTPUT_BLOB_NAME = "prob";
  24. const bool keep_ratio = true;
  25. static Logger gLogger;
  26. using namespace cv;
  27. using namespace std;
  28. typedef struct BoxInfo
  29. {
  30. 	RotatedRect box;
  31. 	float score;
  32. 	int label;
  33. } BoxInfo;
  34.  
  35. cv::Mat resize_image(cv::Mat srcimg, int *newh, int *neww, int *top, int *left)
  36. {
  37. 	int srch = srcimg.rows, srcw = srcimg.cols;
  38. 	*newh = INPUT_H;
  39. 	*neww = INPUT_W;
  40. 	cv::Mat dstimg;
  41. 	if (keep_ratio && srch != srcw) {
  42. 		float hw_scale = (float)srch / srcw;
  43. 		if (hw_scale > 1) {
  44. 			*newh = INPUT_H;
  45. 			*neww = INPUT_W;
  46. 			cv::resize(srcimg, dstimg, Size(*neww, *newh), INTER_AREA);
  47. 			*left = int((INPUT_W - *neww) * 0.5);
  48. 			cv::copyMakeBorder(dstimg, dstimg, 0, 0, *left, INPUT_W - *neww - *left, BORDER_CONSTANT, 114);
  49. 		}
  50. 		else {
  51. 			*newh = (int)INPUT_H * hw_scale;
  52. 			*neww = INPUT_W;
  53. 			cv::resize(srcimg, dstimg, Size(*neww, *newh), INTER_AREA);
  54. 			*top = (int)(INPUT_H - *newh) * 0.5;
  55. 			cv::copyMakeBorder(dstimg, dstimg, *top, INPUT_H - *newh - *top, 0, 0, BORDER_CONSTANT, 114);
  56. 		}
  57. 	}
  58. 	else {
  59. 		resize(srcimg, dstimg, Size(*neww, *newh), INTER_AREA);
  60. 	}
  61. 	return dstimg;
  62.  
  63.  
  64. }
  65. void nms_angle(vector<BoxInfo>& input_boxes)
  66. {
  67. 	sort(input_boxes.begin(), input_boxes.end(), [](BoxInfo a, BoxInfo b) { return a.score > b.score; });
  68. 	vector<float> vArea(input_boxes.size());
  69. 	for (int i = 0; i < int(input_boxes.size()); ++i)
  70. 	{
  71. 		vArea[i] = input_boxes[i].box.size.area();
  72. 	}
  73.  
  74. 	vector<bool> isSuppressed(input_boxes.size(), false);
  75. 	for (int i = 0; i < int(input_boxes.size()); ++i)
  76. 	{
  77. 		if (isSuppressed[i]) { continue; }
  78. 		for (int j = i + 1; j < int(input_boxes.size()); ++j)
  79. 		{
  80. 			if (isSuppressed[j]) { continue; }
  81. 			vector<Point2f> intersectingRegion;
  82. 			rotatedRectangleIntersection(input_boxes[i].box, input_boxes[j].box, intersectingRegion);
  83. 			if (intersectingRegion.empty()) { continue; }
  84. 			float inter = contourArea(intersectingRegion);
  85. 			float ovr = inter / (vArea[i] + vArea[j] - inter);
  86.  
  87. 			if (ovr >= NMS_THRESH)
  88. 			{
  89. 				isSuppressed[j] = true;
  90. 			}
  91. 		}
  92. 	}
  93. 	// return post_nms;
  94. 	int idx_t = 0;
  95. 	input_boxes.erase(remove_if(input_boxes.begin(), input_boxes.end(), [&idx_t, &isSuppressed](const BoxInfo& f) { return isSuppressed[idx_t++]; }), input_boxes.end());
  96. }
  97.  
  98. void doInference(IExecutionContext& context, cudaStream_t& stream, void **buffers, float* input, float* output, int batchSize) {
  99. 	CUDA_CHECK(cudaMemcpyAsync(buffers[0], input, batchSize * 3 * INPUT_H * INPUT_W * sizeof(float), cudaMemcpyHostToDevice, stream));// °ÑÕâ¸öÈÎÎñͨ¹ýcudaMemcpyAsync·Åµ½cudastramÉÏ
  100.  
  101. 	// infer on the batch asynchronously, and DMA output back to host
  102. 	context.enqueue(batchSize, buffers, stream, nullptr);
  103. 	CUDA_CHECK(cudaMemcpyAsync(output, buffers[1], batchSize * OUTPUT_SIZE * sizeof(float), cudaMemcpyDeviceToHost, stream));
  104. 	cudaStreamSynchronize(stream);
  105. }
  106. IExecutionContext* context = nullptr;
  107. cudaStream_t stream;
  108. float* buffers[2];
  109. static float prob[BATCH_SIZE * OUTPUT_SIZE];
  110. ICudaEngine* engine = nullptr;
  111. int Init(std::string engine_name0)
  112. {
  113. 	cudaSetDevice(DEVICE);
  114.  
  115. 	std::string engine_name = engine_name0;
  116.  
  117.  
  118. 	// deserialize the .engine and run inference
  119. 	std::ifstream file(engine_name, std::ios::binary);
  120. 	if (!file.good()) {
  121. 		std::cerr << "read " << engine_name << " error!" << std::endl;
  122. 		return -1;
  123. 	}
  124. 	char* trtModelStream = nullptr;
  125. 	size_t size = 0;
  126. 	file.seekg(0, file.end);
  127. 	size = file.tellg();
  128. 	file.seekg(0, file.beg);
  129. 	trtModelStream = new char[size];
  130. 	assert(trtModelStream);
  131. 	file.read(trtModelStream, size);
  132. 	file.close();
  133.  
  134. 	
  135.  
  136. 	
  137. 	IRuntime* runtime = createInferRuntime(gLogger);
  138. 	assert(runtime != nullptr);
  139.     engine = runtime->deserializeCudaEngine(trtModelStream, size);
  140. 	assert(engine != nullptr);
  141. 	context = engine->createExecutionContext();
  142. 	assert(context != nullptr);
  143. 	delete[] trtModelStream;
  144. 	assert(engine->getNbBindings() == 2);
  145. 	
  146. 	// In order to bind the buffers, we need to know the names of the input and output tensors.
  147. 	// Note that indices are guaranteed to be less than IEngine::getNbBindings()
  148. 	const int inputIndex = engine->getBindingIndex(INPUT_BLOB_NAME);
  149. 	const int outputIndex = engine->getBindingIndex(OUTPUT_BLOB_NAME);
  150. 	assert(inputIndex == 0);
  151. 	assert(outputIndex == 1);
  152. 	// Create GPU buffers on device
  153. 	CUDA_CHECK(cudaMalloc((void**)&buffers[inputIndex], BATCH_SIZE * 3 * INPUT_H * INPUT_W * sizeof(float)));
  154. 	CUDA_CHECK(cudaMalloc((void**)&buffers[outputIndex], BATCH_SIZE * OUTPUT_SIZE * sizeof(float)));
  155.  
  156. 	// Create stream
  157. 	
  158. 	CUDA_CHECK(cudaStreamCreate(&stream));
  159. 	uint8_t* img_host = nullptr;
  160. 	uint8_t* img_device = nullptr;
  161. 	// prepare input data cache in pinned memory 
  162. 	CUDA_CHECK(cudaMallocHost((void**)&img_host, MAX_IMAGE_INPUT_SIZE_THRESH * 3));
  163. 	// prepare input data cache in device memory
  164. 	CUDA_CHECK(cudaMalloc((void**)&img_device, MAX_IMAGE_INPUT_SIZE_THRESH * 3));
  165. 	
  166. }
  167.  
  168. void detect_yolov5_trt(cv::Mat img0, std::string engine_name, Result* stu)
  169. {
  170.  
  171.  
  172. 	static float data[1 * 3 * INPUT_H * INPUT_W];
  173. 	cv::Mat pr_img = img0;
  174.  
  175. 	int newh = 0, neww = 0, padh = 0, padw = 0;
  176. 	Mat img = resize_image(pr_img, &newh, &neww, &padh, &padw);
  177.  
  178. 	int i = 0;
  179. 	int b = 0;//Õâ¸öbÔ­±¾ÓÃÀ´¿ØÖÆbatchsizeµÄ£¬µ«ÊÇÎÒÃÇÖ»ÓÐÒ»ÕÅͼƬ ¾ÍÉèÖóÉÁË0
  180. 	for (int row = 0; row < INPUT_H; ++row)
  181. 	{
  182. 		uchar* uc_pixel = img.data + row * img.step;
  183. 		for (int col = 0; col < INPUT_W; ++col)
  184. 		{
  185. 			data[b * 3 * INPUT_H * INPUT_W + i] = (float)uc_pixel[2] / 255.0;
  186. 			data[b * 3 * INPUT_H * INPUT_W + i + INPUT_H * INPUT_W] = (float)uc_pixel[1] / 255.0;
  187. 			data[b * 3 * INPUT_H * INPUT_W + i + 2 * INPUT_H * INPUT_W] = (float)uc_pixel[0] / 255.0;
  188. 			uc_pixel += 3;
  189. 			++i;
  190. 		}
  191. 	}
  192.  
  193. 	//auto start = std::chrono::system_clock::now();
  194. 	doInference(*context, stream, (void**)buffers, data, prob, 1);
  195. 	//auto end = std::chrono::system_clock::now();
  196. 	//auto costtime = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
  197. 	//std::cout << "inference time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
  198. 	vector<BoxInfo> generate_boxes;
  199. 	float ratioh = (float)pr_img.rows / newh, ratiow = (float)pr_img.cols / neww;
  200. 	float* pdata = (float*)prob;
  201. 	int det_size = 7;//box(4)+conf +classid + classangle
  202. 	for (int i = 0; i < pdata[0] && i < Yolo::MAX_OUTPUT_BBOX_COUNT; i++) {
  203.  
  204. 		if (pdata[7 * i + 4 + 1] <= CONF_THRESH) continue;//ÕâÀïÄã»áºÜÆæ¹ÖΪʲô´Ópdata[5]ÊÇconf ÒòΪpdata[0]´æ·ÅµÄÊÇ0£¬´ú±íµÚÒ»¸öͼƬ
  205. 		Yolo::Detection det;
  206. 		memcpy(&det, &pdata[1 + det_size * i], det_size * sizeof(float));
  207. 		float max_class_socre = det.conf;//ÖÃÐŶÈ
  208. 		if (max_class_socre > CONF_THRESH)
  209. 		{
  210. 			float cx = (det.bbox[0] - padw) * ratiow;
  211. 			float cy = (det.bbox[1] - padh) * ratioh;
  212. 			float w = det.bbox[2] * ratiow;
  213. 			float h = det.bbox[3] * ratioh;
  214.  
  215. 			int class_idx = det.class_id;
  216. 			float angle = 90 - det.angle_id;
  217. 			RotatedRect box = RotatedRect(Point2f(cx, cy), Size2f(w, h), angle);
  218.  
  219. 			generate_boxes.push_back(BoxInfo{ box, (float)max_class_socre, class_idx });
  220. 		}
  221.  
  222. 	}
  223.  
  224. 	nms_angle(generate_boxes);
  225. 	for (size_t i = 0; i < generate_boxes.size(); ++i)
  226. 	{
  227. 		RotatedRect rectInput = generate_boxes[i].box;
  228. 		std::cout << "box center:" << generate_boxes[i].box.center << " angle:" << generate_boxes[i].box.angle << std::endl;
  229. 		Point2f* vertices = new cv::Point2f[4];
  230. 		rectInput.points(vertices);
  231. 		
  232. 		stu[i].x1 = vertices[0].x;
  233. 		stu[i].y1 = vertices[0].y;
  234. 		stu[i].x2 = vertices[1].x;
  235. 		stu[i].y2 = vertices[1].y;
  236. 		stu[i].x3 = vertices[2].x;
  237. 		stu[i].y3 = vertices[2].y;
  238. 		stu[i].x4 = vertices[3].x;
  239. 		stu[i].y4 = vertices[3].y;
  240. 		stu[i].conf = generate_boxes[i].score;
  241. 		stu[i].classid = generate_boxes[i].label;
  242. 		stu[i].angel = generate_boxes[i].box.angle;
  243. 		
  244. 	}
  245. }
  246.  
  247. const bool yolov5_obb_trt(const char* img_dir, const char* eng_dir, Result* stu)
  248. {
  249. 	std::string img_dir2 = img_dir;
  250. 	std::string engine_name = eng_dir;
  251. 	if (engine == nullptr) Init(engine_name);
  252. 	cv::Mat img = cv::imread(img_dir2);
  253. 	detect_yolov5_trt(img, engine_name, stu);
  254. 	return 0;
  255. }
  256. const void yolov5_obb_trt2(uchar* data, int width, int height, int stride, const char* eng_dir, Result* stu)
  257. {
  258. 	std::string engine_name = eng_dir;
  259. 	if (engine == nullptr) Init(engine_name);
  260. 	cv::Mat img = cv::Mat(cv::Size(width, height), CV_8UC3, data, stride);
  261. 	detect_yolov5_trt(img, engine_name, stu);
  262. }
  263.

3.添加 yolov5_obb_dll.h

  1. #pragma once
  2. struct Result
  3. {
  4. 	float classid;
  5. 	float conf;
  6. 	float x1;
  7. 	float y1;
  8. 	float x2;
  9. 	float y2;
  10. 	float x3;
  11. 	float y3;
  12. 	float x4;
  13. 	float y4;
  14. 	float angel;
  15. };
  16.  
  17.  
  18. extern "C" _declspec(dllexport) const bool yolov5_obb_trt(const char* img_dir, const char* eng_dir, Result * stu);
  19. extern "C" _declspec(dllexport) const void yolov5_obb_trt2(uchar * data, int width, int height, int stride, const char* eng_dir, Result * stu);
  20.

4.编译生成dll

5.使用c# 调用dll

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Diagnostics;
  6. using System.Drawing;
  7. using System.Drawing.Imaging;
  8. using System.IO;
  9. using System.Linq;
  10. using System.Runtime.InteropServices;
  11. using System.Text;
  12. using System.Threading.Tasks;
  13. using System.Windows.Forms;
  14. using static System.Net.WebRequestMethods;
  15.  
  16. namespace WindowsFormsApp5
  17. {
  18.     public partial class Form1 : Form
  19.     {
  20.         public Form1()
  21.         {
  22.             InitializeComponent();
  23.         }
  24.         [DllImport("yolov5_obb_trt.dll", CallingConvention = CallingConvention.Cdecl,CharSet = CharSet.Ansi)]
  25.         extern static bool yolov5_obb_trt(string imgdr,string engdr,[Out] Result[] re);//发送路径
  26.         [DllImport("yolov5_obb_trt.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
  27.         extern static bool yolov5_obb_trt2(IntPtr data, int width, int height, int stride, string engdr, [Out] Result[] re);//发送图片
  28.  
  29.         [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1), Serializable]
  30.         public struct Result
  31.         {
  32.             public float classid;
  33.             public float conf;
  34.             public float x1;
  35.             public float y1;
  36.             public float x2;
  37.             public float y2;
  38.             public float x3;
  39.             public float y3;
  40.             public float x4;
  41.             public float y4;
  42.             public float angel;
  43.         }
  44.  
  45.         public static string engdr = Environment.CurrentDirectory + "\\yolov5n-obb-fp16.engine";
  46.         public  Bitmap DrawRect(Bitmap bmp, Result[] re)
  47.         {
  48.            
  49.             Graphics gg = Graphics.FromImage(bmp);
  50.             Pen p = new Pen(Brushes.Lime);
  51.             foreach (var i in re)
  52.             {  
  53.                 if (i.conf == 0) { break; }
  54.                 gg.DrawLine (p, i.x1, i.y1, i.x2, i.y2);
  55.                 gg.DrawLine(p, i.x2, i.y2, i.x3, i.y3);
  56.                 gg.DrawLine(p, i.x3, i.y3, i.x4, i.y4);
  57.                 gg.DrawLine(p, i.x4, i.y4, i.x1, i.y1);
  58.                 Font drawFont = new Font("Arial", 8, FontStyle.Bold, GraphicsUnit.Millimeter);
  59.                 SolidBrush drawBush = new SolidBrush(Color.Lime);
  60.                 gg.DrawString(coco[(int)i.classid]+" "+i.conf.ToString("0.000"), drawFont, drawBush, i.x1, i.y1);
  61.             }
  62.             gg.Dispose();
  63.             return bmp;
  64.         }
  65.         Result[] yolov5_sendbmp(string path)//发送图片
  66.         {
  67.             Result[] re = new Result[100];
  68.             Bitmap img = new Bitmap(path);
  69.             BitmapData imgData = img.LockBits(new Rectangle(0, 0, img.Width, img.Height), ImageLockMode.ReadWrite,
  70.             PixelFormat.Format24bppRgb);
  71.             int width = imgData.Width;
  72.             int height = imgData.Height;
  73.             int stride = imgData.Stride;
  74.             try
  75.             {
  76.                 yolov5_obb_trt2(imgData.Scan0, width, height, stride, engdr, re);
  77.             }
  78.             catch (Exception ex)
  79.             {
  80.                MessageBox.Show(ex.ToString());
  81.             }
  82.             img.UnlockBits(imgData);
  83.             DrawRect(img, re);
  84.  
  85.             pictureBox1.Image =img;
  86.             return re;
  87.          
  88.         }
  89.  
  90.         private void button1_Click(object sender, EventArgs e)//发送图片的路径
  91.         {
  92.             Result[] re = new Result[100];
  93.             label1.Text = "";
  94.             Stopwatch stp = new Stopwatch();
  95.             string imgdr = Environment.CurrentDirectory + "\\images\\OK_00004.bmp";
  96.             stp.Start();
  97.             yolov5_obb_trt(imgdr,engdr,re);
  98.             stp.Stop();
  99.             Bitmap bp=(Bitmap)Image.FromFile(imgdr);
  100.             DrawRect(bp, re);
  101.             pictureBox1.Image = bp;
  102.          
  103.             label1.Text ="耗时："+ stp.ElapsedMilliseconds.ToString() + "ms";
  104.         }
  105.  
  106.         private void button2_Click(object sender, EventArgs e)//直接发送图片
  107.         {
  108.             label1.Text = "";
  109.             Stopwatch stp = new Stopwatch();
  110.             string imgdr = Environment.CurrentDirectory + "\\images\\OK_00408.bmp";
  111.             stp.Start();
  112.             yolov5_sendbmp(imgdr);
  113.             stp.Stop();
  114.             label1.Text = "耗时："+ stp.ElapsedMilliseconds.ToString() + "ms";
  115.         }
  116.  
  117.         string[] coco;
  118.         private void Form1_Load(object sender, EventArgs e)
  119.         {
  120.             Task.Run(() =>
  121.             {
  122.                 coco = System.IO.File.ReadAllLines(Environment.CurrentDirectory + "\\coco.names");
  123.                 Result[] re = new Result[100];
  124.                 string imgdr = Environment.CurrentDirectory + "\\images\\OK_00002.bmp";
  125.  
  126.                 yolov5_obb_trt(imgdr, engdr, re);//先载入一次，预热。
  127.                 Bitmap bp = (Bitmap)Image.FromFile(imgdr);
  128.                 DrawRect(bp, re);
  129.                 pictureBox1.Image = bp;
  130.                 this.BeginInvoke(new MethodInvoker(delegate ()
  131.                 {
  132.                     button1.Visible = true;
  133.                     button2.Visible = true;
  134.                     label1.Text = "载入完毕";
  135.                 }));
  136.  
  137.             });
  138.         }
  139.  
  140.         private void button3_Click(object sender, EventArgs e)
  141.         {
  142.             richTextBox1.Clear();
  143.             StringBuilder sb=new StringBuilder();
  144.             for (int i = 0; i < 100; i++)
  145.             {
  146.                 Result[] re = new Result[100];
  147.                 label1.Text = "";
  148.                 Stopwatch stp = new Stopwatch();
  149.                 string imgdr = Environment.CurrentDirectory + "\\images\\OK_00004.bmp";
  150.                 stp.Start();
  151.                 yolov5_obb_trt(imgdr, engdr, re);
  152.                 stp.Stop();
  153.                 sb.Append(stp.ElapsedMilliseconds.ToString()+"ms\r\n");
  154.             
  155.             }
  156.             richTextBox1.AppendText(sb.ToString());
  157.         }
  158.  
  159.       
  160.     }
  161. }

结果是一样的。 RTX 2060 FP16推理速度， 15ms。

-------------------------------------------------------------------------------

完整代码如下

yolov5obb旋转框tensorrt8.4生成dll供c#调用摄像头实时win10vs2019资源-CSDN文库icon-default.png?t=N4HBhttps://download.csdn.net/download/vokxchh/87804850

注意点：

1.修改包含目录和库目录。自己对应的。

2.dll需要覆盖，用自己的版本，我的tensorrt8.4   opencv4.5.5，改了opencv的话，注意附加依赖项。

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

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

  

闽ICP备14008679号