[C++]使用C++部署yolov10目标检测的tensorrt模型支持图片视频推理windows测试通过

【测试通过环境】
vs2019
cmake==3.24.3
cuda11.7.1+cudnn8.8.0
tensorrt==8.6.1.6
opencv==4.8.0

【部署步骤】
获取pt模型：https://github.com/THU-MIG/yolov10训练自己的模型或者直接使用yolov10官方预训练模型
下载源码：https://github.com/laugh12321/yolov10/tree/nms并安装到环境中
导出onnx：
yolo export model=yolov10n.pt format=onnx opset=13 simplify max_det=100 conf=0.25 iou=0.65 nms

注意导出模型和官方yolov10指令导出的onnx是不一样的，使用yolov10-nms导出模型结构如图

注意一定要是上面类似结构图才能用于这个C++项目
导出tensorrt：

等20分钟左右即可导出需要耐心等待一段时间视个人电脑性能决定，由于tensorrt依赖硬件不一样电脑可能无法共用tensorrt模型，所以必须要重新转换onnx模型到engine才可以运行。请勿直接使用提供的engine模型进行直接测试，否则可能无法正常运行
trtexec –onnx=yolov10n.onnx –saveEngine=yolov10n.engine –fp16

下载安装vs2019勾选桌面C++安装
git clone https://github.com/laugh12321/TensorRT-YOLO
cd TensorRT-YOLO
xmake f -k shared –tensorrt=”C:/Program Files/NVIDIA GPU Computing Toolkit/TensorRT/v8.6.1.6″
xmake -P . -r
将编译好的deploy.dll和deploy.lib文件放到yolov10-tensorrt-cplus/lib文件夹
编译源码yolov10-tensorrt-cplus
运行命令：
推理图片：
yolov10.exe -e C:\Users\Administrator\Desktop\yolov10-tensorrt-cplus\yolov10n.engine -i C:\Users\Administrator\Desktop\yolov10-tensorrt-cplus\images\bus.jpg -o ./out -l C:\Users\Administrator\Desktop\yolov10-tensorrt-cplus\labels.txt

推理视频：
yolov10.exe -e C:\Users\Administrator\Desktop\yolov10-tensorrt-cplus\yolov10n.engine -i D:\car.mp4 -o ./out -l C:\Users\Administrator\Desktop\yolov10-tensorrt-cplus\labels.txt

【视频演示】

使用C++部署yolov10目标检测的tensorrt模型支持图片视频推理windows测试通过_哔哩哔哩_bilibili【测试通过环境】vs2019cmake==3.24.3cuda11.7.1+cudnn8.8.0tensorrt==8.6.1.6opencv==4.8.0更多信息参考博文：https://blog.csdn.net/FL1623863129/article/details/139693743, 视频播放量 3、弹幕量 0、点赞数 0、投硬币枚数 0、收藏人数 0、转发人数 0, 视频作者 未来自主研究中心, 作者简介 未来自主研究中心，相关视频：4060Ti 16G显卡安装Ollama+ChatTTS打造智能语音秘书（突破30秒限制），AI换脸最全面部细节演示：眨眼，捏眉毛，斗鸡眼，戳鼻子，做猪鼻子……认识ai换脸，警惕Ai换脸，Ai变声诈骗！，基于yolo的骑行速度检测，labelme json转yolo工具用于目标检测训练数据集使用教程，使用纯opencv部署yolov8目标检测模型onnx，rk3588 yolov5 目标检测推流rtsp，[深度学习][目标检测][面试提问]Batch Normalization批归一化，[数据集介绍][目标检测]城市街道垃圾数据集VOC格式5266张，GPT：可恶！我好不容易才建立的三观啊！，毕设项目—基于最新YOLOv10+ByteTrack+PaddleOCR实现交通状态分析 (功能：目标检测、轨迹跟踪、车牌检测、车牌号识别、单目测速及目标计数)https://www.bilibili.com/video/BV13S411P7XL/

【部分实现代码】

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include   
#include  
#include "deploy/utils/utils.hpp"
#include "deploy/vision/detection.hpp"
#include "deploy/vision/result.hpp"
#include 
#include 
using namespace cv;
using namespace std;
namespace fs = std::filesystem;
std::string getFileExtension(const std::string& filePath) {  
size_t dotPosition = filePath.rfind('.'); // 从右向左查找'.'的位置  
if (dotPosition == std::string::npos) {  
// 没有找到'.'，返回空字符串  
return "";  
}  
return filePath.substr(dotPosition + 1); // 返回'.'之后的所有字符  
}  
// Get image files in a directory
std::vector getImagesInDirectory(const std::string &folderPath)
{
std::vector imageFiles;
for (const auto &entry : fs::directory_iterator(folderPath))
{
const auto extension = entry.path().extension().string();
if (fs::is_regular_file(entry) && (extension == ".jpg" || extension == ".png" || extension == ".jpeg" || extension == ".bmp"))
{
imageFiles.push_back(entry.path().string());
}
}
return imageFiles;
}
// Get file name from file path
std::string getFileName(const std::string &filePath)
{
return fs::path(filePath).filename().string();
}
// Create output directory
void createOutputDirectory(const std::string &outputPath)
{
if (!fs::exists(outputPath) && !fs::create_directories(outputPath))
{
std::cerr << "Failed to create output directory: " << outputPath << std::endl;
exit(1);
}
else if (!fs::is_directory(outputPath))
{
std::cerr << "Output path exists but is not a directory: " << outputPath << std::endl;
exit(1);
}
}
// Generate label and color pairs
std::vector<std::pair> generateLabelColorPairs(const std::string &labelFile)
{
std::vector<std::pair> labelColorPairs;
std::ifstream file(labelFile);
if (!file.is_open())
{
std::cerr << "Failed to open labels file: " << labelFile << std::endl;
return labelColorPairs;
}
auto generateRandomColor = []()
{
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution dis(0, 255);
return cv::Scalar(dis(gen), dis(gen), dis(gen));
};
std::string label;
while (std::getline(file, label))
{
labelColorPairs.emplace_back(label, generateRandomColor());
}
return labelColorPairs;
}
// Visualize detection results
void visualize(cv::Mat &image, const deploy::DetectionResult &result, const std::vector<std::pair> &labelColorPairs)
{
for (size_t i = 0; i < result.num; ++i)
{
const auto &box = result.boxes[i];
int cls = result.classes[i];
float score = result.scores[i];
const auto &label = labelColorPairs[cls].first;
const auto &color = labelColorPairs[cls].second;
std::string labelText = label + " " + cv::format("%.2f", score);
// Draw rectangle and label
cv::rectangle(image, cv::Point(box.left, box.top), cv::Point(box.right, box.bottom), color, 2, cv::LINE_AA);
int baseLine;
cv::Size labelSize = cv::getTextSize(labelText, cv::FONT_HERSHEY_SIMPLEX, 0.6, 1, &baseLine);
cv::rectangle(image, cv::Point(box.left, box.top - labelSize.height), cv::Point(box.left + labelSize.width, box.top), color, -1);
cv::putText(image, labelText, cv::Point(box.left, box.top), cv::FONT_HERSHEY_SIMPLEX, 0.6, cv::Scalar(255, 255, 255), 1);
}
}
// Process a single image
void processSingleImage(const std::string &imagePath, const std::shared_ptr &model, const std::string &outputPath, const std::vector<std::pair> &labels)
{
cv::Mat cvimage = cv::imread(imagePath, cv::IMREAD_COLOR);
if (cvimage.empty())
{
std::cerr << "Failed to read image: " << imagePath << std::endl;
return;
}
// cv::cvtColor(cvimage, cvimage, cv::COLOR_BGR2RGB);  // It is better to use RGB images, but the impact of using BGR on the results is not significant.
deploy::Image image(cvimage.data, cvimage.cols, cvimage.rows);
std::cout <predict(image);
std::cout << "inference over!
";
if (!outputPath.empty())
{
std::cout << "show result
";
// cv::cvtColor(cvimage, cvimage, cv::COLOR_RGB2BGR);
visualize(cvimage, result, labels);
cv::imwrite(outputPath + "/" + getFileName(imagePath), cvimage);
}
else
{
std::cout << "outputPath is empty
";
}
}
void processVideo(const std::string &videoPath, const std::shared_ptr &model, const std::vector<std::pair> &labels)
{
VideoCapture capture(videoPath);
if (!capture.isOpened())
return;
double fps = capture.get(cv::CAP_PROP_FPS);          // 帧率
int width = capture.get(cv::CAP_PROP_FRAME_WIDTH);   // 视频帧宽度
int height = capture.get(cv::CAP_PROP_FRAME_HEIGHT); // 视频帧高度
while (1)
{
Mat frame;
capture >> frame; // 从相机读取新一帧
if (frame.empty())
{
std::cout <predict(image);
// cv::cvtColor(cvimage, cvimage, cv::COLOR_RGB2BGR);
visualize(frame, result, labels);
cv::imshow("result", frame);
if (char(waitKey(2)) == 'q')
{
break;
}
}
capture.release();
cv::destroyAllWindows();
}
// Process a batch of images
void processBatchImages(const std::vector &imageFiles, const std::shared_ptr &model, const std::string &outputPath, const std::vector<std::pair> &labels)
{
const size_t batchSize = model->batch;
deploy::GpuTimer gpuTimer;
deploy::CpuTimer cpuTimer;
int count = 0;
for (size_t i = 0; i < imageFiles.size(); i += batchSize)
{
std::vector images;
std::vector imgNameBatch;
for (size_t j = i; j < i + batchSize && j < imageFiles.size(); ++j)
{
cv::Mat image = cv::imread(imageFiles[j], cv::IMREAD_COLOR);
if (image.empty())
{
std::cerr << "Failed to read image: " << imageFiles[j] << std::endl;
continue;
}
// cv::cvtColor(image, image, cv::COLOR_BGR2RGB); // It is better to use RGB images, but the impact of using BGR on the results is not significant.
images.push_back(image);
imgNameBatch.push_back(getFileName(imageFiles[j]));
}
if (images.empty())
continue;
std::vector imgBatch;
for (const auto &image : images)
{
imgBatch.emplace_back(image.data, image.cols, image.rows);
}
if (i > 5)
{
cpuTimer.start();
gpuTimer.start();
}
auto results = model->predict(imgBatch);
if (i > 5)
{
cpuTimer.stop();
gpuTimer.stop();
count++;
}
if (!outputPath.empty())
{
for (size_t j = 0; j  0)
{
std::cout << "Average infer CPU elapsed time: " << cpuTimer.microseconds() / 1000 / count << " ms" << std::endl;
std::cout << "Average infer GPU elapsed time: " << gpuTimer.microseconds() / 1000 / count << " ms" <required()->check(CLI::ExistingFile);
app.add_option("-i,--input", inputPath, "Path to image or directory")->required()->check(CLI::ExistingPath);
app.add_option("-o,--output", outputPath, "Directory to save results");
app.add_option("-l,--labels", labelPath, "File to use for reading the class labels from")->check(CLI::ExistingFile);
CLI11_PARSE(app, argc, argv);
std::cout << "load engine...
";
auto model = std::make_shared(enginePath);
std::cout << "engine loaded!
";
std::vector<std::pair> labels;
if (!outputPath.empty())
{
labels = generateLabelColorPairs(labelPath);
createOutputDirectory(outputPath);
}
if (fs::is_regular_file(inputPath))
{
if(getFileExtension(inputPath)=="mp4")
{
processVideo(inputPath, model, labels);
}else{
std::cout << "start process image file
";
processSingleImage(inputPath, model, outputPath, labels);
}
}
else
{
std::cout << "start process image directory
";
auto imageFiles = getImagesInDirectory(inputPath);
if (!imageFiles.empty())
{
processBatchImages(imageFiles, model, outputPath, labels);
}
else
{
std::cerr << "No images found in directory: " << inputPath << std::endl;
return 1;
}
}
std::cout << "Inference completed." << std::endl;
return 0;
}

【源码下载】https://download.csdn.net/download/FL1623863129/89436042