学习使用c++代码完成onnx推理yolov5模型记录

许乌有

已于 2024-12-13 10:23:20 修改

阅读量785

点赞数 17

文章标签：学习 c++ YOLO

于 2024-12-08 15:46:18 首次发布

本文链接：https://blog.youkuaiyun.com/qq_57866557/article/details/144315312

版权

一、OpenCV 的 Mat 对象是什么

在 OpenCV 中，Mat 对象是图像数据的核心表示方式，它是 OpenCV 库中处理图像的基本数据结构。

Mat 是 “matrix”（矩阵）的缩写，表示图像或其他类型的二维数据（例如：灰度图像、彩色图像、深度图像等）。

它是一个非常灵活的类，可以用于表示图像、视频帧、特征图、矩阵数据等。

1. Mat 构造与使用：

从图像文件加载 Mat：

cv::Mat img = cv::imread("image.jpg"); // 从文件中读取图像

创建空的 Mat：

cv::Mat img(480, 640, CV_8UC3); // 创建一个 480x640 的彩色图像，数据类型为 8 位无符号整数（每个像素 3 个通道）

从其他 Mat 复制数据：

cv::Mat img2 = img.clone(); // 克隆图像

访问像素数据：

可以通过 .at<T>() 方法来访问特定像素的值：

cv::Vec3b color = img.at<cv::Vec3b>(y, x); // 访问图像 (y, x) 位置的 RGB 值

Vec3b 是 OpenCV 中的一个类，表示一个三通道的像素值**（BGR）**。

修改像素值：

你也可以通过 .at<T>() 来修改图像中的像素值

img.at<cv::Vec3b>(y, x) = cv::Vec3b(0, 0, 255); // 将 (y, x) 位置的像素值设置为红色

转换数据类型：

Mat 对象的类型可以通过 convertTo() 方法进行转换。例如，将图像从 8 位无符号整数转换为浮动数：

cv::Mat img_float;
img.convertTo(img_float, CV_32F); // 将 img 转换为 32 位浮动数

获取图像的基本信息：

std::cout << "Rows: " << img.rows << std::endl; // 行数 (高度)
std::cout << "Cols: " << img.cols << std::endl; // 列数 (宽度)
std::cout << "Channels: " << img.channels() << std::endl; // 通道数

Mat 对象中存储图像数据的原始指针：

Mat result;
float *pdata = (float *)result.data;

result 是一个 OpenCV 的 Mat 对象，表示一个图像或者多维数组。
data 是 Mat 对象中的一个成员变量，类型是 uchar*（无符号 8 位整数指针）。它指向存储图像像素数据的内存区域。

具体来说，result.data 是一个指向 Mat 中实际数据存储区域的指针。这个数据区域包含了图像的原始像素数据，图像的大小、通道数、数据类型等信息都由 Mat 对象中的其他成员变量描述。

result.total() 是 OpenCV 中 Mat 类的一个成员函数，它返回矩阵中所有元素的总数。具体来说，total() 返回矩阵的所有元素个数，即矩阵中行数和列数相乘的结果。对于一个 Mat 对象来说，矩阵的形状由它的行数 (rows) 和列数 (cols) 决定，而 total() 返回的值是所有元素的总数，包括矩阵的所有通道。

cv::Mat img = cv::imread(“image.jpg”); // 从文件中读取图像这里读取的图像数据的size是多少？

在 OpenCV 中，使用 cv::imread() 函数读取图像文件时，返回的 cv::Mat 对象的 size（即图像的大小）可以通过 Mat 的 rows 和 cols 属性来获取。具体来说：

img.rows 返回图像的高度（即行数），即图像的垂直像素数。
img.cols 返回图像的宽度（即列数），即图像的水平像素数。

此外，图像的 size() 方法也可以直接返回一个 cv::Size 对象，表示图像的宽度和高度。

// 获取图像的高度和宽度
int height = img.rows;  // 高度
int width = img.cols;   // 宽度

// 获取图像的大小（cv::Size 类型）
cv::Size size = img.size();

这里size会返回一个[width,height]格式的数据。

如果图像读取失败（例如路径错误或文件不存在），cv::imread() 会返回一个空的 Mat 对象，此时 img.rows 和 img.cols 都是 0，且 img.empty() 为 true。
你可以通过以下代码检查图像是否成功读取：

if (img.empty()) {
    std::cerr << "图像读取失败!" << std::endl;
}

cv::Mat img(480, 640, CV_8UC3);CV_8UC3还能替换成什么？

cv::Mat img(480, 640, CV_8UC1);  // 创建一个灰度图像，480x640，8 位无符号整数，单通道
cv::Mat img(480, 640, CV_16UC3);  // 创建一个 16 位8无符号整数，彩色图像
cv::Mat img(480, 640, CV_32FC3);  // 创建一个32位浮点数，彩色图像
cv::Mat img(480, 640, CV_64FC1);  // 创建一个 64 位浮点数灰度图像
cv::Mat img(480, 640, CV_8SC3);  // 创建一个 8 位有符号整数彩色图像
cv::Mat img(480, 640, CV_32SC1);  // 创建一个 32 位有符号整数灰度图像

cv::Vec3b color = img.atcv::Vec3b(y, x); // 访问图像 (y, x) 位置的 RGB 值。中cv::Vec3b是一个1x3的矩阵吗

是的，cv::Vec3b 是一个 1x3 的矩阵，但它更常被视为一个包含 3 个元素的向量类型。在 OpenCV 中，cv::Vec3b 表示一个 3 元素的向量，其中 b 代表 uchar（无符号 8 位整数）数据类型。具体来说，它通常用于表示一个 RGB 彩色图像的像素值，每个元素分别对应蓝色 (Blue)、绿色 (Green) 和红色 (Red) 的值。

详细解释：

cv::Vec3b 是 OpenCV 提供的一个类型，它表示一个包含 3 个 uchar（无符号 8 位整数）类型数据的结构体。
这种数据结构常用来存储图像中的 RGB 值，因为每个像素通常由三个颜色通道组成：红色（R）、绿色（G）和蓝色（B），每个通道的值在 0 到 255 之间。

cv::Vec3b color = img.at<cv::Vec3b>(y, x);  // 获取图像中 (y, x) 位置的 RGB 值

img.at<cv::Vec3b>(y, x)：这行代码的作用是访问图像 img 中 (y, x) 位置的像素值，并将其存储到 color 变量中。color 是一个 cv::Vec3b 类型，表示一个 3 元素的向量。
color[0]：对应该像素的蓝色通道（B）。
color[1]：对应该像素的绿色通道（G）。
color[2]：对应该像素的红色通道（R）。

总结：
cv::Vec3b 是一个包含 3 个元素的向量，可以认为是一个 1x3 矩阵，用于存储 RGB 图像的一个像素的三种颜色值。每个元素是 uchar 类型，范围在 0 到 255 之间。

Mat 的常见应用：

图像处理：图像的各种操作（滤波、变换、边缘检测等）通常都使用 Mat 来存储和处理数据。
计算机视觉：从摄像头或视频流中获取图像数据，并进行图像分析（如特征提取、目标检测等）。
机器学习和深度学习：Mat 用于存储输入数据（例如图像）和处理结果（例如卷积神经网络的特征图）。

总结：

Mat 是 OpenCV 中最重要的数据结构，它简洁、高效且功能强大。它允许我们通过非常简便的方式进行图像数据的访问、修改和处理。无论是对单通道灰度图像的简单操作，还是对复杂多通道数据（如彩色图像、深度图像）的高效处理，Mat 都提供了强有力的支持。

二、vector<vector>是什么意思？

vector<vector> 是 C++ 中的二维向量（或称为“向量的向量”），它是一个容器类型，用于存储 vector 类型的元素。每个 vector< float> 对象本身是一个一维数组，而 vector< vector< float>> 就是一个包含多个一维数组的二维结构。

vector<vector<vector>>就是三维数组？

是的，vector<vector<vector>> 可以看作是一个三维数组，它是 C++ 中的三维向量（或称为“向量的向量的向量”）。每个 vector<vector> 表示一个二维矩阵，而 vector<vector<vector>> 则表示一个包含多个二维矩阵的三维结构。

#include <iostream>
#include <vector>

int main() {
    // 一个二维 vector，表示一个 3x3 的矩阵
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 使用基于范围的 for 循环遍历每一行
    for (const auto& row : matrix) {
        // row 是 matrix 中的每一行 (std::vector<int>)
        for (const auto& element : row) {
            std::cout << element << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

for (const auto& row : matrix) 里面row是啥

具体来说：

const：row 是只读的，不能修改。
auto：编译器会自动推导出 row 的类型。假设 matrix 是一个 std::vector<std::vector<int>>，那么 auto 会推导出 row 的类型为 std::vector<int>&（引用类型）。
&：表示我们遍历的是每一行的引用，而不是每一行的拷贝（这样可以避免不必要的拷贝操作，提高效率）。

也就是说auto会把row推理为matrix的一个元素，如果matrix是一个由二维数组组成的三维数组，那么row就是一个二维数组？

是的，你的理解是正确的！

如果 matrix 是一个三维数组（即 std::vector<std::vector<std::vector>> 或类似的类型），那么 auto 会将 row 推导为 matrix 的一个元素，而这个元素在这种情况下就是一个二维数组或者一个二维 std::vector。
解释：

假设 matrix 是一个三维容器，像 std::vector<std::vector<std::vector<int>>>，它表示一个包含多个二维数组（每个二维数组本身是一个 std::vector<std::vector<int>>）的三维结构。
for (const auto& row : matrix) 中的 row 将会是 matrix 中的一个元素，而这个元素是一个二维数组（即 std::vector<std::vector<int>>）。

vector<float> info_line;
info_line.push_back(pdata[j]);

代码里的push_back是啥意思？

push_back 是 std::vector 类中的一个成员函数，它用于在 vector 的末尾添加一个元素。这里 info_line 是一个 std::vector 类型的容器，它用来临时存储符合条件的一行数据。

info_line.push_back(pdata[j]):

push_back 函数会将 pdata[j]（即当前行中的第 j 个数据）添加到 info_line 这个 std::vector<float> 的末尾。

为什么要使用 push_back：

动态大小：std::vector 是一个动态数组，它会自动扩展大小。使用 push_back 可以方便地将元素一个个地添加到 vector 中，而不需要事先知道元素的数量。

避免覆盖：如果不使用 push_back，而是直接通过下标赋值（比如 info_line[j] = pdata[j]），那么每次迭代会覆盖 info_line 中的数据。push_back 则确保每次添加一个新元素，而不会覆盖掉已有的元素。

可读性和灵活性：push_back 使得代码更加简洁且易于理解。它表明当前的意图是将数据逐步加入到一个集合中，而不是直接操作数据结构。

info[i][5] = std::max_element(info[i].cbegin() + 5, info[i].cend()) - (info[i].cbegin() + 5); 这句啥意思？

info[i].cbegin() + 5：

info[i] 是一个 std::vector<float>，它表示第 i 行的数据。

info[i].cbegin() 返回一个指向 info[i] 开始位置的常量迭代器。这个迭代器指向该行的第一个元素。

info[i].cbegin() + 5 将 cbegin() 迭代器偏移 5 个位置，指向该行第 6 个元素，即 info[i][5]。

总结：info[i].cbegin() + 5 实际上是指向 info[i][5] 的迭代器。

info[i].cend()：

info[i].cend() 返回指向 info[i] 最后一个元素后一个位置的常量迭代器。它表示整个向量的末尾。

std::max_element(info[i].cbegin() + 5, info[i].cend()) - (info[i].cbegin() + 5)：

std::max_element 是 C++ STL 中的一个标准算法，用来返回指定范围内最大元素的迭代器。
std::max_element(info[i].cbegin() + 5, info[i].cend()) 计算从 info[i][5] 开始到 info[i][n]（info[i] 的最后一个元素）之间的最大元素，并返回指向该最大元素的迭代器。

赋值给 info[i][5]：

最后，info[i][5] 被赋值为这个偏移量，这意味着 info[i][5] 被更新为从 info[i][5] 开始的子范围中最大元素的位置索引。

什么是常量迭代器？

常量迭代器（const_iterator） 是一种迭代器，它只允许读取元素，而不允许修改元素的值。
它的主要目的是防止在遍历容器时意外修改元素，提供了更强的类型安全性。

常量迭代器的特点：

只读访问：
    使用常量迭代器访问容器时，不能修改容器中的元素。如果尝试修改元素，编译器会报错。
    常量迭代器只能进行读取操作，例如访问元素的值，而不能进行修改（例如使用 *it = value）。

定义方式：
    常量迭代器通常是通过 const_iterator 类型来定义的。
    比如，std::vector<int>::const_iterator 就是 std::vector<int> 容器的常量迭代器类型。

用途：
    常量迭代器通常用于确保容器元素在遍历过程中不被修改。这在需要保证数据不变时非常有用。
    常量迭代器也可以用来遍历常量容器，或者对容器进行只读操作时提供更高的安全性。

常量迭代器与普通迭代器的区别：

普通迭代器：允许修改容器元素的值。

std::vector<int> v = {1, 2, 3};
std::vector<int>::iterator it = v.begin();
*it = 10;  // 允许修改元素的值

常量迭代器：不允许修改容器中的元素。

std::vector<int> v = {1, 2, 3};
std::vector<int>::const_iterator it = v.begin();
*it = 10;  // 错误：不能通过常量迭代器修改元素的值

info[i].resize(6);是把第i行第6个元素七个元素及以后全部删除了？

info[i].resize(6); 这行代码的作用是调整 info[i] 容器的大小为 6。

如果 info[i] 的当前大小大于 6，则会 删除多余的元素，即删除从第 6 个元素到最后一个元素的所有元素。
如果 info[i] 的当前大小小于 6，则会 增加元素，并且这些新元素会使用容器的默认值（对于大多数容器类型，默认值通常是类型的零值，如 0 或空字符串等）。

具体解释：

当前元素数量大于 6：resize(6) 会删除索引从 6 开始到容器末尾的所有元素。例如，如果 info[i] 的大小是 8，那么 resize(6) 会删除 info[i][6] 和 info[i][7] 这两个元素。

当前元素数量小于 6：resize(6) 会添加新元素，直到容器的大小变为 6。新的元素会使用类型的默认构造函数来初始化（例如，如果是 int 类型，默认值是 0，如果是 std::string，默认值是空字符串 ""）。

info.size返回的是行数还是列数？

info.size() 返回的是行数，也就是说，返回的是 info 容器中存储的元素的数量。在你的上下文中，假设 info 是一个二维容器，比如一个 std::vector<std::vector>，那么 info.size() 将返回外层 std::vector 的大小，也就是它包含的子容器的数量（即行数）。

std::find(class_id.begin(), class_id.end(), (int)info[i][5]) == class_id.end() 什么意思？

检查 info[i][5] 转换成 int 类型后，是否存在于 class_id 容器中。

详细解析：

std::find(class_id.begin(), class_id.end(), (int)info[i][5]):
    std::find 是一个算法，用于查找指定值在容器中的位置。它的参数是容器的开始和结束迭代器，以及要查找的值。
    class_id.begin() 是容器 class_id 的开始迭代器。
    class_id.end() 是容器 class_id 的结束迭代器。
    (int)info[i][5] 是将 info[i][5] 强制转换为 int 类型后作为查找目标值。这里假设 info 是一个二维容器（如 std::vector<std::vector<T>>），info[i][5] 表示第 i 行的第 6 个元素。

std::find 的返回值:
    std::find 返回一个迭代器，指向找到的元素位置。如果找到了指定的值，返回该值的位置；如果没有找到，返回 class_id.end()，即容器的末尾。

std::find(class_id.begin(), class_id.end(), (int)info[i][5]) == class_id.end():
    如果 std::find 返回的是 class_id.end()，表示在 class_id 中没有找到与 (int)info[i][5] 相等的元素。此时条件为 true。
    如果找到了，条件为 false。

std::sort(info.begin(), info.end(), [](vector p1, vector p2) { return p1[4] > p2[4]; }); 啥意思？

std::sort(info.begin(), info.end(), …)

info.begin() 和 info.end() 表示 info 容器的开始和结束迭代器，std::sort 将对从 begin 到 end 的范围进行排序。
std::sort 是标准库提供的排序算法，用来对容器中的元素进行排序。排序的方式由第三个参数提供。
[](vector p1, vector p2)

这是一个 Lambda 表达式，用来定义排序规则。
p1 和 p2 是两个 vector 类型的元素，代表排序时比较的两个边界框（info 中的每个元素）。
该 Lambda 表达式的作用是决定两个框之间的大小关系，即通过返回 true 或 false 来确定顺序。
return p1[4] > p2[4];

p1[4] 和 p2[4] 分别表示两个边界框的置信度分数。假设 info 中每个元素是一个包含 [x1, y1, x2, y2, score] 的 vector，那么 p1[4] 就是第一个框的置信度 score，p2[4] 是第二个框的置信度。
p1[4] > p2[4] 说明如果第一个框的置信度大于第二个框的置信度，则返回 true，即将第一个框排在前面（降序排列）。

[](vector p1, vector p2 )

{ return p1[4] > p2[4]; } 为什么这么写？

Lambda 表达式的基本语法

Lambda 表达式是 C++11 引入的一种简便的定义匿名函数的方式，它的基本语法是：

[捕获列表] (参数列表) -> 返回类型 { 函数体 }

在你的代码中：

[](vector<float> p1, vector<float> p2)

这是一个没有捕获任何外部变量的 Lambda 表达式，它接受两个 vector 类型的参数 p1 和 p2。

捕获列表 []

捕获列表指定 Lambda 函数可以访问的外部变量。在你的例子中，[] 表示 Lambda 不捕获任何外部变量。这是因为排序函数只关心 p1 和 p2 这两个参数，不需要访问外部的其他变量。

如果你需要访问外部变量，可以将它们写在 [] 中，例如：

[x, &y]：捕获变量 x 为值捕获，y 为引用捕获。
[=]：捕获所有外部变量为值。
[&]：捕获所有外部变量为引用。

参数列表 (vector p1, vector p2)

这是 Lambda 表达式接受的参数列表，表示这个 Lambda 函数接收两个 vector 类型的参数。对于排序操作来说，p1 和 p2 就是 std::sort 内部进行排序时要比较的两个元素（在这里是 vector 类型的边界框）。
3. 返回类型 ->

如果 Lambda 表达式有明确的返回类型，需要在 -> 后面指定。在你的代码中，-> 被省略了，因为 Lambda 的返回类型可以根据返回语句推导出来。这里返回的是一个 bool 类型值（p1[4] > p2[4] 比较后返回 true 或 false），所以编译器会自动推导出返回类型为 bool。
4. 函数体 { return p1[4] > p2[4]; }

这是 Lambda 表达式的主体，表示比较 p1 和 p2 的置信度值，并返回布尔值。排序时，std::sort 会通过这个比较函数决定两个元素的顺序。

示例

对于以下代码：

std::sort(info.begin(), info.end(), [](vector<float> p1, vector<float> p2)
{
    return p1[4] > p2[4]; 
});

这里的 p1 和 p2 代表的是排序容器 info 中的两个元素。info 是一个包含多个 vector 元素的容器，每个 vector 代表一个边界框，并且包含至少 5 个元素：前四个元素是边界框的坐标（如 x1, y1, x2, y2），第五个元素是该边界框的置信度值（score）。我们通过 p1[4] 和 p2[4] 来比较两个边界框的置信度，从而实现降序排序。