中值滤波C语言优化

图像平滑是图像预处理的基本操作,本文首先用不同的方法对一张图片做预处理比较它们效果的不同,然后针对中值滤波,实现了一种快速实现.(其实是copy的opencv实现,呵呵).因为opencv的实现方法感觉太好了,今天就特别写下来.既有备忘的作用,同时如果谁看到这篇文章,也可以借鉴下opencv的实现.

1 原始图像

2 均值滤波图像

3 中值滤波图像

4 双边滤波图像

5高斯滤波图像

上图的代码

void CDialogTest2013Dlg::OnBnClickedMfcbutton1()

{

char file[10]="e:\\1.jpg";

IplImage *src = cvLoadImage(file,0);

CvSize picSize;

picSize.width = src->width;

picSize.height = src->height;

IplImage *dst_midian= cvCreateImage(picSize,8,1);

IplImage *dst_blur = cvCreateImage(picSize,8,1);

IplImage *dst_gaussian = cvCreateImage(picSize,8,1);

IplImage *dst_bilateral = cvCreateImage(picSize,8,1);

cvSmooth(src, dst_midian, CV_MEDIAN,3,3);

cvSmooth(src, dst_blur, CV_BLUR,3,3);

cvSmooth(src, dst_gaussian, CV_GAUSSIAN,3,3);

cvSmooth(src, dst_bilateral, CV_BILATERAL,3,3);

}

均值滤波原理:把一个点周围点求均值,这个均值给这个点.

中值滤波原理:把一个点周围的点排序,把中位数给这个点.

双边滤波原理:这个一句话说不清楚,可以看这个博文 http://blog.csdn.net/bugrunner/article/details/7170471

高斯滤波原理:均值滤波对一个点周围点求和是每个点的权重都是1,高斯滤波的权重不是1了,是一个类似高斯分布的权重分布,距离目标点

近的地方权重高点,距离目标点远的地方,权重低些.

中值滤波的opencv实现

template<class Op, class VecOp>

staticvoid

medianBlur_SortNet(const Mat& _src, Mat& _dst,int m )

{

typedef typename Op::value_type T;

typedef typename Op::arg_type WT;

typedef typename VecOp::arg_type VT;

const T* src =(const T*)_src.data;

T* dst =(T*)_dst.data;

int sstep =(int)(_src.step/sizeof(T));

int dstep =(int)(_dst.step/sizeof(T));

Size size = _dst.size();

int i, j, k, cn = _src.channels();

Op op;

VecOp vop;

volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);

if( m ==3)

{

if( size.width ==1|| size.height ==1)

{

int len = size.width + size.height -1;

int sdelta = size.height ==1? cn : sstep;

int sdelta0 = size.height ==1?0: sstep - cn;

int ddelta = size.height ==1? cn : dstep;

for( i =0; i < len; i++, src += sdelta0, dst += ddelta )

for( j =0; j < cn; j++, src++)

{

WT p0 = src[i >0?-sdelta :0];

WT p1 = src[0];

WT p2 = src[i < len -1? sdelta :0];

op(p0, p1); op(p1, p2); op(p0, p1);

dst[j]=(T)p1;

}

return;

}

size.width *= cn;

for( i =0; i < size.height; i++, dst += dstep )

{

const T* row0 = src + std::max(i -1,0)*sstep;

const T* row1 = src + i*sstep;

const T* row2 = src + std::min(i +1, size.height-1)*sstep;

int limit = useSIMD ? cn : size.width;

for(j =0;;)

{

for(; j < limit; j++)

{

int j0 = j >= cn ? j - cn : j;

int j2 = j < size.width - cn ? j + cn : j;

WT p0 = row0[j0], p1 = row0[j], p2 = row0[j2];

WT p3 = row1[j0], p4 = row1[j], p5 = row1[j2];

WT p6 = row2[j0], p7 = row2[j], p8 = row2[j2];

op(p1, p2); op(p4, p5); op(p7, p8); op(p0, p1); //op(p1, p2) 交换p1和p2两个数

op(p3, p4); op(p6, p7); op(p1, p2); op(p4, p5);

op(p7, p8); op(p0, p3); op(p5, p8); op(p4, p7);

op(p3, p6); op(p1, p4); op(p2, p5); op(p4, p7);

op(p4, p2); op(p6, p4); op(p4, p2);

dst[j]=(T)p4;

}

if( limit == size.width )

break;

for(; j <= size.width - VecOp::SIZE - cn; j += VecOp::SIZE )

{

VT p0 = vop.load(row0+j-cn), p1 = vop.load(row0+j), p2 = vop.load(row0+j+cn);

VT p3 = vop.load(row1+j-cn), p4 = vop.load(row1+j), p5 = vop.load(row1+j+cn);

VT p6 = vop.load(row2+j-cn), p7 = vop.load(row2+j), p8 = vop.load(row2+j+cn);

vop(p1, p2); vop(p4, p5); vop(p7, p8); vop(p0, p1);

vop(p3, p4); vop(p6, p7); vop(p1, p2); vop(p4, p5);

vop(p7, p8); vop(p0, p3); vop(p5, p8); vop(p4, p7);

vop(p3, p6); vop(p1, p4); vop(p2, p5); vop(p4, p7);

vop(p4, p2); vop(p6, p4); vop(p4, p2);

vop.store(dst+j, p4);

}

limit = size.width;

}