【米尔FZ3深度学习计算卡】视频流识别测试

day_day

（一）PC端测试
由于之前设备端版本不兼容的原因，因此想要现在PC端测试一下。PC端linux部署测试需要训练服务器版本，还需要额外申请一个序列号。
PC端编译与设备端基本相似，但运行的时候有问题，一直提示找不到库：

$ ./mysrc
./mysrc: error while loading shared libraries: libeasyedge.so.0.5.8: cannot open shared object file: No such file or directory

这是因为编译的时候cmake是指定路径来识别库的，而系统中又不像FZ3设备端直接在系统环境变量的路径内带有相关库，因此要在控制台暴露一下库的路径：

1. export LD_LIBRARY_PATH=../../lib/

复制代码

（二）PC端视频流
1-PC端又可以用我最熟悉的Qt了
只需要在pro文件里面加入opencv和百度AI相关的系统库即可：

1. LIBS += -L /usr/local/lib/libopencv_*.so
   
2. LIBS += -L ../../lib/lib*.so

复制代码

2-进行一些初始化配置

1.     global_controller()->set_licence_key("");
   
2. 
   
3.     // 1. 配置输出log
   
4.     EdgeLogConfig log_config;
   
5.     log_config.enable_debug = false;
   
6.     global_controller()->set_log_config(log_config);
   
7. 
   
8.     // 2. 设置识别配置
   
9.     PaddleFluidConfig config;
   
10. 
    
11.     // 2.1. 使用CPU预测
    
12.     config.use_gpu = false;
    
13. 
    
14.     // 2.2. 使用NVIDIA GPU预测；请务必下载GPU版本SDK
    
15. //    config.use_gpu = true;
    
16. //    config.fraction_of_gpu_memory = 0.2;
    
17. //    config.device = 0;
    
18. 
    
19. //    config.model_dir = argv[1];
    
20.     config.model_dir = "../../../../RES";
    
21. 
    
22.     // 3. 加载
    
23.     auto predictor = global_controller()->CreateEdgePredictor<PaddleFluidConfig>(config);
    
24. 
    
25.     // 4. 初始化
    
26.     if (predictor->init() != EDGE_OK)
    
27.     {
    
28.         exit(-1);
    
29.     }
    
30. 
    
31.     // 5.读取待识别图片路径
    
32. //    std::stringstream img_path;
    
33. ////    img_path << argv[2];
    
34. //    img_path << "1.jpg";
    
35. //    auto img = cv::imread(img_path.str().c_str());
    
36. 
    
37.     cv::Mat rgbImageL;
    
38.     cv::VideoCapture left_VideoCapture;
    
39.     left_VideoCapture.set(cv::CAP_PROP_FRAME_WIDTH,640);
    
40.     left_VideoCapture.set(cv::CAP_PROP_FRAME_HEIGHT,480);
    
41.     if(!left_VideoCapture.isOpened())
    
42.         left_VideoCapture.open(0);

复制代码

3-为了更好地展示，我将至保存为视频流

1.     cv::Size size = cv::Size(640,480);
   
2.     cv::VideoWriter Writer("dect_result2.avi", CV_FOURCC('D', 'I', 'V', 'X'), 1, size, true);
   

复制代码

4-识别时输出到视频流

1. 
   
2.     struct timeval tpstart, tpend;
   
3.     gettimeofday(&tpstart,NULL);
   
4. 
   
5.     while(true)
   
6.     {
   
7.         cv::Mat img;
   
8.         left_VideoCapture >> img;
   
9.         if(img.empty()) break;
   
10.         // 6.识别
    
11.         std::vector<EdgeResultData> result2;
    
12.         predictor->infer(img, result2);
    
13. 
    
14.         if (result2.empty()) {
    
15.             std::cerr << "Result is empty: " << std::endl;
    
16.         }
    
17.         int top = 0;
    
18.         for (auto &v : result2)
    
19.         {
    
20.             std::cout << v.index << ", " << v.label << ", p:" << v.prob;
    
21.             if (predictor->model_kind() == EdgeModelKind::kObjectDetection
    
22.                     || predictor->model_kind() == EdgeModelKind::kImageSegmentation
    
23.                     || predictor->model_kind() == EdgeModelKind::kFaceDetection)
    
24.             {
    
25.                 std::cout << " loc: "
    
26.                           << v.x1 << ", " << v.y1 << ", " << v.x2 << ", " << v.y2;
    
27.                 auto p1 = cv::Point(static_cast<int>(v.x1 * img.cols),
    
28.                                     static_cast<int>(v.y1 * img.rows));
    
29.                 auto p2 = cv::Point(static_cast<int>(v.x2 * img.cols),
    
30.                                     static_cast<int>(v.y2 * img.rows));
    
31.                 if(v.prob>0.8)
    
32.                     cv::rectangle(img, p1, p2, RED, 2);
    
33.                 else
    
34.                     cv::rectangle(img, p1, p2, PINK, 2);
    
35.                 if (predictor->model_kind() == EdgeModelKind::kFaceDetection) {
    
36.                     cv::putText(img, std::to_string(v.prob), p1, cv::FONT_HERSHEY_PLAIN, 0.8, GREEN, 1);
    
37.                 } else {
    
38.                     cv::putText(img, v.label, p1, cv::FONT_HERSHEY_PLAIN, 1, BLUE, 2);
    
39.                 }
    
40.             }
    
41. 
    
42.             // 图像分割画mask
    
43.             if (predictor->model_kind() == EdgeModelKind::kImageSegmentation)
    
44.             {
    
45.                 cv::Mat tmp(img.rows, img.cols, CV_8UC3, cv::Scalar(0, 0, 0));
    
46.                 cv::Vec3b random_color((v.index + 3) * 13 % 255,
    
47.                                        (v.index + 7) * 19 % 255,
    
48.                                        (v.index + 11) * 29 % 255);
    
49.                 for(int y = 0; y < tmp.rows; ++y)
    
50.                 {
    
51.                     for(int x = 0; x < tmp.cols; ++x)
    
52.                     {
    
53.                         if (v.mask.at<uint8_t>(y, x) == 1)
    
54.                         {
    
55.                             tmp.at<cv::Vec3b>(y, x) = random_color;
    
56.                         }
    
57.                     }
    
58.                 }
    
59. 
    
60.                 // 图片融合
    
61.                 cv::addWeighted(tmp, 0.95, img, 1, 0.0, img);
    
62.             }
    
63.             gettimeofday(&tpend,NULL);
    
64.             std::cout << std::endl;
    
65.         }
    
66.         if (predictor->model_kind() == EdgeModelKind::kObjectDetection
    
67.                 || predictor->model_kind() == EdgeModelKind::kImageSegmentation
    
68.                 || predictor->model_kind() == EdgeModelKind::kFaceDetection)
    
69.         {
    
70. //            img_path << ".result.jpg";
    
71. //            std::cout << "Write result to " << img_path.str() << std::endl;
    
72. //            cv::imwrite(img_path.str(), img);
    
73. //            cv::imwrite("dect_result.jpg", img);
    
74.             Writer.write(img);
    
75.             cv::imshow("dect result", img);
    
76.             if(cv::waitKey(30)=='q') break;
    
77.             static int i=0;
    
78.             i++;
    
79.             if(i>30) break;
    
80.         }
    
81. 
    
82.         std::cout << "\tuse time:"
    
83.                   << (tpend.tv_sec-tpstart.tv_sec) * 1000000 + (tpend.tv_usec - tpstart.tv_usec);
    
84.         tpstart = tpend;
    
85.         std::cout << std::endl;
    
86.     }
    
87.     Writer.release();
    
88.     std::cout << "Done" << std::endl;

复制代码

识别效果：


紫色部分是不足0.8置信度的，超过0.8置信度标为红色，可以看到效果还不错。

在识别图片的时候，PC端和设备端高性能模式下都是将近1s，但实际应用到视频的时候，只有开始的几帧耗时有些波动，其余都在300ms出头。



（三）设备端视频流尝试
设备端一上来就遭遇了滑铁卢：
显示报了一个mmap错误，然后设备干脆利落地死机了。
然后我改成录像再放到FZ3上，让opencv直接读avi视频文件，结果还是不行，依然死机：


估计是opencv的库在移植的时候没有适配解码部分的驱动。
但是转念一想，之前的帖子测试螺丝识别的时候是可以用摄像头的，打开其源码一看，果然没有那么简单：

1. int Camera::read_frame(void) {
   
2.     struct v4l2_buffer buf;
   
3.     unsigned int i = 0;
   
4. 
   
5.     CLEAR(buf);
   
6.     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
7.     buf.memory = V4L2_MEMORY_MMAP;
   
8. 
   
9.     if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
   
10.         switch (errno) {
    
11.         case EAGAIN:
    
12.             return 0;
    
13.         case EIO:
    
14.                 /* Could ignore EIO, see spec. */
    
15.                 /* fall through */
    
16.         default:
    
17.                 errno_exit("VIDIOC_DQBUF");
    
18.         }
    
19.     }
    
20. 
    
21.     process_image(buffers[buf.index].start, buf.bytesused);
    
22. 
    
23.     if (-1 == xioctl(fd, VIDIOC_QBUF, &buf)) {
    
24.         errno_exit("VIDIOC_QBUF");
    
25.     }
    
26.     return 0;
    
27. }

复制代码

这是使用v4l2来读的，初始化的时候还要初始化mmap，门槛还挺高的。

1. void Camera::init_mmap(void) {
   
2.     struct v4l2_requestbuffers req;
   
3.     CLEAR(req);
   
4. 
   
5.     req.count = 3;
   
6.     req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
7.     req.memory = V4L2_MEMORY_MMAP;
   
8. 
   
9.     if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
   
10.         if (EINVAL == errno) {
    
11.             fprintf(stderr, "%s does not support "
    
12.                      "memory mappingn", dev_name);
    
13.             exit(EXIT_FAILURE);
    
14.         } else {
    
15.             errno_exit("VIDIOC_REQBUFS");
    
16.         }
    
17.     }
    
18. 
    
19.     if (req.count < 2) {
    
20.         fprintf(stderr, "Insufficient buffer memory on %s\n",
    
21.                  dev_name);
    
22.         exit(EXIT_FAILURE);
    
23.     }
    
24.     buffers = (struct buffer*)calloc(req.count, sizeof(*buffers));
    
25.     if (!buffers) {
    
26.         fprintf(stderr, "Out of memory\\n");
    
27.         exit(EXIT_FAILURE);
    
28.     }
    
29. 
    
30.     for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
    
31.         struct v4l2_buffer buf;
    
32.         CLEAR(buf);
    
33. 
    
34.         buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
35.         buf.memory      = V4L2_MEMORY_MMAP;
    
36.         buf.index       = n_buffers;
    
37. 
    
38.         if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
    
39.             errno_exit("VIDIOC_QUERYBUF");
    
40. 
    
41.         buffers[n_buffers].length = buf.length;
    
42.         buffers[n_buffers].start =
    
43.                 mmap(NULL /* start anywhere */,
    
44.                       buf.length,
    
45.                       PROT_READ | PROT_WRITE /* required */,
    
46.                       MAP_SHARED /* recommended */,
    
47.                       fd, buf.m.offset);
    
48. 
    
49.         if (MAP_FAILED == buffers[n_buffers].start) {
    
50.             errno_exit("mmap");
    
51.         }         
    
52.     }
    
53. }

复制代码

。