1、OpenCV4环境搭建
-
VS2017新建一个控制台项目
-
配置包含目录
-
配置库目录
-
配置链接器
-
配置环境变量
-
重新启动VS2017
2、第一个图像显示程序
main.cpp
#include效果：
3、图像加载与保存
添加一个项目opencv4_001
将该项目设为启动项目
opencv4_001.cpp
#include效果：
4、认识Mat对象
depth：深度，即每一个像素的位数(bits)，在opencv的Mat.depth()中得到的是一个 0-6 的数字，分别代表不同的位数：enum{ CV_8U=0,CV_8S=1,CV_16U=2,CV_16S=3,CV_32S=4,CV_32F=5,CV_64F=6}；可见 0和1都代表8位，2和3都代表16位，4和5代表32位，6代表64位；
depth：深度，即每一个像素的位数(bits)，那么我们创建的时候就可以知道根据类型也就可以知道每个像素的位数，也就是知道了创建mat的深度。
图像深度(depth)
| 代表数字 | 图像深度 | 对应数据类型 |
|---|---|---|
| 0 | CV_8U | 8位无符号-字节类型 |
| 1 | CV_8S | 8位有符号-字节类型 |
| 2 | CV_16U | 16位无符号类型 |
| 3 | CV_16S | 16位有符号类型 |
| 4 | CV_32S | 32整型数据类型 |
| 5 | CV_32F | 32位浮点数类型 |
| 6 | CV_64F | 64位双精度类型 |
图像类型即图像深度与图像通道数组合，单通道图像类型代表的数字与图像深度相同，每增加一个通道，在单通道对应数字基础上加8。例如：单通道CV_8UC1=0，双通道CV_8UC2=CV8UC1+8=8，三通道CV_8UC3=CV8UC1+8+8=16。
图像类型(type(对应数字))
| 单通道 | 双通道 | 三通道 | 四通道 |
|---|---|---|---|
| CV_8UC1(0) | CV_8UC2(8) | CV_8UC3(16) | CV_8UC4(24) |
| CV_32SC1(4) | CV_32SC2(12) | CV_32SC3(20) | CV_32SC4(28) |
| CV_32FC1(5) | CV_32FC2(13) | CV_32FC3(21) | CV_32FC4(29) |
| CV_64FC1(6) | CV_64FC2(14) | CV_64FC3(22) | CV_64FC4(30) |
| CV_16SC1(3) | CV_16SC2(11) | CV_16SC3(19) | CV_16SC4(27) |
opencv4_002.cpp
#include效果：
5、Mat对象创建与使用
#include效果：
6、遍历与访问每个像素
#include(row, col); //Vec3i,Vec3f对应不同类型图像像素值
int blue = pixel[0];
int green = pixel[1];
int red = pixel[2];
src.at(row, col)[0] = 255 - blue; //BGR图像反转
src.at(row, col)[1] = 255 - green;
src.at(row, col)[2] = 255 - red;
}
if (ch == 1) {
int pv = src.at(row, col);
src.at(row, col) = 255 - pv;
}
}
}*/
Mat result = Mat::zeros(src.size(), src.type());
for (int row = 0; row < height; row++) { //使用指针遍历
uchar* current_row = src.ptr(row);
uchar* result_row = result.ptr(row); //使用指针控制图像复制输出
for (int col = 0; col < width; col++) {
if (dim == 3) {
int blue = *current_row++;
int green = *current_row++;
int red = *current_row++;
*result_row++ = blue;
*result_row++ = green;
*result_row++ = red;
}
if (dim == 1) {
int pv = *current_row++;
*result_row++ = pv;
}
}
}
//imshow("pixel-demo", src);
imshow("pixel-demo", result);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
1、通过行列遍历每个像素
2、使用指针遍历图像
7、图像的算术操作
#include效果：
1、不同图像加减乘除运算
2、图像亮度及对比度调整
8、图像位操作
位操作包括：与、或、非、异或，进行图像取反等操作时效率较高。
#include(row, col) = 127;
}
}
Mat dst; //图像取反
//mask表示ROI区域
//非操作
bitwise_not(src, dst, mask); //bitwise_not(输入图像，输出图像，进行图像取反的范围(对mask中不为0的部分对原图像进行取反))
imshow("bitwise_not", dst);
//与操作
bitwise_and(src, src, dst, mask);
imshow("bitwise_and", dst);
//或操作
bitwise_or(src, src, dst, mask);
imshow("bitwise_or", dst);
//异或操作，表示两幅图或操作后不相同的部分
bitwise_xor(src, src, dst, mask);
imshow("bitwise_xor", dst);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
9、像素信息统计
#include(row, col);
hist[pv]++;
}
}
//均值方差
Scalar s = mean(src);
printf("mean:%.2f,%.2f,%.2f\n", s[0], s[1], s[2]);
Mat mm, mstd;
meanStdDev(src, mm, mstd);
int rows = mstd.rows;
printf("rows:%d\n", rows);
printf("stddev:%.2f,%.2f,%.2f\n", mstd.at<double>(0, 0), mstd.at<double>(1, 0), mstd.at<double>(2, 0));
waitKey(0);
destroyAllWindows();
return 0;
}
效果一（最大最小值）：
效果二（均值方差）：
10、图形绘制与填充
#include效果：
11、图像通道合并与分离
#include mv; //通道分离保存的容器
split(src, mv);
int size = mv.size();
printf("number of channels:%d\n", size);
imshow("blue channel", mv[0]);
imshow("green channel", mv[1]);
imshow("red channel", mv[2]);
mv[1] = Scalar(0); //将mv[1]通道像素值都设为0
Mat dst;
merge(mv, dst);
imshow("result", dst);
Rect roi; //选取图像中的roi区域显示
roi.x = 100;
roi.y = 100;
roi.width = 250;
roi.height = 200;
Mat sub = src(roi);
imshow("roi", sub);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
12、图像直方图统计
#include mv; //通道分离保存的容器
split(src, mv);
int size = mv.size();
//计算直方图
int histSize = 256;
float range[] = { 0,255 };
const float* histRanges = { range };
Mat blue_hist, green_hist, red_hist;
calcHist(&mv[0], 1, 0, Mat(), blue_hist, 1, &histSize, &histRanges, true, false); //计算每个通道的直方图
calcHist(&mv[1], 1, 0, Mat(), green_hist, 1, &histSize, &histRanges, true, false);
calcHist(&mv[2], 1, 0, Mat(), red_hist, 1, &histSize, &histRanges, true, false);
Mat result = Mat::zeros(Size(600, 400), CV_8UC3);
int margin = 50;
int nm = result.rows - 2 * margin;
normalize(blue_hist, blue_hist, 0, nm, NORM_MINMAX, -1, Mat()); //将直方图进行归一化操作，映射到指定范围内
normalize(green_hist, green_hist, 0, nm, NORM_MINMAX, -1, Mat());
normalize(red_hist, red_hist, 0, nm, NORM_MINMAX, -1, Mat());
float step = 500.0 / 256.0;
for (int i = 0; i < 255; i++) { //循环遍历直方图每个像素值的数量，将相邻的两个像素值数量相连
line(result, Point(step*i + 50, 50 + nm - blue_hist.at<float>(i, 0)), Point(step*(i + 1) + 50, 50 + nm - blue_hist.at<float>(i + 1, 0)), Scalar(255, 0, 0), 2, LINE_AA, 0);
line(result, Point(step*i + 50, 50 + nm - green_hist.at<float>(i, 0)), Point(step*(i + 1) + 50, 50 + nm - green_hist.at<float>(i + 1, 0)), Scalar(0, 255, 0), 2, LINE_AA, 0);
line(result, Point(step*i + 50, 50 + nm - red_hist.at<float>(i, 0)), Point(step*(i + 1) + 50, 50 + nm - red_hist.at<float>(i + 1, 0)), Scalar(0, 0, 255), 2, 8, 0);
}
imshow("histgram-demo", result);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
13、图像直方图均衡化
#include效果：
14、图像直方图相似比较
对输入的两张图像计算得到直方图H1与H2，归一化到相同的尺度空间，然后可以通过计算H1与H2的之间的距离得到两个直方图的
相似度进而比较图像本身的相似程度。
OpenCV提供的比较方法有四种：
-
Correlation 相关性比较
-
Chi-Square 卡方比较
-
Intersection 十字交叉性
-
Bhattacharyya distance 巴氏距离
#include效果：
15、图像查找表与颜色表
LUT（Look Up Tables）：图像查找表。通过预先对每一个像素值对应的计算结果进行计算，将计算结果放在图像查找表中，在实际图像处理时，只需要查找每个像素在图像查找表中对应的结果即可，不需要再进行大量重复计算。
#include(i, 0) = color.at(10, i);
}
imshow("color", color);
Mat dst;
LUT(src, lut, dst); //使用自己的图像查找表
imshow("lut-demo", dst);
applyColorMap(src, dst, COLORMAP_COOL); //使用OpenCV内置的图像查找表
imshow("color-map", dst);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
16、图像卷积
#include(row - 1, col - 1)[0] + src.at(row - 1, col)[0] + src.at(row - 1, col + 1)[0] +
src.at(row, col - 1)[0] + src.at(row, col)[0] + src.at(row, col + 1)[0] +
src.at(row + 1, col - 1)[0] + src.at(row + 1, col)[0] + src.at(row + 1, col + 1)[0];
int sg = src.at(row - 1, col - 1)[1] + src.at(row - 1, col)[1] + src.at(row - 1, col + 1)[1] +
src.at(row, col - 1)[1] + src.at(row, col)[1] + src.at(row, col + 1)[1] +
src.at(row + 1, col - 1)[1] + src.at(row + 1, col)[1] + src.at(row + 1, col + 1)[1];
int sr = src.at(row - 1, col - 1)[2] + src.at(row - 1, col)[2] + src.at(row - 1, col + 1)[2] +
src.at(row, col - 1)[2] + src.at(row, col)[2] + src.at(row, col + 1)[2] +
src.at(row + 1, col - 1)[2] + src.at(row + 1, col)[2] + src.at(row + 1, col + 1)[2];
result.at(row, col)[0] = sb / 9;
result.at(row, col)[1] = sg / 9;
result.at(row, col)[2] = sr / 9;
}
}
imshow("conv-demo", result);
Mat dst;
blur(src, dst, Size(13, 13), Point(-1, -1), BORDER_DEFAULT); //锚定点Point坐标为负值时，默认取图像中心点
imshow("blur-demo", dst);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
17、卷积边缘处理
- 卷积处理时的边缘像素填充方法
| 填充类型 | 方法 |
|---|---|
| BORDER_CONSTANT | iiiiii|abcdefgh|iiiiiii |
| BORDER_REPLICATE | aaaaaa|abcdefgh|hhhhhhh |
| BORDER_WRAP | cdefgh|abcdefgh|abcdefg |
| BORDER_REFLECT_101（轴对称） | gfedcb|abcdefgh|gfedcba |
| BORDER_DEFAULT | gfedcb|abcdefgh|gfedcba |
#include(row - 1, col - 1)[0] + src.at(row - 1, col)[0] + src.at(row - 1, col + 1)[0] +
src.at(row, col - 1)[0] + src.at(row, col)[0] + src.at(row, col + 1)[0] +
src.at(row + 1, col - 1)[0] + src.at(row + 1, col)[0] + src.at(row + 1, col + 1)[0];
int sg = src.at(row - 1, col - 1)[1] + src.at(row - 1, col)[1] + src.at(row - 1, col + 1)[1] +
src.at(row, col - 1)[1] + src.at(row, col)[1] + src.at(row, col + 1)[1] +
src.at(row + 1, col - 1)[1] + src.at(row + 1, col)[1] + src.at(row + 1, col + 1)[1];
int sr = src.at(row - 1, col - 1)[2] + src.at(row - 1, col)[2] + src.at(row - 1, col + 1)[2] +
src.at(row, col - 1)[2] + src.at(row, col)[2] + src.at(row, col + 1)[2] +
src.at(row + 1, col - 1)[2] + src.at(row + 1, col)[2] + src.at(row + 1, col + 1)[2];
result.at(row, col)[0] = sb / 9;
result.at(row, col)[1] = sg / 9;
result.at(row, col)[2] = sr / 9;
}
}
imshow("conv-demo", result);
Mat dst;
blur(src, dst, Size(13, 13), Point(-1, -1), BORDER_DEFAULT); //锚定点Point坐标为负值时，默认取图像中心点
imshow("blur-demo", dst);
//边缘填充
int border = 8;
Mat border_m01, border_m02, border_m03;
copyMakeBorder(src, border_m01, border, border, border, border, BORDER_DEFAULT);
copyMakeBorder(src, border_m02, border, border, border, border, BORDER_CONSTANT, Scalar(0, 0, 255));
copyMakeBorder(src, border_m03, border, border, border, border, BORDER_WRAP);
imshow("border fill demo01", border_m01);
imshow("border fill demo02", border_m02);
imshow("border fill demo03", border_m03);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
18、图像模糊
#include效果：
19、自定义滤波
#include效果：
20、图像梯度
- 图像卷积
- 模糊
- 梯度：Sobel算子，Scharr算子，Robot算子
- 边缘
- 锐化
每种算子有两个，分别为x方向算子和y方向算子。
1、robot算子，最简单但效果最差
2、sobel算子，梯度检测效果较好，抗噪能力不如scharr算子
3、scharr算子，抗噪能力比sobel算子好但干扰信息较多
#include效果：
1、robot算子
2、sobel算子
3、scharr算子
21、图像边缘发现
拉普拉斯算子（二阶导数算子），对噪声敏感！
拉普拉斯运算模板
图像锐化
#include效果：
拉普拉斯边缘发现：
图像锐化：
22、USM锐化（Un Sharp Mask）
图像锐化增强：sharp_image = blur - laplacian
#include效果：
23、图像噪声
噪声类型：
- 椒盐噪声
- 高斯噪声
- 其他噪声...
#include(y, x) = Vec3b(255, 255, 255);
}
else {
src.at(y, x) = Vec3b(0, 0, 0);
}
}
imshow("salt and pepper noise", src);
//高斯噪声 正态分布的不同颜色的点
Mat noise = Mat::zeros(image.size(), image.type());
randn(noise, Scalar(25, 25, 25), Scalar(30, 30, 30));
Mat dst;
add(image, noise, dst);
imshow("gaussian noise", dst);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
24、图像去噪声
中值滤波与均值滤波示意图：
#include(y, x) = Vec3b(255, 255, 255);
}
else {
image.at(y, x) = Vec3b(0, 0, 0);
}
}
imshow("salt and pepper noise", image);
}
void add_gaussian_noise(Mat &image) {
//高斯噪声 正态分布的不同颜色的点
Mat noise = Mat::zeros(image.size(), image.type());
randn(noise, Scalar(25, 25, 25), Scalar(30, 30, 30));
Mat dst;
add(image, noise, dst);
imshow("gaussian noise", dst);
dst.copyTo(image);
}
效果：
椒盐噪声：
高斯噪声：
25、边缘保留滤波EPF（高斯噪声）
- 高斯双边滤波
- 除了空间位置核函数以外，增加了一个颜色差异和函数，当中心像素与其他像素颜色差异过大时，则w权重趋近于0，忽略该像素的影响，只对与中心像素颜色相近的像素进行高斯滤波
- 主要是降低像素值高的像素对像素值低的中心像素的影响，像素值高的像素权重低，最终中心像素的值仍然会保持较低。最终保持像素之间的差异。而像素值低的像素不管权重高低，对像素值高的中心像素本来影响都较小。
-
均值迁移滤波
-
非局部均值滤波
- 相似的像素块，权重比较大，不相似的像素块权重比较小
- 效果好，但运算量大，速度慢
-
局部均方差
#include(y, x) = Vec3b(255, 255, 255);
}
else {
image.at(y, x) = Vec3b(0, 0, 0);
}
}
imshow("salt and pepper noise", image);
}
void add_gaussian_noise(Mat &image) {
//高斯噪声 正态分布的不同颜色的点
Mat noise = Mat::zeros(image.size(), image.type());
randn(noise, Scalar(25, 25, 25), Scalar(30, 30, 30));
Mat dst;
add(image, noise, dst);
imshow("gaussian noise", dst);
dst.copyTo(image);
}
效果：
中值滤波、高斯滤波与双边滤波对高斯噪声的效果：
双边滤波对原图的效果：
调整后双边滤波与非局部均值滤波对原图的效果：
双边滤波与非局部均值滤波对高斯噪声的作用：
26、边缘提取
- 边缘法线：单位向量在该方向上图像像素强度变化最大。
- 边缘方向：与边缘法线垂直的向量方向。
- 边缘位置或者中心：图像边缘所在位置。
- 边缘强度：跟沿法线方向的图像局部对比相关，对比越大，越是边缘。
Canny边缘提取：
- 模糊去噪声 - 高斯模糊
- 提取梯度与方向
- 非最大信号抑制（比较边缘方向像素值是否比两侧像素值都大）
- 高低阈值链接：
- 高低阈值链接T1，T2，其中T1/T2=2~3，策略：
- 大于高阈值T1的全部保留
- 小于低阈值T2的全部丢弃
- 在T1到T2之间的，可以链接（八邻域）到高阈值的像素点，保留；无法链接的，丢弃
- 高低阈值链接T1，T2，其中T1/T2=2~3，策略：
#include效果：
Canny边缘提取：
Canny彩色边缘提取：
27、二值图像概念
灰度与二值图像：
- 灰度图像 - 单通道，取值范围 0~255
- 二值图像 - 单通道，取值0（黑色）与255（白色）
二值分割：
- 五种阈值分割方法
二值化与阈值化区别：
- 二值化为大于阈值的像素设为255，小于阈值的像素设为0；阈值化为大于阈值或小于阈值的设为0，其余部分不变。
#include效果：
28、全局阈值分割
- 图像二值化分割，最重要的就是计算域值
- 阈值计算算法很多，基本分为两类，全局阈值与自适应阈值
- OTSU（基于最小类内方差之和求取最佳阈值），多峰图像效果较好
- Triangle（三角法），对于医学图像等单峰图像效果较好
#include效果：
1、基于像素均值分割
2、基于OTSU、triangle分割
29、自适应阈值分割
-
全局阈值的局限性，对光照度不均匀的图像容易错误的二值化分割
-
自适应阈值对图像模糊求差值然后二值化
-
算法流程：(C+原图) - D > 0 ? 255:0
- 盒子模糊（高斯模糊、均值模糊）图像 → D
- 原图 + 加上偏置常量C得到 → S
- T = S - D + 255
#include效果：
1、文字：
2、其他图像：
30、联通组件扫描
四邻域与八邻域联通：
常用算法：BBDT(Block Base Decision Table)
-
基于像素扫描的方法
-
基于块扫描的方法
-
两步法扫描：
- 第一步：
- 第二步：
扫描模板：
决策表：
OpenCV中联通组件扫描算法-BBDT：
31、带统计信息的联通组件扫描
API知识点：
- connectedComponentsWithStats
- 黑色背景
| 输出 | 内容 |
|---|---|
| 1 | 联通组件数目 |
| 2 | 标签矩阵 |
| 3 | 状态矩阵 |
| 4 | 中心位置坐标 |
状态矩阵[label,COLUMN]
| 标签索引 | 列-1 | 列-1 | 列-1 | 列-1 | 列-1 |
|---|---|---|---|---|---|
| 1 | CC_STAT_LEFT | CC_STAT_TOP | CC_STAT_WIDTH | CC_STAT_HEIGHT | CC_STAT_AREA |
#include colorTable(num_labels);
//background color
colorTable[0] = Vec3b(0, 0, 0);
for (int i = 1; i < num_labels; i++) { //背景标签为0，跳过背景从1开始
colorTable[i] = Vec3b(rng.uniform(0, 256), rng.uniform(0, 256), rng.uniform(0, 256));
}
Mat result = Mat::zeros(src.size(), src.type());
int w = result.cols;
int h = result.rows;
for (int row = 0; row < h; row++) {
for (int col = 0; col < w; col++) {
int label = labels.at(row, col); //判断每一个像素的标签
result.at(row, col) = colorTable[label]; //根据每一个像素的标签对该像素赋予颜色
}
}
putText(result, format("number:%d", num_labels - 1), Point(50, 50), FONT_HERSHEY_PLAIN, 1.0, Scalar(0, 255, 0), 1);
printf("total labels:%d\n", (num_labels - 1)); //num_labels包含背景，num_labels - 1为前景对象个数
imshow("CCL demo", result);
*/
waitKey(0);
destroyAllWindows();
return 0;
}
void ccl_stats_demo(Mat &image) {
Mat labels = Mat::zeros(image.size(), CV_32S);
Mat stats, centroids;
int num_labels = connectedComponentsWithStats(image, labels, stats, centroids, 8, CV_32S, CCL_DEFAULT);
vector colorTable(num_labels) ;
//background color
colorTable[0] = Vec3b(0, 0, 0);
for (int i = 1; i < num_labels; i++) { //背景标签为0，跳过背景从1开始
colorTable[i] = Vec3b(rng.uniform(0, 256), rng.uniform(0, 256), rng.uniform(0, 256));
}
Mat result = Mat::zeros(image.size(), CV_8UC3);
int w = result.cols;
int h = result.rows;
for (int row = 0; row < h; row++) {
for (int col = 0; col < w; col++) {
int label = labels.at<int>(row, col); //判断每一个像素的标签
result.at(row, col) = colorTable[label]; //根据每一个像素的标签对该像素赋予颜色
}
}
for (int i = 1; i < num_labels; i++) {
//center
int cx = centroids.at<double>(i, 0);
int cy = centroids.at<double>(i, 1);
//rectangle and area
int x = stats.at<int>(i, CC_STAT_LEFT);
int y = stats.at<int>(i, CC_STAT_TOP);
int width = stats.at<int>(i, CC_STAT_WIDTH);
int height = stats.at<int>(i, CC_STAT_HEIGHT);
int area = stats.at<int>(i, CC_STAT_AREA);
//绘制
circle(result, Point(cx, cy), 3, Scalar(0, 0, 255), 2, 8, 0);
//外接矩形
Rect box(x, y, width, height);
rectangle(result, box, Scalar(0, 255, 0), 2, 8);
putText(result, format("%d", area), Point(x, y), FONT_HERSHEY_PLAIN, 1.0, Scalar(0, 255, 0), 1);
}
putText(result, format("number:%d", num_labels - 1), Point(10, 10), FONT_HERSHEY_PLAIN, 1.0, Scalar(0, 255, 0), 1);
printf("total labels:%d\n", (num_labels - 1)); //num_labels包含背景，num_labels - 1为前景对象个数
imshow("CCL demo", result);
}
效果：
1、OSTU二值化分割
2、带统计信息的联通组件
32、图像轮廓发现
- 图像轮廓 - 图像边界
- 主要针对二值图像，轮廓是一系列点的集合
轮廓发现
- 基于联通组件
- 反映图像拓扑结构（将最后一个像素标记为负数，与负数相邻的像素标记为相同的负数）
API知识点
- findContours
- drawContours
层次信息 vector
| 同层下个轮廓索引 | 同层上个轮廓索引 | 下层第一个孩子索引 | 上层父轮廓索引 |
|---|---|---|---|
| hierarchy [i] [0] | hierarchy [i] [1] | hierarchy [i] [2] | hierarchy [i] [3] |
| 参数顺序 | 解释 |
|---|---|
| Image | 二值图像 |
| mode | 拓扑结构（Tree、List、External） |
| method | 编码方式 |
| contours | 轮廓个数 - 每个轮廓有一系列的点组成 |
#include> contours;
vector hirearchy;
//RETR_EXTERNAL表示只绘制最外面的轮廓（外轮廓内的轮廓不绘制），RETR_TREE表示绘制所有轮廓
findContours(binary, contours, hirearchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
drawContours(src, contours, -1, Scalar(0, 0, 255), 2, 8);
imshow("find contours external demo", src);
findContours(binary, contours, hirearchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point()); //simple表示用四个点表示轮廓
drawContours(src, contours, -1, Scalar(0, 0, 255), 2, 8);
imshow("find contours tree demo", src);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
33、图像轮廓计算
轮廓面积与周长：
-
基于格林公式求面积
- 格林公式：
-
二重积分概念理解：
（1）曲顶柱体的体积
什么是曲顶柱体？设一立体，它的底是一闭合区域D，侧面是以D的边界曲线为准线而母线平行于底的柱面，顶是一个曲面。因为柱体的顶是一个曲面，所以叫曲顶柱体。
想求出这种柱体的体积该怎么办呢？一般柱体的体积=底×高，曲顶柱体显然不适合这种方法，因为顶是曲面。来回想一下不定积分的思想：把曲线分割成非常多份，每一份就相当于一个矩形，所有矩形的面积和就是曲线覆盖的面积。这种思想在这里仍然适用。如果把这个曲顶柱体分割成无穷多份，每一份就可以近似看成一个平顶柱体，这些平顶柱体体积的和就是曲顶柱体的体积。
再详细点讲，当分割的柱体直径最大值趋近0时，取上述和的极限，这个极限就是就是曲顶柱体的体积。
曲顶柱体的体积用公式表达就是这样子的。公式中f(x,y)是平顶柱体的高，Δ&就是平顶柱体的底。
(2) 平面薄片的质量
一个密度不均匀的薄片，如何计算其质量呢？可以拿称测量，总之有很多方法。这里用一个不是特别常规的方法。像上一个例子一样，把薄片分成若干份，当分的份数足够多时，每一份小薄片可以看成密度均匀的薄片，密度均匀的薄片求质量是很好算的，所有小薄片的质量的和就是整个薄片的质量。
整个薄片质量用公式来表达就是这样。公式里的f（x，y）代表在点（x，y）处薄片的面密度，Δ&代表小薄片的面积。
-
基于L2距离来求周长
#include> contours;
vector hirearchy;
//RETR_EXTERNAL表示只绘制最外面的轮廓（外轮廓内的轮廓不绘制），RETR_TREE表示绘制所有轮廓
findContours(binary, contours, hirearchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point());
for (size_t t = 0; t < contours.size(); t++) {
double area = contourArea(contours[t]); //面积
double length = arcLength(contours[t], true); //周长
if (area < 100 || length < 10) continue; //添加绘制时的过滤条件
Rect box = boundingRect(contours[t]);
//rectangle(src, box, Scalar(0, 0, 255), 2, 8, 0); //绘制最大外接矩形
RotatedRect rrt = minAreaRect(contours[t]);
//ellipse(src, rrt, Scalar(255, 0, 0), 2, 8);
Point2f pts[4];
rrt.points(pts);
for (int i = 0; i < 4; i++) {
line(src, pts[i], pts[(i + 1) % 4], Scalar(0, 255, 0), 2, 8); //绘制最小外接矩形
}
printf("area:%.2f,contour length:%.2f,angle:%.2f\n", area, length, rrt.angle);
//drawContours(src, contours, t, Scalar(0, 0, 255), 2, 8);
}
imshow("find contours demo", src);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
1、最大外接矩形及周长面积
2、最小外接矩形及周长面积角度
34、轮廓匹配
- 图像几何矩与Hu矩（最终得到的七个值有放缩、旋转、平移不变性）
- 先令 x 或 y 等于0，求取 x 和 y 的平均值，再计算Hu矩
- 基于Hu矩轮廓匹配
#include> &contours) ;
int main(int argc, char** argv) {
Mat src1 = imread("D:/images/abc.png");
Mat src2 = imread("D:/images/a.png");
if (src1.empty() || src2.empty()) {
printf("could not find image file");
return -1;
}
imshow("input1", src1);
imshow("input2", src2);
vector> contours1;
vector> contours2;
contour_info(src1, contours1);
contour_info(src2, contours2);
Moments mm2 = moments(contours2[0]); //计算几何矩
Mat hu2;
HuMoments(mm2, hu2); //计算Hu矩
for (size_t t = 0; t < contours1.size(); t++) {
Moments mm = moments(contours1[t]);
double cx = mm.m10 / mm.m00; //绘制每个轮廓中心点
double cy = mm.m01 / mm.m00;
circle(src1, Point(cx, cy), 3, Scalar(255, 0, 0), 2, 8, 0);
Mat hu;
HuMoments(mm, hu);
double dist = matchShapes(hu, hu2, CONTOURS_MATCH_I1, 0);
if (dist < 1.0) {
printf("matched distance value:%.2f\n", dist);
drawContours(src1, contours1, t, Scalar(0, 0, 255), 2, 8);
}
}
imshow("match contours demo", src1);
waitKey(0);
destroyAllWindows();
return 0;
}
void contour_info(Mat &image, vector> &contours) {
//二值化
Mat dst;
GaussianBlur(image, dst, Size(3, 3), 0); //最好在分割处理之前使用高斯滤波降噪
Mat gray, binary;
cvtColor(dst, gray, COLOR_BGR2GRAY);
threshold(gray, binary, 0, 255, THRESH_BINARY | THRESH_OTSU);
//轮廓发现
vector hirearchy;
//RETR_EXTERNAL表示只绘制最外面的轮廓（外轮廓内的轮廓不绘制），RETR_TREE表示绘制所有轮廓
findContours(binary, contours, hirearchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
}
效果：
35、轮廓逼近与拟合
- 轮廓逼近，本质是减少编码点
- 拟合圆，生成最相似的圆或者椭圆
#include> contours;
vector hirearchy;
//RETR_EXTERNAL表示只绘制最外面的轮廓（外轮廓内的轮廓不绘制），RETR_TREE表示绘制所有轮廓
findContours(binary, contours, hirearchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
//多边形逼近演示程序
for (size_t t = 0; t < contours.size(); t++) {
Moments mm = moments(contours[t]);
double cx = mm.m10 / mm.m00; //绘制每个轮廓中心点
double cy = mm.m01 / mm.m00;
circle(src, Point(cx, cy), 3, Scalar(255, 0, 0), 2, 8, 0);
double area = contourArea(contours[t]);
double clen = arcLength(contours[t], true);
Mat result;
approxPolyDP(contours[t], result, 4, true);
printf("corners:%d,contour area:%.2f,contour length:%.2f\n", result.rows, area, clen);
if (result.rows == 6) {
putText(src, "poly", Point(cx, cy - 10), FONT_HERSHEY_PLAIN, 1.0, Scalar(0, 0, 255), 1, 8);
}
if (result.rows == 4) {
putText(src, "rectangle", Point(cx, cy - 10), FONT_HERSHEY_PLAIN, 1.0, Scalar(0, 255, 255), 1, 8);
}
if (result.rows == 3) {
putText(src, "triangle", Point(cx, cy - 10), FONT_HERSHEY_PLAIN, 1.0, Scalar(255, 0, 255), 1, 8);
}
if (result.rows > 10) {
putText(src, "circle", Point(cx, cy - 10), FONT_HERSHEY_PLAIN, 1.0, Scalar(255, 255, 0), 1, 8);
}
}
imshow("find contours demo", src);
*/
waitKey(0);
destroyAllWindows();
return 0;
}
void fit_circle_demo(Mat &image) {
//二值化
GaussianBlur(image, image, Size(3, 3), 0); //最好在分割处理之前使用高斯滤波降噪
Mat gray, binary;
cvtColor(image, gray, COLOR_BGR2GRAY);
threshold(gray, binary, 0, 255, THRESH_BINARY | THRESH_OTSU);
imshow("otsu binary", binary);
//轮廓发现
vector> contours;
vector hirearchy;
//RETR_EXTERNAL表示只绘制最外面的轮廓（外轮廓内的轮廓不绘制），RETR_TREE表示绘制所有轮廓
findContours(binary, contours, hirearchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
//拟合圆或者椭圆
for (size_t t = 0; t < contours.size(); t++) {
//drawContours(image, contours, t, Scalar(0, 0, 255), 2, 8); //绘制原图轮廓
RotatedRect rrt = fitEllipse(contours[t]); //获取拟合的椭圆
float w = rrt.size.width;
float h = rrt.size.height;
Point center = rrt.center;
circle(image, center, 3, Scalar(255, 0, 0), 2, 8, 0); //绘制中心
ellipse(image, rrt, Scalar(0, 255, 0), 2, 8); //绘制拟合的椭圆
}
imshow("fit result", image);
}
效果：
1、多边形逼近
2、图像椭圆拟合
36、霍夫直线检测1
- 直线在平面坐标由两个参数决定（截距B，斜率K）
- 在极坐标空间由两个参数决定（半径R，角度θ）
- 图片讲解：三条曲线相交于一点，由该点确定的 r 和 θ 确定唯一的一条直线。
-
原理进一步理解：
- 1、图像空间x-y中的一点对应于参数空间k-b中的一条直线。
- 2、图像空间中的一条直线对应于参数空间k-b中的一个点。
#include lines;
HoughLines(binary, lines, 1, CV_PI / 180.0, 200, 0, 0);
//绘制直线
Point pt1, pt2;
for (size_t i = 0; i < lines.size(); i++) {
float rho = lines[i][0]; //距离
float theta = lines[i][1]; //角度
float acc = lines[i][2]; //累加值
printf("rho:%.2f,theta:%.2f,acc:%.2f\n", rho, theta, acc);
double a = cos(theta);
double b = sin(theta);
double x0 = a * rho, y0 = b * rho;
pt1.x = cvRound(x0 + 1000 * (-b));
pt1.y = cvRound(y0 + 1000 * (a));
pt2.x = cvRound(x0 - 1000 * (-b));
pt2.y = cvRound(y0 - 1000 * (a));
//line(src, pt1, pt2, Scalar(0, 0, 255), 2, 8, 0);
int angle = round((theta / CV_PI) * 180);
if (rho > 0) { //右倾
line(src, pt1, pt2, Scalar(0, 0, 255), 2, 8, 0);
if (angle == 90) { //水平线
line(src, pt1, pt2, Scalar(0, 255, 255), 2, 8, 0);
}
if (angle < 1) { //垂直线
line(src, pt1, pt2, Scalar(255, 255, 0), 4, 8, 0);
}
}
else { //左倾
line(src, pt1, pt2, Scalar(255, 0, 0), 2, 8, 0);
}
}
imshow("hough line detection", src);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
1、检测直线
2、检测不同角度的直线
37、直线类型与线段（霍夫直线检测2）
#include lines;
HoughLinesP(binary, lines, 1, CV_PI / 180.0, 80, 30, 10);
Mat result = Mat::zeros(src.size(), src.type());
for (int i = 0; i < lines.size(); i++) {
line(result, Point(lines[i][0], lines[i][1]), Point(lines[i][2], lines[i][3]), Scalar(0, 0, 255), 1, 8);
}
imshow("hough linesp demo", result);
}
效果：
38、霍夫圆检测
原理：
其实检测圆形和检测直线的原理差别不大，只不过直线是在二维空间，因为y=kx+b，只有k和b两个自由度。而圆形的一般性方程表示为(x-a)²+(y-b)²=r²。那么就有三个自由度圆心坐标a,b,和半径r。这就意味着需要更多的计算量，而OpenCV中提供的cvHoughCircle()函数里面可以设定半径r的取值范围，相当于有一个先验设定，在每一个r来说，在二维空间内寻找a和b就可以了，能够减少计算量。
具体步骤如下：
-
对输入图像进行边缘检测，获取边界点，即前景点。
-
假如图像中存在圆形，那么其轮廓必定属于前景点（此时请忽略边缘提取的准确性）。
-
同霍夫变换检测直线一样，将圆形的一般性方程换一种方式表示，进行坐标变换。由x-y坐标系转换到a-b坐标系。写成如下形式(a-x)²+(b-y)²=r²。那么x-y坐标系中圆形边界上的一点对应到a-b坐标系中即为一个圆。
-
那x-y坐标系中一个圆形边界上有很多个点，对应到a-b坐标系中就会有很多个圆。由于原图像中这些点都在同一个圆形上，那么转换后a,b必定也满足a-b坐标系下的所有圆形的方程式，也就是有那么一对a,b会使得所有点都在以该点为圆心的圆上。直观表现为这许多点对应的圆都会相交于一个点，那么这个交点就可能是圆心(a, b)。
-
统计局部交点处圆的个数，取每一个局部最大值，就可以获得原图像中对应的圆形的圆心坐标(a,b)。一旦在某一个r下面检测到圆，那么r的值也就随之确定。
#include circles;
//通过调整半径等参数来提高圆的检出率
double minDist = 10;
double min_radius = 10;
double max_radius = 50;
HoughCircles(gray, circles, HOUGH_GRADIENT, 3, minDist, 100, 100, min_radius, max_radius); //输入为灰度图像
for (size_t t = 0; t < circles.size(); t++) {
Point center(circles[t][0], circles[t][1]);
int radius = round(circles[t][2]);
//绘制圆
circle(src, center, radius, Scalar(0, 0, 255), 2, 8, 0);
circle(src, center, 3, Scalar(255, 0, 0), 2, 8, 0);
}
imshow("hough circle demo", src);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
39、图像形态学操作
图像形态学介绍：
- 是图像处理学科的一个单独分支学科
- 灰度与二值图像处理中重要手段
- 是由数学的集合论等相关理论发展起来的
- 在机器视觉、OCR等领域有重要作用
腐蚀与膨胀：
- 膨胀操作（最大值替换中心像素）
- 腐蚀操作（最小值替换中心像素）
结构元素形状：
- 线形 - 水平与垂直
- 矩形 - w*h
- 十字交叉形状
#include效果：
1、二值图像腐蚀与膨胀操作
2、BGR彩色图像腐蚀与膨胀操作
40、开闭操作
开操作：
- 开操作 = 腐蚀 + 膨胀
- 开操作 → 删除小的干扰块
闭操作：
- 闭操作 = 膨胀 + 腐蚀
- 闭操作 → 填充闭合区域
#include效果：
1、简单图形开闭操作
2、圆形闭操作
3、文字干扰开操作
4、直线提取开操作
41、形态学梯度（轮廓）
形态学梯度定义
- 基本梯度 - 膨胀减去腐蚀之后的结果，OpenCV中支持的计算形态学梯度的方法
- 内梯度 - 原图减去腐蚀之后的结果
- 外梯度 - 膨胀减去原图的结果
#include效果：
42、更多形态学操作
黑帽与顶帽
- 顶帽：原图减去开操作之后的结果
- 黑帽：闭操作之后的结果减去原图
- 顶帽与黑帽的作用是用来提取图像中微小有用的信息块
击中击不中（提取与结构元素完全相同的元素）
#include效果：
1、顶帽（开操作去除的干扰信息）
2、黑帽（闭操作填补的区域）
3、击中与击不中
43、图像分析 案例实战一
- 提取星云最大轮廓面积
- 提取编码点/极值点
#include> contours;
vector hirearchy;
//RETR_EXTERNAL表示只绘制最外面的轮廓（外轮廓内的轮廓不绘制），RETR_TREE表示绘制所有轮廓
findContours(binary, contours, hirearchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
double max_area = -1;
int cindex = -1;
for (size_t t = 0; t < contours.size(); t++) {
Rect rect = boundingRect(contours[t]);
if (rect.height >= height || rect.width >= width) { //跳过图像边框轮廓
continue;
}
double area = contourArea(contours[t]); //面积
double length = arcLength(contours[t], true); //周长
if (area > max_area) {
max_area = area;
cindex = t;
}
}
drawContours(src, contours, cindex, Scalar(0, 0, 255), 2, 8);
Mat pts;
approxPolyDP(contours[cindex], pts, 4, true); //通过多边形逼近找到极值点
Mat result = Mat::zeros(src.size(), src.type());
drawContours(result, contours, cindex, Scalar(0, 0, 255), 2, 8);
for (int i = 0; i < pts.rows; i++) {
Vec2i pt = pts.at(i, 0);
circle(src, Point(pt[0], pt[1]), 2, Scalar(0, 255, 0), 2, 8, 0);
circle(result, Point(pt[0], pt[1]), 2, Scalar(0, 255, 0), 2, 8, 0);
}
imshow("find max contours", src);
imshow("result contours analysis", result);
printf("area:%.2f\n", max_area);
waitKey(0);
destroyAllWindows();
return 0;
}
效果：
1、查找绘制最大面积轮廓
2、查找最大轮廓的极值点并绘制
44、视频读写
- 支持视频文件读写
- 摄像头与视频流
#include 效果：
45、图像色彩空间转换
色彩空间
- RGB色彩空间（非设备依赖）
- HSV色彩空间
- Lab色彩空间
- YCbCr色彩空间
相互转换
- BGR2HSV
#include 效果：
1、rgb图像转换为hsv及Lab色彩空间
2、去除hsv图像的绿色部分
46、直方图反向投影
基本原理
- 计算直方图
- 计算比率
- 卷积模糊
- 反向输出
查找过程示例：
假设我们有一张100x100的输入图像，有一张10x10的模板图像，查找的过程是这样的：
（1）从输入图像的左上角(0,0)开始，切割一块(0,0)至(10,10)的临时图像；
（2）生成临时图像的直方图；
（3）用临时图像的直方图和模板图像的直方图对比，对比结果记为c；
（4）直方图对比结果c，就是结果图像(0,0)处的像素值；
（5）切割输入图像从(0,1)至(10,11)的临时图像，对比直方图，并记录到结果图像；
（6）重复（1）～（5）步直到输入图像的右下角。
反向投影的结果包含了：以每个输入图像像素点为起点的直方图对比结果。可以把它看成是一个二维的浮点型数组，二维矩阵，或者单通道的浮点型图像。
#include 效果：
47、Harris角点检测
角点：在x方向和y方向都有梯度变化最大的像素点；边缘：在一个方向上像素梯度变化最大。
Harris角点检测原理：
shi-tomasi角点检测：
#include (row, col);
if (rsp > 150) {
int b = rng.uniform(0, 255);
int g = rng.uniform(0, 255);
int r = rng.uniform(0, 255);
circle(image, Point(col, row), 5, Scalar(b, g, r), 2, 8, 0);
}
}
}
}
效果：
48、shi-tomasi角点检测
#include corners;
double quality_level = 0.01; //角点检测最小阈值
RNG rng(12345);
goodFeaturesToTrack(gray, corners, 200, quality_level, 3, Mat(), 3, false);
for (int i = 0; i < corners.size(); i++) {
int b = rng.uniform(0, 255);
int g = rng.uniform(0, 255);
int r = rng.uniform(0, 255);
circle(image, corners[i], 5, Scalar(b, g, r), 2, 8, 0);
}
}
效果：
49、基于颜色的对象跟踪
视频帧颜色分析与提取
- 查看帧图像像素值分布（image watch）
- 设置正确range取得mask
- 对mask图像进行轮廓分析
#include > contours;
vector hirearchy;
findContours(mask, contours, hirearchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
int index = -1;
double max_area = 0;
for (size_t t = 0; t < contours.size(); t++) {
double area = contourArea(contours[t]);
if (area > max_area) {
max_area = area;
index = t;
}
}
//进行轮廓拟合与输出
if (index >= 0) {
RotatedRect rrt = minAreaRect(contours[index]);
ellipse(image, rrt, Scalar(255, 0, 0), 2, 8);
circle(image, rrt.center, 4, Scalar(0, 255, 0), 2, 8, 0);
}
imshow("color object detection", image);
}
效果：
50、背景分析
-
常见算法
- KNN
- GMM
- Fuzzy Integral
-
基本流程
- 背景初始化阶段
- 前景检测阶段
- 背景更新/维护
#include > contours;
vector hirearchy;
findContours(mask, contours, hirearchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
int index = -1;
double max_area = 0;
for (size_t t = 0; t < contours.size(); t++) {
double area = contourArea(contours[t]);
if (area < 200) {
continue;
}
Rect box = boundingRect(contours[t]);
RotatedRect rrt = minAreaRect(contours[t]);
//rectangle(image, box, Scalar(0, 0, 255), 2, 8, 0);
circle(image, rrt.center, 2, Scalar(255, 0, 0), 2, 8);
ellipse(image, rrt, Scalar(0, 0, 255), 2, 8);
}
imshow("result", image);
}
void process_frame(Mat &image) {
Mat mask, bg_image;
pMOG2->apply(image, mask); //获取前景
pMOG2->getBackgroundImage(bg_image);
imshow("mask", mask);
imshow("background", bg_image);
}
效果：
1、获取背景与前景
2、将获取到的前景在原图中用矩形表示出来
3、过滤面积较小的干扰区域并将前景元素中心及元素用最小面积椭圆表示出来
51、光流分析 - 光流法原理及稀疏光流法
光流法概述
- 光流可以看成是图像结构光的变化或者图像亮度模式明显的移动
- 分为稀疏光流与稠密光流
- 基于相邻视频帧进行分析
KLT光流分析原理（稀疏光流法）
- 三个假设条件
- 亮度恒定
- 近距离移动
- 空间一致性
KLT光流分析流程
#include pts1, vector pts2) ;
int main(int argc, char** argv) {
VideoCapture capture("D:/images/vtest.avi"); //获取摄像头
if (!capture.isOpened()) {
printf("could not open the camera...\n");
}
namedWindow("frame", WINDOW_AUTOSIZE);
Mat old_frame, old_gray;
capture.read(old_frame);
cvtColor(old_frame, old_gray, COLOR_BGR2GRAY); //转换为灰度图像进行角点检测
vector feature_pts; //存放角点
vector initPoints;
double quality_level = 0.01;
int minDistance = 5;
goodFeaturesToTrack(old_gray, feature_pts, 200, quality_level, minDistance, Mat(), 3, false);
Mat frame, gray;
vector pts[2];
pts[0].insert(pts[0].end(), feature_pts.begin(), feature_pts.end());
initPoints.insert(initPoints.end(), feature_pts.begin(), feature_pts.end());
vector status;
vector<float> err;
TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 10, 0.01); //迭代循环10次就不再计算
while (true) {
bool ret = capture.read(frame);
if (!ret) break;
imshow("frame", frame);
cvtColor(frame, gray, COLOR_BGR2GRAY);
//calculate optical flow 计算光流
calcOpticalFlowPyrLK(old_gray, gray, pts[0], pts[1], status, err, Size(21, 21), 3, criteria, 0);
size_t k = 0;
for (int i = 0; i < pts[1].size(); i++) {
//距离与状态检测
double dist = abs(pts[0][i].x - pts[1][i].x) + abs(pts[0][i].y - pts[1][i].y); //L2距离
if (status[i] && dist > 2) {
pts[0][k] = pts[0][i];
initPoints[k] = initPoints[i];
pts[1][k++] = pts[1][i];
int b = rng.uniform(0, 255);
int g = rng.uniform(0, 255);
int r = rng.uniform(0, 255);
circle(frame, pts[1][i], 2, Scalar(b, g, r), 2, 8, 0);
line(frame, pts[0][i], pts[1][i], Scalar(b, g, r), 2, 8, 0);
}
}
//update key points
pts[0].resize(k);
pts[1].resize(k);
initPoints.resize(k);
//绘制跟踪线
draw_lines(frame, initPoints, pts[1]); //连接起始点与最新光流检测点
//绘制跟踪
imshow("KLT-demo", frame);
char c = waitKey(50);
if (c == 27) { //ESC
break;
}
//update to old
std::swap(pts[1], pts[0]); //将pts[0]，old_gray保存信息更新为当前的帧，继续循环
cv::swap(old_gray, gray);
//re-init
if (pts[0].size() < 40) {
goodFeaturesToTrack(old_gray, feature_pts, 200, quality_level, minDistance, Mat(), 3, false);
pts[0].insert(pts[0].end(), feature_pts.begin(), feature_pts.end());
initPoints.insert(initPoints.end(), feature_pts.begin(), feature_pts.end());
}
}
capture.release(); //读写完成后关闭释放资源
waitKey(0);
destroyAllWindows();
return 0;
}
void draw_lines(Mat &frame, vector pts1, vector pts2) {
vector lut;
for (size_t t = 0; t < pts1.size(); t++) {
int b = rng.uniform(0, 255);
int g = rng.uniform(0, 255);
int r = rng.uniform(0, 255);
lut.push_back(Scalar(b, g, r));
}
for (size_t t = 0; t < pts1.size(); t++) {
line(frame, pts1[t], pts2[t], lut[t], 2, 8, 0);
}
}
效果：
1、基于状态检测绘制光流
2、基于距离及状态绘制光流
52、光流分析之稠密光流法
基于多项式的稠密光流法
- 基于二次多项式实现光流评估算法
- 对每个像素点都计算移动距离
- 基于总位移与均值评估
#include flow;
vector mv;
split(hsv, mv);
Mat bgr;
while (true) {
bool ret = capture.read(frame);
if (!ret) break;
cvtColor(frame, gray, COLOR_BGR2GRAY);
//flow包含dx和dy两个值
calcOpticalFlowFarneback(preGray, gray, flow, 0.5, 3, 15, 3, 5, 1.2, 0);
for (int row = 0; row < flow.rows; row++) {
for (int col = 0; col < flow.cols; col++) {
const Point2f &flow_xy = flow.at(row, col);
xpts.at<float>(row, col) = flow_xy.x;
ypts.at<float>(row, col) = flow_xy.y;
}
}
//cartToPolar（）这个API的参数如下：第一个参数x：输入的x分量数据，也就是dx；第二个参数y：输入的y分量数据，也就是dy；第三个参数magnitude：输出的振幅信息；第四个参数angle：输出的相位信息。
cartToPolar(xpts, ypts, mag, ang); //直角坐标转换为极坐标（横纵坐标转换为向量值角度值）
ang = ang * 180 / CV_PI / 2.0; //ang取值范围是0~2Π，转换为hsv中的h(0~180°)
normalize(mag, mag, 0, 255, NORM_MINMAX);
convertScaleAbs(mag, mag); //负值转正并且保持相对大小
convertScaleAbs(ang, ang);
mv[0] = ang;
mv[1] = Scalar(255);
mv[2] = mag;
merge(mv, hsv);
cvtColor(hsv, bgr, COLOR_HSV2BGR);
imshow("frame", frame);
imshow("result", bgr);
char c = cv::waitKey(1); //命名空间冲突，要明确指定使用的命名空间
if (c == 27) { //ESC
break;
}
}
capture.release();
cv::waitKey(0);
cv::destroyAllWindows();
return 0;
}
效果：
53、基于均值迁移的视频分析（对目标对象追踪）
均值迁移算法原理
- 基于图像直方图反向投影，需要提供ROI区域
- 基于均值迁移/自适应均值迁移（窗口大小自适应改变）分析
#include 效果：
1、均值迁移
2、自适应均值迁移
54、总结思维导图
