OpenCV之邻域运算之最值滤波

写了一段小程序，分享给大家！

//====================================================================

// 作者   : quarryman

// 邮箱   : quarrying{at}qq.com

// 主页   : http://blog.csdn.net/quarryman

// 日期   : 2013年08月03日

// 描述   : 实现最值滤波，非最值抑制

//====================================================================

#include <cv.h>

#include <highgui.h>

#define max(a,b)            (((a) > (b)) ? (a) : (b))

#define min(a,b)            (((a) < (b)) ? (a) : (b))

CvRect kcvRectIntersection(CvRect rect1,CvRect rect2)

{

	CvRect rect;

	rect.x=max(rect1.x, rect2.x);

	rect.y=max(rect1.y, rect2.y);

	rect.width=min(rect1.x+rect1.width, rect2.x+rect2.width);

	rect.width=rect.width-rect.x;

	rect.height=min(rect1.y+rect1.height, rect2.y+rect2.height);

	rect.height=rect.height-rect.y;

	return rect;

}

CvRect kcvGetRectFromCenterAndSize(int cx, int cy, int w, int h=0)

{

	CvRect rect;

	rect.x=cx-(w>>1);

	rect.y=cy-(h>>1);

	rect.width=w;

	rect.height=(h==0?w:h);

	return rect;

}

int minValue(IplImage* img,CvRect rect)

{

	uchar minval=255;

	for(int i=rect.y;i<rect.y+rect.height;++i)

	{

		for(int j=rect.x;j<rect.x+rect.width;++j)

		{

			if(CV_IMAGE_ELEM(img,uchar,i,j)<minval)

			{

				minval=CV_IMAGE_ELEM(img,uchar,i,j);

			}

		}

	}

	return minval;

}

int maxValue(IplImage* img,CvRect rect)

{

	uchar maxval=0;

	for(int i=rect.y;i<rect.y+rect.height;++i)

	{

		for(int j=rect.x;j<rect.x+rect.width;++j)

		{

			if(CV_IMAGE_ELEM(img,uchar,i,j)>maxval)

			{

				maxval=CV_IMAGE_ELEM(img,uchar,i,j);

			}

		}

	}

	return maxval;

}

enum

{

	KCV_MAX,		// 最大值滤波器，类似于形态学膨胀

	KCV_MIN,		// 最小值滤波器，类似于形态学腐蚀

	KCV_NMS_MAX,	// 非最大值抑制

	KCV_NMS_MIN		// 非最小值抑制

};

void maxminFilter(IplImage* src,IplImage* dst,int width,int height=0,int mode=KCV_MAX)

{

	for(int j=0;j<src->width;++j)

	{

		for(int i=0;i<src->height;++i)

		{

			CvRect rect1=cvRect(0,0,src->width,src->height);

			CvRect rect2=kcvGetRectFromCenterAndSize(j,i,width,height);

			CvRect rect=kcvRectIntersection(rect1,rect2);

			switch(mode)

			{

			case KCV_MAX:

				CV_IMAGE_ELEM(dst,uchar,i,j)=maxValue(src,rect);

				break;

			case KCV_MIN:

				CV_IMAGE_ELEM(dst,uchar,i,j)=minValue(src,rect);

				break;

			case KCV_NMS_MAX:

				if(CV_IMAGE_ELEM(src,uchar,i,j)!=maxValue(src,rect))

				{

					CV_IMAGE_ELEM(dst,uchar,i,j)=0;

				}

				else

				{

					CV_IMAGE_ELEM(dst,uchar,i,j)=CV_IMAGE_ELEM(src,uchar,i,j);

				}

				break;

			case KCV_NMS_MIN:

				if(CV_IMAGE_ELEM(src,uchar,i,j)!=minValue(src,rect))

				{

					CV_IMAGE_ELEM(dst,uchar,i,j)=255;

				}

				else

				{

					CV_IMAGE_ELEM(dst,uchar,i,j)=CV_IMAGE_ELEM(src,uchar,i,j);

				}

				break;

			}

		}

	}

}

int main()

{

	IplImage* src=cvLoadImage("lena.jpg",0);

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

	cvNamedWindow("original image");

	cvShowImage("original image",src);

	maxminFilter(src,dst,5,5,KCV_MAX);

	cvNamedWindow("maximum filter");

	cvShowImage("maximum filter",dst);

	cvSaveImage("maximum filter.jpg",dst);

	maxminFilter(src,dst,5,5,KCV_MIN);

	cvNamedWindow("minimum filter");

	cvShowImage("minimum filter",dst);

	cvSaveImage("minimum filter.jpg",dst);

	maxminFilter(src,dst,5,5,KCV_NMS_MAX);

	cvNamedWindow("non-maximum suppression");

	cvShowImage("non-maximum suppression",dst);

	cvSaveImage("non-maximum suppression.jpg",dst);

	maxminFilter(src,dst,5,5,KCV_NMS_MIN);

	cvNamedWindow("non-minimum suppression");

	cvShowImage("non-minimum suppression",dst);

	cvSaveImage("non-minimum suppression.jpg",dst);

	cvWaitKey(0);

	cvDestroyAllWindows();

	cvReleaseImage(&src);

	cvReleaseImage(&dst);

	return 0;

}

最大值滤波结果：

最小值滤波结果：

非最大值抑制结果：

非最小值抑制结果：