Canny边缘检测原理与C++实现(2)实现部分

转载请说明出处：

  http://blog.csdn.net/zhubaohua_bupt/article/details/73844187

                   本代码实现完全脱离opencv，如果需要显示，可以调用，以便观察检测效果。

首先，由于多次用到图像，所以定义图像数据结构，

DATA.h

#ifndef DATA_
#define DATA_
#include <vector>
#include<deque>
#include"memory.h"
using namespace std;


typedef  unsigned char PIXUC1;
typedef   float  PIXFC1;

//单通道 类型图像
template<class PIXVALUETYPE>
class IMGCH1{
public:
   IMGCH1(unsigned int HEIGHT_,unsigned int WIDTH_,unsigned char INITVALUE);
   IMGCH1(unsigned int HEIGHT_,unsigned int WIDTH_,PIXVALUETYPE* dataPtr_);
   ~IMGCH1();
PIXVALUETYPE* dataPtr;
unsigned int rows;
unsigned int cols;

};


////////////////////////////////////////////////////////////////////////////////////////////////////

template<class PIXVALUETYPE>
IMGCH1<PIXVALUETYPE>::IMGCH1(unsigned int HEIGHT_,unsigned int WIDTH_,unsigned char INITVALUE):rows(HEIGHT_),cols(WIDTH_)
{
   dataPtr=new PIXVALUETYPE[rows*cols];
   memset(dataPtr,INITVALUE,rows*cols);
}
template<class PIXVALUETYPE>
IMGCH1<PIXVALUETYPE>::IMGCH1(unsigned int HEIGHT_,unsigned int WIDTH_,PIXVALUETYPE* dataPtr_):rows(HEIGHT_),cols(WIDTH_)
{
 dataPtr=new PIXVALUETYPE[rows*cols];
 long int datalength =rows*cols;
 //拷贝数据
 PIXVALUETYPE*pt=dataPtr;
 PIXVALUETYPE*pt_=dataPtr_;
for(int i=0;i<datalength;i++,pt++,pt_++)
   *pt=*pt_;
}
template<class PIXVALUETYPE>
  IMGCH1<PIXVALUETYPE>:: ~IMGCH1()
{
      delete [] dataPtr;
  }

#endif

MyCanny.h

#include "iostream"  
#include "math.h"  
#include"DATA.h"
using namespace std;   

class MyCanny
{
public:

void operator()(const IMGCH1<PIXUC1>& srcimg,IMGCH1<PIXUC1>& CannyImg,int lowthread,int highthread,int gaussSize);
	//******************灰度转换函数*************************  
//第一个参数image输入的彩色RGB图像；  
//第二个参数imageGray是转换后输出的灰度图像；  
//*************************************************************  

void ToUchar(const IMGCH1<PIXFC1> &floatImage,IMGCH1<PIXUC1> &imageUchar);
//******************高斯卷积核生成函数*************************  
// gaus是一个指向含有N个double类型数组的二维指针；  
// size是高斯卷积核的尺寸大小；  
// gausArray 是一个指向含有N个double类型数组的一维指针；  
// sigma是卷积核的标准差  
//*************************************************************  
void GetGaussianKernel(float **gaus, float* gausArray,const int size,const float sigma);  

  
//******************高斯滤波*************************  
//imageSource是待滤波原始图像；  
//imageGaussian是滤波后输出图像；  
//gausArray是一个指向含有N个double类型数组的指针；  
//size是滤波核的尺寸  
//*************************************************************  

void GaussianFilter(const IMGCH1<PIXUC1>& srcimg,IMGCH1<PIXUC1>&imageGaussian,float gausArray[],int size);


//******************Sobel算子计算梯度和方向********************  
//imageSourc原始灰度图像；  
//imageSobelXY是梯度图像；  
//pointDrection是梯度方向数组指针  
//*************************************************************  
void SobelGradDirection(const IMGCH1<PIXUC1> &imageSource,IMGCH1<PIXUC1> &imageSobelXY,char *pointDrection);

  
//******************局部极大值抑制*************************  
//imageInput输入的Sobel梯度图像；
//imageOutPut是输出的局部极大值抑制图像；
//pointDrection是图像上每个点的梯度方向数组指针  梯度方向角,简化为 0(水平) 45，-45,90(垂直)
//*************************************************************  
void LocalMaxValue(const  IMGCH1<PIXUC1> &imageInput, IMGCH1<PIXUC1> &imageOutput,  char *pointDrection);
  
//******************双阈值处理*************************  
//imageInput经过局部极大值抑制的梯度图  
//lowThreshold是低阈值  
//highThreshold是高阈值  
//******************************************************  
void DoubleThreshold(  IMGCH1<PIXUC1> &imageIput,int lowThreshold,int highThreshold);
  
//******************双阈值中间像素连接处理*********************  
//imageInput 经过处理的局部极大值抑制的梯度图 <lowThreshold ->0    >highThreshold  ->255
//函数执行完后是Canny边缘检测图, 边缘(255)其他(0)
//lowThreshold是低阈值  
//highThreshold是高阈值  
//*************************************************************  
void DoubleThresholdLink(IMGCH1<PIXUC1> &imageInput,IMGCH1<PIXUC1> &CannyImg,int lowThreshold)  ;

//******************递归连接边缘*********************  
//imageInput 梯度幅值图像；  
// x,y 为要检测点的坐标
//lowThreshold是低阈值  
//*************************************************************  
void LinkEdge(IMGCH1<PIXUC1> &imageInput,int x,int y,int lowThreshold );

void SHOW(const IMGCH1<PIXUC1> &imageInput);
int width;
int height;
};

MyCanny.cpp

#include"MyCanny.h"
//////为了显示，可以把类里的show函数注释掉，就可以在实现部分不依赖于opencv  
#include"opencv.hpp"
using namespace cv;
void MyCanny::operator()(const IMGCH1<PIXUC1>& srcimg_,IMGCH1<PIXUC1>& CannyImg_ ,int lowthread,int highthread,int size)
{
   if(srcimg_.cols==0&&srcimg_.rows==0)
    {  
        cerr<<"  imageSource is empty"<<endl;
        return ;  
    }  
   	    if(lowthread>highthread) 
   {
	   cerr<<"Fourth parameter must large than third parameter. "<<endl;
	   return;
   }
	if(size<1) 
  {
	   cerr<<"size  must be a Positive. "<<endl;
	   return;
   }
  if(size%2!=1)
  {
	   cout<<"  size is expected a Odd. "<<endl;
	  size+=1;
  }
  if(lowthread<1) lowthread=1;
 width=srcimg_.cols;
 height=srcimg_.rows;

   //高斯核
    float **gaus=new float *[size];  //卷积核数组  
    for(int i=0;i<size;i++)  
    {  
        gaus[i]=new float[size];  //二维矩阵
    }     

	float *gausArray=new float[size*size];
    GetGaussianKernel(gaus,gausArray,size,1); //生成size*size 大小高斯卷积核，Sigma=1；
	//滤波
    IMGCH1<PIXUC1> imageGaussian_(height,width,PIXUC1(0));
    GaussianFilter(srcimg_,imageGaussian_,gausArray,size);

   //梯度
   IMGCH1<PIXUC1> SobelGradAmpl_(height,width,PIXUC1(0));
     char *pointDirection=new  char[srcimg_.cols*srcimg_.rows];  //定义梯度方向角数组
    SobelGradDirection(imageGaussian_,SobelGradAmpl_,pointDirection);  //计算X、Y方向梯度和方向角


 //局部非极大值抑制
       IMGCH1<PIXUC1> imageLocalMax_(height,width,PIXUC1(0));
    LocalMaxValue(SobelGradAmpl_,imageLocalMax_,pointDirection);

    //双阈值处理
    DoubleThreshold(imageLocalMax_,lowthread,highthread);
	
 //双阈值中间阈值滤除及连接
    DoubleThresholdLink(imageLocalMax_,CannyImg_,lowthread);


	delete []pointDirection;
 for(int i=0;i<size;i++)   //删除高斯核数组
    delete [] gaus[i];
    delete []gausArray;
}
void MyCanny::GetGaussianKernel(float **gaus,	float *gausArray, const int size,const float sigma)  
{  
    const double PI=4.0*atan(1.0); //圆周率π赋值  
    int center=size/2;  
    double sum=0;  
    for(int i=0;i<size;i++)  
    {  
        for(int j=0;j<size;j++)  
        {  
            gaus[i][j]=(1/(2*PI*sigma*sigma))*exp(-((i-center)*(i-center)+(j-center)*(j-center))/(2*sigma*sigma));  
            sum+=gaus[i][j];  
        }  
    }  
    for(int i=0;i<size;i++)  
     for(int j=0;j<size;j++)  
            gaus[i][j]/=sum;  

    for(int i=0;i<size*size;i++)  
    {  
        gausArray[i]=0;  //赋初值，空间分配  
    }  
    int array=0;  
    for(int i=0;i<size;i++) 
     for(int j=0;j<size;j++)  
		{  
            gausArray[array]=gaus[i][j];//二维数组到一维 方便计算  
            array++;  
        }  
	
    return ;  
}  
  



//******************高斯滤波*************************  

void MyCanny::GaussianFilter(const  IMGCH1<PIXUC1>& imageSource, IMGCH1<PIXUC1> &imageGaussian,float *gausArray,int size)
{  

    
    //滤波  
    for(int _row=0;_row<imageSource.rows;_row++)
    {  
        for(int _col=0;_col<imageSource.cols;_col++)
        {  
            int k=0;  
            for(int l=-size/2;l<=size/2;l++)  
            {  
                for(int g=-size/2;g<=size/2;g++)  
                {  
                    //以下处理针对滤波后图像边界处理，为超出边界的值赋值为边界值  
                    int row=_row+l;
                    int col=_col+g;
                    row=row<0?0:row;  
                    row=row>=imageSource.rows?imageSource.rows-1:row;  
                    col=col<0?0:col;  
                    col=col>=imageSource.cols?imageSource.cols-1:col;  
                    //卷积和  
                    imageGaussian.dataPtr[_row*width+_col]+=gausArray[k]*imageSource.dataPtr[row*width+col];
                    k++;  
                }  
            }  
        }  
    }  
}  
//******************Sobel算子计算X、Y方向梯度和梯度方向角********************  

void MyCanny::SobelGradDirection(const IMGCH1<PIXUC1>& imageSource, IMGCH1<PIXUC1>&SobelAmpXY, char *pointDrection)
{    
    for(int i=0;i<(imageSource.rows-1)*(imageSource.cols-1);i++)  
    {  
        pointDrection[i]=0;  
    }  
   IMGCH1<PIXFC1> imageSobelX(height,width,PIXFC1(0));
   IMGCH1<PIXFC1> imageSobelY(height,width,PIXFC1(0));
    PIXUC1 *P=imageSource.dataPtr;
    PIXFC1 *PX=imageSobelX.dataPtr;
    PIXFC1 *PY=imageSobelY.dataPtr;
  
    int k=0;  


    for(int row=1;row<(imageSource.rows-1);row++)
    {    
        for(int col=1;col<(imageSource.cols-1);col++)
        {    


             pointDrection[k]=-1;
			
				//通过指针遍历图像上每一个像素   
                int gradY=P[(row-1)*width+col+1]+P[row*width+col+1]*2+P[(row+1)*width+col+1]-P[(row-1)*width+col-1]-P[row*width+col-1]*2-P[(row+1)*width+col-1];
                PY[row*width+col]=abs(gradY);

                int gradX=P[(row+1)*width+col-1]+P[(row+1)*width+col]*2+P[(row+1)*width+col+1]-P[(row-1)*width+col-1]-P[(row-1)*width+col]*2-P[(row-1)*width+col+1];
                PX[row*width+col]=abs(gradX);

				if(gradX==0)  
				{  
					gradX=0.01;  //防止除数为0异常  
				}  
		
				float gradDrection=atan2(gradY,gradX)*57.3;//弧度转换为度  
	 
				if(gradDrection<=-67.5&&gradDrection<=-112.5||gradDrection>=67.5&&gradDrection<=-112.5)
					pointDrection[k]=90;
				else if(gradDrection>=22.5&&gradDrection<67.5||gradDrection>=-157.5&&gradDrection<-112.5)
					pointDrection[k]=45;
				else if(gradDrection>=-67.5&&gradDrection<22.5||gradDrection>=112.5&&gradDrection<157.5)
					pointDrection[k]=-45;
				else 
					pointDrection[k]=0;

			 k++;  

        }    
    }   
    IMGCH1<PIXFC1> imageSobelXY(height,width,PIXFC1(0));


    for(int row=0;row<imageSobelXY.rows;row++)
        for(int col=0;col<imageSobelXY.cols;col++)
            imageSobelXY.dataPtr[row*width+col]=sqrt(imageSobelX.dataPtr[row*width+col]*imageSobelX.dataPtr[row*width+col]+imageSobelY.dataPtr[row*width+col]*imageSobelY.dataPtr[row*width+col]);


    ToUchar(imageSobelXY,SobelAmpXY);
}  

//******************局部极大值抑制*************************  
 

void MyCanny::LocalMaxValue(const  IMGCH1<PIXUC1> &imageInput, IMGCH1<PIXUC1> &imageOutput,  char *pointDrection)
{  

    for(int row=0;row<height;row++)
        for(int col=0;col<width;col++)
            imageOutput.dataPtr[row*width+col]=   imageInput.dataPtr[row*width+col];
    int k=0;  

    for(int row=1;row<imageInput.rows-1;row++)
    {  
        for(int col=1;col<imageInput.cols-1;col++)
        {
            int U=row-1,D=row+1,L=col-1,R=col+1;
                     int value00=imageInput.dataPtr[U*width+L];
                     int value01=imageInput.dataPtr[U*width+col];
                     int value02=imageInput.dataPtr[U*width+R];
                     int value10=imageInput.dataPtr[row*width+L];
                     int value11=imageInput.dataPtr[row*width+col];
                     int value12=imageInput.dataPtr[row*width+R];
                     int value20=imageInput.dataPtr[D*width+L];
                     int value21=imageInput.dataPtr[D*width+col];
                     int value22=imageInput.dataPtr[D*width+R];
            if(pointDrection[k]==90)  
            {  
                if(value11<=value01||value11<=value21)  
                            imageOutput.dataPtr[row*width+col]=0;
            }     
            else if(pointDrection[k]=45)  
  
            {  
                if(value11<=value20||value11<value02)  
                      imageOutput.dataPtr[row*width+col]=0;
            }  
            else if(pointDrection[k]=-45)  
            {  
                if(value11<=value00||value11<=value22)  
                       imageOutput.dataPtr[row*width+col]=0;
            }  
			else 
            {  
                if(value11<=value10||value11<=value12)               
                    imageOutput.dataPtr[row*width+col]=0;
            }  
            k++;  
        }  
    }  
}  
//******************双阈值处理*************************  

void MyCanny::DoubleThreshold( IMGCH1<PIXUC1> &imageIput,int lowThreshold,int highThreshold)
{  
    for(int row=0;row<imageIput.rows;row++)
    for(int col=0;col<imageIput.cols;col++)
        { 
            if(imageIput.dataPtr[row*width+col]>highThreshold)
               imageIput.dataPtr[row*width+col]=255;
     
            if(imageIput.dataPtr[row*width+col]<lowThreshold)
              imageIput.dataPtr[row*width+col]=0;
        }       
}  
//******************双阈值中间像素连接处理*********************  

void MyCanny::DoubleThresholdLink(IMGCH1<PIXUC1> &imageInput,IMGCH1<PIXUC1> &CannyImg,int lowThreshold)
{  
    for(int row=1;row<imageInput.rows-1;row++)
      for(int col=1;col<imageInput.cols-1;col++)
        {  		
            if(imageInput.dataPtr[row*width+col]==255)
             LinkEdge(imageInput,col, row, lowThreshold );
			
        } 

       for(int row=1;row<imageInput.rows;row++)
      for(int col=1;col<imageInput.cols;col++)
        {  		
            if(imageInput.dataPtr[row*width+col]==255)
          CannyImg.dataPtr[row*width+col]=255;
        } 
}  

//******************递归连接边缘*********************  
void MyCanny::LinkEdge(IMGCH1<PIXUC1> &imageInput,int x,int y,int lowThreshold )
{
	int nextpoint_x=-1;
	int nextpoint_y=-1;
	if(x<1||x>width-1||y<1||y>height-1) return;
    if( imageInput.dataPtr[(y-1)*width+x-1]>=lowThreshold&& imageInput.dataPtr[(y-1)*width+x-1]!=255)
	{
	 nextpoint_x=x-1;
	 nextpoint_y=y-1;
	 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);	
	}
    else if( imageInput.dataPtr[(y-1)*width+x]>=lowThreshold&&imageInput.dataPtr[(y-1)*width+x]!=255)
	{
	 nextpoint_x=x;
	 nextpoint_y=y-1;
	 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);
	}
    else if(imageInput.dataPtr[(y-1)*width+x+1]>=lowThreshold&&imageInput.dataPtr[(y-1)*width+x+1]!=255)
	{
	 nextpoint_x=x+1;
	 nextpoint_y=y-1;
	 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);
	}
    else if( imageInput.dataPtr[y*width+x-1]>=lowThreshold&&imageInput.dataPtr[y*width+x-1]!=255 )
	{
		 nextpoint_x=x-1;
		 nextpoint_y=y;
		 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);
	}
    else if( imageInput.dataPtr[y*width+x+1]>=lowThreshold&&imageInput.dataPtr[y*width+x+1]!=255 )
	{
		 nextpoint_x=x+1;
		 nextpoint_y=y;
		 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);
	}
    else if( imageInput.dataPtr[(y+1)*width+x-1]>=lowThreshold&&imageInput.dataPtr[(y+1)*width+x-1]!=255 )
	{
		 nextpoint_x=x-1;
		 nextpoint_y=y+1;
		 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);
	}
    else if( imageInput.dataPtr[(y+1)*width+x]>=lowThreshold&& imageInput.dataPtr[(y+1)*width+x]!=255 )
	{
		 nextpoint_x=x;
	     nextpoint_y=y+1;
		 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);
	}
    else if(imageInput.dataPtr[(y+1)*width+x+1]>=lowThreshold&&imageInput.dataPtr[(y+1)*width+x+1]!=255)
	{
	     nextpoint_x=x+1;
	     nextpoint_y=y+1;
		 imageInput.dataPtr[nextpoint_y*width+nextpoint_x]=255;
	LinkEdge(imageInput,nextpoint_x,nextpoint_y,lowThreshold);
	}
}
void MyCanny::ToUchar(const IMGCH1<float> &floatImage,IMGCH1<PIXUC1> &imageUchar)
{

    for(int row=0;row<floatImage.rows;row++)
        for(int col=0;col<floatImage.cols;col++)
            imageUchar.dataPtr[row*width+col]=  floatImage.dataPtr[row*width+col]>255?255: floatImage.dataPtr[row*width+col];
}
void MyCanny::SHOW(const IMGCH1<PIXUC1> &imageInput)
{
	Mat show=Mat::zeros(imageInput.rows,imageInput.cols,CV_8UC1);
	for(int row=0;row<imageInput.rows;row++)
		for(int col=0;col<imageInput.cols;col++)
		{
		
			show.at<uchar>(row,col)=imageInput.dataPtr[row*imageInput.cols+col];
		}
		imshow(" ",show);
		waitKey(0);
}

测试

#include"opencv.hpp"
using namespace cv;
#include"MyCanny.h"
using namespace std;

int main()
{

	
	Mat src=imread("E:\matchpic\right_16488.jpg",0);
	
	//转换数据结构
	IMGCH1<PIXUC1> src_(src.rows,src.cols,PIXUC1(0));
	for(int row=0;row<src.rows;row++)
	for(int col=0;col<src.cols;col++)
     src_.dataPtr[row*src.cols+col]=src.at<uchar>(row,col);

	Mat Cannyedge=Mat::zeros(src.rows,src.cols,CV_8UC1);
	IMGCH1<PIXUC1> Cannyedge_(src.rows,src.cols,PIXUC1(0));


	
	MyCanny MyCanny_;

	

	MyCanny_(src_,Cannyedge_,10,100,3);//检测

	//转换回Mat显示	
	for(int row=0;row<src_.rows;row++)
	for(int col=0;col<src_.cols;col++)
    Cannyedge.at<uchar>(row,col)=Cannyedge_.dataPtr[row*src.cols+col];

		imshow("Cannyedge ",Cannyedge);
		
		waitKey(0); 
}