1自定义线性滤波
1.1卷积概念
卷积是图像处理中一个操作，是kernel在图像的每个像素上的操作。
Kernel本质上一个固定大小的矩阵数组，其中心点称为锚点(anchor point)
卷积如何工作：
把kernel放到像素数组之上，求锚点周围覆盖的像素乘积之和（包括锚点），用来替换锚点覆盖下像素点值称为卷积处理。数学表达如下：
例子：
Sum = 8x1+6x1+6x1+2x1+8x1+6x1+2x1+2x1+8x1
New pixel = sum / (mn) = Sum / (33)
卷积作用：
1模糊图像；
2)提取边缘；
3）进行图像増显，锐化等。
1.2 常见算子
1）Robert 算子（Robert X 算子 和 Robert Y 算子）
例子：Mat robert_x = (Mat_(2, 2) << 1, 0, 0, -1);
2）Sobel 算子（Sobel X 算子 和 Sobel Y 算子）
例：Mat sobel_x = (Mat_(3, 3) << -1, 0, 1, -2, 0, 2, -1, 0, 1);
3)拉普拉斯算子
例子： Mat lpls = (Mat_(3, 3) << 0, -1, 0, -1, 4, -1, 0, -1, 0);
自定义卷积模糊API：
filter2D方法filter2D(
Mat src, //输入图像
Mat dst, // 模糊图像
int depth, // 图像深度32/8
Mat kernel, // 卷积核/模板
Point anchor, // 锚点位置
double delta // 计算出来的像素+delta
)
注意：其中kernel是可以自定义的卷积核。
综合示例：
#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>
using namespace cv;
int main(int argc, char** argv) {
Mat src, dst;
int ksize = 0;
src = imread("D:/vcprojects/images/test1.png");
if (!src.data) {
printf("could not load image...\n");
return -1;
}
char INPUT_WIN[] = "input image";
char OUTPUT_WIN[] = "Custom Blur Filter Result";
namedWindow(INPUT_WIN, CV_WINDOW_AUTOSIZE);
namedWindow(OUTPUT_WIN, CV_WINDOW_AUTOSIZE);
imshow(INPUT_WIN, src);
// Sobel X 方向
// Mat kernel_x = (Mat_<int>(3, 3) << -1, 0, 1, -2,0,2,-1,0,1);
// filter2D(src, dst, -1, kernel_x, Point(-1, -1), 0.0);
// Sobel Y 方向
// Mat yimg;
// Mat kernel_y = (Mat_<int>(3, 3) << -1, -2, -1, 0,0,0, 1,2,1);
// filter2D(src, yimg, -1, kernel_y, Point(-1, -1), 0.0);
// 拉普拉斯算子
//Mat kernel_y = (Mat_<int>(3, 3) << 0, -1, 0, -1, 4, -1, 0, -1, 0);
//filter2D(src, dst, -1, kernel_y, Point(-1, -1), 0.0);
int c = 0;
int index = 0;
while (true) {
c = waitKey(500);
if ((char)c == 27) {// ESC
break;
}
ksize = 5 + (index % 8) * 2;
Mat kernel = Mat::ones(Size(ksize, ksize), CV_32F) / (float)(ksize * ksize);
filter2D(src, dst, -1, kernel, Point(-1, -1));
index++;
imshow(OUTPUT_WIN, dst);
}
// imshow("Sobel Y", yimg);
return 0;
}
2卷积边缘问题
图像在进行卷积运算的时候，图像的边界像素不能被卷积操作，原因在于边界像素没有完全跟kernel重叠，所以在进行33滤波的时候，有一个像素的边缘没有被处理，55滤波的时候有2个像素的边缘没有被处理。
2.1处理边缘
在卷积开始之前增加边缘像素，填充的像素值为0或者RGB黑色，比如3x3在
四周各填充1个像素的边缘，这样就确保图像的边缘被处理，在卷积处理之
后再去掉这些边缘。openCV中默认的处理方法是： BORDER_DEFAULT，此外
常用的还有如下几种：
- BORDER_CONSTANT – 填充边缘用指定像素值
- BORDER_REPLICATE – 填充边缘像素用已知的边缘像素值。
- BORDER_WRAP – 用另外一边的像素来补偿填充
相应的API：
CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst,
int top, int bottom, int left, int right,
int borderType, const Scalar& value = Scalar() );
top,bottom,left,right分别表示在原图四周扩充边缘的大小
borderType：扩充边缘的类型，就是外插的类型
* BORDER_REPLICATE
* BORDER_REFLECT
* BORDER_REFLECT_101
* BORDER_WRAP
* BORDER_CONSTANT
const Scalar& value=Scalar()：表示如果边界的类型是 BORDER_CONSTANT ，那么边界的颜色值
综合示例：
#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>
using namespace cv;
int main(int argc, char** argv) {
Mat src, dst;
src = imread("D:/vcprojects/images/test.jpg");
if (!src.data) {
printf("could not load image...\n");
return -1;
}
char INPUT_WIN[] = "input image";
char OUTPUT_WIN[] = "Border Demo";
namedWindow(INPUT_WIN, CV_WINDOW_AUTOSIZE);
namedWindow(OUTPUT_WIN, CV_WINDOW_AUTOSIZE);
imshow(INPUT_WIN, src);
/*
int top = (int)(0.05*src.rows);
int bottom = (int)(0.05*src.rows);
int left = (int)(0.05*src.cols);
int right = (int)(0.05*src.cols);
RNG rng(12345);
int borderType = BORDER_DEFAULT;
int c = 0;
while (true) {
c = waitKey(500);
// ESC
if ((char)c == 27) {
break;
}
if ((char)c == 'r') {
borderType = BORDER_REPLICATE;
} else if((char)c == 'w') {
borderType = BORDER_WRAP;
} else if((char)c == 'c') {
borderType = BORDER_CONSTANT;
}
Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
copyMakeBorder(src, dst, top, bottom, left, right, borderType, color);
imshow(OUTPUT_WIN, dst);
}
*/
GaussianBlur(src, dst, Size(5, 5), 0, 0);
imshow(OUTPUT_WIN, dst);
waitKey(0);
return 0;
}
3卷积应用–图像边缘提取
边缘是什么 – 是像素值发生跃迁的地方，是图像的显著特征之一，在图像特征提取、对象检测、模式识别等方面都有重要的作用。
如何捕捉/提取边缘 – 对图像求它的一阶导数。
delta = f(x) – f(x-1), delta越大，说明像素在X方向变化越大，边缘信号越强，
3.1Sobel算子
是离散微分算子（discrete differentiation operator），用来计算图像灰度的近似梯度；
Soble算子功能集合高斯平滑和微分求导；
又被称为一阶微分算子，求导算子，在水平和垂直两个方向上求导，得到图像X方法与Y方向梯度图像。
求取导数的近似值，kernel=3时不是很准确，OpenCV使用改进版本Scharr函数，算子如下：
相应的API:
cv::Sobel (
InputArray Src // 输入图像
OutputArray dst// 输出图像，大小与输入图像一致
int depth // 输出图像深度.
Int dx. // X方向，几阶导数
int dy // Y方向，几阶导数.
int ksize, SOBEL算子kernel大小，必须是1、3、5、7、
double scale = 1
double delta = 0
int borderType = BORDER_DEFAULT
)
cv::Scharr (
InputArray Src // 输入图像
OutputArray dst// 输出图像，大小与输入图像一致
int depth // 输出图像深度.
Int dx. // X方向，几阶导数
int dy // Y方向，几阶导数.
double scale = 1
double delta = 0
int borderType = BORDER_DEFAULT
)
综合示例：
#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>
using namespace cv;
int main(int argc, char** argv) {
Mat src, dst;
src = imread("D:/vcprojects/images/test.png");
if (!src.data) {
printf("could not load image...\n");
return -1;
}
char INPUT_TITLE[] = "input image";
char OUTPUT_TITLE[] = "sobel-demo";
namedWindow(INPUT_TITLE, CV_WINDOW_AUTOSIZE);
namedWindow(OUTPUT_TITLE, CV_WINDOW_AUTOSIZE);
imshow(INPUT_TITLE, src);
Mat gray_src;
GaussianBlur(src, dst, Size(3, 3), 0, 0);
cvtColor(dst, gray_src, CV_BGR2GRAY);
imshow("gray image", gray_src);
Mat xgrad, ygrad;
Scharr(gray_src, xgrad, CV_16S, 1, 0);
Scharr(gray_src, ygrad, CV_16S, 0, 1);
// Sobel(gray_src, xgrad, CV_16S, 1, 0, 3);
// Sobel(gray_src, ygrad, CV_16S, 0, 1, 3);
convertScaleAbs(xgrad, xgrad);
convertScaleAbs(ygrad, ygrad);
imshow("xgrad", xgrad);
imshow("ygrad", ygrad);
Mat xygrad = Mat(xgrad.size(), xgrad.type());
printf("type : %d\n", xgrad.type());
int width = xgrad.cols;
int height = ygrad.rows;
for (int row = 0; row < height; row++) {
for (int col = 0; col < width; col++) {
int xg = xgrad.at<uchar>(row, col);
int yg = ygrad.at<uchar>(row, col);
int xy = xg + yg;
xygrad.at<uchar>(row, col) = saturate_cast<uchar>(xy);
}
}
//addWeighted(xgrad, 0.5, ygrad, 0.5, 0, xygrad);
imshow(OUTPUT_TITLE, xygrad);
waitKey(0);
return 0;
}
4 Laplance算子
Laplance算子本质是对图像进行二阶求导，如下图所示：
解释：在二阶导数的时候，最大变化处的值为零即边缘是零值。通过二阶
导数计算，依据此理论我们可以计算图像二阶导数，提取边缘。
二阶导数就是一阶导数的导数，因为图像有行列两个方向，所以要两个方向分别求导数：
拉普拉斯算子由OpenCV函数cv :: Laplacian实现。 实际上，由于拉普拉斯算子使用图像的梯度，因此它在内部调用Sobel算子来执行其计算。
相应的API为：
void Laplacian( InputArray src, OutputArray dst,int ddepth,int ksize = 3,double scale = 1,double delta = 0, int borderType = BORDER_DEFAULT
);
函数参数含义如下：
（1）InputArray类型的src ，输入图像。
（2）OutputArray类型的dst ，输出图像，图像的大小、通道数和输入图像相同。
（3）int类型的ddepth，目标图像的所需深度。
（4）int类型的ksize，用于计算二阶导数滤波器的孔径大小。大小必须是正数和奇数。
（5）double类型的scale，计算拉普拉斯值的可选比例因子。默认情况下，不应用缩放。
（6）double类型的delta，在将筛选的像素存储到dst中之前添加到这些像素的可选值。说的有点专业了其实就是给所选的像素值添加一个值delta。
（7）int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT。
处理流程为：
高斯模糊 – 去噪声GaussianBlur()；
转换为灰度图像cvtColor()；
拉普拉斯 – 二阶导数计算Laplacian()；
取绝对值convertScaleAbs()；
显示结果。
**模糊的作用：**当我们只想得到感兴趣的物体时，通过图像模糊，可以将那些尺寸和亮度较小的物体过滤掉，较大的物体则易于检测，以免对后续的算法产生不利影响。除了降低噪声，这就是图像平滑（模糊）的另一个重要应用：目标提取。
综合示例：
#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>
using namespace cv;
int main(int argc, char** argv) {
Mat src, dst;
src = imread("D:/vcprojects/images/lena.png");
if (!src.data) {
printf("could not load image");
}
char input_title[] = "input image";
char output_title[] = "Laplaiance Result";
namedWindow(input_title, CV_WINDOW_AUTOSIZE);
imshow(input_title, src);
Mat gray_src, edge_image;
GaussianBlur(src, dst, Size(3, 3), 0, 0);
cvtColor(dst, gray_src, CV_BGR2GRAY);
Laplacian(gray_src, edge_image, CV_16S, 3);
convertScaleAbs(edge_image, edge_image);
threshold(edge_image, edge_image, 0, 255, THRESH_OTSU | THRESH_BINARY);
namedWindow(output_title, CV_WINDOW_AUTOSIZE);
imshow(output_title, edge_image);
waitKey(0);
return 0;
}
5 Canny算法介绍
5.1边缘检测性能优劣性
评价边缘检测性能优劣的三个指标：
（1）好的信噪比，即将非边缘点判定为边缘点的概率要低，将边缘点判为非边缘点的概率要低；
（2）高的定位性能，即检测出的边缘点要尽可能在实际边缘的中心；
（3）对单一边缘仅有唯一响应，即单个边缘产生多个响应的概率要低，并且虚假响应边缘应该得到最大抑制。
用一句话说，就是希望在提高对景物边缘的敏感性的同时，可以抑制噪声的方法才是好的边缘提取方法。
5.2 Canny边缘检测算法的步骤：
（1）图像高斯滤波进行降噪处理。
（2）用一阶偏导的有限差分计算梯度的幅值和方向。
（3）对梯度幅值进行非极大值抑制。
（4）用双阈值算法检测和连接边缘。
5.3 Canny边缘检测算法的通俗理解
Canny算法的目的就是边缘检测，何为边缘？图象局部区域亮度变化显著的部分，对于灰度图像来说，也就是灰度值有一个明显变化，既从一个灰度值在很小的缓冲区域内急剧变化到另一个灰度相差较大的灰度值。那么怎么表征这种灰度值的变化呢？这里想到的就是导数微分，导数就是表征变化率的，但是数字图像都是离散的，也就是导数肯定会用差分来代替。
也就是具体算法中的步骤2，用相邻像素的差分来计算梯度的大小和方向。但是在真实的图像中，一般会有噪声，噪声会影响梯度的计算，所以步骤1要先滤波。理论上将图像梯度幅值的元素值越大，说明图像中该点的梯度值越大，但这不能说明该点就是边缘。在Canny算法中，步骤3的非极大值抑制是进行边缘检测的重要步骤，通俗意义上是指寻找像素点的局部最大值，沿着梯度方向，比较它前面和后面的梯度值，若梯度值局部最大则有可能为边缘像素，进行保留，否则就进行抑制。
步骤4是一个典型算法，有时候我们并不能一刀切，也就是超过阈值的都是边缘点，而是设两个阈值，希望在高阈值和低阈值之间的点也可能是边缘点，而且这些点最好在高阈值的附近，也就是说这些中间阈值的点是高阈值边缘点的一种延伸。所以步骤4用了双阈值来进行检测和连接边缘。双阈值有时也叫做滞后阈值。
步骤4高低阈值操作：T1， T2为阈值，凡是高于T2的都保留，凡是小于T1都丢弃，从高于T2的像素出发，凡是大于T1而且相互连接的，都保留。最终得到一个输出二值图像。推荐的高低阈值比值为 T2: T1 = 3:1/2:1其中T2为高阈值，T1为低阈值。
相应的API:
Canny（
InputArray src, // 8-bit的输入图像
OutputArray edges,// 输出边缘图像， 一般都是二值图像，背景是黑色
double threshold1,// 低阈值，常取高阈值的1/2或者1/3
double threshold2,// 高阈值
int aptertureSize,// Soble算子的size，通常3x3，取值3
bool L2gradient // 选择 true表示是L2来归一化，否则用L1归一化
）
综合示例：
#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>
using namespace cv;
Mat src, gray_src, dst;
int t1_value = 50;
int max_value = 255;
const char* OUTPUT_TITLE = "Canny Result";
void Canny_Demo(int, void*);
int main(int argc, char** argv) {
src = imread("D:/vcprojects/images/lena.png");
if (!src.data) {
printf("could not load image...\n");
return -1;
}
char INPUT_TITLE[] = "input image";
namedWindow(INPUT_TITLE, CV_WINDOW_AUTOSIZE);
namedWindow(OUTPUT_TITLE, CV_WINDOW_AUTOSIZE);
imshow(INPUT_TITLE, src);
cvtColor(src, gray_src, CV_BGR2GRAY);
createTrackbar("Threshold Value:", OUTPUT_TITLE, &t1_value, max_value, Canny_Demo);
Canny_Demo(0, 0);
waitKey(0);
return 0;
}
void Canny_Demo(int, void*) {
Mat edge_output;
blur(gray_src, gray_src, Size(3, 3), Point(-1, -1), BORDER_DEFAULT);
Canny(gray_src, edge_output, t1_value, t1_value * 2, 3, false);
//dst.create(src.size(), src.type());
//src.copyTo(dst, edge_output);
// (edge_output, edge_output);
imshow(OUTPUT_TITLE, ~edge_output);
}
