2. 程式人生 > >影象增強演算法實現--影象邊緣提取

影象增強演算法實現--影象邊緣提取

阿新 • • 發佈：2019-01-03

(1)演算法描述：

Laplacian 運算元是n維歐幾里德空間中的一個二階微分運算元，定義為梯度grad（）的散度div（）。因此如果f是二階可微的實函式，則f的拉普拉斯運算元定義為：(1) f的拉普拉斯運算元也是笛卡兒座標系xi中的所有非混合二階偏導數求和：(2) 作為一個二階微分運算元，拉普拉斯運算元把C函式對映到C函式，對於k ≥ 2。表示式(1)（或(2)）定義了一個運算元Δ : C(R) → C(R)，或更一般地，定義了一個運算元Δ : C(Ω) → C(Ω)，對於任何開集Ω。

Roberts運算元是一種最簡單的運算元，是一種利用區域性差分運算元尋找邊緣的運算元，他採用對角線方向相鄰兩象素之差近似梯度幅值檢測邊緣。

Prewitt運算元是一種一階微分運算元的邊緣檢測，利用畫素點上下、左右鄰點的灰度差，在邊緣處達到極值檢測邊緣，去掉部分偽邊緣，對噪聲具有平滑作用 。其原理是在影象空間利用兩個方向模板與影象進行鄰域卷積來完成的，這兩個方向模板一個檢測水平邊緣，一個檢測垂直邊緣。對數字影象f(x，y)，Prewitt運算元的定義如下：

G(i)=|[f(i-1,j-1)+f(i-1,j)+f(i-1，j+1)]-[f(i+1,j-1)+f(i+1，j)+f(i+1，j+1)]|   

G(j)=|[f(i-1,j+1)+f(i,j+1)+f(i+1，j+1)]-[f(i-1,j-1)+f(i,j-1)+f(i+1，j-1)]|

則 P(i,j)=max[G(i),G(j)]或 P(i,j)=G(i)+G(j)

經典Prewitt運算元認為：凡灰度新值大於或等於閾值的畫素點都是邊緣點。即選擇適當的閾值T，若P(i,j)≥T，則(i,j)為邊緣點，P(i,j)為邊緣影象。這種判定是欠合理的，會造成邊緣點的誤判，因為許多噪聲點的灰度值也很大，而且對於幅值較小的邊緣點，其邊緣反而丟失了。

Sobel 運算元有兩個，一個是檢測水平邊緣的 ；另一個是檢測垂直邊緣的 。與Prewitt運算元相比，Sobel運算元對於象素的位置的影響做了加權，可以降低邊緣模糊程度，因此效果更好。該運算元包含兩組3x3的矩陣，分別為橫向及縱向，將之與影象作平面

卷積，即可分別得出橫向及縱向的亮度差分近似值。如果以A代表原始影象，Gx及Gy分別代表經縱向及橫向邊緣檢測的影象，其公式如下:

 

影象的每一個畫素的橫向及縱向梯度近似值可用以下的公式結合，來計算梯度的大小。

然後可用以下公式計算梯度方向。

 

在以上例子中，如果上述角度Θ等於零，即代表影象該處擁有縱向邊緣，左方較右方暗。

Canny 運算元的目標是找到一個最優的邊緣檢測演算法，Canny 使用了變分法（calculus of variations），這是一種尋找優化特定功能的函式的方法。最優檢測使用四個指數函式項表示，但是它非常近似於高斯函式的一階導數。Canny邊緣檢測演算法可以分為以下5個步驟：1.應用高斯濾波來平滑影象，目的是去除噪聲。 2.找尋影象的強度梯度（intensity gradients）。3.應用非最大抑制（non-maximum suppression）技術來消除邊誤檢（本來不是但檢測出來是）。4.應用雙閾值的方法來決定可能的（潛在的）邊界。5.利用滯後技術來跟蹤邊界。

(2)實驗結果，介面圖：

整體執行截圖：



                  左上：原圖                              右上：sobel運算元

                        左中：robert運算元     右中：laplacian運算元

                        左下：prewitt運算元    右下：差分（對角）

(3)關鍵程式碼:

#include <opencv/cv.h>
#include <opencv/highgui.h> 
#include<opencv/cxcore.h>
#include "math.h"
float max(float x, float y);
void prewitt(IplImage *src, IplImage *dst);//Prewitt運算元
void roberts(IplImage *src, IplImage *dst); //roberts運算元
void sobel(IplImage *src, IplImage *dst);  //sobel運算元
void canny(IplImage *src, IplImage *dst);//canny運算元
void Laplacian(IplImage *src, IplImage *dst32,IplImage *dst); //Laplacian運算元
int main()
{
	//載入影象
	IplImage *src = NULL;
	src = cvLoadImage("lena.jpg", 0);
	cvNamedWindow("【原圖】", 1);
	cvShowImage("【原圖】", src);

	IplImage *pCannyImg = cvCreateImage(cvGetSize(src), 8, 1);
	canny(src, pCannyImg);

	IplImage *pLaplaceImg_32 = cvCreateImage(cvGetSize(src), 32, 1);
	IplImage *pLaplaceImg = cvCreateImage(cvGetSize(src), 8, 1);
	Laplacian(src, pLaplaceImg_32, pLaplaceImg);
	
	IplImage *pSobelImg = cvCreateImage(cvGetSize(src), 8, 1);
	sobel(src, pSobelImg);
	cvReleaseImage(&pSobelImg);

	IplImage *pRobertsImg = cvCreateImage(cvGetSize(src), 8, 1);
	roberts(src, pRobertsImg);
	cvReleaseImage(&pRobertsImg);

	IplImage *pPrewittImg = cvCreateImage(cvGetSize(src), 8, 1);
	prewitt(src, pPrewittImg);
	cvReleaseImage(&pPrewittImg);

	cvWaitKey(0);
	//銷燬視窗,釋放影象
	cvDestroyWindow("【原圖】");
	cvReleaseImage(&src);
	return -1;
}
float max(float x, float y)
{
	float z;
	if (x>y)z = x;
	else z = y;
	return(z);
}
//Prewitt運算元
void prewitt(IplImage *src, IplImage *dst)
{
	//定義prewitt運算元的模板
	float prewittx[9] =
	{
		-1, 0, 1,
		-1, 0, 1,
		-1, 0, 1
	};
	float prewitty[9] =
	{
		1, 1, 1,
		0, 0, 0,
		-1, -1, -1
	};
	CvMat px;
	px = cvMat(3, 3, CV_32F, prewittx);
	CvMat py;
	py = cvMat(3, 3, CV_32F, prewitty);

	IplImage *dstx = cvCreateImage(cvGetSize(src), 8, 1);
	IplImage *dsty = cvCreateImage(cvGetSize(src), 8, 1);

	//對影象使用模板，自動填充邊界
	cvFilter2D(src, dstx, &px, cvPoint(-1, -1));
	cvFilter2D(src, dsty, &py, cvPoint(-1, -1));

	//計算梯度，
	int i, j, temp;
	float tempx, tempy;  //定義為浮點型是為了避免sqrt函式引起歧義
	uchar* ptrx = (uchar*)dstx->imageData;
	uchar* ptry = (uchar*)dsty->imageData;
	for (i = 0; i<src->width; i++)
	{
		for (j = 0; j<src->height; j++)
		{
			tempx = ptrx[i + j*dstx->widthStep];   //tempx,tempy表示的是指標所指向的畫素
			tempy = ptry[i + j*dsty->widthStep];
			temp = (int)sqrt(tempx*tempx + tempy*tempy);
			dst->imageData[i + j*dstx->widthStep] = temp;
		}
	}
	double min_val = 0, max_val = 0;//取圖並顯示像中的最大最小畫素值
	cvMinMaxLoc(dst, &min_val, &max_val);
	printf("max_val = %f\nmin_val = %f\n", max_val, min_val);

	cvSaveImage("PrewittImg.jpg", dst);//把影象存入檔案
	cvReleaseImage(&dstx);
	cvReleaseImage(&dsty);
	cvNamedWindow("【效果圖】prewitt運算元", 1);
	cvShowImage("【效果圖】prewitt運算元", dst);
}

//roberts運算元
void roberts(IplImage *src, IplImage *dst)
{
	dst = cvCloneImage(src);
	int x, y, i, w, h;
	int temp, temp1;

	uchar* ptr = (uchar*)(dst->imageData);
	int ptr1[4] = { 0 };
	int indexx[4] = { 0, 1, 1, 0 };
	int indexy[4] = { 0, 0, 1, 1 };
	w = dst->width;
	h = dst->height;
	for (y = 0; y<h - 1; y++)
		for (x = 0; x<w - 1; x++)
		{

		for (i = 0; i<4; i++)    //取每個2*2矩陣元素的指標      0 | 1
		{                   //                             3 | 2
			ptr1[i] = *(ptr + (y + indexy[i])*dst->widthStep + x + indexx[i]);

		}
		temp = abs(ptr1[0] - ptr1[2]);    //計算2*2矩陣中0和2位置的差，取絕對值temp
		temp1 = abs(ptr1[1] - ptr1[3]);   //計算2*2矩陣中1和3位置的差，取絕對值temp1
		temp = (temp>temp1 ? temp : temp1); //若temp1>temp,則以temp1的值替換temp
		temp = (int)sqrt(float(temp*temp) + float(temp1*temp1));  //輸出值
		*(ptr + y*dst->widthStep + x) = temp;	   //將輸出值存放於dst畫素的對應位置
		}
	double min_val = 0, max_val = 0;//取圖並顯示像中的最大最小畫素值
	cvMinMaxLoc(dst, &min_val, &max_val);
	printf("max_val = %f\nmin_val = %f\n", max_val, min_val);
	cvSaveImage("RobertsImg.jpg", dst);
	cvNamedWindow("【效果圖】robert運算元", 1);
	cvShowImage("【效果圖】robert運算元", dst);
}
//sobel運算元
void sobel(IplImage *src, IplImage *dst)
{
	IplImage *pSobelImg_dx = cvCreateImage(cvGetSize(src), 32, 1);
	IplImage *pSobelImg_dy = cvCreateImage(cvGetSize(src), 32, 1);
	IplImage *pSobelImg_dxdy = cvCreateImage(cvGetSize(src), 32, 1);

	//用sobel運算元計算兩個方向的微分
	cvSobel(src, pSobelImg_dx, 1, 0, 3);
	cvSobel(src, pSobelImg_dy, 0, 1, 3);

	int i, j;
	double v1, v2, v;
	for (i = 0; i<src->height; i++)
	{
		for (j = 0; j<src->width; j++)
		{
			v1 = cvGetReal2D(pSobelImg_dx, i, j);
			v2 = cvGetReal2D(pSobelImg_dy, i, j);
			v = sqrt(v1*v1 + v2*v2);
			/*	if(v>100) v = 255;
			else v = 0;*/
			cvSetReal2D(pSobelImg_dxdy, i, j, v);
		}
	}
	cvConvertScale(pSobelImg_dxdy, dst);   //將影象轉化為8位
	double min_val = 0, max_val = 0;//取圖並顯示像中的最大最小畫素值
	cvMinMaxLoc(pSobelImg_dxdy, &min_val, &max_val);
	printf("max_val = %f\nmin_val = %f\n", max_val, min_val);

	//歸一化
	cvNormalize(dst, dst, 0, 255, CV_MINMAX, 0);

	cvReleaseImage(&pSobelImg_dx);
	cvReleaseImage(&pSobelImg_dy);
	cvReleaseImage(&pSobelImg_dxdy);
	cvSaveImage("SobelImg.jpg", dst);//把影象存入檔案
	cvNamedWindow("【效果圖】sobel運算元", 1);
	cvShowImage("【效果圖】sobel運算元", dst);
}
//canny運算元
void canny(IplImage *src, IplImage *dst)
{
	cvCanny(src, dst, 100, 150, 3),
		cvNamedWindow("【效果圖】差分（對角）", 1);
	cvShowImage("【效果圖】差分（對角）", dst);
	cvSaveImage("CannyImg.jpg", dst);//把影象存入檔案
	cvReleaseImage(&dst);
}
//Laplacian運算元
void Laplacian(IplImage *src, IplImage *dst32,IplImage *dst)
{
	double min_val = 0, max_val = 0;//取圖並顯示像中的最大最小畫素值
	cvLaplace(src, dst32, 5);
	cvConvertScale(dst32, dst);   //將影象轉化為8位
	cvMinMaxLoc(dst, &min_val, &max_val);
	printf("max_val = %f\nmin_val = %f\n", max_val, min_val);
	cvNormalize(dst, dst, 0, 255, CV_MINMAX, 0);
	cvNamedWindow("【效果圖】laplacian運算元", 1);
	cvShowImage("【效果圖】laplacian運算元", dst);
	cvSaveImage("LaplaceImg.jpg", dst);//把影象存入檔案
	cvReleaseImage(&dst);
}

(4)完成作業體會，總結:

寫這個程式遇見的最大的難題在於對幾種運算元的原理，不是特別的理解。特別是差分，網上根本沒有相關的演算法介紹，後來看到了canny演算法，發現它是用到了差分演算法。可以說，寫完這個程式後，對每種演算法的具體實現並不能做到百分百的理解，對各種矩陣變換還是一頭霧水。寫這個程式主要的時間都花費在理解各種演算法，實現各種演算法，將各種演算法封裝成函式直接呼叫，這期間也遇到了許多零零碎碎的問題，學到了很多。


相關推薦

影象增強演算法實現--影象邊緣提取

(1)演算法描述： Laplacian 運算元是n維歐幾里德空間中的一個二階微分運算元，定義為梯度grad（）的散度div（）。因此如果f是二階可微的實函式，則f的拉普拉斯運算元定義為：(1) f的拉普拉斯運算元也是笛卡兒座標系xi中的所有非混合二階偏導數求和：(2) 作為

影象增強演算法實現（直方圖均衡化、拉普拉斯、Log、Gamma）

OpenCV影象增強演算法實現（直方圖均衡化、拉普拉斯、Log、Gamma） 轉載自： https://blog.csdn.net/dcrmg/article/details/53677739 1. 基於直方圖均衡化的影象增強   直方圖均衡化是通過調整影象的灰階分佈，使得

OpenCV影象增強演算法實現（直方圖均衡化、拉普拉斯、對數變換、Gamma）

1. 基於直方圖均衡化的影象增強 直方圖均衡化是通過調整影象的灰階分佈，使得在0~255灰階上的分

OpenCV影象增強演算法實現（直方圖均衡化、拉普拉斯、Log、Gamma）

1. 基於直方圖均衡化的影象增強 直方圖均衡化是通過調整影象的灰階分佈，使得在0~255灰階上的分佈更加均衡，提高了影象的對比度，達到改善影象主觀視覺效果的目的。對比度較低的影象適合使用直方圖均衡化

OpenCV，常用影象增強演算法的實現

非CS科班出身，喜歡用C/C++思考數學 ，專注於影象處理和軟體開發！本部落格基於交流和記錄學習的歷程為目的，與諸君共勉，歡迎交流。同時，博文有不少文字並非一字一字地敲打，若侵權，請聯絡本人， E-mail：[email protected]

影象增強演算法效果評價指標及實現

前言： 對於一種影象處理方法，怎麼樣來判斷該演算法效果的好壞呢？除了人眼本身的觀察，還可以用某種指標來量化評判，本文將總結一下影象質量評判的方法及實現。 影象質量評價分類（IQA:image quality assessment）： 影象質量評價目前來看主要分為兩類： （1

多媒體技術 || 用中位切割演算法實現影象減色

實現環境：python 處理一張紅蘋果圖： 先描述一下中位切割演算法吧： 將圖片內的所有畫素加入到同一個區域 對於所有的區域做以下的事： 計算此區域內所有畫素的 RGB 三元素最大值與最小值的差。 選出相差最大的那個顏色（R 或 G 或 B）

KNN演算法實現影象分類

首先，回顧k-Nearest Neighbor（k-NN）分類器，可以說是最簡單易懂的機器學習演算法。 實際上，k-NN非常簡單，根本不會執行任何“學習”，以及介紹k-NN分類器的工作原理。 然後，我們將k-NN應用於Kaggle Dogs vs. Cats資料集，這是Microsoft的A

retinex影象增強演算法ssr-msr-msrcr詳解及其opencv原始碼

原文：https://blog.csdn.net/ajianyingxiaoqinghan/article/details/71435098 Retinex影象增強演算法(SSR, MSR, MSRCR)詳解及其OpenCV原始碼 Retinex是一種常用的建立在科學實驗和科學分析基

機器學習之BP神經網路演算法實現影象分類

BP 演算法是一個迭代演算法，它的基本思想為：(1) 先計算每一層的狀態和啟用值，直到最後一層（即訊號是前向傳播的）；(2) 計算每一層的誤差，誤差的計算過程是從最後一層向前推進的（這就是反向傳播演算法名字的由來）；(3) 更新引數（目標是誤差變小），迭代前面兩

Opencv 影象增強演算法 影象檢測結果

                本code通過直方圖變換增強了影象對比度，實現了單通道影象增強。將影象灰度閾值拉伸到0-255，影象檢測結果見底部Keywords: 影象增強 增強對比度 直方圖變換int ImageStretchByHistogram(IplImage *src1,IplImage *dst

影象處理演算法4——Sobel 邊緣檢測運算元

Sobel 運算元是一個離散微分運算元 (discrete differentiation operator)。 它結合了高斯平滑和微分求導，用來計算影象灰度函式的近似梯度。     影象邊緣,相素值會發生顯著的變化了。表示這一改變的一個方法是使用 導數 。 梯度值的大

圖形影象處理之——實現影象子區域影象的簡單提取

           今天經過高人點醒，我好想懂了點點我要做的東東的思路，今天晚上就拿出來試了一下，居然還小小的實現了一番，太開心了，迫不及待的拿出來分享一下： 不過當然還沒有完全實現，還需要進一步的設計批量操作。程式碼貼出來： image=imread('E:\qww

retinex影象增強演算法的研究

     影象增強方面我共研究了Retinex、暗通道去霧、ACE等演算法。其實，它們都是共通的。甚至可以說，Retinex和暗通道去霧就是同一個演算法的兩個不同視角，而ACE演算法又是將Retinex和灰度世界等白平衡理論相結合的產物。下面將依次討論，每個演算法寫一個心

影象增強演算法之 限制對比度自適應直方圖均衡化演算法原理

一、自適應直方圖均衡化(Adaptive histgram equalization/AHE)       1.簡述        自適應直方圖均衡化(AHE)用來提升影象的對比度的一種計算機影象處理技術。和普通的直方圖均衡演算法不同，AHE演算法通過計算影象的區域性直方圖，然後重新分佈亮度來來改變影象對比

基於FPGA的Alpha半透明影象疊加演算法實現

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

用線性插值演算法實現影象縮放

  為了方便理解，先考慮一維情況下的線性插值  對於一個數列c，我們假設c[a]到c[a+1]之間是線性變化的  那麼對於浮點數x(a<=x<a+1)，c(x)=c[a+1]*(x-a)+c[a]*(1+a-x);  這個好理解吧？ 把這種插值方式擴充套件到二維情況  對於一個二維陣列c，我們假

k-means演算法實現影象顏色聚類

#include<stdio.h> #include <cstdio> #include<string> #include<math.h> #include<stdlib.h>

opencv讀影象C語言實現canny邊緣檢測

1 ////////第四步：非極大值抑制 2 //注意事項 權重的選取，也就是離得近權重大 3 ///////////////////////////////////////////////////////////////// 4 IplImage * N;//非極大值抑制結果 5

5.5用分水嶺演算法實現影象分割

<img src="https://img-blog.csdn.net/20160409220852681?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0