OpenCV图像处理基础(C++版)_opencv c++-程序员宅基地

#include<opencv2\opencv.hpp>
using namespace cv;

int main(int argc, char** argv)
{
	Mat src = imread("C:\\Users\\td\\Desktop\\he.jpeg");
	if (src.empty())
	{
		printf("could not load image ...\n");
		return -1;
	}
	namedWindow("test opencv setup ", CV_WINDOW_AUTOSIZE);
	imshow("test opencv setup", src);

	waitKey(0);
	
	return 0;
}

加载修改保存图像

imread函数

imread功能是加载图像文件成为一个Mat对象，其中第一个参数表示图像文件名称

第二个参数，表示加载的图像是什么类型，支持常见的三个参数值

IMREAD_UNCHANGED (<0) 表示加载原图，不做任何改变

IMREAD_GRAYSCALE (0)表示把原图作为灰度图像加载进来,如下这行代码就是加载灰度图像.

Mat src = imread("C:\\Users\\td\\Desktop\\he.jpeg", IMREAD_GRAYSCALE);

IMREAD_COLOR (>0) 表示把原图作为RGB图像加载进来

注意：OpenCV支持JPG、PNG、TIFF等常见格式图像文件加载

namedWindow函数

namedWindos功能是创建一个OpenCV窗口，它是由OpenCV自动创建与释放，你无需取销毁它。常见用法namedWindow("Window Title", WINDOW_AUTOSIZE)

WINDOW_AUTOSIZE会自动根据图像大小，显示窗口大小，不能人为改变窗口大小 WINDOW_NORMAL,跟QT集成的时候会使用，允许修改窗口大小。

imshow函数

imshow根据窗口名称显示图像到指定的窗口上去，第一个参数是窗口名称，第二参数是Mat对象

cvtColor函数

cvtColor的功能是把图像从一个彩色空间转换到另外一个色彩空间，有三个参数，第一个参数表示源图像、第二参数表示色彩空间转换之后的图像、第三个参数表示源和目标色彩空间如：COLOR_BGR2HLS 、COLOR_BGR2GRAY 等

imwrite函数

保存图像文件到指定目录路径

只有8位、16位的PNG、JPG、Tiff文件格式而且是单通道或者三通道的BGR的图像才可以通过这种方式保存

保存PNG格式的时候可以保存透明通道的图片

可以指定压缩参数

#include<opencv2\opencv.hpp>
using namespace cv;

int main(int argc, char** argv)
{
	Mat src = imread("C:\\Users\\td\\Desktop\\he.jpeg");
	if (src.empty())
	{
		printf("could not load image ...\n");
		return -1;
	}
	namedWindow("test opencv setup ", CV_WINDOW_AUTOSIZE);
	imshow("test opencv setup", src);
	waitKey(20);
	
	//转换相应的色彩空间
	namedWindow("output windows", CV_WINDOW_AUTOSIZE);
	Mat output;//存储转换之后的图像
	cvtColor(src, output,CV_BGR2BGR555);
	imshow("output windows", output);
	
	//保存图片的过程
	imwrite("D:/zhubajie.png", output);
	waitKey(0);
	
	return 0;
}

矩阵的掩膜操作

掩膜操作:实现图像对比度调整(来重新计算每个像素的像素值)

红色是中心像素，从上到下，从左到右对每个像素做同样的处理操作，得到最终结果就是对比度提高之后的输出图像Mat对象.如下图所示:

计算公式是如下所示:

图像的通道数

基本上，描述一个像素点，如果是灰度，那么只需要一个数值来描述它，就是单通道。
如果一个像素点，有RGB三种颜色来描述它，就是三通道.

获取图像像素指针

CV_Assert(myImage.depth() == CV_8U);

Mat.ptr<uchar>(int i=0) 获取像素矩阵的指针，索引i表示第几行，从0开始计行数。

获得当前行指针const uchar* current= myImage.ptr<uchar>(row );

获取当前像素点P(row, col)的像素值 p(row, col) =current[col]

像素范围处理saturate_cast<uchar>

saturate_cast<uchar>（-100），返回 0。

saturate_cast<uchar>（288），返回255

saturate_cast<uchar>（100），返回100 这个函数的功能是确保RGB值得范围在0~255之间

矩阵的掩膜操作的过程是如下代码所示:

#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>

using namespace cv;

int main(int argc, char** argv) {
	Mat src, dst;
	src = imread("C:\\Users\\td\\Desktop\\he.jpeg");
	if (!src.data) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input image", CV_WINDOW_AUTOSIZE);
	imshow("input image", src);

	/*
	int cols = (src.cols-1) * src.channels();//宽度上面提前打算
	int offsetx = src.channels();
	int rows = src.rows;

	dst = Mat::zeros(src.size(), src.type());//获取和src Mat类型
	for (int row = 1; row < (rows - 1); row++) {//第一行和最后一行是很难形成相应的图形,因此,进行一个省略的操作.
	const uchar* previous = src.ptr<uchar>(row - 1);//获取前一行
	const uchar* current = src.ptr<uchar>(row);//获取当前行
	const uchar* next = src.ptr<uchar>(row + 1);//获取下一行
	uchar* output = dst.ptr<uchar>(row);
	for (int col = offsetx; col < cols; col++) {
	output[col] = saturate_cast<uchar>(5 * current[col] - (current[col- offsetx] + current[col+ offsetx] + previous[col] + next[col]));
	}
	}
	namedWindow("contrast image demo", CV_WINDOW_AUTOSIZE);
	imshow("contrast image demo", dst);

	*/
	double t = getTickCount();
	Mat kernel = (Mat_<char>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);//定义一个掩膜
	filter2D(src, dst, src.depth(), kernel);//掩膜操作,将src之中的计算结果直接输出到dst之中
	double timeconsume = (getTickCount() - t) / getTickFrequency();
	printf("tim consume %.2f\n", timeconsume);

	namedWindow("contrast image demo", CV_WINDOW_AUTOSIZE);
	imshow("contrast image demo", dst);

	waitKey(0);
	return 0;
}

Mat对象

什么叫做Mat对象??

在人眼之中,这是一个一个对象,但是在计算机的眼中,这是一个个数据.

Mat对象与IplImage对象的对比

Mat对象OpenCV2.0之后引进的图像数据结构、自动分配内存、不存在内存泄漏的问题，是面向对象的数据结构。分了两个部分，头部与数据部分

IplImage是从2001年OpenCV发布之后就一直存在，是C语言风格的数据结构，需要开发者自己分配与管理内存，对大的程序使用它容易导致内存泄漏问题(建议不进行使用)

常用的构造函数

Mat对象的使用

部分复制：一般情况下只会复制Mat对象的头和指针部分，不会复制数据部分 Mat A= imread(imgFilePath); Mat B(A) // 只复制

完全复制：如果想把Mat对象的头部和数据部分一起复制，可以通过如下两个API实现 Mat F = A.clone(); 或 Mat G; A.copyTo(G);

Mat对象使用的四个要点

输出图像的内存是自动分配的

使用OpenCV的C++接口，不需要考虑内存分配问题

赋值操作和拷贝构造函数只会复制头部分

使用clone与copyTo两个函数实现数据完全复制

Mat对象创建

(1)cv::Mat::Mat 构造函数

Mat M(2,2,CV_8UC3, Scalar(0,0,255)) 其中前两个参数分别表示行(row)跟列(column)、第三个CV_8UC3中的8表示每个通道占8位、U表示无符号、C表示Char类型、3表示通道数目是3，第四个参数是向量表示初始化每个像素值是多少，向量长度对应通道数目一致

(2)cv::Mat::create 创建多维数组

int sz[3] = {2,2,2}; Mat L(3,sz, CV_8UC1, Scalar::all(0)); 一般我们是用不到这个的,进行了解一下就行.

一些代码

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main(int argc, char** argv) {
	Mat src;
	src = imread("C:\\Users\\td\\Desktop\\zhu.jpg");
	if (src.empty()) {
		cout << "could not load image..." << endl;
		return -1;
	}
	namedWindow("input", CV_WINDOW_AUTOSIZE);
	imshow("input", src);

	/*Mat dst;
	dst = Mat(src.size(), src.type());
	dst = Scalar(127, 0, 255);
	namedWindow("output", CV_WINDOW_AUTOSIZE);
	imshow("output", dst);*/
	Mat dst;
	//src.copyTo(dst);
	namedWindow("output", CV_WINDOW_AUTOSIZE);

	cvtColor(src, dst, CV_BGR2GRAY);
	printf("input image channels : %d\n", src.channels());
	printf("output image channels : %d\n", dst.channels());

	int cols = dst.cols;
	int rows = dst.rows;

	printf("rows : %d cols : %d\n", rows, cols);
	const uchar* firstRow = dst.ptr<uchar>(0);
	printf("fist pixel value : %d\n", *firstRow);

	Mat M(100, 100, CV_8UC1, Scalar(127));
	//cout << "M =" << endl << M << endl;

	Mat m1;
	m1.create(src.size(), src.type());
	m1 = Scalar(0, 0, 255);

	Mat csrc;
	Mat kernel = (Mat_<char>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
	filter2D(src, csrc, -1, kernel);

	Mat m2 = Mat::eye(2, 2, CV_8UC1);
	cout << "m2 =" << endl << m2 << endl;

	Mat m2 = Mat::zeros(2, 2, CV_8UC1);//纯黑的图片

	imshow("output", m2);
	waitKey(0);
	return 0;
}

图像操作

读取像素

读一个GRAY像素点的像素值（CV_8UC1）

Scalar intensity = img.at<uchar>(y, x); 或者 Scalar intensity = img.at<uchar>(Point(x, y));

读一个RGB像素点的像素值

Vec3f intensity = img.at<Vec3f>(y, x); float blue = intensity.val[0]; float green = intensity.val[1]; float red = intensity.val[2];

修改像素值
灰度图像

img.at<uchar>(y, x) = 128;

RGB三通道图像

img.at<Vec3b>(y,x)[0]=128; // blue

img.at<Vec3b>(y,x)[1]=128; // green

img.at<Vec3b>(y,x)[2]=128; // red

空白图像赋值 img = Scalar(0);

ROI选择 Rect r(10, 10, 100, 100); Mat smallImg = img(r);

代码示例:

#include <opencv2/core/core.hpp> 
#include <opencv2/imgcodecs.hpp> 
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>

using namespace cv;
using namespace std;
int main(int argc, char** args) {
	Mat image = imread("C:/Users/td/Desktop/zhu.jpg", IMREAD_COLOR);
	if (image.empty()) {
		cout << "could not find the image resource..." << std::endl;
		return -1;
	}

	Mat grayImg;
	Mat dst;
	cvtColor(image, grayImg, COLOR_BGR2GRAY);
	 //单通道的一个像素提取过程
	int height = image.rows;
	int width = image.cols;
	int channels = image.channels();
	printf("height=%d width=%d channels=%d", height, width, channels);
	for (int row = 0; row < height; row++) {
	for (int col = 0; col < width; col++) {
	int grey = image.at<uchar>(row,col);
	}
	}
	
	//三通道的像素提取过程
	int height = image.rows;
	int width = image.cols;
	int channels = image.channels();
	printf("height=%d width=%d channels=%d", height, width, channels);
	for (int row = 0; row < height; row++) {
	for (int col = 0; col < width; col++) {
	if (channels == 3) {
	int b = image.at<Vec3b>(row, col)[0]; // blue
	int g = image.at<Vec3b>(row, col)[1]; // green
	int r = image.at<Vec3b>(row, col)[2]; // red
	}
	}
	}
	bitwise_not(image,dst);//将255-现在的像素值得到相应的结果.
}

图像混合

理论-线性混合操作

上述表示是两幅图像进行一个合并的过程,其中a代表着相应的权重,上述是线型混合理论.

API:addWeighted

参数1：输入图像Mat – src1

参数2：输入图像src1的alpha值权重

参数3：输入图像Mat – src2

参数4：输入图像src2的beta值权重

参数5：gamma值:校验值

参数6：输出混合图像

注意点：两张图像的大小和类型必须一致才可以

调整图像亮度与对比度

理论

像素变换 – 点操作 (调整图像亮度和对比度属于像素变换-点操作)

邻域操作 – 区域

API回顾

Mat new_image = Mat::zeros( image.size(), image.type() ); 创建一张跟原图像大小和类型一致的空白图像、像素值初始化为0

saturate_cast<uchar>(value)确保值大小范围为0~255之间

Mat.at<Vec3b>(y,x)[index]=value 给每个像素点每个通道赋值

代码实现

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
int main(int argc, char** argv) {
	Mat src, dst;
	src = imread("C:/Users/td/Desktop/zhu.jpg");
	if (!src.data) {
		printf("could not load image...\n");
		return -1;
	}
	char input_win[] = "input image";
	cvtColor(src, src, CV_BGR2GRAY);
	namedWindow(input_win, CV_WINDOW_AUTOSIZE);
	imshow(input_win, src);

	// contrast and brigthtness changes 
	int height = src.rows;
	int width = src.cols;
	dst = Mat::zeros(src.size(), src.type());
	float alpha = 1.2;//对比度
	float beta = 30;//调节亮度的关键参数

	Mat m1;
	src.convertTo(m1, CV_32F);
	for (int row = 0; row < height; row++) {
		for (int col = 0; col < width; col++) {
			if (src.channels() == 3) {
				float b = m1.at<Vec3f>(row, col)[0];// blue
				float g = m1.at<Vec3f>(row, col)[1]; // green
				float r = m1.at<Vec3f>(row, col)[2]; // red

													 // output
				dst.at<Vec3b>(row, col)[0] = saturate_cast<uchar>(b*alpha + beta);
				dst.at<Vec3b>(row, col)[1] = saturate_cast<uchar>(g*alpha + beta);
				dst.at<Vec3b>(row, col)[2] = saturate_cast<uchar>(r*alpha + beta);
			}
			else if (src.channels() == 1) {
				float v = src.at<uchar>(row, col);
				dst.at<uchar>(row, col) = saturate_cast<uchar>(v*alpha + beta);
			}
		}
	}

	char output_title[] = "contrast and brightness change demo";
	namedWindow(output_title, CV_WINDOW_AUTOSIZE);
	imshow(output_title, dst);

	waitKey(0);
	return 0;
}

绘制形状与文字

cv::Point与cv::Scalar

Point表示2D平面上一个点x,y Point p; p.x = 10; p.y = 8; or p = Pont(10,8);

Scalar表示四个元素的向量 Scalar(a, b, c);// a = blue, b = green, c = red表示RGB三个通道

测试代码

#include <opencv2/opencv.hpp>
#include <iostream>

	using namespace std;
	using namespace cv;
	Mat bgImage;
	const char* drawdemo_win = "draw shapes and text demo";
	void MyLines();
	void MyRectangle();
	void MyEllipse();
	void MyCircle();
	void MyPolygon();
	void RandomLineDemo();
	int main(int argc, char** argv) {
		bgImage = imread("C:\\Users\\td\\Desktop/li.jpg");
		if (!bgImage.data) {
			printf("could not load image...\n");
			return -1;
		}
	    MyLines();
		MyRectangle();
		MyEllipse();
		MyCircle();
		MyPolygon();
		//参数的含义                                      代表着不同的字体         放缩系数                 
		putText(bgImage, "Hello OpenCV", Point(300, 300), CV_FONT_HERSHEY_COMPLEX, 1.0, Scalar(12, 23, 200), 3, 8);
		namedWindow(drawdemo_win, CV_WINDOW_AUTOSIZE);
		imshow(drawdemo_win, bgImage);

		RandomLineDemo();
		waitKey(0);
		return 0;
	}

	void MyLines() {//执行一个划线的操作
		Point p1 = Point(20, 30);
		Point p2;
		p2.x = 400;
		p2.y = 400;
		Scalar color = Scalar(0, 0, 255);
		line(bgImage, p1, p2, color, 1, LINE_AA);//LINE_AA的含义是进行一个反锯齿操作,LINE_8是进行一个常规的划线操作
	}

	void MyRectangle() {//画出矩形
		Rect rect = Rect(200, 100, 300, 300);//参数1 参数2是起始位置,参数3 参数4是宽高
		Scalar color = Scalar(255, 0, 0);
		rectangle(bgImage, rect, color, 2, LINE_8);//参数4是线宽
	}

	void MyEllipse() {//椭圆
		Scalar color = Scalar(0, 255, 0);
		//下面参数的含义
		//     图像      中心点位置                                 长                    高                 角度  0-360  颜色  线宽  
		ellipse(bgImage, Point(bgImage.cols / 2, bgImage.rows / 2), Size(bgImage.cols / 4, bgImage.rows / 8), 90, 0, 360, color, 2, LINE_8);
	}

	void MyCircle() {//圆
		Scalar color = Scalar(0, 255, 255);
		Point center = Point(bgImage.cols / 2, bgImage.rows / 2);
		circle(bgImage, center, 150, color, 2, 8);//参数3是半径长度  
	}

	void MyPolygon() {//多边形
		Point pts[1][5];
		pts[0][0] = Point(100, 100);
		pts[0][1] = Point(100, 200);
		pts[0][2] = Point(200, 200);
		pts[0][3] = Point(200, 100);
		pts[0][4] = Point(100, 100);

		const Point* ppts[] = { pts[0] };
		int npt[] = { 5 };
		Scalar color = Scalar(255, 12, 255);

		fillPoly(bgImage, ppts, npt, 1, color, 8);//参数4是轮廓的含义
	}

	void RandomLineDemo() {
		RNG rng(12345);//随机的函数,给他一个种子
		Point pt1;
		Point pt2;
		Mat bg = Mat::zeros(bgImage.size(), bgImage.type());//生成一个纯黑色的图片,在这个纯黑色的图片之中进行相应的操作.
		namedWindow("random line demo", CV_WINDOW_AUTOSIZE);
		for (int i = 0; i < 100000; i++) {
			//生成随机数的过程
			pt1.x = rng.uniform(0, bgImage.cols);
			pt2.x = rng.uniform(0, bgImage.cols);
			pt1.y = rng.uniform(0, bgImage.rows);
			pt2.y = rng.uniform(0, bgImage.rows);

			Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));//给定一个随机的颜色
			if (waitKey(50) > 0) {
				break;
			}
			line(bg, pt1, pt2, color, 1, 8);
			imshow("random line demo", bg);
		}
	}

模糊图像一

原理

Smooth/Blur 是图像处理中最简单和常用的操作之一

使用该操作的原因之一就为了给图像预处理时候减低噪声

使用Smooth/Blur操作其背后是数学的卷积计算

通常这些卷积算子计算都是线性操作，所以又叫线性滤波

过程上面的边缘处理过程是需要进行使用插值处理
模糊原理

归一化盒子滤波（均值滤波）
高斯滤波

相关API

均值模糊 - blur(Mat src, Mat dst, Size(xradius, yradius), Point(-1,-1));

高斯模糊 - GaussianBlur(Mat src, Mat dst, Size(11, 11), sigmax, sigmay); 其中Size（x, y）, x, y 必须是正数而且是奇数

代码示例

#include <opencv2/opencv.hpp> 
#include <iostream> 
using namespace cv;

int main(int argc, char** argv) {
	Mat src, dst;
	src = imread("C:\\Users\\td\\Desktop/li.jpg");
	if (!src.data) {
		printf("could not load image...\n");
		return -1;
	}
	char input_title[] = "input image";
	char output_title[] = "blur image";
	namedWindow(input_title, CV_WINDOW_AUTOSIZE);
	namedWindow(output_title, CV_WINDOW_AUTOSIZE);
	imshow(input_title, src);

	//均值模糊
	blur(src, dst, Size(11, 12), Point(-1, -1)); //这里的size(15,1)就是相当于电影之中的武打片,模糊
	imshow(output_title, dst);

	//高斯模糊
	Mat gblur;
	GaussianBlur(src, gblur, Size(11, 11), 11, 11);
	imshow("gaussian blur", gblur);

	waitKey(0);
	return 0;
}

结果

模糊图像二

中值滤波

统计排序滤波器

中值对椒盐噪声有很好的抑制作用（就像是一个图像上面撒了一些白点和黑点）

双边滤波

均值模糊无法克服边缘像素信息丢失缺陷。原因是均值滤波是基于平均权重

高斯模糊部分克服了该缺陷，但是无法完全避免，因为没有考虑像素值的不同(只是考虑了相应的空间之间的不用,但是没有考虑像素的不同)

高斯双边模糊 – 是边缘保留的滤波方法，避免了边缘信息丢失，保留了图像轮廓不变(边缘保留的)

高斯滤波是高度中心对称的，相应的一个权重是对应的。是需要进行一个中心化的过程，这就是进行一个高斯的过程，比较容易进行理解。就比如说下面的

x=-2,w=0.05; x=-1,w=0.15; x=0,w=0.6; x=1,w=0.15; x=1,w=0.15; x=2,w=0.05;

API的调用

中值模糊medianBlur（Mat src, Mat dest, ksize）

双边模糊bilateralFilter(src, dest, d=15, 150, 3);(有一个数学公式,一头雾水,就不看了)

- 15 –计算的半径，半径之内的像数都会被纳入计算，如果提供-1 则根据sigma space参数取值

- 150 – sigma color 决定多少差值之内的像素会被计算

- 3 – sigma space 如果d的值大于0则声明无效，否则根据它来计算d值中值模糊的ksize大小必须是大于1而且必须是奇数。

代码

#include <opencv2/opencv.hpp> 
#include <iostream> 
		using namespace cv;

		int main(int argc, char** argv) {
			Mat src, dst;
			src = imread("C:\\Users\\td\\Desktop/li.jpg");
			if (!src.data) {
				printf("could not load image...\n");
				return -1;
			}
			namedWindow("input image", CV_WINDOW_AUTOSIZE);
			imshow("input image", src);

			//medianBlur(src, dst, 3);//中值滤波 3*3类型
			bilateralFilter(src, dst, 15, 100, 5);//轮廓是还在的,只是模糊了一下,如果要是使用高斯滤波的话GaussianBlur进行处理的话,会变成更加模糊.双边的会更加好一点
			namedWindow("BiBlur Filter Result", CV_WINDOW_AUTOSIZE);
			imshow("BiBlur Filter Result", dst);

			Mat resultImg;
			Mat kernel = (Mat_<int>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
			filter2D(dst, resultImg, -1, kernel, Point(-1, -1), 0);
			imshow("Final Result", resultImg);

			waitKey(0);
			return 0;

		}

膨胀与腐蚀

形态学操作(morphology operators)-膨胀

图像形态学操作 – 基于形状的一系列图像处理操作的合集，主要是基于集合论基础上的形态学数学

形态学有四个基本操作：腐蚀、膨胀、开、闭

膨胀与腐蚀是图像处理中最常用的形态学操作手段

膨胀

跟卷积操作类似，假设有图像A和结构元素B，结构元素B在A上面移动，其中B定义其中心为锚点，计算B覆盖下A的最大像素值用来替换锚点的像素，其中B作为结构体可以是任意形状

腐蚀

腐蚀跟膨胀操作的过程类似，唯一不同的是以最小值替换锚点重叠下图像的像素值

getStructuringElement(int shape, Size ksize, Point anchor)

- 形状 (MORPH_RECT \MORPH_CROSS \MORPH_ELLIPSE)

- 大小必须是奇数

- 锚点默认是Point(-1, -1)意思就是中心像素

dilate(src, dst, kernel)

调整结构元素的大小

TrackBar – createTrackbar(const String & trackbarname, const String winName, int* value, int count, Trackbarcallback func, void* userdata=0)

其中最中要的是 callback 函数功能。如果设置为NULL就是说只有值update，但是不会调用callback的函数

代码

#include <opencv2/opencv.hpp> 
#include <iostream> 
		using namespace cv;

		Mat src, dst;
		char OUTPUT_WIN[] = "output image";
		int element_size = 3;
		int max_size = 21;
		void CallBack_Demo(int, void*);
		int main(int argc, char** argv) {

			src = imread("C:\\Users\\td\\Desktop/li.jpg");
			if (!src.data) {
				printf("could not load image...\n");
				return -1;
			}
			namedWindow("input image", CV_WINDOW_AUTOSIZE);
			imshow("input image", src);

			namedWindow(OUTPUT_WIN, CV_WINDOW_AUTOSIZE);
			createTrackbar("Element Size :", OUTPUT_WIN, &element_size, max_size, CallBack_Demo);
			CallBack_Demo(0, 0);

			waitKey(0);
			return 0;
		}

		void CallBack_Demo(int, void*) {
			int s = element_size * 2 + 1;
			Mat structureElement = getStructuringElement(MORPH_RECT, Size(s, s), Point(-1, -1));
			dilate(src, dst, structureElement, Point(-1, -1), 1);
			//erode(src, dst, structureElement);
			imshow(OUTPUT_WIN, dst);
			return;
		}

通过代码的运行可以知道,膨胀是进行一个变白的过程,腐蚀是一个图片变黑的过程.

实际的项目之中可以通过中值滤波,消除椒盐噪声,在用一次腐蚀去除掉相应的干扰,最后,加上膨胀将轮廓进行一个放大的过程.

形态学操作

开操作- open

先腐蚀后膨胀:可以去掉小的对象，假设对象是前景色，背景是黑色

闭操作-close

先膨胀后腐蚀(bin2) - 可以填充小的洞（fill hole），假设对象是前景色，背景是黑色

形态学梯度- Morphological Gradient

膨胀减去腐蚀又称为基本梯度（其它还包括-内部梯度、方向梯度）

顶帽 – top hat

顶帽是原图像与开操作之间的差值图像

黑帽

黑帽是闭操作图像与源图像的差值图像

API调用

morphologyEx(src, dest, CV_MOP_BLACKHAT, kernel);

- Mat src – 输入图像

- Mat dest – 输出结果

- int OPT – CV_MOP_OPEN/ CV_MOP_CLOSE/ CV_MOP_GRADIENT / CV_MOP_TOPHAT/ CV_MOP_BLACKHAT 形态学操作类型

-Mat kernel 结构元素 int Iteration 迭代次数，默认是1

代码

#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>

using namespace cv;
int main(int argc, char** argv) {
	Mat src, dst;
	src = imread("C:\\Users\\td\\Desktop/li.jpg");
	if (!src.data) {
		printf("could not load image...\n");
	}
	namedWindow("input image", CV_WINDOW_AUTOSIZE);
	imshow("input image", src);
	char output_title[] = "morphology demo";
	namedWindow(output_title, CV_WINDOW_AUTOSIZE);

	//结构元素的大小的选取会影响相应的最后获得的结果
	Mat kernel = getStructuringElement(MORPH_RECT, Size(11, 11), Point(-1, -1));
	
	//开操作:CV_MOP_OPEN	闭操作:CV_MOP_CLOSE		梯度:CV_MOP_GRADIENT	顶帽:CV_MOP_TOPHAT:原图像-开操作图像	黑帽:CV_MOP_BLACKHAT:闭操作与原图像之间的插值图像
	morphologyEx(src, dst, CV_MOP_BLACKHAT, kernel);
	imshow(output_title, dst);

	waitKey(0);
	return 0;
}

结果:图片是贼好看的

形态学操作应用-提取水平线和垂直线

形态学操作的原理

图像形态学操作时候，可以通过自定义的结构元素实现结构元素对输入图像一些对象敏感、另外一些对象不敏感，这样就会让敏感的对象改变而不敏感的对象保留输出。通过使用两个最基本的形态学操作 – 膨胀与腐蚀，使用不同的结构元素实现对输入图像的操作、得到想要的结果。

- 膨胀，输出的像素值是结构元素覆盖下输入图像的最大像素值

- 腐蚀，输出的像素值是结构元素覆盖下输入图像的最小像素值

灰度图像的膨胀
灰度图像的腐蚀
结构元素

上述膨胀与腐蚀过程可以使用任意的结构元素

常见的形状：矩形、园、直线、磁盘形状、砖石形状等各种自定义形状。

提取步骤

输入图像彩色图像 imread
转换为灰度图像 – cvtColor
转换为二值图像 – adaptiveThreshold
定义结构元素开操作（腐蚀+膨胀）

提取水平与垂直线
转换为二值图像 – adaptiveThreshold API

代码

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
int main(int argc, char** argv) {
	Mat src, dst;
	src = imread("D:/vcprojects/images/chars.png");
	if (!src.data) {
		printf("could not load image...\n");
		return -1;
	}

	char INPUT_WIN[] = "input image";
	char OUTPUT_WIN[] = "result image";
	namedWindow(INPUT_WIN, CV_WINDOW_AUTOSIZE);
	imshow(INPUT_WIN, src);

	Mat gray_src;
	cvtColor(src, gray_src, CV_BGR2GRAY);
	imshow("gray image", gray_src);
	
	Mat binImg;
	adaptiveThreshold(~gray_src, binImg, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
	imshow("binary image", binImg);

	// 水平结构元素
	Mat hline = getStructuringElement(MORPH_RECT, Size(src.cols / 16, 1), Point(-1, -1));
	// 垂直结构元素
	Mat vline = getStructuringElement(MORPH_RECT, Size(1, src.rows / 16), Point(-1, -1));
	// 矩形结构
	Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1, -1));

	Mat temp;
	erode(binImg, temp, kernel);
	dilate(temp, dst, kernel);
	// morphologyEx(binImg, dst, CV_MOP_OPEN, vline);
	bitwise_not(dst, dst);
	//blur(dst, dst, Size(3, 3), Point(-1, -1));
	imshow("Final Result", dst);

	waitKey(0);
	return 0;
}

图像金字塔-上采集与降采集

图像金字塔概念

1. 我们在图像处理中常常会调整图像大小，最常见的就是放大(zoom in)和缩小（zoom out），尽管几何变换也可以实现图像放大和缩小，但是这里我们介绍图像金字塔

2. 一个图像金字塔式一系列的图像组成，最底下一张是图像尺寸最大，最上方的图像尺寸最小，从空间上从上向下看就想一个古代的金字塔。

图像金字塔概念

高斯金子塔 – 用来对图像进行降采样

拉普拉斯金字塔 – 用来重建一张图片根据它的上层降采样图片

高斯金字塔

高斯金子塔是从底向上，逐层降采样得到。

降采样之后图像大小是原图像MxN的M/2 x N/2 ,就是对原图像删除偶数行与列，即得到降采样之后上一层的图片。(降采样的过程就是相当于是进行一个将上层之中的精英进行一个采样的过程)

高斯金子塔的生成过程分为两步：(逐层采样的过程)

- 对当前层进行高斯模糊

- 删除当前层的偶数行与列, 即可得到上一层的图像，这样上一层跟下一层相比，都只有它的1/4大小。

高斯不同(Difference of Gaussian-DOG)

定义：就是把同一张图像在不同的参数下做高斯模糊之后的结果相减，得到的输出图像。称为高斯不同(DOG) 高斯不同是图像的内在特征，在灰度图像增强、角点检测中经常用到。

采样相关API

上采样(cv::pyrUp) – zoom in 放大

降采样 (cv::pyrDown) – zoom out 缩小

pyrUp(Mat src, Mat dst, Size(src.cols*2, src.rows*2)) 生成的图像是原图在宽与高各放大两倍 pyrDown(Mat src, Mat dst, Size(src.cols/2, src.rows/2)) 生成的图像是原图在宽与高各缩小1/2

代码

#include <opencv2/opencv.hpp>
#include <iostream>
#include "math.h"

using namespace cv;
int main(int agrc, char** argv) {
	Mat src, dst;
	src = imread("C:\\Users\\td\\Desktop/li.jpg");
	if (!src.data) {
		printf("could not load image...");
		return -1;
	}

	char INPUT_WIN[] = "input image";
	char OUTPUT_WIN[] = "sample up";
	namedWindow(INPUT_WIN, CV_WINDOW_AUTOSIZE);
	namedWindow(OUTPUT_WIN, CV_WINDOW_AUTOSIZE);
	imshow(INPUT_WIN, src);

	// 上采样
	pyrUp(src, dst, Size(src.cols * 2, src.rows * 2));
	imshow(OUTPUT_WIN, dst);

	// 降采样
	Mat s_down;
	pyrDown(src, s_down, Size(src.cols / 2, src.rows / 2));
	imshow("sample down", s_down);

	// DOG
	Mat gray_src, g1, g2, dogImg;
	cvtColor(src, gray_src, CV_BGR2GRAY);
	GaussianBlur(gray_src, g1, Size(5, 5), 0, 0);
	GaussianBlur(g1, g2, Size(5, 5), 0, 0);
	subtract(g1, g2, dogImg, Mat());

	// 归一化显示:线性提亮的过程使用
	normalize(dogImg, dogImg, 255, 0, NORM_MINMAX);
	imshow("DOG Image", dogImg);

	waitKey(0);
	return 0;
}

结果

基本阈值操作

图像阈值（threshold）

阈值是什么？简单点说是把图像分割的标尺，这个标尺是根据什么产生的，阈值产生算法？阈值类型。（Binary segmentation）将像素值看成是苹果的大小, 大于某一个像素可以看成是一个部分,小于一个像素可以看成是另一个像素.这个像素标尺就是可以看成是相应的阈值.