基于YOLO11实例分割与奥比中光相机的快递包裹抓取点检测

本博客泉源于CSDN呆板鱼，未同意任何人转载。
更多内容，接待点击本专栏，检察更多内容。

目次
0 弁言
1 奥比中光相机测试
1.1 SDK相机初体验
1.2 将SDK的Example改成所必要步伐
2 YOLO11S-SEG的onnxruntime推理
3 结语

---

0 弁言

项目接纳六轴呆板臂搭配末了真空吸盘，从无序包裹中抓取想要的包裹。AI算法必要提供各包裹的抓取点的3D坐标与3D姿态。由于快递包裹含有多个面，且大多为倾斜状态，为了顺遂抓取，我们的算法必要如下几个步调：
①从彩色图的包裹堆内里辨认、分割出每个单独的包裹，得到2D掩码Mask1；
②从对齐的深度图中提取每个包裹Mask1对应的深度掩码Mask2；
③根据相机参数，盘算Mask2对应的三维点云DisMask；
④将DisMask中的非常点云值剔除后做平面分割，只要含点云数目最多的谁人平面；
⑤求平面的质心作为抓取点，求平面的法向量与x、y、z轴的角度为末了抓取姿态。
终极得到6个值返回给下位机做呆板臂的控制。
本次是在windows上举行开发，我用到的软件与SDK有：cmak-3.28.1，vs2019，opencv-4.6.1，open3d-0.18.0，orbbecsdk1.10.18、cuda-11.6、cudnn-8.5.0、onnxruntime-gpu-1.14.0（本来仍然用tensorrt的究竟快，但是我之前已经出过yolov8-seg的tensorrt推理博客了，而yolov11-seg的可以直接用，再写一遍没啥意思，以是改成onnxruntime-gpu举行推理，实测比tensorrt差不到很多，还可以省掉onnx转tensorrt模子的步调，巴适的板。我的PC显卡是3060，yolo11s-seg的推理速率是11ms，而onnxruntime的速率是24ms左右）。
模子用的ultralytics最新版练习的yolo11s-seg，练习好之后转好的onnx模子与练习数据可以在【这里】下载，练习方法网上随处都有，不是此博客的重点。
1 奥比中光相机测试

1.1 SDK相机初体验

从前做这种对精度要求不那么高项目用的都是intel的realsense系列，但代价越来越贵了，加上奥博中光每天网上吹牛批，以是某鱼买了一款二手的GeminiPro相机，是奥比中光与轮趣科技一同研发的。
起首设置奥比中光相机的驱动与SDK，必须要装驱动才气利用，下载所在：所在1。由于我接纳的win11，以是下载的win_x64这个版本。

解压后的目次为D:/Project/OrbbecSDK/（这是我放置的目次），也可以换其他路径存放。有个driver的文件夹，内里的exe无脑安装即可。

安装完成后，打开CMAKE_GUI与VS2019，CMAKE我接纳的版本是3.28.1。起首打开CMakeLists.txt将OpenCV_DIR的路径改成自己的实际路径，关于opencv的安装编译网上有很多，这里就不赘述了。

https://github.com/orbbec/OrbbecSDK/releases然后打开cmakegui按照下列步调设置并天生vs的工程文件，天生好之后打开，末了ALL_BUILD。

 

ALL_BUILD右键天生之后会在bin目次下天生很多exe文件，插上相机、运行color_viewer有画面就代表已经可以精确利用SDK了，下面我们对其举行改写，得到我们想要的步伐。

1.2 将SDK的Example改成所必要步伐

在我的案例中，对于SDK必要有以下几个功能：
①设定参数与初始化相机；②获取彩色图与深度图；③对彩色图与深度图举行对齐；④传入检测得到的box与mask盘算3d点云；⑤点云处理惩罚得到三维抓取点与三维姿态。
起首创建一个camera.h，界说必要的函数，代码如下：

1. #ifndef CAMERAUTIL_H
2. #define CAMERAUTIL_H
4. #include "libobsensor/ObSensor.hpp"
5. #include "libobsensor/hpp/Pipeline.hpp"
6. #include <Eigen/Dense>
7. #include <open3d/Open3D.h>
8. #include "opencv2/opencv.hpp"
9. #include <fstream>
10. #include <iostream>
11. #include <cmath>
12. #include <vector>
13. class Orbbec {
14. public:
15.         bool Init(void);//初始化相机
16.         bool GetRgbAndDepth(cv::Mat& src, cv::Mat& dep);//获取当前帧，并进行深度图与彩色图的对齐
17.         void GetDistance(int x, int y);//打印提取某个点的x、y、z坐标
18.         void GetDistance(int box[4], cv::Mat& mask, cv::Mat& dis_mask);//提取某个box中mask对应的所有点的三维点云，并组成dis_mask
19.         void ProcessPointcloud(cv::Mat& dis_mask, cv::Mat imgcrop, std::vector<float>& result, float *ylength, float *xlength);//对点云进行后处理得到抓取坐标与抓取姿态
20.         void Postprocess(int box[4], cv::Mat& mask, cv::Mat srcimg, float result[10]);//对提取的dis_mask进行后处理,GetDistance与ProcessPointcloud
21.         //都是后处理需要用到的函数
22.         void close(void);
23. private:
24.         ob::Pipeline pipe;
25.         OBCameraParam cameraParam;
26.         cv::Mat depth;
27.         float scale;
28.         ob::Align* align=nullptr;
29. };
30. #endif

复制代码

然后新建一个camera.cpp，orbbec的函数举行实现，代码如下：

1. #include "camera.h"
3. bool Orbbec::Init(void) {
4.     // Query the list of connected devices
5.     // Create a Context.
6.     ob::Context ctx;
7.     auto devList = ctx.queryDeviceList();
8.     // Get the number of connected devices
9.     if (devList->deviceCount() == 0) {
10.         std::cerr << "Device not found!" << std::endl;
11.         return false;
12.     }
13.    
14.     // Configure which streams to enable or disable for the Pipeline by creating a Config
15.     std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
17.     // Get all stream profiles of the color camera, including stream resolution, frame rate, and frame format
18.     auto colorProfiles = pipe.getStreamProfileList(OB_SENSOR_COLOR);
19.     // Get the default color profile
20.     //auto colorProfile = colorProfiles->getProfile(OB_PROFILE_DEFAULT);
21.     std::shared_ptr<ob::VideoStreamProfile> colorProfile = nullptr;
22.     colorProfile = colorProfiles->getVideoStreamProfile(640, 480, OB_FORMAT_RGB, 30);
23.     config->enableStream(colorProfile);
25.     // Get all stream profiles of the depth camera, including stream resolution, frame rate, and frame format
26.     auto depthProfiles = pipe.getStreamProfileList(OB_SENSOR_DEPTH);
27.     // Get the default depth profile
28.      //auto depthProfile = depthProfiles->getProfile(OB_PROFILE_DEFAULT);
29.     std::shared_ptr<ob::VideoStreamProfile> depthProfile = nullptr;
30.     depthProfile = depthProfiles->getVideoStreamProfile(640, OB_HEIGHT_ANY, OB_FORMAT_Y11, 30);
31.     config->enableStream(depthProfile);
33.     // Configure the alignment mode as hardware D2C alignment
34.     config->setAlignMode(ALIGN_D2C_HW_MODE);
36.     align = new ob::Align(OB_STREAM_COLOR);
38.     try {
39.         pipe.start(config);
40.         cameraParam = pipe.getCameraParam();
41.     }
42.     catch (ob::Error& e) {
43.         std::cerr << "function:" << e.getName() << "\nargs:" << e.getArgs() << "\nmessage:" << e.getMessage() << "\ntype:" << e.getExceptionType() << std::endl;
44.         return false;
45.     }
46.     return true;
47. };
49. bool Orbbec::GetRgbAndDepth(cv::Mat& src, cv::Mat& dep) {
50.     auto frameset = pipe.waitForFrames(100);
51.     if (frameset == nullptr || frameset->depthFrame() == nullptr || frameset->colorFrame() == nullptr) {
52.         return false;
53.     }
54.     auto newFrame = align->process(frameset);
55.     auto newFrameSet = newFrame->as<ob::FrameSet>();
56.     auto colorFrame = newFrameSet->colorFrame();
57.     auto depthFrame = newFrameSet->depthFrame();
58.     uint32_t  width = colorFrame->width();
59.     uint32_t  height = colorFrame->height();
60.     cv::Mat rawMat(height, width, CV_8UC3, (uint16_t*)colorFrame->data(), cv::Mat::AUTO_STEP);
61.     cv::cvtColor(rawMat, src, cv::COLOR_RGB2BGR);
63.     width = depthFrame->width();
64.     height = depthFrame->height();
65.     scale = depthFrame->getValueScale();
66.     uint16_t* data = (uint16_t*)depthFrame->data();
67.     cv::Mat depimg(height, width, CV_16U, data, cv::Mat::AUTO_STEP);
68.     depimg.copyTo(depth);
69.     // 将深度图转换为8位图像，进行可视化
70.     cv::Mat depth_image_8bit;
71.     double minVal, maxVal;
72.     cv::Point minLoc, maxLoc;
73.     cv::minMaxLoc(depimg, &minVal, &maxVal, &minLoc, &maxLoc);
74.     cv::convertScaleAbs(depimg, depth_image_8bit, 255.0 / maxVal);
75.     cv::applyColorMap(depth_image_8bit, dep, cv::COLORMAP_JET);
76.     //float centerDistance = data[width * height / 2 + width / 2] * scale;
77.     return true;
78. };
79. void Orbbec::GetDistance(int x,int y) {
80.     float Z = (float)depth.at<uint16_t>(y,x) * scale;
81.     float X= (x - cameraParam.depthIntrinsic.cx) * Z / cameraParam.depthIntrinsic.fx;
82.     float Y= (y - cameraParam.depthIntrinsic.cy) * Z / cameraParam.depthIntrinsic.fy;
84.     printf("X,Y,Z:%f,%f.%f\n", X, Y, Z);
85. }
87. void Orbbec::GetDistance(int box[4], cv::Mat& mask, cv::Mat& dis_mask) {
88.     for (int i = box[0]; i < box[2]; i++) {
89.         for (int j = box[1]; j < box[3]; j++) {
90.             if (mask.at<uchar>(j - box[1], i - box[0]) != 0){
91.                 float upoint[3];
92.                 upoint[2] = (float)depth.at<uint16_t>(j, i)* scale/1000.f;//转换成米
93.                 upoint[0] = (i - cameraParam.depthIntrinsic.cx) * upoint[2] / cameraParam.depthIntrinsic.fx;
94.                 upoint[1] = (j - cameraParam.depthIntrinsic.cy) * upoint[2] / cameraParam.depthIntrinsic.fy;
95.                 dis_mask.at<cv::Vec3f>(j - box[1], i - box[0]) = cv::Vec3f(upoint[0], upoint[1], upoint[2]);
96.                 if (upoint[2] == 0.0f)
97.                 {
98.                     mask.at<uchar>(j - box[1], i - box[0]) = 0; // 深度值为0的地方 mask也改成0
99.                 }
100.             }
101.         }
102.     }
103. }
105. void Orbbec::Postprocess(int box[4], cv::Mat& mask, cv::Mat srcimg,float result[10]) {
106.     cv::Rect r = cv::Rect(box[0], box[1], box[2] - box[0], box[3] - box[1]);
107.     cv::Mat imgcrop = srcimg(r).clone();
108.     mask = mask(r).clone();
109.     cv::Mat dis_mask = cv::Mat::zeros(r.height,r.width, CV_32FC3);
110.     GetDistance(box, mask, dis_mask);
111.     //cv::Mat dis_show;
112.     //cv::convertScaleAbs(dis_mask, dis_show, 255.0 / 1000);
113.     //cv::applyColorMap(dis_show, dis_show, cv::COLORMAP_JET);
114.     //cv::imshow("dismask", dis_show);
115.    
116.     // 利用open3d进行点云的后处理
117.     // segment plane分割平面，因为快递分割结果里面会含有侧面，因此先分割，取最大的那个面，然后提取这个面的中点作抓取点
118.     // 以及该面的法向量
119.     float ylength = 0, xlength = 0;
120.     std::vector<float> Normals_and_Axis;
121.     ProcessPointcloud(dis_mask, imgcrop, Normals_and_Axis, &ylength, &xlength);
122.    
123.     // 通过抓取点反算彩色图上的抓取点，用来观察是否抓对点
124.     float CX = Normals_and_Axis[3] * cameraParam.depthIntrinsic.fx / Normals_and_Axis[5] + cameraParam.depthIntrinsic.cx;
125.     float CY = Normals_and_Axis[4] * cameraParam.depthIntrinsic.fy / Normals_and_Axis[5] + cameraParam.depthIntrinsic.cy;
126.     // 通过点云算出来的包裹长宽来反算彩色图中的2D最小包围框,用于观察是否抓准平面
127.     float Width = 0, Height = 0;
128.     if (Normals_and_Axis[5] > 0) {//只计算有合理深度值的
129.         //根据xlength与ylength，反算框的wh，与XY形成抓取面的2d最小包围框
130.         Width = xlength * cameraParam.depthIntrinsic.fx / Normals_and_Axis[5];
131.         Height = ylength * cameraParam.depthIntrinsic.fy / Normals_and_Axis[5];
132.     }
133.     for (int i = 0; i < 6; i++) {
134.         result[i] = Normals_and_Axis[i];
135.     }
136.     result[6] = CX;
137.     result[7] = CY;
138.     result[8] = Width;
139.     result[9] = Height;
141. }
142. void Orbbec::ProcessPointcloud(cv::Mat& dis_mask, cv::Mat image, std::vector<float>& result, float* ylength, float* xlength)
143. {
144.         // //dis_mask to pointcloud
145.         auto outputPC = std::make_shared<open3d::geometry::PointCloud>();
146.         int num_points = dis_mask.cols * dis_mask.rows;
147.         for (int i = 0; i < dis_mask.rows; i++)
148.         {
149.                 for (int j = 0; j < dis_mask.cols; j++)
150.                 {
151.                         Eigen::Vector3d pc = { dis_mask.at<cv::Vec3f>(i, j)[0], dis_mask.at<cv::Vec3f>(i, j)[1], dis_mask.at<cv::Vec3f>(i, j)[2] };
152.                         Eigen::Vector3d clr = { (float)image.at<cv::Vec3b>(i,j)[2] / 255.0,
153.                                                                    (float)image.at<cv::Vec3b>(i,j)[1] / 255.0,
154.                                                                    (float)image.at<cv::Vec3b>(i,j)[0] / 255.0 };
155.                         outputPC->points_.push_back(pc);
156.                         outputPC->colors_.push_back(clr);
157.                 }
158.         }
159.         //open3d::visualization::DrawGeometries({ outputPC}, "outputPC", 800, 450);
160.         //异常值剔除，剔除z距离为0的无效点云
161.         std::vector<size_t> indices;
162.         for (size_t i = 0; i < outputPC->points_.size(); i++) {
163.                 if (outputPC->points_[i][2] == 0.0) {
164.                         indices.push_back(i);
165.                 }
166.         }
167.         outputPC = outputPC->SelectByIndex(indices, true);
168.         if (outputPC->points_.size() <= 3) {
169.                 result = { 0,0,0,0,0,0,0 };
170.                 printf("points size too small\n");
171.                 return;
172.         }
173.     // 平面分割 取出来最大的平面
174.         auto start = std::chrono::system_clock::now();
175.         double tDis = 0.01; // 邻域距离
176.         int minNum = 3;    // 最小点云数
177.         int numIter = 200; // 迭代数  
178.         std::tuple<Eigen::Vector4d, std::vector<size_t>> vRes = outputPC->SegmentPlane(tDis, minNum, numIter);
179.         // 平面参数
180.         // AX+BY+CZ+D=0  ==> Z=-(AX+BY+D)/C
181.         Eigen::Vector4d para = std::get<0>(vRes);
182.         //printf("Segment plane:%.3fX+%.3fY+%.3fZ+%.3f=0\n",para[0],para[1],para[2],para[3]);
183.         // 内点索引
184.         std::vector<size_t> selectedIndex = std::get<1>(vRes);
185.         std::shared_ptr<open3d::geometry::PointCloud> inPC = outputPC->SelectByIndex(selectedIndex, false);
186.         //open3d::visualization::DrawGeometries({ inPC}, "inPC", 800, 450);
188.         // 点云质心作为距离坐标
189.         Eigen::Vector3d Axis;
190.         Axis = inPC->GetCenter();
191.         // 计算法向量z夹角
192.         Eigen::Vector3d A(para[0], para[1], para[2]), X(-1, 0, 0), Y(0, -1, 0), Z(0, 0, 1);
193.         double angleX0, angleX, angleY, angleZ;
194.         double PI = 3.1415926;
195.         angleZ = std::acos(A.dot(Z) / (A.norm() * Z.norm())) * 180 / PI;
196.         angleX0 = std::acos(A.dot(X) / (A.norm() * X.norm())) * 180 / PI;
197.         angleY = std::acos(A.dot(Y) / (A.norm() * Y.norm())) * 180 / PI;
198.         angleX = std::atan2(A[1], A[0]) * 180 / PI;
199.         if (angleZ > 90) {
201.                 angleZ = 180 - angleZ;
202.                 X = { 1, 0, 0 };
203.                 Y = { 0, 1, 0 };
204.                 angleX0 = std::acos(A.dot(X) / (A.norm() * X.norm())) * 180 / PI;
205.                 angleY = std::acos(A.dot(Y) / (A.norm() * Y.norm())) * 180 / PI;
206.                 angleX = std::atan2(-A[1], A[0]) * 180 / PI;
207.                
208.         }
209.         //printf("angle:%f,%f,%f,xplane:%f\n", angleX0, angleY, angleZ, angleX);
210.         //angleX的角度是与法向量投影到xoy平面的并于x负方向的夹角,顺时针是0-180，逆时针是0-负180
211.     //
212.        
213.         result.push_back(angleX0);
214.         result.push_back(angleY);
215.         result.push_back(angleZ);
216.         result.push_back(Axis[0]);
217.         result.push_back(Axis[1]);
218.         result.push_back(Axis[2]);
219.        
220.         auto end = std::chrono::system_clock::now();
221.         //std::cout << "open3d process time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
222.         // // 绘制分割出来的平面模型
223.         Eigen::Vector3d min_pt, max_pt;
224.         min_pt = inPC->GetMinBound();
225.         max_pt = inPC->GetMaxBound();
226.         double Xmin = min_pt[0], Ymin = min_pt[1], Zmin = min_pt[2];
227.         double Xmax = max_pt[0], Ymax = max_pt[1], Zmax = max_pt[2];
228.         *ylength = (float)Ymax - (float)Ymin;
229.         *xlength = (float)Xmax - (float)Xmin;
230.         //展示结果
231.         if (0) {
232.                 // 外点   绿色
233.                 std::shared_ptr<open3d::geometry::PointCloud> outPC = outputPC->SelectByIndex(selectedIndex, true);
234.                 const Eigen::Vector3d colorOut = { 0,1,0 };
235.                 outPC->PaintUniformColor(colorOut);
236.                 // open3d::visualization::DrawGeometries({ outPC}, "outPC", 800, 450);
238.                 auto Plane = std::make_shared<open3d::geometry::PointCloud>();
239.                 int width = 20, height = 20;
240.                 for (int i = 0; i < width; i++) {
241.                         double x = Xmin + (Xmax - Xmin) / width * i;
242.                         for (int j = 0; j < height; j++) {
243.                                 double y = Ymin + (Ymax - Ymin) / height * j;
244.                                 double z = -(para[0] * x + para[1] * y + para[3]) / para[2];
245.                                 Eigen::Vector3d pc = { x, y, z };
246.                                 Plane->points_.push_back(pc);
247.                         }
248.                 }
250.                 const Eigen::Vector3d color = { 1,0,1 };
251.                 Plane->PaintUniformColor(color);
253.                 // 夹爪方向
254.                 auto lineCloud = std::make_shared<open3d::geometry::PointCloud>();
255.                 lineCloud->points_.resize(20);
256.                 for (size_t i = 0; i < lineCloud->points_.size(); ++i)
257.                 {
258.                         lineCloud->points_[i] = Axis - i * 0.01 * A;
259.                 }
260.                 lineCloud->PaintUniformColor(color);
262.                 // 抓取点
263.                 auto mesh = open3d::geometry::TriangleMesh::CreateSphere(0.01);
264.                 mesh->ComputeVertexNormals();
265.                 mesh->PaintUniformColor(Eigen::Vector3d(0.1, 0.1, 0.1));
266.                 mesh->Translate(Axis);
267.                 //圆心坐标
268.                 auto mesh1 = open3d::geometry::TriangleMesh::CreateCoordinateFrame(0.1);
269.                 mesh1->ComputeVertexNormals();
270.                 //旋转到相机方向 方便我们观看
271.                 Eigen::Matrix4d transform;
272.                 transform << 1.0, 0.0, 0.0, 0.0,
273.                         0.0, -1.0, 0.0, 0.0,
274.                         0.0, 0.0, -1.0, 0.0,
275.                         0.0, 0.0, 0.0, 1.0;
276.                 inPC->Transform(transform);
277.                 outPC->Transform(transform);
278.                 lineCloud->Transform(transform);
279.                 Plane->Transform(transform);
281.                 mesh->Transform(transform);
282.                 mesh1->Transform(transform);
284.                 // open3d::io::WritePointCloudToPCD("inPC.pcd", *inPC,false);
285.                 // open3d::io::WritePointCloudToPCD("outPC.pcd", *outPC,false);
286.                 // open3d::io::WritePointCloudToPCD("lineCloud.pcd", *lineCloud,false);
287.                 // open3d::io::WritePointCloudToPCD("Plane.pcd", *Plane,false);
289.                 open3d::visualization::DrawGeometries({ inPC,outPC,lineCloud,Plane,mesh,mesh1 }, "Result", 800, 450);
290.         }
291. }
293. void Orbbec::close(void) {
294.     pipe.stop();
295. };

复制代码

再新建一个主函数，用来调用上面的函数，名字就叫main1_testcamera.cpp写，主体代码如下所示：

1. #include "camera.h"
2. // #include "opencv2/opencv.hpp"
3. #include <fstream>
4. #include <iostream>
5. #include <cmath>
6. #include <conio.h>
7. using namespace std;
9. int main(int argc, char** argv) try {
10.     Orbbec camera;
11.     camera.Init();
12.     while (true)  {
13.         cv::Mat src, dep;
14.         if (!camera.GetRgbAndDepth(src, dep)) {
15.             continue;
16.         }
17.         cv::Mat show=src.clone();
18.         //cv::addWeighted(src,0.5,dep,0.8,0.5,show);
19.         int box[4] = { 280,200,360,280};//检测框的xmin,ymin,xmax,ymax
20.         cv::Mat mask = cv::Mat::ones(cv::Size(src.cols, src.rows), CV_8UC1);
21.         float result[10] = {0};
22.         camera.Postprocess(box, mask, src, result);
23.         printf("ax,ay,az,x,y,z,:%f,%f,%f,%f,%f,%f\n", result[0], result[1], result[2], result[3], result[4], result[5]);
24.         
25.         cv::Point p1((int)(0.5 * box[0] + 0.5 * box[2]), (int)(0.5 * box[1] + 0.5 * box[3]));
26.         cv::circle(show, p1, 3, cv::Scalar(0, 255, 255), 3);//center point
27.         cv::Point p2((int)result[6], (int)result[7]);
28.         cv::circle(show, p2, 3, cv::Scalar(0, 0, 255), 3);//pick point   
29.         cv::Rect rdraw0 = cv::Rect((int)box[0], (int)box[1], (int)(box[2]-box[0]), (int)(box[3] - box[1]));
30.         cv::rectangle(show, rdraw0, cv::Scalar(0, 255, 255), 2);//detect box
31.         cv::Rect rdraw1 = cv::Rect((int)(result[6] - 0.5 * result[8]),(int)(result[7] - 0.5 * result[9]),
32.             (int)result[8], (int)result[9]);
33.         cv::rectangle(show, rdraw1, cv::Scalar(0, 0, 255), 2);//postprocess box
34.         printf("-------------------------------------------------\n");
35.         cv::imshow("show", show);
36.         char c = cv::waitKey(1);
37.         if (c == 27) {
38.             cv::destroyAllWindows();
39.             break;
40.         }
41.     }
42.     camera.close();
43.     return 0;
44. }
45. catch (ob::Error& e) {
46.     std::cerr << "function:" << e.getName() << "\nargs:" << e.getArgs() << "\nmessage:" << e.getMessage() << "\ntype:" << e.getExceptionType() << std::endl;
47.     exit(EXIT_FAILURE);
48. }

复制代码

末了，新建一个CMakeLists.txt设置我们的环境，如下所示，必要根据现真相况修改OpenCV_DIR、OrbbecSDK_ROOT_DIR、Open3D_DIR，

1. cmake_minimum_required(VERSION 3.10)
3. project(orbbec)
5. add_definitions(-std=c++11)
6. add_definitions(-DAPI_EXPORTS)
7. set(CMAKE_CXX_STANDARD 11)
8. set(CMAKE_BUILD_TYPE Release)
9. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/bin)
11. include_directories(include/)
12. link_directories(lib/) #添加特定的库文件搜索路径 相当于g++的 -L参数
14. include_directories(${PROJECT_SOURCE_DIR}/src/)
15. file(GLOB_RECURSE SRCS ${PROJECT_SOURCE_DIR}/src/*.cpp)
17. #opencv
18. Set(OpenCV_DIR D:/Project/opencv/build/)
19. find_package(OpenCV)
20. include_directories(${OpenCV_INCLUDE_DIRS})
21. include_directories(${OpenCV_DIR}/include/)
22. link_directories(${OpenCV_DIR}/x64/vc15/lib/)
24. #orbbec
25. set(OrbbecSDK_ROOT_DIR D:/Project/OrbbecSDK/SDK)
26. set(OrbbecSDK_LIBRARY_DIRS ${OrbbecSDK_ROOT_DIR}/lib)
27. set(OrbbecSDK_INCLUDE_DIR ${OrbbecSDK_ROOT_DIR}/include)
28. include_directories(${OrbbecSDK_INCLUDE_DIR})
29. link_directories(${OrbbecSDK_LIBRARY_DIRS})
31. #open3d
32. Set(Open3D_DIR D:/Project/open3d-0.18.0/CMake/)
33. find_package( Open3D  REQUIRED)
34. include_directories(${Open3D_INCLUDE_DIRS})
35. link_directories(${Open3D_LIBRARY_DIRS})
37. add_executable(test main1_test_camera.cpp ${SRCS})
38. target_link_libraries(test OrbbecSDK ${OpenCV_LIBS})
39. target_link_libraries(test ${Open3D_LIBRARIES})
40. target_include_directories(test PUBLIC ${Open3D_INCLUDE_DIRS})

复制代码

末了，利用Cmake-gui与vs2019天生可实行文件即可，运行步伐时间将这3个dll文件放在test.exe的同级目次即可。

2 YOLO11S-SEG的onnxruntime推理

 直接上代码，起首创建Segment.h，用来界说推理用到的函数，如下

1. #ifndef SEGMENT_H
2. #define SEGMENT_H
3. #include <fstream>
4. #include <sstream>
5. #include <iostream>
6. #include <opencv2/imgproc.hpp>
7. #include <opencv2/highgui.hpp>
8. //#include <cuda_provider_factory.h>
9. #include <onnxruntime_cxx_api.h>
10. #include <chrono>
11. using namespace std;
12. using namespace Ort;
13. struct BoxInfo
14. {
15.         float x;
16.         float y;
17.         float w;
18.         float h;
19.         float score;
20.         int label;
21.         float mask[32];
22. };
24. struct Net_config
25. {
26.         float confThreshold; // Confidence threshold
27.         float nmsThreshold;  // Non-maximum suppression threshold
28.         std::string modelpath;
29.         std::string labelpath;
30. };
32. constexpr static int num_class = 1;//我们只有一类就是1，多类就要改这儿
33. const static int kOutputSize = num_class + 4 + 32;
34. class YOLOV8
35. {
36. public:
37.         YOLOV8(Net_config config);//加载模型
38.         void preprocess_img(cv::Mat& img, cv::Mat& dis, int input_w, int input_h);//将图像letterbox resize到640*640
39.         void normalize_(cv::Mat img);//除以255，归一化，同时将rgbrgbrgb转成rrrgggbbb
40.         void detect(cv::Mat& frame, std::vector<BoxInfo>& generate_boxes, std::vector<cv::Mat>& masks);//输入图像进行检测与后处理
41.         //得到每个目标的检测框与每个目标的mask1
42.         float iou(float lbox[4], float rbox[4]);//iou计算
43.         void nms(vector<BoxInfo>& input_boxes);//nms
45.         std::vector<cv::Mat> process_mask(const float* proto, int proto_size, std::vector<BoxInfo>& dets, cv::Mat img);//后处理得到mask
46.         cv::Rect get_downscale_rect(float bbox[4], float scale);//将640*640输入的box尺寸下采样到160*160的特征图上
47.         cv::Mat scale_mask(cv::Mat mask, cv::Mat img); // 将640 * 640输入得到的掩码还原到原图上, 很好理解，就跟processimg反着操作
48.         cv::Rect get_rect(cv::Mat& img, float bbox[4]);// 将640 * 640输入得到的box还原到原图上, 很好理解，就跟processimg反着操作
49.        
50.        
52. private:
53.         int inpWidth;
54.         int inpHeight;
55.         int nout;
56.         int num_proposal;
57.         std::vector<string> class_names;
58.         float confThreshold;
59.         float nmsThreshold;
60.         std::vector<float> input_image_;//ONNXRUMTIME接收的数据是一个vector
61.        
62.         Env env = Env(ORT_LOGGING_LEVEL_ERROR, "YOLOV8");
63.         Ort::Session* ort_session = nullptr;
64.         SessionOptions sessionOptions = SessionOptions();
65.         std::vector<char*> input_names;
66.         std::vector<char*> output_names;
67.         std::vector<vector<int64_t>> input_node_dims; // >=1 outputs
68.         std::vector<vector<int64_t>> output_node_dims; // >=1 outputs
69.         const std::vector<uint32_t> colors = { 0xFF3838, 0xFF9D97, 0xFF701F, 0xFFB21D, 0xCFD231, 0x48F90A,
70.                                                                                 0x92CC17, 0x3DDB86, 0x1A9334, 0x00D4BB, 0x2C99A8, 0x00C2FF,
71.                                                                                 0x344593, 0x6473FF, 0x0018EC, 0x8438FF, 0x520085, 0xCB38FF,
72.                                                                                 0xFF95C8, 0xFF37C7 };
73. };
74. #endif

复制代码

然后新建Segment.cpp开详细实现这些函数，代码如下：

1. #include "Segment.h"
3. YOLOV8::YOLOV8(Net_config config)
4. {
5.         confThreshold = config.confThreshold;
6.         nmsThreshold = config.nmsThreshold;
7.         string classesFile = config.labelpath;
8.         string model_path = config.modelpath;
9.         std::wstring widestr = std::wstring(model_path.begin(), model_path.end());
10.         OrtStatus* status = OrtSessionOptionsAppendExecutionProvider_CUDA(sessionOptions, 0);
11.         sessionOptions.SetGraphOptimizationLevel(ORT_ENABLE_BASIC);
12.         ort_session = new Session(env, widestr.c_str(), sessionOptions);
13.         size_t numInputNodes = ort_session->GetInputCount();
14.         size_t numOutputNodes = ort_session->GetOutputCount();
16.         AllocatorWithDefaultOptions allocator;
17.         for (int i = 0; i < numInputNodes; i++)
18.         {
19.                 AllocatedStringPtr input_name_Ptr = ort_session->GetInputNameAllocated(i, allocator);
20.                 input_names.push_back(input_name_Ptr.get());
22.                 Ort::TypeInfo input_type_info = ort_session->GetInputTypeInfo(i);
23.                 auto input_tensor_info = input_type_info.GetTensorTypeAndShapeInfo();
24.                 auto input_dims = input_tensor_info.GetShape();
25.                 input_node_dims.push_back(input_dims);
26.         }
27.         for (int i = 0; i < numOutputNodes; i++)
28.         {
29.                 AllocatedStringPtr output_name_Ptr = ort_session->GetOutputNameAllocated(i, allocator);
30.                 output_names.push_back(output_name_Ptr.get());
32.                 Ort::TypeInfo output_type_info = ort_session->GetOutputTypeInfo(i);
33.                 auto output_tensor_info = output_type_info.GetTensorTypeAndShapeInfo();
34.                 auto output_dims = output_tensor_info.GetShape();
35.                 output_node_dims.push_back(output_dims);
36.         }
37.         inpHeight = input_node_dims[0][2];
38.         inpWidth = input_node_dims[0][3];
39.         nout = output_node_dims[0][1];
40.         num_proposal = output_node_dims[0][2];
42.         ifstream ifs(classesFile.c_str());
43.         string line;
44.         while (getline(ifs, line))  class_names.push_back(line);
45.         printf("classsize is:%d\n", num_class);
46.         assert(num_class = class_names.size());
47. }
48. cv::Rect YOLOV8::get_rect(cv::Mat& img, float bbox[4]) {
49.         float l, r, t, b;
50.         float r_w = inpWidth / (img.cols * 1.0);
51.         float r_h = inpHeight / (img.rows * 1.0);//inpHeight inpWidth
52.         if (r_h > r_w) {
53.                 l = bbox[0] - bbox[2] / 2.f;
54.                 r = bbox[0] + bbox[2] / 2.f;
55.                 t = bbox[1] - bbox[3] / 2.f - (inpHeight - r_w * img.rows) / 2;
56.                 b = bbox[1] + bbox[3] / 2.f - (inpHeight - r_w * img.rows) / 2;
57.                 l = l / r_w;
58.                 r = r / r_w;
59.                 t = t / r_w;
60.                 b = b / r_w;
61.         }
62.         else {
63.                 l = bbox[0] - bbox[2] / 2.f - (inpWidth - r_h * img.cols) / 2;
64.                 r = bbox[0] + bbox[2] / 2.f - (inpWidth - r_h * img.cols) / 2;
65.                 t = bbox[1] - bbox[3] / 2.f;
66.                 b = bbox[1] + bbox[3] / 2.f;
67.                 l = l / r_h;
68.                 r = r / r_h;
69.                 t = t / r_h;
70.                 b = b / r_h;
71.         }
72.         return cv::Rect(round(l), round(t), round(r - l), round(b - t));
73. }
75. cv::Rect YOLOV8::get_downscale_rect(float bbox[4], float scale) {
76.         float left = bbox[0] - bbox[2] / 2;
77.         float top = bbox[1] - bbox[3] / 2;
78.         float right = bbox[0] + bbox[2] / 2;
79.         float bottom = bbox[1] + bbox[3] / 2;
80.         left /= scale;
81.         top /= scale;
82.         right /= scale;
83.         bottom /= scale;
84.         return cv::Rect(round(left), round(top), round(right - left), round(bottom - top));
85. }
87. cv::Mat YOLOV8::scale_mask(cv::Mat mask, cv::Mat img) {
88.         int x, y, w, h;
89.         float r_w = inpWidth / (img.cols * 1.0);
90.         float r_h = inpHeight / (img.rows * 1.0);
91.         if (r_h > r_w) {
92.                 w = inpWidth;
93.                 h = r_w * img.rows;
94.                 x = 0;
95.                 y = (inpHeight - h) / 2;
96.         }
97.         else {
98.                 w = r_h * img.cols;
99.                 h = inpHeight;
100.                 x = (inpWidth - w) / 2;
101.                 y = 0;
102.         }
103.         cv::Rect r(x, y, w, h);
104.         cv::Mat res;
105.         cv::resize(mask(r), res, img.size());
107.         return res;
108. }
110. std::vector<cv::Mat> YOLOV8::process_mask(const float* proto, int proto_size, std::vector<BoxInfo>& dets, cv::Mat img) {
111.         std::vector<cv::Mat> masks;
112.         //proto 32x(H/4)x(W/4)
113.         //auto start = std::chrono::system_clock::now();
114.         for (size_t i = 0; i < dets.size(); i++) {
115.                 cv::Mat mask_mat = cv::Mat::zeros(inpHeight / 4, inpWidth / 4, CV_8UC1);//160*160
116.                 float bbox[4] = { dets[i].x, dets[i].y, dets[i].w, dets[i].h };
117.                 auto r = get_downscale_rect(bbox, 4);//将640*640输入的box尺寸下采样到160*160的特征图上
118.                 for (int x = r.x; x < r.x + r.width; x++) {
119.                         for (int y = r.y; y < r.y + r.height; y++) {
120.                                 float e = 0.0f;
121.                                 for (int j = 0; j < 32; j++) {
122.                                         //1x32 x 1*32*160*160 =1*160*160 可以理解成160*160特征图上的每一个像素有32个值，要与mask的32个值分别相乘再相加
123.                                         //而1*32*160*160在内存中的存储方式是160*160 160*160 160*160 .... 因此每次乘法操作的时候都要跳过160*160个内存空间
125.                                         e += dets[i].mask[j] * proto[j * proto_size / 32 + y * mask_mat.cols + x];
126.                                 }
127.                                 e = 1.0f / (1.0f + expf(-e));
128.                                 if (e > 0.5) {
129.                                         mask_mat.at<uchar>(y, x) = 1;
130.                                 }
131.                         }
132.                 }
133.                 //160*160的掩码resize到640*640上
134.                 cv::resize(mask_mat, mask_mat, cv::Size(inpWidth, inpHeight), 0, 0, 1);
135.                 //再将640*640的掩码还原到原图上,很好理解，就跟processimg反着操作
136.                 cv::Mat img_mask = scale_mask(mask_mat, img);
137.                 //将640*640的box还原到原图上,很好理解，就跟processimg反着操作
138.                 r = get_rect(img, bbox);
139.                 cv::Rect holeImgRect(0, 0, img.cols, img.rows);
140.                 r = r & holeImgRect;
141.                 dets[i].x = r.x;
142.                 dets[i].y = r.y;
143.                 dets[i].w = r.width;
144.                 dets[i].h = r.height;
145.                 masks.push_back(img_mask);
147.         }
148.         return masks;
149. }
150. void YOLOV8::normalize_(cv::Mat img)
151. {
152.         int row = img.rows;
153.         int col = img.cols;
154.         input_image_.resize(row * col * img.channels());
155.         // bgrbgrbgr to rrrgggbbb
156.         for (int c = 0; c < 3; c++)
157.         {
158.                 for (int i = 0; i < row; i++)
159.                 {
160.                         for (int j = 0; j < col; j++)
161.                         {
162.                                 float pix = img.ptr<uchar>(i)[j * 3 + 2 - c];
163.                                 input_image_[c * row * col + i * col + j] = pix / 255.0;
164.                         }
165.                 }
166.         }
167. }
168. float YOLOV8::iou(float lbox[4], float rbox[4]) {
169.         float interBox[] = {
170.           (std::max)(lbox[0] - lbox[2] / 2.f , rbox[0] - rbox[2] / 2.f), //left
171.           (std::min)(lbox[0] + lbox[2] / 2.f , rbox[0] + rbox[2] / 2.f), //right
172.           (std::max)(lbox[1] - lbox[3] / 2.f , rbox[1] - rbox[3] / 2.f), //top
173.           (std::min)(lbox[1] + lbox[3] / 2.f , rbox[1] + rbox[3] / 2.f), //bottom
174.         };
176.         if (interBox[2] > interBox[3] || interBox[0] > interBox[1])
177.                 return 0.0f;
179.         float interBoxS = (interBox[1] - interBox[0]) * (interBox[3] - interBox[2]);
180.         return interBoxS / (lbox[2] * lbox[3] + rbox[2] * rbox[3] - interBoxS);
181. }
182. void YOLOV8::nms(vector<BoxInfo>& input_boxes)
183. {
184.         sort(input_boxes.begin(), input_boxes.end(), [](BoxInfo a, BoxInfo b) { return a.score > b.score; });
186.         vector<bool> isSuppressed(input_boxes.size(), false);
187.         for (int i = 0; i < int(input_boxes.size()); ++i)
188.         {
189.                 if (isSuppressed[i]) { continue; }
190.                 for (int j = i + 1; j < int(input_boxes.size()); ++j)
191.                 {
192.                         if (isSuppressed[j]) { continue; }
193.                         float lbox[4] = { input_boxes.at(i).x,input_boxes.at(i).y,input_boxes.at(i).w,input_boxes.at(i).h };
194.                         float rbox[4] = { input_boxes.at(j).x,input_boxes.at(j).y,input_boxes.at(j).w,input_boxes.at(j).h };
195.                         float ovr = iou(lbox, rbox);
196.                         if (ovr >= nmsThreshold)
197.                         {
198.                                 isSuppressed[j] = true;
199.                         }
200.                 }
201.         }
202.         int idx_t = 0;
203.         input_boxes.erase(remove_if(input_boxes.begin(), input_boxes.end(), [&idx_t, &isSuppressed](const BoxInfo& f) { return isSuppressed[idx_t++]; }), input_boxes.end());
204. }
205. void YOLOV8::preprocess_img(cv::Mat& img, cv::Mat& dis, int input_w, int input_h) {
206.         int w, h, x, y;
207.         float r_w = input_w / (img.cols * 1.0);
208.         float r_h = input_h / (img.rows * 1.0);
209.         if (r_h > r_w) {//宽大于高
210.                 w = input_w;
211.                 h = r_w * img.rows;
212.                 x = 0;
213.                 y = (input_h - h) / 2;
214.         }
215.         else {
216.                 w = r_h * img.cols;
217.                 h = input_h;
218.                 x = (input_w - w) / 2;
219.                 y = 0;
220.         }
221.         cv::Mat re(h, w, CV_8UC3);
222.         cv::resize(img, re, re.size(), 0, 0, cv::INTER_LINEAR);
223.         cv::Mat out(input_h, input_w, CV_8UC3, cv::Scalar(128, 128, 128));
224.         re.copyTo(out(cv::Rect(x, y, re.cols, re.rows)));
225.         out.copyTo(dis);
227. }
229. void YOLOV8::detect(cv::Mat& frame, vector<BoxInfo>& generate_boxes,std::vector<cv::Mat>& masks)
230. {
231.         cv::Mat dstimg;
232.         preprocess_img(frame, dstimg, inpWidth, inpHeight);
233.         normalize_(dstimg);
234.         array<int64_t, 4> input_shape_{ 1, 3,  inpHeight,  inpWidth };
235.         auto allocator_info = MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU);
236.         Value input_tensor_ = Value::CreateTensor<float>(allocator_info, input_image_.data(), input_image_.size(), input_shape_.data(), input_shape_.size());
237.         // 开始推理
238.         const std::array<const char*, 1> inputNames = { "images" };
239.         const std::array<const char*, 2> outNames = { "output0","output1" };
240.         vector<Value> ort_outputs = ort_session->Run(Ort::RunOptions{ nullptr }, inputNames.data(), &input_tensor_, 1, outNames.data(), outNames.size());
241.         /////generate proposals
242.         //vector<BoxInfo> generate_boxes;
243.         int n = 0, k = 0;
244.         const float* pdata = ort_outputs[0].GetTensorMutableData<float>();// 1 * 116 *8400
245.         const float* pdata1 = ort_outputs[1].GetTensorMutableData<float>();//1*32*160*160 mask propsal
246.         for (n = 0; n < num_proposal; n++)
247.         {
248.                 float out[kOutputSize];//4+class+32
249.                 float mask[32];
250.                 for (int j = 0; j < nout; j++) {
251.                         out[j] = pdata[n + num_proposal * j];
252.                 }
253.                 memcpy(&mask, &out[4 + num_class], 32 * sizeof(float));
254.                 int max_ind = 0;
255.                 float max_class_socre = 0;
256.                 // 计算最大的置信度得分
257.                 for (k = 0; k < num_class; k++)
258.                 {
259.                         if (out[k + 4] > max_class_socre)
260.                         {
261.                                 max_class_socre = out[k + 4];
262.                                 max_ind = k;
263.                         }
264.                 }
266.                 if (max_class_socre > confThreshold)
267.                 {
268.                         float cx = out[0];
269.                         float cy = out[1];
270.                         float w = out[2];
271.                         float h = out[3];
272.                         BoxInfo det;
273.                         det.x = cx;
274.                         det.y = cy;
275.                         det.w = w;
276.                         det.h = h;
277.                         det.score = max_class_socre;
278.                         det.label = max_ind;
279.                         for (int jj = 0; jj < 32; jj++) {
280.                                 det.mask[jj] = mask[jj];
281.                         }
283.                         generate_boxes.push_back(det);
284.                 }
285.         }
286.         nms(generate_boxes);
287.         int kOutputSize2 = 32 * (inpHeight / 4) * (inpWidth / 4);
288.         masks = process_mask(pdata1, kOutputSize2, generate_boxes, frame);
290.         // draw at original frame
292.         for (size_t i = 0; i < generate_boxes.size(); i++) {
294.                 cv::Mat img_mask = masks[i];
295.                 auto color = colors[(int)generate_boxes[i].label % colors.size()];
296.                 auto bgr = cv::Scalar(color & 0xFF, color >> 8 & 0xFF, color >> 16 & 0xFF);
297.                 cv::Rect r = cv::Rect((int)generate_boxes[i].x, (int)generate_boxes[i].y, (int)generate_boxes[i].w, (int)generate_boxes[i].h);
298.                 cv::rectangle(frame, r, bgr, 2);
299.                 // mask 画原图上
300.                 for (int x = r.x; x < r.x + r.width; x++) {
301.                         for (int y = r.y; y < r.y + r.height; y++) {
302.                                 float val = img_mask.at<uchar>(y, x);
303.                                 if (val == 0) continue;
304.                                 frame.at<cv::Vec3b>(y, x)[0] = frame.at<cv::Vec3b>(y, x)[0] / 2 + bgr[0] / 2;
305.                                 frame.at<cv::Vec3b>(y, x)[1] = frame.at<cv::Vec3b>(y, x)[1] / 2 + bgr[1] / 2;
306.                                 frame.at<cv::Vec3b>(y, x)[2] = frame.at<cv::Vec3b>(y, x)[2] / 2 + bgr[2] / 2;
307.                         }
308.                 }
310.                 char label[100];
311.                 sprintf(label, "%s:%.2f", class_names[generate_boxes[i].label], generate_boxes[i].score);
312.                 cv::putText(frame, label, cv::Point(r.x, r.y - 4), cv::FONT_HERSHEY_PLAIN, 1.2, cv::Scalar(128, 128, 255), 2);
314.         }
315. }

复制代码

然后再创建一个主步伐，叫main.cpp用来调用这些步伐，代码如下：

2. #include <iostream>
3. #include <chrono>
4. #include <cmath>
5. #include <assert.h>
6. #include "Segment.h"
7. #include "camera.h"
8. #include <stdio.h>
9. using namespace std;
11. int main(int argc, char** argv) {
12.     Net_config YOLOV8_nets = { 0.9, 0.5,
13.             "D:/Project/inference/Orbbec_example/model/kuaidi.onnx" ,
14.             "D:/Project/inference/Orbbec_example/model/kuaidi.names" };
15.     YOLOV8 net(YOLOV8_nets);
16.     Orbbec camera;
17.     camera.Init();
19.     while (1){
20.         cv::Mat src, dep;
21.         if (!camera.GetRgbAndDepth(src, dep)) {
22.             continue;
23.         }
24.         cv::Mat show = src.clone();
25.         // Run inference
26.         auto start = std::chrono::system_clock::now();
27.         std::vector<BoxInfo> res;
28.         std::vector<cv::Mat> masks;
29.         net.detect(src, res, masks);
30.         auto end = std::chrono::system_clock::now();
31.         std::cout << "inference time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
32.         if (res.size()==0){printf("no target detect\n");}
33.         cv::imshow("reult", src);
34.         char c = cv::waitKey(1);
36.         for (int i = 0; i < res.size(); i++){
37.             int box[4] = { (int)res[i].x, (int)res[i].y,(int)(res[i].x + res[i].w),(int)(res[i].y + res[i].h) };
38.             cv::Mat mask = masks[i].clone();
39.             float result[10] = { 0 };
40.             camera.Postprocess(box, mask, src, result);
41.             cv::Point p1((int)(0.5 * box[0] + 0.5 * box[2]), (int)(0.5 * box[1] + 0.5 * box[3]));
42.             cv::circle(show, p1, 3, cv::Scalar(0, 255, 255), 3);//center point
43.             cv::Point p2((int)result[6], (int)result[7]);
44.             cv::circle(show, p2, 3, cv::Scalar(0, 0, 255), 3);//pick point   
45.             cv::Rect rdraw0 = cv::Rect((int)box[0], (int)box[1], (int)(box[2] - box[0]), (int)(box[3] - box[1]));
46.             cv::rectangle(show, rdraw0, cv::Scalar(0, 255, 255), 2);//detect box
47.             cv::Rect rdraw1 = cv::Rect((int)(result[6] - 0.5 * result[8]), (int)(result[7] - 0.5 * result[9]),
48.                 (int)result[8], (int)result[9]);
49.             cv::rectangle(show, rdraw1, cv::Scalar(0, 0, 255), 2);//postprocess box
50.         }
51.         printf("-------------------------------------------------\n");
52.         cv::imshow("show", show);
53.         c = cv::waitKey(1);
54.         if (c == 27) {
55.             cv::destroyAllWindows();
56.             break;
57.         }
58.    
59.     }
60.   
61.   camera.close();
62.   printf("exit prgram\n");
63.   return 0;
64. }

复制代码

改写以下CMakeLists.txt，使其可以同时利用1.2与这一章节，如下：

1. cmake_minimum_required(VERSION 3.10)
3. project(orbbec)
5. add_definitions(-std=c++11)
6. add_definitions(-DAPI_EXPORTS)
7. set(CMAKE_CXX_STANDARD 11)
8. set(CMAKE_BUILD_TYPE Release)
9. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/bin)
11. include_directories(include/)
12. link_directories(lib/) #添加特定的库文件搜索路径 相当于g++的 -L参数
14. include_directories(${PROJECT_SOURCE_DIR}/src/)
15. file(GLOB_RECURSE SRCS ${PROJECT_SOURCE_DIR}/src/*.cpp)
17. #opencv
18. Set(OpenCV_DIR D:/Project/opencv/build/)
19. find_package(OpenCV)
20. include_directories(${OpenCV_INCLUDE_DIRS})
21. include_directories(${OpenCV_DIR}/include/)
22. link_directories(${OpenCV_DIR}/x64/vc15/lib/)
24. #orbbec
25. set(OrbbecSDK_ROOT_DIR D:/Project/OrbbecSDK/SDK)
26. set(OrbbecSDK_LIBRARY_DIRS ${OrbbecSDK_ROOT_DIR}/lib)
27. set(OrbbecSDK_INCLUDE_DIR ${OrbbecSDK_ROOT_DIR}/include)
28. include_directories(${OrbbecSDK_INCLUDE_DIR})
29. link_directories(${OrbbecSDK_LIBRARY_DIRS})
30. #open3d
31. Set(Open3D_DIR D:/Project/open3d-0.18.0/CMake/)
32. find_package( Open3D  REQUIRED)
33. include_directories(${Open3D_INCLUDE_DIRS})
34. link_directories(${Open3D_LIBRARY_DIRS})
36. #onnxruntinme
37. Set(ONNXRUNTIME_ROOT_DIR D:/Project/onnxruntime-win-x64-gpu-1.14.0/)
38. include_directories(${ONNXRUNTIME_ROOT_DIR}/include/)
39. link_directories(${ONNXRUNTIME_ROOT_DIR}/lib/)
41. add_executable(test main1_test_camera.cpp ${SRCS})
42. target_link_libraries(test OrbbecSDK ${OpenCV_LIBS})
43. target_link_libraries(test ${Open3D_LIBRARIES})
44. target_include_directories(test PUBLIC ${Open3D_INCLUDE_DIRS})
45. target_link_libraries(test onnxruntime)
47. add_executable(main main.cpp ${SRCS})
48. target_link_libraries(main OrbbecSDK ${OpenCV_LIBS})
49. target_link_libraries(main ${Open3D_LIBRARIES})
50. target_include_directories(main PUBLIC ${Open3D_INCLUDE_DIRS})
51. target_link_libraries(main onnxruntime)

复制代码

 仍然基于cmake-gui与vs，天生对应的exe文件，运行exe的时间记得将下面几个dll拷贝到同一个目次下，否则会报错。

别的将camra.cpp中的ProcessPointcloud下面的改成1，就可以可视化抓取点与姿态。

3 结语

实测奥比中光的相机彩色图很暗，调了好久曝光参数啥的也没realsense的彩色图看起来真实。大概跟我买的相机型号有关。
末了说一下，这个博客的内容恰当有一点c++底子的食用，至少要会用cmake、vs嘛。