OPENCV4笔记_opencv 4库

opencv4库编译

Mat对象

创建 Mat 对象
Mat 是一个非常优秀的图像类，它同时也是一个通用的矩阵类，可以用来创
建和操作多维矩阵。有多种方法创建一个 Mat 对象。
构造函数方法
Mat 类提供了一系列构造函数，可以方便的根据需要创建 Mat 对象。下面是
一个使用构造函数创建对象的例子。
Mat M(3,2, CV_8UC3, Scalar(0,0,255));
创建一个行数（高度）为 3，列数（宽度）为 2 的图像，图像元
素是 8 位无符号整数类型，且有三个通道。图像的所有像素值被初始化为(0, 0,
255)。由于 OpenCV 中默认的颜色顺序为 BGR，因此这是一个全红色的图像。

常用的构造函数有：
Mat::Mat() 无参数构造方法；
Mat::Mat(int rows, int cols, int type) 创建行数为 rows，列数为 col，类型为 type 的图像；
Mat::Mat(Size size, int type) 创建大小为 size，类型为 type 的图像；
Mat::Mat(int rows, int cols, int type, const Scalar& s)创建行数为 rows，列数为 col，类型为 type 的图像，并将所有元素初始
化为值 s；
Mat::Mat(Size size, int type, const Scalar& s) 创建大小为 size，类型为 type 的图像，并将所有元素初始化为值 s；
Mat::Mat(const Mat& m) 将 m 赋值给新创建的对象，此处不会对图像数据进行复制，m 和新对象
共用图像数据；
Mat::Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP) 创建行数为 rows，列数为 col，类型为 type 的图像，此构造函数不创建 图像数据所需内存，而是直接使用 data 所指内存，图像的行步长由 step 指定。
Mat::Mat(Size size, int type, void* data, size_t step=AUTO_STEP) 创建大小为 size，类型为 type 的图像，此构造函数不创建图像数据所需
内存，而是直接使用 data 所指内存，图像的行步长由 step 指定。
Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) 创建的新图像为 m 的一部分，具体的范围由 rowRange 和 colRange 指 定，此构造函数也不进行图像数据的复制操作，新图像与 m 共用图像数据；
Mat::Mat(const Mat& m, const Rect& roi) 创建的新图像为 m 的一部分，具体的范围 roi 指定，此构造函数也不进 行图像数据的复制操作，新图像与 m 共用图像数据。

这些构造函数中，很多都涉及到类型type。type可以是CV_8UC1，CV_16SC1，…，
CV_64FC4 等。里面的 8U 表示 8 位无符号整数，16S 表示 16 位有符号整数，64F
表示 64 位浮点数（即 double 类型）；C 后面的数表示通道数，例如 C1 表示一个
通道的图像，C4 表示 4 个通道的图像，以此类推。
如果你需要更多的通道数，需要用宏 CV_8UC(n)，例如：
Mat M(3,2, CV_8UC(5));//创建行数为 3，列数为 2，通道数为 5 的图像

opencv4图片操作

1. 图像类型转换和颜色模型转换

/**@brief:类型转换
// img2：目标图像
// CV_32F：目标数据类型
// 1 / 255.0：缩放因子，默认为1
// 0：偏移量，默认为0
*/
img.convertTo(img2, CV_32F, 1 / 255.0, 0);

/**@brief:颜色类型转换
COLOR_BGR2GRAY=6;     //彩色到灰度
COLOR_GRAY2BGR=8;     //灰度到彩色
COLOR_BGR2HSV=40;     //彩色到HSV
COLOR_HSV2BGR=54;     //HSV到彩色 
*/
cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 二值化

/**@brief:二值化或者叫做阈值分割
// src：目标Mat
// dst：处理之后的Mat
// thresh：分割阈值 < 最大值
// maxval：最大值通常是255
*/
cv::threshold(src, dst, thresh, maxval, cv::THRESH_BINARY_INV);
1
2
3
4
5
6
7

3. 图像模糊

/**@brief:均值滤波
// src：目标Mat
// dst：处理之后的Mat
// ksize：内核大小
// anchor ：锚点，默认(-1,-1)锚点在中心
// borderType ：
*/
void blur( InputArray src, OutputArray dst,Size ksize, Point anchor = Point(-1,-1),int borderType = BORDER_DEFAULT );

/**@brief:高斯滤波,去除高斯噪声
// src：目标Mat
// dst：处理之后的Mat
// ksize：内核大小 大小必须是大于1而且必须是奇数
// sigmaX：X方向滤波系数
// sigmaY :Y方向滤波系数
// borderType ：
*/
void GaussianBlur( InputArray src, OutputArray dst, Size ksize,double sigmaX, double sigmaY = 0,int borderType = BORDER_DEFAULT );

/**@brief:中值滤波,椒盐噪声有很好的抑制作用
// src：目标Mat
// dst：处理之后的Mat
// ksize：内核大小 大小必须是大于1而且必须是奇数
*/
void medianBlur( InputArray src, OutputArray dst, int ksize );

/**@brief:双边滤波 （边缘保护）
// src：目标Mat
// dst：处理之后的Mat
// d：滤波过程中每个像素邻域的直径
// sigmaColor：颜色空间滤波器的标准差值 参数越大表明该像素领域内有越多的颜色被混合到一起
// sigmaSpace:空间间坐标中滤波器的标准差值
// borderType ：
*/
void bilateralFilter( InputArray src, OutputArray dst, int d,double sigmaColor, double sigmaSpace,int borderType = BORDER_DEFAULT );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

4. 腐蚀和膨胀

//    getStructuringElement
//    参数1：结构元的形状（0：矩形结构元；1：十字架结构元；2：椭圆结构元）；
//    参数2：结构元大小（size（m, n））；
//    参数3：结构元中心点所在位置（point(x, y)）默认为中心点
cv::Mat se = cv::getStructuringElement(structType, cv::Size(), CV::Point()); 
/**@brief:膨胀
// src：目标Mat
// dst：处理之后的Mat
// se：滤波过程中每个像素邻域的直径
// point：锚点
// iterations:操作次数 数值越大效果越明显
*/
cv::dilate(src, dst, se, cv::Point(), iterations); //执行膨胀操作
// 腐蚀
cv::erode(src, dst, se, cv::Point(), iterations); //执行腐蚀操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5. 图像、视频读写和显示

/**@brief:读取图片
// filename：图片路径
第二个参数flag：
IMREAD_UNCHANGED：不对图像文件进行任何转换，直接读取；
IMREAD_GRAYSCALE：将任何图像均转换为灰度图像(单通道)进行读取；
IMREAD_COLOR：将任何图像均转为RGB彩色图像(三通道)进行读取；
IMREAD_ANYDEPTH：如果不设置这个参数，16/32位图像将会自动转为8位图像；
IMREAD_ANYCOLOR：将按照图像文件设定的颜色格式进行图像读取；
IMREAD_LOAD_GDAL：调用gdal库进行图像文件读取(可以简单地理解为读取TIFF图像文件)。
*/
Mat imread( const String& filename, int flags = IMREAD_COLOR );

/**@brief:图片弹窗显示
// winname：显示窗口的title
// mat：显示的mat
*/
void imshow(const String& winname, InputArray mat);

/**@brief:图片保存
// filename：保存的图片路径需要加后缀 xx/xx/.jpg
// img：保存的mat
// params ：默认可不写
*/
bool imwrite( const String& filename, InputArray img,
              const std::vector<int>& params = std::vector<int>());
/**@brief:视频读写代码段
// filename：保存的图片路径需要加后缀 xx/xx/.jpg
// img：保存的mat
// params ：默认可不写
*/
/*
 海康摄像头实时获取监控画面
    RTSP(Real Time Streaming Protocol)，是一种语法和操作类似HTTP协议，专用于音频和视频的应用协议，格式如下：
    rtsp://[username]:[password]@[ip]:[port]/[codes]/[channel]/[subtype]/av_stream
        1)username  用户名  
        2)password  密码
        3)ip        摄像头IP
        4)port      端口号
        5)codec     视频编码模式，常见的有h264,MPEG-4,mpeg4等
        6)channel   通道号，起始为1，例如通道1，则为ch1
        7)subtype   码流类型，主码流为main，辅码流为sub

    eg "rtsp://admin:kl88888888@192.168.30.166:554/h264/ch33/main/av_stram"
*/             
cv::VideoCapture stream = cv::VideoCapture(srtsp, cv::CAP_FFMPEG); // 读取hk网络相机的输入流
// cv::VideoCapture stream = cv::VideoCapture(String filepath); // 读取本地视频
// cv::VideoCapture stream = cv::VideoCapture(0); // 读取本地接入设备的视频
cv::VideoWriter wri;
wri.open("test_copy.avi", CV_FOURCC('M', 'P', '4', '2'), frameRate, cv::Size(width, height));
if (!stream.isOpened()){ // 判断打开是否成功
    std::cout << "open camera failed" << std::endl;
    return -1;
}

while (true){
    if (stream.read(frame)){ // 读取一帧
    	wri << frame;
        break;
    }
}
stream.release(); // 释放采集对象，相当于关闭视频源
wri.release();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

6. 图像翻转、锐化、亮度

/**@brief:调节亮度和对比度
// imgSrc：目标Mat
// imgDst：处理之后的Mat
// contrast：对比度值
// brightness：亮度值
*/
imgSrc.convertTo (imgDst,-1,contrast,brightness);
1
2
3
4
5
6
7

7. 图像边缘检测

/**@brief:Canny边缘检测
// image：目标Mat，要求是单通道灰度图
// edges：处理之后的Mat
// threshold1：滞后性阈值1 阈值1和2比例在1:2和1:3之间 100、300
// threshold2：滞后性阈值2
// apertureSize：算子的孔径的大小，默认值3.
// L2gradient:图像梯度复制的标识
*/
void Canny(InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)

/**@brief:拉普拉斯算子，对噪声比较敏感，因此常需要配合高斯滤波一起使用
// src：目标Mat
// dst：处理之后的Mat
// ddepth：图像深度，可取值-1、CV_16S、CV_32F、CV_64F
// ksize ：滤波器的大小，必须为正奇数
// scale ：缩放因子
// delta :偏值，在计算结果中加上偏值
// borderType
*/
void Laplacian( InputArray src, OutputArray dst, int ddepth,
                             int ksize = 1, double scale = 1, double delta = 0,
                             int borderType = BORDER_DEFAULT );

/**@brief:Sobel边缘检测
// image：目标Mat
// edges：处理之后的Mat
// ddepth：图像深度，可取值-1、CV_16S、CV_32F、CV_64F
// dx：x方向上的差分阶数
// dy：y方向上的差分阶数
// ksize:默认值是3，卷积核的大小，只能取1，3，5，7
// scale：计算导数时的可选尺度因子，默认值是1，表示默认情况下是没有应用缩放的
// delta：
// borderType
*/
void Sobel(InputArray src, OutputArray dst, int ddepth,int dx, int dy, int ksize=3 , double scale=1, double delta=0, int borderType=BORDER_DEFAULT) ;
//eg 原文链接：https://blog.csdn.net/xddwz/article/details/111597472
int main()
{
//    初始化x和y方向的梯度
    Mat grad_x, grad_y;
    Mat abs_grad_x, abs_grad_y;
 
    Mat srcImage;
    srcImage = imread("/Users/dwz/Desktop/cpp/1.jpg");
    cvtColor(srcImage, srcImage, COLOR_BGR2GRAY);
//    计算x方向的梯度
    Sobel(srcImage, grad_x,CV_16S, 1, 0, 3, 1, 0, BORDER_DEFAULT);
    convertScaleAbs(grad_x, abs_grad_x);
 
//    计算y方向的梯度
    Sobel(srcImage, grad_y, CV_16S, 0, 1, 3, 1, 0, BORDER_DEFAULT);
    convertScaleAbs(grad_y, abs_grad_y);
 
//    合并梯度
    Mat dstImage;
    addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, dstImage);
    imwrite("sobel.jpg", dstImage);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59