开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 人工智能 -> 图像处理基础+OpenCV实践 -> 正文阅读

[人工智能]图像处理基础+OpenCV实践

图像概述和直方图

卷积算子

$g=f\ast h$

定义为：
$g(i,j)=\sum_{k,l}f(i-k,j-l)h(k,l)$
显然
$f\ast h=f\otimes rot180(h)$
rotN表示将矩阵元素绕中心逆时针旋转N度。

灰度化

以RGB格式的彩图为例，通常灰度化采用的方法主要有：

$G r a y = (R + G + B) / 3$ ;
$Gray=\max(R,G,B)$ ;
$G r a y = 0.299 R + 0.587 G + 0.114 B$ .

灰度直方图

灰度直方图是灰度级的函数，描述图像中该灰度级的像素个数（或该灰度级像素出现的频率）：其横坐标是灰度级，纵坐标表示图像中该灰度级出现的个数（频率）。

一维直方图的结构表示为:
$N(P)=[n_1,n_2,\dots,n_{L-1}] \\ N=\sum_{i=0}^{L-1}n_i,p_i=\frac{n_i}{N}$
其中，L为灰度级的个数， $n_i$ 为每个灰度的像素个数，其频率为 $p_i$ 。

直方图均衡化

直方图均衡化主要处理曝光不够或曝光过度的图像，用于提高图片的对比度。

算法步骤：

建立图像灰度直方图。
计算累积分布函数 $P (k)$ :
$P(k)=\sum_{i=0}^k p_i$
生成新的灰度和旧的灰度的对应关系数组：
$T (i) = P (i) ? L$
其中 $T (i)$ 表示新灰度值。
用新的灰度值代替旧的灰度值。

图像几何变换

请添加图片描述

平移
自由度为2.
$\bold{x}'= \begin{bmatrix}\bold{I} & \bold{t} \end{bmatrix} \bold{x} \quad or \quad \bold{x}'= \begin{bmatrix}\bold{I} & \bold{t} \\ \bold{0}^T & 1\end{bmatrix} \bold{x}$
刚体运动（旋转+平移）
自由度为3。
$\bold{x}'= \begin{bmatrix}\bold{R} & \bold{t} \end{bmatrix} \bold{x}$
其中
$\bold{R}=\begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix}$
相似变换（缩放旋转+平移）
自由度为4.
$\bold{x}'= \begin{bmatrix}s\bold{R} & \bold{t} \end{bmatrix} \bold{x}= \begin{bmatrix}a & -b & t_x \\ b & a & t_y \end{bmatrix} \bold{x}$
仿射变换

自由度为6，仿射变换后的平行线仍然保持平行。
$\bold{x}'= \bold{A} \bold{x}= \begin{bmatrix}a_{00} & a_{01} & a_{02} \\ a_{10} & a_{11} & a_{12} \end{bmatrix} \bold{x}$
```
// 根据Point2f[] srcPts和dstPts计算仿射变换矩阵，warp_mat为2x3的矩阵
Mat warp_mat = getAffineTransform(srcPts, dstPts);

// 将图像进行仿射变换
Mat warp_dst = Mat::zeros(src.rows, src.cols, src.type());
// 输入图像、输出图像、仿射变换矩阵、输出图像的尺寸
warpAffine(src, warp_dst, warp_mat, warp_dst.size());
```
透视/单应性变换
自由度为8.
$\bold{x}'_{3\times1}= \bold{H}_{3\times3} \bold{x}_{3\times1}$
齐次坐标 $\bold{x}'_{3\times1}$ 必须经过归一化以得到非齐次坐标，即
$x'=\frac{h_{00}x+h_{01}y+h_{02}}{h_{20}x+h_{21}y+h_{22}},\quad y'=\frac{h_{10}x+h_{11}y+h_{12}}{h_{20}x+h_{21}y+h_{22}}$
单应性变换保留了直线。

模板匹配

匹配方法有平方差TM_SQDIFF、归一化平方差TM_SQDIFF_NORMED、相关性TM_CCORR、归一化相关性TM_CCORR_NORMED、协方差TM_CCOEFF、归一化协方差TM_CCOEFF_NORMED。

// 输入图像I、模板T、匹配结果R、匹配方法、掩码图像M
matchTemplate(img, temp1, result, match_method=TM_SQDIFF, mask);
// 定位结果R中的最大和最小值
double minVal; double maxVal; Point minLoc; Point maxLoc;
minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc, Mat());
// 对于平方差方法最佳匹配是R的最小值，对于其他方法最佳匹配是R的最大值
Point matchLoc;
if (match_method == TM_SQDIFF || match_method == TM_SQDIFF_NORMED) {
    matchLoc = minLoc;
} else {
    matchLoc = maxLoc;
}

图像滤波和变换

请添加图片描述

高通滤波

高通滤波器(HPF)是检测图像的某个区域，然后根据像素与周围像素的亮度差值来提升该像素的亮度的滤波器。如果亮度变化很大，中央像素的亮度会增加，反之则不会。主要用于边缘检测。

# 高通滤波器
kernel_3x3 = np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])
# 卷积运算
k3 = ndimage.convolve(img, kernel_3x3)

边缘检测

梯度算子

Sobel算子
$G_{x} = \begin{bmatrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \end{bmatrix} * I, G_{y} = \begin{bmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ +1 & +2 & +1 \end{bmatrix} * I \\ 梯度向量的模G=\sqrt{G_x^2+G_y^2}\\ 梯度方向\theta=arctan(\frac{G_y}{G_x})$
```
Mat grad_x, grad_y;
int ddepth = CV_16S;
int ksize = 3;
double scale = 1;
double delta = 0;
// 输入图像、输出图像、输出图像的深度、x方向导数的阶数、y方向导数的阶数、核尺寸、...
Sobel(src_gray, grad_x, ddepth, 1, 0, ksize, scale, delta, BORDER_DEFAULT); // x方向梯度
Sobel(src_gray, grad_y, ddepth, 0, 1, ksize, scale, delta, BORDER_DEFAULT); // y方向梯度

// 将输出转换为CV_8U图像
Mat abs_grad_x, abs_grad_y;
convertScaleAbs(grad_x, abs_grad_x);
convertScaleAbs(grad_y, abs_grad_y);

// 合并梯度：将x、y方向的梯度进行加权
Mat grad;
addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);
imshow("sobel gradient", grad);
```
Laplace算子
拉普拉斯算子是一种二阶微分算子，因此，它一般用二阶微分符号 $^2f$ 来表示。其常用的相关核有：
$h_1=\left[\begin{array}{ccc} 0&-1&0\\ -1&4&-1 \\ 0&-1&0\end{array} \right],h_2=\left[\begin{array}{ccc} -1&-1&-1\\ -1&8&-1 \\ -1&-1&-1\end{array} \right]$
```
Mat dst, abs_dst;
// 输入、输出、输出图像深度(应为CV_16S防止溢出)、核尺寸、...
Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
// 将输出转换为CV_8U
convertScaleAbs(dst, abs_dst);
imshow("Laplace gradient", abs_dst);
```

Canny边缘

Canny边缘检测算法非常复杂，但是也很有趣，它有5个步骤，即使用高斯滤波器对图像进行去噪，计算梯度，在边缘上使用非最大抑制，在检测到的边缘上使用双阈值去除假阳性，最后还会分析所有的边缘及其之间的连接，以保留真正的边缘并消除不明显的边缘。

算法步骤

使用高斯滤波去噪：
$\dfrac{1}{159}\begin{bmatrix} 2 & 4 & 5 & 4 & 2 \\ 4 & 9 & 12 & 9 & 4 \\ 5 & 12 & 15 & 12 & 5 \\ 4 & 9 & 12 & 9 & 4 \\ 2 & 4 & 5 & 4 & 2 \end{bmatrix}$
使用Sobel算子计算梯度，梯度方向离散化为4个方向。
非最大值抑制，消除边误检。
双阈值：若像素梯度大于上界，认为该像素为边缘；若像素梯度小于下界，则去除；若像素梯度位于中间，则仅当该像素和一个梯度大于上界的像素相连时，才认为该像素为边缘。上下界比通常为2:1或3:1。

cv2.Canny函数部分参数如下：

第一个参数是需要处理的原图像，该图像必须是单通道的灰度图；
第二个参数是阈值1。
第三个参数是阈值2.

其中较大的阈值2用于检测图像中明显的边缘，但是一般情况下检测的效果不会那么完美，边缘检测出来是断断续续的。所以这时候较小的第一个阈值用于将这些断续的边缘连接起来。

Mat img_gray, canny_output; 
// 输入、输出（二值化Canny图像）、下界、上界、Sobel算子的核尺寸
Canny(img_gray, canny_output, lowThresh, highThresh, kernel_size);

轮廓提取

在提取了Canny边缘后，可以通过findContours函数进一步提取图像的轮廓，函数签名如下：

/*
image: 单通道输入图像，通常用经过Canny、Laplace等边缘检测算子处理过的二值化图像
contours: 是一个二重向量，向量的每个元素代表了一组Point点集构成的一个轮廓
hierarchy: 也是一个向量，其元素和contours内的轮廓一一对应，其内部的4个int值分别表示轮廓的后一个轮廓、前一个轮廓、父轮廓和内嵌轮廓的索引。
mode: 轮廓的检索模式，包括：
		CV_RETR_EXTERNAL 只检测最外围轮廓
		CV_RETR_LIST 	 检测所有轮廓，但是检测的轮廓不建立等级关系（没有父和内嵌轮廓），彼此独立
		CV_RETR_CCOMP	 检测所有轮廓，但是轮廓只建立两个等级关系，外围为顶层。
		CV_RETR_TREE 	 检测所有轮廓，建立一个等级树结构，外层轮廓包含内层轮廓。
method: 轮廓近似方法，包括：
		CV_CHAIN_APPROX_NONE  	保存物体边界上所有连续的轮廓点
		CV_CHAIN_APPROX_SIMPLW  仅保存轮廓的拐点信息
offset: 所有轮廓信息相对于原图对应点的偏移量，相当于在轮廓点上加一个偏移
*/
findContours(InputOutputArray image, vector<vector<Point>> contours, vector<Vec4i> hierarchy, 
             int mode, int method, Point offset=Point());


// 实例程序
Canny(img_gray, img_canny, 100, 250);
vector<vector<Point>> contours;
vector<Vec4i> hierarchy;
findContours(img_canny, contours, hierarchy, RETR_TREE, CHAIN_APPORX_SIMPLE);

// 绘制轮廓
Mat drawing = Mat::zeros(canny_output.size(), CV_8UC3);
for (size_t i = 0; i < contours.size(); i++) {
    Scalar color = Scalar(rng.uniform(0, 256), rng.uniform(0, 256), rng.uniform(0, 256));
    drawContours(drawing, contours, (int)i, color, 2, 8, hierarchy, 0);
}

低通滤波

低通滤波器(LPF)是在像素与周围像素的亮度差值小于一定特征值，平滑该像素的亮度。它主要用于去噪和模糊化，比如说，高斯模糊是最常用的模糊滤波器(平滑滤波器)之一，它是削弱高频信号强度的低通滤波器。

方框滤波
$g=f\otimes h,h=\alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 \\ 1 & 1 & 1 & \cdots & 1 \\ \cdots & \cdots & \cdots & \cdots & \cdots \\ 1 & 1 & 1 & \cdots & 1 \end{bmatrix} ,\alpha = \begin{cases} \frac{1}{SUM(h)}, & \text{normalize=true} \\ 1, & \text{normalize=false} \\ \end{cases}$
当normalize=true时方框滤波变为均值滤波。

// 输入图像、输出图像、滤波器尺寸、anchor点位置(默认为核中心)
blur(src, dst, Size(i, i), Point(-1, -1));

中值滤波

// 输入、输出、核尺寸
medianBlur(src, dst, i);

高斯滤波

$G_{0}(x, y) = A e^{ \dfrac{ -(x - \mu_{x})^{2} }{ 2\sigma^{2}_{x} } + \dfrac{ -(y - \mu_{y})^{2} }{ 2\sigma^{2}_{y} } }$

最常用的3x3高斯滤波器为：
$\left[\begin{array}{ccc} 0.0625&0.125&0.0625\\ 0.125&0.25&0.125 \\ 0.0625&0.125&0.0625\end{array}\right]$

// 输入、输出、核尺寸、X方向的高斯核标准差、Y方向的标准差
GaussianBlur(src, dst, Size(i, i), 0, 0);

膨胀（最大值滤波）
$g(i,j)=max_{k,l}f(i,j)$
```
// 矩形结构元、结构元尺寸、anchor位置
Mat element = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1, -1));
// 输入、输出、结构元
dilate(src, dst, element);
```
腐蚀（最小值滤波）
$g(i,j)=min_{k,l}f(i,j)$
```
// 十字结构元、结构元尺寸、anchor位置
Mat element = getStructuringElement(MORPH_CROSS, Size(3, 3), Point(-1, -1));
// 输入、输出、结构元
erode(src, dst, element);
```
双边滤波
用于保边去噪，如美颜。其输出像素依赖于邻域像素值的加权组合
$g(i,j)=\frac{\sum_{k,l}f(k,l)w(i,j,k,l)}{\sum_{k,l}w(i,j,k,l)}$
其中，
$w(i,j,k,l)=d(i,j,k,l)\cdot r(i,j,k,l)=\exp\left(-\frac{(i-k)^2+(j-l)^2}{2\sigma_d^2}\right)\cdot \exp\left(-\frac{\|f(i,j)-f(k,l)\|^2}{2\sigma_r^2}\right)$

形态学操作

开操作
用以消除小物体（噪点）
$o p e n (s r c) = d i l a t e (e r o d e (s r c))$
闭操作
用于消除小的黑洞
$d s t = c l o s e (s r c, e l e m e n t) = e r o d e (d i l a t e (s r c, e l e m e n t))$
形态学梯度

对二值图像进行这一操作可以将团块（blob）的边缘突出出来。我们可以用形态学梯度来保留物体的边缘轮廓。
$m o r p h g r a d (s r c) = d i l a t e (s r c) ? e r o d e (s r c)$

代码实现

// operation为形态学操作，包括：
// 开=MORPH_OPEN,闭=MORPH_CLOSE，梯度=MORPH_GRADIENT
morphologyEx(src, dst, operation, element);

图像金字塔

高斯金字塔（用于图像下采样）
下采样：高斯滤波，然后移除图像的偶数列和行（取1/4）。

上采样：将图像在每个方向扩大为原来的2倍，新增的值以0填充；使用先前同样的核（乘以4）与放大后的图像卷积，获得“新值像素”的近似值。
```
// 输入、输出、输出尺寸
pyrDown( src, src, Size( src.cols/2, src.rows/2 ) );
pyrUp(src, src, Size(src.cols*2, src.rows*2));
```
拉普拉斯金字塔（用于下层图像的重建上采样）
为使上采样和下采样可逆，拉普拉斯金字塔定义为：
$L_i=G_i-PyrUp(PyrDown(G_i))=G_i-Up(PyrDown(G_i))\otimes H_{5\times 5}$
其中Up操作是将源图像中位置为(x,y)的像素映射到目标图像的(2x+1,2y+1)位置， $H_{5×5}$ 表示5x5的高斯核。

Mat src; // 原图
Mat laplace_pyramid, temp; // 金字塔图像、暂存原图
  
pyrDown(src, src, Size(src.cols / 2, src.rows / 2));
pyrUp(src, src, Size(src.cols * 2, src.rows * 2));
  
laplace_pyr![请添加图片描述](https://img-blog.csdnimg.cn/03511b9e32294adc9f4592d0d5c613be.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JlcmV6ZQ==,size_16,color_FFFFFF,t_70)
amid = temp - src;  
imshow("Laplace_pyramid", laplace_pyramid);

请添加图片描述

Hough变换

Hough变换用于检测直线，在使用前需要先经过边缘检测的预处理。

对于一条直线，可以使用极坐标形式描述：
请添加图片描述
$(-\frac{\cos \theta}{\sin \theta})x+(\frac{r}{\sin \theta})$

对于每个点 $x_0,y_0)$ ，可以定义穿过该点的直线簇：
$r_{\theta}=x_0\cos\theta+y_0\sin\theta$
一对 $(r_{\theta},\theta)$ 就代表一条穿过 $x_0,y_0)$ 的直线。
对于给定的一个点 $x_0,y_0)$ ，可以绘制 $(r,\theta)$ 的曲线，其为一条正弦曲线：（只考虑 $r > 0$ 和 $0<\theta<2\pi$ ）

在这里插入图片描述

我们对图像中的所有点都绘制这样的曲线。如果两个不同点的曲线相交于一点 $(r,\theta)$ ，这表明这两个点都在这条直线上。
由此，可以定义一个交点阈值来检测一条直线，当交点个数超过该阈值时，表明该交点 $(r,\theta)$ 可以描述一条直线。这就是Hough线变换。

// 原图、边缘检测处理过的二值化图、标准Hough变换检测结果、概率Hough变换检测结果
Mat src, img_canny, cdst, cdst_p;  
// step 1边缘检测预处理
Canny(src, img_canny, 50, 200, 3);
// 将边缘图像变为BGR图像，以便结果可视化
cvtColor(img_canny, cdst, COLOR_GRAY2BGR);
cdst_p = cdst.clone();

// step 2 Standard Hough line transform
vector<Vec2f> lines;  // 存储检测到的直线的向量，其中每个元素表示一条直线(rho, theta)
// 输入图像、直线向量、以像素为单位的距离精度、以弧度为单位的角度精度、检测阈值、(...)
HoughLines(img_canny, lines, 1, CV_PI/180, 150, 0, 0);
// Draw the lines
for (size_t i = 0; i < lines.size(); i++) {
    float rho = lines[i][0], theta = lines[i][1];
    Point pt1, pt2;
    double a = cos(theta), 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(cdst, pt1, pt2, Scalar(0, 0, 255), 3, LINE_AA);
}

// step 3 Probabilistic Hough transform 累计概率霍夫变换（相比标准霍夫变换效果更好）
vector<Vec4i> lines_p;  // 每条直线由四个int值(x1, y1, x2, y2)表示，(x1, y1)和(x2, y2)为线段的端点
// 输入图像、直线向量、距离精度、角度精度、检测阈值、最短线段长度、同一直线上两点之间的最大间隔
HoughLinesP(img_canny, lines_p, 1, CV_PI/180, 50, 50, 10);
// Draw the lines
for (size_t i = 0; i < lines_p.size(); i++) {
    Vec4i l = lines_p[i];
    line(cdst_p, Point(l[0], l[1]), Point(l[2],l[3]), Scalar(0, 0, 255), 3, LINE_AA);
}

// Show results
imshow("Source", src);
imshow("Detected Lines (in red) - Standard", cdst);
imshow("Detected Lines (in red) - Probabilistic", cdst_p);

在这里插入图片描述

经典手工特征

Harris角点

Harris角点具有旋转不变性，但不具有尺度不变性。

基本思想

使用一个固定窗口在图像上进行任意方向上的滑动，比较滑动前后窗口中像素灰度变化，如果存在任意方向上的滑动，使得灰度变化都较大，则认为该窗口中存在角点。

算法步骤

计算图像 $I (x, y)$ 在 $x$ 和 $y$ 方向上的梯度 $I_x,I_y$ ：
$I_x=\frac{?I}{?x}=I×\begin{bmatrix} -1 & 0 & 1 \end{bmatrix} \\ I_y=\frac{?I}{?y}=I×\begin{bmatrix} -1 & 0 & 1 \end{bmatrix}^T$
计算图像两个方向梯度的乘积：
$I_x^2 =I_x*I_x \\ I_y^2 =I_y*I_y \\ I_xI_y =I_x*I_y$
使用高斯函数对 $I_x^2$ 、 $I_y^2$ 、 $I_xI_y$ 进行高斯加权(取 $σ = 2$ , $k s i z e = 3$ )，计算中心点为 $(x, y)$ 的窗口 $W$ 对应的矩阵 $M$ ：
$A=\sum\limits_{(x,y)€W}g(I_x^2)=\sum\limits_{(x,y)€W}I_x^2*w(x,y)\\ B=\sum\limits_{(x,y)€W}g(I_y^2)=\sum\limits_{(x,y)€W}I_y^2*w(x,y)\\ C=\sum\limits_{(x,y)€W}g(I_xI_y)=\sum\limits_{(x,y)€W}I_xI_y*w(x,y)\\$
其中 $M=\begin{bmatrix} A & C \\C & B\end{bmatrix}=\sum\limits_{(x,y)€W}w(x,y)\begin{bmatrix} I_x^2 & I_xIy \\I_xI_y & I_y^2\end{bmatrix}$ ， $w (x, y)$ 表示高斯滑动窗口。
计算每个像素点 $(x, y)$ 处的Harris响应值 $R$ ：
$R=det(M)-k(trace(M))^2 \\ det(M)=λ_1λ_2 \\ trace(M)=λ_1+λ_2$
这里 $λ_1,λ_2$ 是矩阵 $M$ 的2个特征值， $k$ 是一个指定值，这是一个经验参数，需要实验确定它的合适大小，通常它的值在0.04和0.06之间,它的存在只是调节函数的形状而已。

$R$ 取决于 $M$ 的特征值，对于角点 $∣ R ∣$ 很大，平坦的区域 $∣ R ∣$ 很小，边缘的 $R$ 为负值。
滤除小于阈值 $t$ 的 $R$ 值：
$R=\{R:det(M)-k(trace(M))^2 \gt t \}$
如果在3×3或者5×5的邻域进行非最大值抑制，则局部最大值点即为图像中的角点。

代码实现

Mat dst = Mat::zeros(src.size(), CV_32FC1);  // 输出图像（存储角点响应R）
int block_size = 2;		// 窗口大小
int aperture_size = 3;	// 计算梯度时Sobel算子的核尺寸
double k = 0.04;		// 角点响应计算中的k值，增大k的值会减少被检测角点的数量

cornerHarris(src_gray, dst, block_size, aperture_size, k);

Mat dst_norm, dst_norm_scaled;
// 将角点响应归一化到[0, 255]
normalize(dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat());
// 转换为单通道CV_8UC1
converScaleAbs(dst_norm, dst_norm_scaled);

// 绘制满足阈值条件的角点
int thresh = 200;
for (int i = 0; i < dst_norm.rows; i++) {
    for (int j = 0; j < dst_norm.cols; j++) {
        if ((int) dst_norm.at<float>(i,j) > thresh) {
            circle(dst_norm_scaled, Point(j, i), 5, Scalar(0), 2, 8, 0);
        }
    }
}
imshow("harris corner", dst_norm_scaled);

在这里插入图片描述

Shi-Tomasi角点（GFFT）

Shi-Tomasi角点检测原理与Harris角点检测相同，只是在最后判别式的选取上不同，Shi-Tomasi角点检测选取特征中的最小的那个来判别。即角点响应变为
$R=\min(\lambda_1,\lambda_2)$

vector<Point2f> corners;  	  // 角点向量，每个元素为一个角点
int max_corners = 23;  	  	  // 检测的角点数目最大值，若有更多的角点，则返回响应值大的
double quality_level = 0.01;  // 可接受的最小响应值，若响应最大值为1500，quality_level=0.01，则小于15的响应都被拒绝
double min_distance = 10;				// 角点之间的最小欧式距离
int block_size = 3, gradient_size = 3;  // 计算M矩阵的窗口大小、梯度算子的核尺寸
bool use_harris_detector = false;		// 是否使用harris角点检测器
double k = 0.04;						// harris角点检测的k值
goodFeaturesToTrack(src_gray,
                   corners,
                   max_corners,
                   quality_level,
                   min_distance,
                   Mat(),  // ROI mask
                   block_size,
                   gradient_size,
                   use_harris_detector,
                   k);
// 绘制角点
for (size_t i = 0; i < corners.size(); i++) {
    circle(src, corners[i], 3, Scalar(0,0,255), FILLED);
}
imshow("Image", src);

在这里插入图片描述

SIFT特征

SIFT具有旋转、尺度、亮度不变性。

基本思想

尺度不变特征变换（Scale-Invariant Feature Transform），使用DoG（差分高斯）来提取特征点，DoG是用不同的尺度空间因子（高斯分布的标准差 $\sigma$ ）对图像进行平滑，然后比较平滑后图像的区别，差别大的像素就可能是特征点。对得到的所有特征点，剔除一些不好的，SIFT算子会把剩下的每个特征点用一个128维的向量进行描述。

算法步骤

DoG尺度空间的极值检测：
首先构造DoG尺度空间，在SIFT中使用不同参数的高斯模糊来表示不同的尺度空间。而构造尺度空间是为了检测在不同尺度下都存在的特征点，特征点的检测使用DoG（利用差分代替微分）来近似计算LoG（图像的二阶导数）。
删除不稳定的极值点：

主要删除两类：低对比度的极值点和不稳定的边缘响应点。
确定特征点的主方向：

以特征点的坐标为中心、以 $3\times1.5\sigma$ 为半径的邻域内计算各个像素点的梯度的幅值和幅角，然后使用直方图对梯度的辐角进行统计。直方图的横轴为梯度的方向，纵轴为梯度方向对应梯度幅值的累和，直方图中的最高峰所对应的方向即为特征点的主方向。
生成特征点的描述子

首先将坐标轴旋转为特征点的方向，以特征点为中心的 $16\times16$ 窗口的像素的梯度幅值和方向，将窗口内的像素分成 $4\times4$ 的块，每块是其内部16个像素的8个方向的直方图统计，对于一个特征点，可形成 $4\times4\times8=128$ 维的特征向量。

代码实现

int numFeatures = 400;  // 提取的特征点数目
Ptr<SIFT> detector = SIFT::create(numFeatures);

// step 1 detect the keypoints
vector<KeyPoint> keypoints;
detector->detect(src_gray, keypoints);

// draw keypoints
Mat img_keypoints;
drawKeypoints(src, keypoints, img_keypoints);

// show detected keypoints
imshow("SIFT", img_keypoints);
waitKey(0);

// detect the keypoints and descriptors
vector<KeyPoint> kp1, kp2;
Mat desc1, desc2;
detector->detectAndCompute(img1, Mat(), kp1, desc1);
detector->detectAndCompute(img2, Mat(), kp2, desc2);

// match，使用flann加速匹配
vector<vector<DMatch>> nn_matches;
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
matcher->knnMatch(desc1, desc2, nn_matches, 2);

// 选择好的匹配
const float match_ratio = 0.8f;
vector<DMatch> good_matches;
for (size_t i = 0; i < nn_matches.size(); i++) {
    if (nn_matches[i][0].distance < match_ratio * nn_matches[i][1].distance) {
        good_matches.push_back(nn_matches[i][0]);
    }
}

ORB特征

基本原理

ORB算法将FAST特征点的检测方法和BRIEF特征描述子结合起来，并进行改进和优化。

算法步骤

利用FAST检测特征点，然后利用Harris角点的度量方法，从FAST特征点中挑选除Harris角点响应值最大的N个特征点。其中响应函数为
$R=det(M)-k(trace(M))^2$
ORB中用NMS来筛选关键点，只保留分数最大的前n个关键点。由于FAST关键点不具备尺度不变性，因此ORB采用了图像金字塔来实现尺度不变性，通过构建高斯金字塔，然后在每一层金字塔图像上检测角点。
利用灰度质心法实现BRIEF描述子的旋转不变性。
灰度质心法认为角点的灰度和质心之间存在一个偏移，这个向量可以用于表示方向。对于任意特征点p，p的领域像素的矩定义为：
$m_{ij}=\sum\limits_{x=-r}^{r}\sum\limits_{y=-r}^{r}x^iy^jI(x,y)$
其中 $I (x, y)$ 为点 $(x, y)$ 处的灰度值， $q$ 为质心, $i, j = 0, 1$ 。那么我们可以得到图像的质心为：
$C=(\frac{m_{10}}{m_{00}},\frac{m_{01}}{m_{00}})$
那么特征点与质心的夹角定义为FAST特征点的方向：
$\theta=arctan(m_{01},m_{10})$
BRIEF描述子是通过比较中心像素点p的任意邻域内的256对像素间的差值来生成二进制描述子，其结果是一个长度为256的二值码串，由特征点邻域内的256个点对组成，这 $2\times256$ 个点 $x_i,y_i),i=1,2,.....,2n$ 组成一个矩阵 $S$ ：
$S=\begin{bmatrix} x_1 & x_2 & ... &x_{2n} \\ y_1 & y_2 & ... & y_{2n} \end{bmatrix}$
ORB使用邻域方向 $\theta$ 和对应的旋转矩阵 $R_{\theta}$ ，构建 $S$ 的校正版本 $S_{\theta}$ :
$S_{\theta}=R_{\theta}S$
其中，
$R_{\theta}=\begin{bmatrix} cos\theta & sin\theta \\ -sin\theta & cos\theta \end{bmatrix}$
$\theta$ 就是上面求得的FAST特征点的方向。

对于任意一对像素点 $x_i,y_i$ ，若 $x_i<y_i$ ，则该位置的描述子为1，否则为0。
rBRIEF解决描述子的区分性。

代码实现

Ptr<ORB> detector = ORB::create();
vector<KeyPoint> keypoints1, keypoints2;
Mat descriptors1, descriptors2;
// step 1: Detect the keypoints using ORB detector, compute the descriptors
detector->detectAndCompute(img_gray1, Mat(), keypoints1, descriptors1);  // 第二个参数为ROI mask
detector->detectAndCompute(img_gray2, Mat(), keypoints2, descriptors2);

// step 2: Matching descriptor vectors with a brute force matcher
// 由于ORB的描述子是uchar类型的，因此只能用BF匹配法
// Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");
Ptr<DescriptorMatcher> matcher = 
    DescriptorMatcher::create(DescriptorMatcher::BRUTEFORCE_HAMMING);
// 单一匹配
// vector<DMatch> matches;
// matcher->match(descriptors1, decriptors2, matches);
// knn匹配，knn_matches[i]包括k对候选匹配
vector<vector<DMatch>> knn_matches;  
matcher->knnMatch(descriptors1, decriptors2, knn_matches, 2);  // 最后一个参数为k近邻的k值

// step 3: Filter matches using the Lowe's ratio test
const float ratio_thresh = 0.7f;
vector<DMatch> good_matches;
for (size_t i = 0; i < knn_matches.size(); i++) {
    // 若[i]中最好的匹配[i][0]小于第二好的匹配[i][1]的距离的0.7，则认为是好的匹配对
    if (knn_matches[i][0].distance < ratio_thresh * knn_matches[i][1].distance) {
        good_matches.push_back(knn_matches[i][0]);
    }
}

// step 4: Draw matches
Mat img_matches;
drawMatches(img1, keypoints1, img2, keypoints2, good_matches, img_matches, 
            // 其他默认参数
            Scalar::all(-1),  // 匹配的颜色
            Scalar::all(-1),  // 关键点的颜色
            vector<char>(),   // 匹配掩码
            DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
imshow("Good matches", img_matches);
waitKey(0);

光流Optical flow

光流是空间运动物体在观察成像平面上得像素运动的瞬时速度，是利用图像序列中像素在时间域上的变化和相邻帧之间的相关性来找到上一帧和当前帧之间的对应关系，从而计算出相邻帧之间的运动信息的一种方法。

可以通过不同目标的光流运动速度判断它们离我们的距离。一些较远的目标，如云，运动得很慢；而一些较近的目标，如门、运动得较快。

光流约束方程

光流基于如下两个假设：

在很短的时间内目标的像素值不会变化；
邻近的像素具有相似的运动。

令 $I (x, y, t)$ 表示t时刻的像素点 $(x, y)$ 的灰度值，则根据亮度恒定假设，我们有：
$\Delta x, y + \Delta y, t + \Delta t)$
我们对上式右侧进行一阶Taylor展开，可得：
$\Delta x, y + \Delta y, t + \Delta t) \approx I(x,y,t) + \frac{\partial I}{\partial x}\Delta x + \frac{\partial I}{\partial y}\Delta y + \frac{\partial I}{\partial t}\Delta t$
最后得到光流约束方程：
$\frac{\partial I}{\partial x}\Delta x + \frac{\partial I}{\partial y}\Delta y + \frac{\partial I}{\partial t}\Delta t = 0$
由于这个方程有两个未知数 $(\Delta x,\Delta y)$ ，所以没有唯一解。为了得到唯一解，就必须新增约束或假设，因此也就有了不同的算法。

Lucas-Kanade算法

Lucas-Kanade算法假设局部光流恒定，他使用一个3x3的patch，patch内的9个像素都具有同样的运动。因此，问题变为了：9个方程，求解2个未知数。算法使用最小二乘法求解：
$\begin{bmatrix} \Delta x \\ \Delta y \end{bmatrix} = \begin{bmatrix} \sum_{i}{f_{x_i}}^2 & \sum_{i}{f_{x_i} f_{y_i} } \\ \sum_{i}{f_{x_i} f_{y_i}} & \sum_{i}{f_{y_i}}^2 \end{bmatrix}^{-1} \begin{bmatrix} - \sum_{i}{f_{x_i} f_{t_i}} \\ - \sum_{i}{f_{y_i} f_{t_i}} \end{bmatrix}$
其中
$f_x = \frac{\partial I}{\partial x} \; ; \; f_y = \frac{\partial I}{\partial y}; \;f_t= \frac{\partial I}{\partial t}\\$
注意，式中的逆矩阵和Harris角点检测中的M很像，这表明角点更适合跟踪。

为了解决较大运动时无法跟踪的问题，算法使用图像金字塔，当图像进行上采样时，大运动变成了小运动，小运动被去除了。

代码实现

vector<Point2f> prevPts, currPts;
// 输入图像、输出角点、角点数目最大值、角点质量、角点之间的最小欧式距离、ROI区域、计算互相关函数的窗口尺寸、是否使用Harris角点、Harris角点的k值
goodFeaturesToTrack(prevImg, prevPts, 100, 0.3, 7, Mat(), 7, false, 0.04);
vector<uchar> status;
vector<float> err;
TermCriteria criteria = TermCriteria((TermCriteria::COUNT) + (TermCriteria::EPS), 10, 0.03);

// 前一帧图像、后一帧图像、前一帧跟踪点、后一帧跟踪点、是否找到光流（是否跟踪成功）、误差、金字塔的窗口尺寸、金字塔的层数-1、迭代终止条件
calcOpticalFlowPyrLK(prevImg, currImg, prevPts, currPts, status, err, Size(15,15), 2, criteria);

// 选择好点
vector<Point2f> good_new;
for (uint i = 0; i < prevPts.size(); i++) {
    if (status[i] == 1) {
        good_new.push_back(currPts[i]);
        // draw the tracks
        line(prevImg, currPts[i], prevPts[i], color, thickness);
    }
}

图像插值

双线性插值

已知 $Q 11 (x 1, y 1) 、 Q 12 (x 1, y 2) 、 Q 21 (x 2, y 1) 、 Q 22 (x 2, y 2)$ ，求其中点P(x,y)的值。
在这里插入图片描述

双线性插值是分别在两个方向计算了共3次单线性插值，如图所示，先在x方向求2次单线性插值，获得R1(x, y1)、R2(x, y2)两个临时点，再在y方向计算1次单线性插值得出P(x, y)（实际上调换2次轴的方向先y后x也是一样的结果）。

几何中心点重合对应
$src_x=(dst_x+0.5)*src_w/dst_w-0.5 \\src_y=(dst_y+0.5)*src_h/dst_h-0.5$
对于计算出来得 $src_x, src_y$ ，由于一般是浮点数，需要找到其邻近的四个实际存在的像素点。
比如 $s r c = (1.2, 3.4)$ ，先找到邻近像素(1, 3) (2, 3) (1, 4) (2, 4)，
x方向单线性插值
$f(R_1)=\frac{x_2-x}{x_2-x_1}f(Q_{11})+\frac{x-x_1}{x_2-x_1}f(Q_{21}) \\ f(R_2)=\frac{x_2-x}{x_2-x_1}f(Q_{12})+\frac{x-x_1}{x_2-x_1}f(Q_{22})$
y方向单线性插值

$=\frac{y_2-y}{y_2-y_1}f(R_1)+\frac{y-y_1}{y_2-y_1}f(R_2)$

将上式整理得
$=\frac{(x_2-x)(y_2-y)}{(x_2-x_1)(y_2-y_1)}f(Q_{11})+\frac{(x-x_1)(y_2-y)}{(x_2-x_1)(y_2-y_1)}f(Q_{21})+\frac{(x_2-x)(y-y_1)}{(x_2-x_1)(y_2-y_1)}f(Q_{12})$

由于 $x_2=x_1+1, y_2=y_1+1$ ，因此有
$\begin{aligned}f(x,y) = &f(Q_{11})(x_2-x)(y_2-y)+f(Q_{21})(x-x_1)(y_2-y)+ \\&f(Q_{12})(x_2-x)(y-y_1)+f(Q_{22})(x-x_1)(y-y_1) \end{aligned}$

相机标定

成像

对于一个3D点 $P (X, Y, Z)$ ，其对应相机图像坐标为 $p (u, v)$ ，可以建立如下投影关系：
$s\left[ \begin{matrix} u \\ v \\ 1 \end{matrix} \right] = \left[ \begin{matrix} a & r & u_0 \\ 0 & b & v_0 \\ 0 & 0 & 1 \end{matrix} \right] \begin{bmatrix} \bold{r}_1 & \bold{r}_2 & \bold{r}_3 & \bold{t} \end{bmatrix} \left[ \begin{matrix} X \\ Y \\ Z \\ 1\end{matrix} \right] = \bold{K} \bold{T} \bold{P}$

其中K为相机内参矩阵，[R, t]为相机外参。此外还有相机畸变参数：
$\left \{ \begin{aligned}x_{distorted}=x(1+k_1r^2+k_2r_4+k_3r^6)+2p_1xy+p_2(r^2+2x^2) \\y_{distorted}=y(1+k_1r^2+k_2r_4+k_3r^6)+p_1(r^2+2y^2)+2p_2xy\end{aligned}\right.$
(x, y)为相机归一化平面坐标。相机标定的目的就是求解上述这些参数。

闭式解（不考虑畸变）

我们使用标定板来进行标定，其所有特征点都共面，可以假设该平面为Z=0，从而去掉 $r_3$ ，于是投影关系可以写为：

$s\left[ \begin{matrix} u \\ v \\ 1 \end{matrix} \right] = \left[ \begin{matrix} a & r & u_0 \\ 0 & b & v_0 \\ 0 & 0 & 1 \end{matrix} \right] \begin{bmatrix} \bold{r}_1 & \bold{r}_2 & \bold{t} \end{bmatrix} \left[ \begin{matrix} X \\ Y \\ 1\end{matrix} \right]$

中间的这块 $\bold{K}[\bold{r}_1 , \bold{r}_2 , \bold{t}]$ 就代表3D点和其图像坐标间的单应H，因此有：

$\bold{H}= \begin{bmatrix} \bold{h}_1 & \bold{h}_2 & \bold{h}_3 \end{bmatrix} =\lambda \bold{K} \begin{bmatrix} \bold{r}_1 & \bold{r}_2 & \bold{t} \end{bmatrix}$

$\lambda$ 为标量（可以理解为1/s），将矩阵里面的元素展开有
$\left \{ \begin{aligned} \bold{r}_1=\bold{K}^{-1}\bold{h}_1 \\ \bold{r}_2=\bold{K}^{-1}\bold{h}_2 \end{aligned}\right.$
又由于旋转矩阵有正交性和单位性，因此我们有
$\left \{ \begin{aligned} \bold{r}_1^T\bold{r}_2 &= 0 \rightarrow \bold{h}_1^T\bold{K}^{-T}\bold{K}^{-1} \bold{h}_2 = 0 \\ ||\bold{r}_1||&=||\bold{r}_2|| \rightarrow \bold{h}_1^T\bold{K}^{-T}\bold{K}^{-1} \bold{h}_1= \bold{h}_2^T\bold{K}^{-T}\bold{K}^{-1} \bold{h}_2 \end{aligned}\right.$
我们令 $\bold{B}=\bold{K}^{-T}\bold{K}^{-1}$ ，则有
$\bold{B}=\bold{K}^{-T}\bold{K}^{-1}= \begin{bmatrix} B_{11} & B_{12} &B_{13}\\ B_{21} & B_{22} & B_{23} \\ B_{31} & B_{32} & B_{33} \end{bmatrix} = \\ \begin{bmatrix} \frac{1}{a^2} & -\frac{r}{a^2b} & \frac{v_0r-u_0b}{a^2b} \\ -\frac{r}{a^2b} & \frac{r}{a^2b}+\frac{1}{b^2} & -\frac{r(v_0r-u_0b)}{a^2b^2}-\frac{v_0}{b^2} \\ \frac{v_0r-u_0b}{a^2b} & -\frac{r(v_0r-u_0b)}{a^2b^2}-\frac{v_0}{b^2} & \frac{(v_0r-u_0b)^2}{a^2b^2}+\frac{v_0^2}{b^2}+1 \end{bmatrix}$
因为B是对称矩阵，因此不妨设向量 $\bold{b}$ 为：
$\bold{b}=\begin{bmatrix} B_{11},B_{12},B_{22},B_{13},B_{23},B_{33} \end{bmatrix}^T$
对于单应矩阵H的列向量 $\bold{h}_i$ ，有：
$\bold{h}_i=[h_{i1},h_{i2},h_{i3}]^T$
将 $b$ 和 $h_i$ 代入到旋转矩阵的两个约束中去，得到：

$\bold{h}_i^T\bold{B}\bold{h}_j=\bold{m}_{ij}^T\bold{b}=0$
其中， $\bold{m}_{ij}=[h_{i1}h_{j1},h_{i1}h_{j2}+h_{i2}h_{j1},h_{i2}h_{j2},h_{i3}h_{j1}+h_{i1}h_{j3},h_{i3}h_{j2}+h_{i2}h_{j3},h_{i3}h_{j3}]^T$ 。

最终，两个约束可以写为齐次方程：
$\begin{bmatrix} \bold{m}_{12}^T \\ (\bold{m}_{11}-\bold{m}_{22})^T \end{bmatrix} \bold{b}=\bold{M}_{2\times6}\bold{b}= \bold{0}$
M是由单应H决定的已知量，因此只要求解上述方程即可得到b。由于一张图像就可以得到2个约束，因此求解该方程至少需要采集3张图像，实际中，通常会采集15-20张左右。

该方程可以使用SVD进行求解，即 $\bold{M}=\bold{U}\bold{D}\bold{V}_{6\times6}^T$ ，将V按D中特征值的降序排序，取V的最后一列的列向量即为所求b。

当求出b和矩阵B后，即可按(55)描述的 $\bold{B}=\bold{K}^{-T}\bold{K}^{-1}$ 求解内参K：
$\begin{aligned} v_0&=(B_{12}B_{13}-B_{11}B_{23})/(B_{11}B_{22}-B_{12}^2) \\ \lambda&=B_{33}-[B_{13}^2+v_0(B_{12}B_{13}-B_{11}B_{23})]/B_{11} \\ a&=\sqrt{\lambda/B_{11}} \\ b&=\sqrt{\lambda B_{11}/(B_{11}B_{22}-B_{12}^2)} \\ r&=-B_{12}a^2b/\lambda \\ u_0&=rv_0/a-B_{13}a^2/\lambda \end{aligned}$
外参可以由内参和单应求出：
$\begin{aligned} \bold{r}_1=\lambda \bold{K}^{-1}\bold{h}_1 \\ \bold{r}_2=\lambda \bold{K}^{-1}\bold{h}_2 \\ \bold{r}_1=\bold{r}_{1}\times\bold{r}_2 \\ \bold{t}=\lambda \bold{K}^{-1}\bold{h}_3 \end{aligned}$
其中， $\lambda=1/||\bold{K}^{-1}\bold{h}_1||=1/||\bold{K}^{-1}\bold{h}_2||$ ，由于噪声存在，计算出来的旋转矩阵R并不一定满足单位正交的性质，因此可以用QR分解，或者将结果从矩阵空间重投影到SE(3)流形上：
$\bold{R}=(\bold{R}\bold{R}^T)^{-1/2}\bold{R}$

优化解（考虑畸变）

之前的闭式解计算没有考虑畸变，因此我们还需要对闭式解进一步优化。我们定义考虑了畸变的重投影误差目标函数：
$\sum_{i=1}^n\sum_{j=1}^m ||\bold{p}_{ij}-\bold{\hat{p}}(\bold{K},k_1,k_2,k_3,p_1,p_2,\bold{R_i},\bold{t_i},\bold{P}_j)||$
其中，有n张图像，m个3D点。通过最小化该目标函数，即可求解相机的内参、畸变、外参。