使用opencv4.1.0+cuda10.1实现yolo3实时目标检测

笔记本安装opencv和cuda，安装好了但是检测经常出错，绕了很多弯路，好在解决了，因此记录一下。

1.ubuntu18.04安装opencv4.1.0

参考这篇文章 ubuntu18.04安装opencv4.1.0

注意1：文章中第一步，一定要安装opencv_contrib，且版本要和你要安装的opencv一致，否则文章中的第三步编译opencv的cmake会编译不过，导致后面的make出错，显示：make: *** 没有指明目标并且找不到 makefile。

注意2：文章中的第二步，添加opencv所需要的依赖库中可能会出现“OpenCV安装libjasper-dev依赖包错误：E: Unable to locate package libjasper-dev”
解决办法：

sudo add-apt-repository "deb http://security.ubuntu.com/ubuntu xenial-security main"
sudo apt update
sudo apt install libjasper1 libjasper-dev

再运行：

sudo apt install libjasper1 libjasper-dev

注意3：编译过后然后在/usr/local/lib下可以看到编译的结果。
查看有没有缺少lib库，缺少的话，后面运行会提示缺少，通常按照前面的步骤，lib库不会缺少。

注意4：最后安装opencv-python
1.使用如下命令

pip install opencv-python

2.安装opencv-contrib-python
opencv-pyhon中只是包含了opencv的主要模块，很多比较新的高级的算法、某些不免费的算法如sift、surf特征点算法没有包含进去，如果你想使用这些功能，需要卸载opencv-python，然后安装opencv-contrib-python。

pip install opencv-contrib-python

将自动安装最新版本。

3.如何使用不免费的模块？
non-free算法目前仅在opencv-contrib-python3.4.2.17及以下的版本中可以使用。当然opencv本身并不收费，只不过如果你是在商业项目中使用non-free算法，那就需要交费了，因为算法的发明者申请并持有了该算法的专利。对于学生而言，平常的学习中一般还是会用到的：

pip install opencv-contrib-python==3.4.2.17

opencv-contrib-python3.4.2.17版本下载特别慢，建议从github或其他途径将.whl文件下载下来再进行安装。这里提供给大家供下载。

2.yolov3实时检测

将darknet下makefile文件中opencv=0改为opencv=1，重新回到darknet目录下进行make，可能会出现错误，如下：

./src/image_opencv.cpp:12:1: error:‘IplImage’ does not name a type; did you mean ‘image’ ? IplImage *image_to_ipl(image im)
^~~~~~~~~

解决办法：上面这个错误opencv版本兼容性问题。随着opencv版本的演化，c++11语法越来越占主流， 尤其到了opencv4后，基本上所有c语法都 被放弃了，都是类的概念。回到上面这个错误，IplImage是一个典型的c struct，在opencv2用的很多，opencv3用的比较少了，但支持。到了opencv4，该图像数据结构被摒弃，只能用Mat这个class来表示图像结构。
要想darknet在opencv4下面编译并能够运行，必须要将image_opencv.cpp做如上所示修改。

#ifdef OPENCV
 
#include "stdio.h"
#include "stdlib.h"
#include "opencv2/opencv.hpp"
#include "image.h"
 
using namespace cv;
 
extern "C" {
 
/*IplImage *image_to_ipl(image im)
{
    int x,y,c;
    IplImage *disp = cvCreateImage(cvSize(im.w,im.h), IPL_DEPTH_8U, im.c);
    int step = disp->widthStep;
    for(y = 0; y < im.h; ++y){
        for(x = 0; x < im.w; ++x){
            for(c= 0; c < im.c; ++c){
                float val = im.data[c*im.h*im.w + y*im.w + x];
                disp->imageData[y*step + x*im.c + c] = (unsigned char)(val*255);
            }
        }
    }
    return disp;
}
image ipl_to_image(IplImage* src)
{
    int h = src->height;
    int w = src->width;
    int c = src->nChannels;
    image im = make_image(w, h, c);
    unsigned char *data = (unsigned char *)src->imageData;
    int step = src->widthStep;
    int i, j, k;
    for(i = 0; i < h; ++i){
        for(k= 0; k < c; ++k){
            for(j = 0; j < w; ++j){
                im.data[k*w*h + i*w + j] = data[i*step + j*c + k]/255.;
            }
        }
    }
    return im;
}*/
 
Mat image_to_mat(image im)
{
    image copy = copy_image(im);
    constrain_image(copy);
    if(im.c == 3) rgbgr_image(copy);
 
	int x, y, c;
	Mat m = Mat(Size(im.w, im.h), CV_8UC(im.c));
	int step = m.step;
 
	for (y = 0; y < im.h; ++y) {
			for (x = 0; x < im.w; ++x) {
					for (c = 0; c < im.c; ++c) {
							float val = copy.data[c*im.h*im.w + y * im.w + x];
							m.data[y*step + x * im.c + c] = (unsigned char)(val * 255);
					}
			}
	}
 
/*    IplImage *ipl = image_to_ipl(copy);
    Mat m = cvarrToMat(ipl, true);
    cvReleaseImage(&ipl);*/
    free_image(copy);
    return m;
}
 
image mat_to_image(Mat m)
{
/*    IplImage ipl = m;
    image im = ipl_to_image(&ipl);
    rgbgr_image(im);*/
	int h = m.rows;
	int w = m.cols;
	int c = m.channels();
	image im = make_image(w, h, c);
	unsigned char *data = (unsigned char *)m.data;
	int step = m.step;
	int i, j, k;
 
	for (i = 0; i < h; ++i) {
			for (k = 0; k < c; ++k) {
					for (j = 0; j < w; ++j) {
							im.data[k*w*h + i * w + j] = data[i*step + j * c + k] / 255.;
					}
			}
	}
    if (im.c == 3) rgbgr_image(im);
	
    return im;
}
 
void *open_video_stream(const char *f, int c, int w, int h, int fps)
{
    VideoCapture *cap;
    if(f) cap = new VideoCapture(f);
    else cap = new VideoCapture(c);
    if(!cap->isOpened()) return 0;
    if(w) cap->set(CAP_PROP_FRAME_WIDTH, w);
    if(h) cap->set(CAP_PROP_FRAME_HEIGHT, w);
    if(fps) cap->set(CAP_PROP_FPS, w);
    return (void *) cap;
}
 
image get_image_from_stream(void *p)
{
    VideoCapture *cap = (VideoCapture *)p;
    Mat m;
    *cap >> m;
    if(m.empty()) return make_empty_image(0,0,0);
    return mat_to_image(m);
}
 
image load_image_cv(char *filename, int channels)
{
    int flag = -1;
    if (channels == 0) flag = -1;
    else if (channels == 1) flag = 0;
    else if (channels == 3) flag = 1;
    else {
        fprintf(stderr, "OpenCV can't force load with %d channels\n", channels);
    }
    Mat m;
    m = imread(filename, flag);
    if(!m.data){
        fprintf(stderr, "Cannot load image \"%s\"\n", filename);
        char buff[256];
        sprintf(buff, "echo %s >> bad.list", filename);
        system(buff);
        return make_image(10,10,3);
        //exit(0);
    }
    image im = mat_to_image(m);
    return im;
}
 
int show_image_cv(image im, const char* name, int ms)
{
    Mat m = image_to_mat(im);
    imshow(name, m);
    int c = waitKey(ms);
    if (c != -1) c = c%256;
    return c;
}
 
void make_window(char *name, int w, int h, int fullscreen)
{
    namedWindow(name, WINDOW_NORMAL); 
    if (fullscreen) {
        setWindowProperty(name, WND_PROP_FULLSCREEN, WINDOW_FULLSCREEN);
    } else {
        resizeWindow(name, w, h);
        if(strcmp(name, "Demo") == 0) moveWindow(name, 0, 0);
    }
}
 
}
 
#endif

参考文章如何将darknet在opencv4.1上编译运行通过。

注意 ：通过上面操作，在darknet下可以make通过，但是运行

./darknet detector demo cfg/coco.data cfg/yolov3.cfg yolov3.weights

会出现错误

yolov3 CUDA Error: out of memory darknet: ./src/cuda.c:36: check_error: Assertion `0' failed.

网上有用户称需要在./darknet 前加上sudo，我试了没有作用，然后在这篇文章中发现将darknet中的cfg中的yolov3cfg中

batch=64
subdivisions=8
width=608
height=608

改为：

batch=1
subdivisions=1
width=416
height=416

但是更改后可以运行多几行，但是还是显示out of memory.于是我继续将width和height改小改为width=320,height=320后，可以运行了，所以遇到此类问题可以尝试改width和height。

目前遇到的问题就是这些，现在解决了可以完美运行了，如果你们遇到其他相关问题或是此类问题不知如何解决，可以一起讨论。