OpenCV圖像處理基礎(chǔ)(C++版)

這篇具有很好參考價值的文章主要介紹了OpenCV圖像處理基礎(chǔ)(C++版)。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

OpenCV環(huán)境搭建

加載修改保存圖像

矩陣的掩膜操作

Mat對象

圖像操作

圖像混合

調(diào)整圖像亮度與對比度

繪制形狀與文字

模糊圖像一

模糊圖像二

膨脹與腐蝕

形態(tài)學(xué)操作

形態(tài)學(xué)操作應(yīng)用-提取水平線和垂直線

圖像金字塔-上采集與降采集

基本閾值操作

自定義線性濾波

處理邊緣

Sobel算子

Laplance算子

Canny邊緣檢測

霍夫變換-直線

霍夫圓變換

像素重映射

直方圖均衡化

直方圖計算

直方圖比較

直方圖反向透射

模板匹配

輪廓發(fā)現(xiàn)

凸包

輪廓周圍繪制矩形框和圓形框

圓形矩

點多邊形測試

基于距離變換與分水嶺的圖像分割

OpenCV環(huán)境搭建

配置環(huán)境變量

OpenCV圖像處理基礎(chǔ)(C++版)

?新建項目

視圖 - 其他窗口 - 屬性管理器 OpenCV圖像處理基礎(chǔ)(C++版)

?添加附加依賴項 OpenCV圖像處理基礎(chǔ)(C++版)

?測試代碼(這里應(yīng)當注意,在進行測試的時候,注意相應(yīng)位數(shù))

#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函數(shù)

imread功能是加載圖像文件成為一個Mat對象，其中第一個參數(shù)表示圖像文件名稱

第二個參數(shù)，表示加載的圖像是什么類型，支持常見的三個參數(shù)值

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函數(shù)

namedWindos功能是創(chuàng)建一個OpenCV窗口，它是由OpenCV自動創(chuàng)建與釋放，你無需取銷毀它。常見用法namedWindow("Window Title", WINDOW_AUTOSIZE)

WINDOW_AUTOSIZE會自動根據(jù)圖像大小，顯示窗口大小，不能人為改變窗口大小 WINDOW_NORMAL,跟QT集成的時候會使用，允許修改窗口大小。

imshow函數(shù)

imshow根據(jù)窗口名稱顯示圖像到指定的窗口上去，第一個參數(shù)是窗口名稱，第二參數(shù)是Mat對象

cvtColor函數(shù)

cvtColor的功能是把圖像從一個彩色空間轉(zhuǎn)換到另外一個色彩空間，有三個參數(shù)，第一個參數(shù)表示源圖像、第二參數(shù)表示色彩空間轉(zhuǎn)換之后的圖像、第三個參數(shù)表示源和目標色彩空間如：COLOR_BGR2HLS 、COLOR_BGR2GRAY 等?

imwrite函數(shù)

保存圖像文件到指定目錄路徑

只有8位、16位的PNG、JPG、Tiff文件格式而且是單通道或者三通道的BGR的圖像才可以通過這種方式保存

保存PNG格式的時候可以保存透明通道的圖片

可以指定壓縮參數(shù)

#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);
	
	//轉(zhuǎn)換相應(yīng)的色彩空間
	namedWindow("output windows", CV_WINDOW_AUTOSIZE);
	Mat output;//存儲轉(zhuǎn)換之后的圖像
	cvtColor(src, output,CV_BGR2BGR555);
	imshow("output windows", output);
	
	//保存圖片的過程
	imwrite("D:/zhubajie.png", output);
	waitKey(0);
	
	return 0;
}

矩陣的掩膜操作

?掩膜操作:實現(xiàn)圖像對比度調(diào)整(來重新計算每個像素的像素值)

????????紅色是中心像素，從上到下，從左到右對每個像素做同樣的處理操作，得到最終結(jié)果就是對比度提高之后的輸出圖像Mat對象.如下圖所示:

OpenCV圖像處理基礎(chǔ)(C++版)

????????計算公式是如下所示:

OpenCV圖像處理基礎(chǔ)(C++版)

?圖像的通道數(shù)

基本上，描述一個像素點，如果是灰度，那么只需要一個數(shù)值來描述它，就是單通道。
如果一個像素點，有RGB三種顏色來描述它，就是三通道.

獲取圖像像素指針

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

Mat.ptr<uchar>(int i=0) 獲取像素矩陣的指針，索引i表示第幾行，從0開始計行數(shù)。

獲得當前行指針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 這個函數(shù)的功能是確保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++) {//第一行和最后一行是很難形成相應(yīng)的圖形,因此,進行一個省略的操作.
	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之中的計算結(jié)果直接輸出到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對象??

OpenCV圖像處理基礎(chǔ)(C++版)

????????在人眼之中,這是一個一個對象,但是在計算機的眼中,這是一個個數(shù)據(jù).?

Mat對象與IplImage對象的對比

????????Mat對象OpenCV2.0之后引進的圖像數(shù)據(jù)結(jié)構(gòu)、自動分配內(nèi)存、不存在內(nèi)存泄漏的問題，是面向?qū)ο蟮臄?shù)據(jù)結(jié)構(gòu)。分了兩個部分，頭部與數(shù)據(jù)部分

????????IplImage是從2001年OpenCV發(fā)布之后就一直存在，是C語言風(fēng)格的數(shù)據(jù)結(jié)構(gòu)，需要開發(fā)者自己分配與管理內(nèi)存，對大的程序使用它容易導(dǎo)致內(nèi)存泄漏問題(建議不進行使用)

常用的構(gòu)造函數(shù)

OpenCV圖像處理基礎(chǔ)(C++版)

Mat對象的使用

部分復(fù)制：一般情況下只會復(fù)制Mat對象的頭和指針部分，不會復(fù)制數(shù)據(jù)部分 Mat A= imread(imgFilePath); Mat B(A) ?// 只復(fù)制

完全復(fù)制：如果想把Mat對象的頭部和數(shù)據(jù)部分一起復(fù)制，可以通過如下兩個API實現(xiàn) Mat F = A.clone(); 或 Mat G; A.copyTo(G);?

Mat對象使用的四個要點

輸出圖像的內(nèi)存是自動分配的

使用OpenCV的C++接口，不需要考慮內(nèi)存分配問題

賦值操作和拷貝構(gòu)造函數(shù)只會復(fù)制頭部分

使用clone與copyTo兩個函數(shù)實現(xiàn)數(shù)據(jù)完全復(fù)制

Mat對象創(chuàng)建

(1)cv::Mat::Mat 構(gòu)造函數(shù) ?? ?

Mat M(2,2,CV_8UC3, Scalar(0,0,255)) ?? ?其中前兩個參數(shù)分別表示行(row)跟列(column)、第三個CV_8UC3中的8表示每個通道占8位、U表示無符號、C表示Char類型、3表示通道數(shù)目是3，第四個參數(shù)是向量表示初始化每個像素值是多少，向量長度對應(yīng)通道數(shù)目一致

(2)cv::Mat::create 創(chuàng)建多維數(shù)組 ?? ?

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-現(xiàn)在的像素值得到相應(yīng)的結(jié)果.
}

圖像混合

理論-線性混合操作

OpenCV圖像處理基礎(chǔ)(C++版)

上述表示是兩幅圖像進行一個合并的過程,其中a代表著相應(yīng)的權(quán)重,上述是線型混合理論.

?API:addWeighted

OpenCV圖像處理基礎(chǔ)(C++版)

參數(shù)1：輸入圖像Mat – src1

參數(shù)2：輸入圖像src1的alpha值權(quán)重

參數(shù)3：輸入圖像Mat – src2

參數(shù)4：輸入圖像src2的beta值權(quán)重

參數(shù)5：gamma值:校驗值

參數(shù)6：輸出混合圖像

注意點：兩張圖像的大小和類型必須一致才可以?

調(diào)整圖像亮度與對比度

理論

?像素變換 – 點操作 (調(diào)整圖像亮度和對比度屬于像素變換-點操作) OpenCV圖像處理基礎(chǔ)(C++版)

?鄰域操作 – 區(qū)域

API回顧

Mat new_image = Mat::zeros( image.size(), image.type() ); ?創(chuàng)建一張跟原圖像大小和類型一致的空白圖像、像素值初始化為0 ?

saturate_cast<uchar>(value)確保值大小范圍為0~255之間

Mat.at<Vec3b>(y,x)[index]=value 給每個像素點每個通道賦值

代碼實現(xiàn)

#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;//調(diào)節(jié)亮度的關(guān)鍵參數(shù)

	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();
		//參數(shù)的含義                                      代表著不同的字體         放縮系數(shù)                 
		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() {//執(zhí)行一個劃線的操作
		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是進行一個常規(guī)的劃線操作
	}

	void MyRectangle() {//畫出矩形
		Rect rect = Rect(200, 100, 300, 300);//參數(shù)1 參數(shù)2是起始位置,參數(shù)3 參數(shù)4是寬高
		Scalar color = Scalar(255, 0, 0);
		rectangle(bgImage, rect, color, 2, LINE_8);//參數(shù)4是線寬
	}

	void MyEllipse() {//橢圓
		Scalar color = Scalar(0, 255, 0);
		//下面參數(shù)的含義
		//     圖像      中心點位置                                 長                    高                 角度  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);//參數(shù)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);//參數(shù)4是輪廓的含義
	}

	void RandomLineDemo() {
		RNG rng(12345);//隨機的函數(shù),給他一個種子
		Point pt1;
		Point pt2;
		Mat bg = Mat::zeros(bgImage.size(), bgImage.type());//生成一個純黑色的圖片,在這個純黑色的圖片之中進行相應(yīng)的操作.
		namedWindow("random line demo", CV_WINDOW_AUTOSIZE);
		for (int i = 0; i < 100000; i++) {
			//生成隨機數(shù)的過程
			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 是圖像處理中最簡單和常用的操作之一

使用該操作的原因之一就為了給圖像預(yù)處理時候減低噪聲

使用Smooth/Blur操作其背后是數(shù)學(xué)的卷積計算

OpenCV圖像處理基礎(chǔ)(C++版)

通常這些卷積算子計算都是線性操作，所以又叫線性濾波

過程上面的邊緣處理過程是需要進行使用插值處理
?模糊原理

歸一化盒子濾波（均值濾波）
高斯濾波

?相關(guān)API

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

OpenCV圖像處理基礎(chǔ)(C++版)

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

?代碼示例

#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;
}

?結(jié)果

模糊圖像二

中值濾波

統(tǒng)計排序濾波器

中值對椒鹽噪聲有很好的抑制作用（就像是一個圖像上面撒了一些白點和黑點）

OpenCV圖像處理基礎(chǔ)(C++版)

?雙邊濾波

均值模糊無法克服邊緣像素信息丟失缺陷。原因是均值濾波是基于平均權(quán)重

高斯模糊部分克服了該缺陷，但是無法完全避免，因為沒有考慮像素值的不同(只是考慮了相應(yīng)的空間之間的不用,但是沒有考慮像素的不同)

高斯雙邊模糊 – 是邊緣保留的濾波方法，避免了邊緣信息丟失，保留了圖像輪廓不變(邊緣保留的)

OpenCV圖像處理基礎(chǔ)(C++版) 高斯濾波是高度中心對稱的，相應(yīng)的一個權(quán)重是對應(yīng)的。是需要進行一個中心化的過程，這就是進行一個高斯的過程，比較容易進行理解。就比如說下面的

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的調(diào)用

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

雙邊模糊bilateralFilter(src, dest, d=15, 150, 3);(有一個數(shù)學(xué)公式,一頭霧水,就不看了)

- 15 –計算的半徑，半徑之內(nèi)的像數(shù)都會被納入計算，如果提供-1 則根據(jù)sigma space參數(shù)取值 ?? ?

- 150 – sigma color 決定多少差值之內(nèi)的像素會被計算 ??? ?

- 3 – sigma space 如果d的值大于0則聲明無效，否則根據(jù)它來計算d值中值模糊的ksize大小必須是大于1而且必須是奇數(shù)。

代碼

#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;

		}

膨脹與腐蝕

形態(tài)學(xué)操作(morphology operators)-膨脹

圖像形態(tài)學(xué)操作 – 基于形狀的一系列圖像處理操作的合集，主要是基于集合論基礎(chǔ)上的形態(tài)學(xué)數(shù)學(xué)

形態(tài)學(xué)有四個基本操作：腐蝕、膨脹、開、閉

膨脹與腐蝕是圖像處理中最常用的形態(tài)學(xué)操作手段

膨脹

跟卷積操作類似，假設(shè)有圖像A和結(jié)構(gòu)元素B，結(jié)構(gòu)元素B在A上面移動，其中B定義其中心為錨點，計算B覆蓋下A的最大像素值用來替換錨點的像素，其中B作為結(jié)構(gòu)體可以是任意形狀

OpenCV圖像處理基礎(chǔ)(C++版)

腐蝕

腐蝕跟膨脹操作的過程類似，唯一不同的是以最小值替換錨點重疊下圖像的像素值

OpenCV圖像處理基礎(chǔ)(C++版)

?API

getStructuringElement(int shape, Size ksize, Point anchor) ?

- 形狀 (MORPH_RECT \MORPH_CROSS \MORPH_ELLIPSE) ?

- 大小必須是奇數(shù) ?

- 錨點默認是Point(-1, -1)意思就是中心像素

dilate(src, dst, kernel)

OpenCV圖像處理基礎(chǔ)(C++版)

?調(diào)整結(jié)構(gòu)元素的大小

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

其中最中要的是 callback 函數(shù)功能。如果設(shè)置為NULL就是說只有值update，但是不會調(diào)用callback的函數(shù)

代碼

#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;
		}

通過代碼的運行可以知道,膨脹是進行一個變白的過程,腐蝕是一個圖片變黑的過程.

實際的項目之中可以通過中值濾波,消除椒鹽噪聲,在用一次腐蝕去除掉相應(yīng)的干擾,最后,加上膨脹將輪廓進行一個放大的過程.

形態(tài)學(xué)操作

開操作- open

先腐蝕后膨脹:可以去掉小的對象，假設(shè)對象是前景色，背景是黑色 OpenCV圖像處理基礎(chǔ)(C++版)

OpenCV圖像處理基礎(chǔ)(C++版)

閉操作-close

先膨脹后腐蝕(bin2)? -? 可以填充小的洞（fill hole），假設(shè)對象是前景色，背景是黑色?

OpenCV圖像處理基礎(chǔ)(C++版)

形態(tài)學(xué)梯度- Morphological Gradient

膨脹減去腐蝕又稱為基本梯度（其它還包括-內(nèi)部梯度、方向梯度）? OpenCV圖像處理基礎(chǔ)(C++版)

??頂帽 – top hat

頂帽是原圖像與開操作之間的差值圖像

OpenCV圖像處理基礎(chǔ)(C++版)

黑帽

黑帽是閉操作圖像與源圖像的差值圖像

OpenCV圖像處理基礎(chǔ)(C++版)

API調(diào)用

morphologyEx(src, dest, CV_MOP_BLACKHAT, kernel); ?

- Mat src – 輸入圖像 ?

- Mat dest – 輸出結(jié)果 ?

- int OPT – CV_MOP_OPEN/ CV_MOP_CLOSE/ CV_MOP_GRADIENT / CV_MOP_TOPHAT/ CV_MOP_BLACKHAT 形態(tài)學(xué)操作類型

-Mat kernel 結(jié)構(gòu)元素 int Iteration 迭代次數(shù)，默認是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);

	//結(jié)構(gòu)元素的大小的選取會影響相應(yīng)的最后獲得的結(jié)果
	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;
}

結(jié)果:圖片是賊好看的

OpenCV圖像處理基礎(chǔ)(C++版)

形態(tài)學(xué)操作應(yīng)用-提取水平線和垂直線

形態(tài)學(xué)操作的原理

圖像形態(tài)學(xué)操作時候，可以通過自定義的結(jié)構(gòu)元素實現(xiàn)結(jié)構(gòu)元素對輸入圖像一些對象敏感、另外一些對象不敏感，這樣就會讓敏感的對象改變而不敏感的對象保留輸出。通過使用兩個最基本的形態(tài)學(xué)操作 – 膨脹與腐蝕，使用不同的結(jié)構(gòu)元素實現(xiàn)對輸入圖像的操作、得到想要的結(jié)果。 ?

- 膨脹，輸出的像素值是結(jié)構(gòu)元素覆蓋下輸入圖像的最大像素值 ?

- 腐蝕，輸出的像素值是結(jié)構(gòu)元素覆蓋下輸入圖像的最小像素值

灰度圖像的膨脹
灰度圖像的腐蝕
結(jié)構(gòu)元素

上述膨脹與腐蝕過程可以使用任意的結(jié)構(gòu)元素

常見的形狀：矩形、園、直線、磁盤形狀、磚石形狀等各種自定義形狀。

OpenCV圖像處理基礎(chǔ)(C++版)

?提取步驟

輸入圖像彩色圖像 imread
轉(zhuǎn)換為灰度圖像 – cvtColor
轉(zhuǎn)換為二值圖像 – adaptiveThreshold
定義結(jié)構(gòu)元素開操作（腐蝕+膨脹）

提取水平與垂直線
轉(zhuǎn)換為二值圖像 – adaptiveThreshold? ? ? API

OpenCV圖像處理基礎(chǔ)(C++版)

?代碼

#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);

	// 水平結(jié)構(gòu)元素
	Mat hline = getStructuringElement(MORPH_RECT, Size(src.cols / 16, 1), Point(-1, -1));
	// 垂直結(jié)構(gòu)元素
	Mat vline = getStructuringElement(MORPH_RECT, Size(1, src.rows / 16), Point(-1, -1));
	// 矩形結(jié)構(gòu)
	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. 我們在圖像處理中常常會調(diào)整圖像大小，最常見的就是放大(zoom in)和縮?。▃oom out），盡管幾何變換也可以實現(xiàn)圖像放大和縮小，但是這里我們介紹圖像金字塔

2. 一個圖像金字塔式一系列的圖像組成，最底下一張是圖像尺寸最大，最上方的圖像尺寸最小，從空間上從上向下看就想一個古代的金字塔。

OpenCV圖像處理基礎(chǔ)(C++版)

?圖像金字塔概念

高斯金子塔 – 用來對圖像進行降采樣

拉普拉斯金字塔 – 用來重建一張圖片根據(jù)它的上層降采樣圖片

高斯金字塔

高斯金子塔是從底向上，逐層降采樣得到。

降采樣之后圖像大小是原圖像MxN的M/2 x N/2 ,就是對原圖像刪除偶數(shù)行與列，即得到降采樣之后上一層的圖片。(降采樣的過程就是相當于是進行一個將上層之中的精英進行一個采樣的過程)

高斯金子塔的生成過程分為兩步：(逐層采樣的過程)? ? ??

- 對當前層進行高斯模糊 ??? ?

- 刪除當前層的偶數(shù)行與列, 即可得到上一層的圖像，這樣上一層跟下一層相比，都只有它的1/4大小。

OpenCV圖像處理基礎(chǔ)(C++版)

?高斯不同(Difference of Gaussian-DOG)

定義：就是把同一張圖像在不同的參數(shù)下做高斯模糊之后的結(jié)果相減，得到的輸出圖像。稱為高斯不同(DOG) 高斯不同是圖像的內(nèi)在特征，在灰度圖像增強、角點檢測中經(jīng)常用到。

?采樣相關(guān)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;
}

結(jié)果

OpenCV圖像處理基礎(chǔ)(C++版)

基本閾值操作

圖像閾值（threshold）

閾值是什么？簡單點說是把圖像分割的標尺，這個標尺是根據(jù)什么產(chǎn)生的，閾值產(chǎn)生算法？閾值類型。（Binary segmentation）將像素值看成是蘋果的大小, 大于某一個像素可以看成是一個部分,小于一個像素可以看成是另一個像素.這個像素標尺就是可以看成是相應(yīng)的閾值.

OpenCV圖像處理基礎(chǔ)(C++版)