滤波算法(均值、中值、最大均值、最大中值、几何均值)

均值滤波

void meanfilter(Mat src, Mat dst, int kernalsize)
{
	int ksize;
	vector<uchar> tempdata;
	tempdata.clear();
	if (kernalsize % 2 == 0)
	{
		ksize = kernalsize / 2;
	}
	else
	{
		ksize = (kernalsize - 1) / 2;
	}
	if (kernalsize>src.rows || kernalsize>src.cols)
		cout << "核输入过大" << endl;

	for (int i = ksize; i < src.rows - ksize; i++)
	{
		uchar* datadst = dst.ptr<uchar>(i);
		for (int j = ksize; j < src.cols - ksize; j++)
		{
			
				for (int l = i - ksize; l <= i + ksize; l++)
				{
					uchar* datatemp = src.ptr<uchar>(l);
					for (int k = j - ksize; k <= j + ksize; k++)
					{
						tempdata.push_back(datatemp[k]);
					}
				}
				int tempsum = 0;
				for (size_t tempi = 0; tempi < tempdata.size(); tempi++)
				{
					tempsum += tempdata[tempi];
				}

				double s = 1.0 / (kernalsize*kernalsize);
				datadst[j] = s*tempsum;
				tempdata.clear();
		}
	}

	return;
}

修改：新方法解决了边界像素问题。而原始做法是将原图边界复制，即边界像素不做处理。

Mat mean(Mat src, int kernelSize)
{
	Mat dst = src.clone();
	int padding=0;
	if (kernelSize % 2 == 0)
	{
		padding = kernelSize / 2;
	}
	else
	{
		padding = (kernelSize - 1) / 2;
	}
	if (kernelSize>src.rows || kernelSize>src.cols)
		cout << "核输入过大" << endl;
	
	Mat addsrc(src.rows + padding, src.cols + padding, CV_8U);
	
	//将src边界放大，解决了边界像素的处理问题
	copyMakeBorder(src, addsrc, padding, padding, padding, padding, BORDER_CONSTANT, Scalar(255));

	for (int i = 0; i < src.rows; i++)
	{
		for (int j = 0; j < src.cols; j++)
		{
			double sum = 0;
			for (int irow = i; irow < i+kernelSize; irow++)
			{
				for (int jcol = j; jcol < j+kernelSize; jcol++)
				{
					sum += addsrc.at<uchar>(irow, jcol);
				}
			}
				sum= sum / (kernelSize*kernelSize);
				dst.at<uchar>(i,j)= sum;
		}

	}
	return dst;
}

中值滤波

void medianfilter(Mat src, Mat dst, int kernalsize)
{
	int ksize;
	vector<uchar> tempdata;
	tempdata.clear();
	if (kernalsize % 2 == 0)
	{
		ksize = kernalsize / 2;
	}
	else
	{
		ksize = (kernalsize - 1) / 2;
	}
	if (kernalsize>src.rows || kernalsize>src.cols)
		cout << "核输入过大" << endl;

	for (int i = ksize; i < src.rows - ksize; i++)
	{
		uchar* datadst = dst.ptr<uchar>(i);
		for (int j = ksize; j < src.cols - ksize; j++)
		{

			for (int l = i - ksize; l <= i + ksize; l++)
			{
				uchar* datatemp = src.ptr<uchar>(l);
				for (int k = j - ksize; k <= j + ksize; k++)
				{
					tempdata.push_back(datatemp[k]);
				}
			}

			//排序
			sort(tempdata.begin(), tempdata.end());
			datadst[j] = tempdata[tempdata.size() / 2];
			tempdata.clear();
	
		}
	}

	return;
}

最大均值滤波

void max_meanfilter(Mat src, Mat dst, int kernalsize)
{
	int ksize;
	vector<uchar> tempdata1,tempdata2,tempdata3,tempdata4;
	tempdata1.clear();
	tempdata2.clear();
	tempdata3.clear();
	tempdata4.clear();
	if (kernalsize % 2 == 0)
	{
		ksize = kernalsize / 2;
	}
	else
	{
		ksize = (kernalsize - 1) / 2;
	}
	if (kernalsize>src.rows || kernalsize>src.cols)
		cout << "核输入过大" << endl;
	/*最大均值滤波 f'=max(Z1,Z2,Z3,Z4)*/
	for (int i = ksize; i < src.rows - ksize; i++)
	{
		uchar* datadst = dst.ptr<uchar>(i);
		for (int j = ksize; j < src.cols - ksize; j++)
		{
			/*Z1*/
			for (int l = j - ksize; l <= j + ksize; l++)
			{
				tempdata1.push_back(src.at<uchar>(i,l));
			}
			int tempsum1 = 0;
			for (size_t tempi = 0; tempi < tempdata1.size(); tempi++)
			{
				tempsum1 += tempdata1[tempi];
			}

			/*Z2*/
			for (int k = i - ksize; k <= i + ksize; k++)
			{
				tempdata2.push_back(src.at<uchar>(k, j));
			}
			int tempsum2 = 0;
			for (size_t tempi = 0; tempi < tempdata2.size(); tempi++)
			{
				tempsum2 += tempdata2[tempi];
			}

			/*Z3*/
			for (int l = i + ksize, k = j - ksize; l >= i - ksize, k <= j + ksize; --l,++k)
			{
				tempdata3.push_back(src.at<uchar>(l, k));
			}
			int tempsum3 = 0;
			for (size_t tempi = 0; tempi < tempdata3.size(); tempi++)
			{
				tempsum3 += tempdata3[tempi];
			}
			/*Z4*/
			for (int l = i - ksize, k = j - ksize; l <= i + ksize, k <= j + ksize; ++l,++k)
			{
				tempdata4.push_back(src.at<uchar>(l, k));
			}
			int tempsum4 = 0;
			for (size_t tempi = 0; tempi < tempdata4.size(); tempi++)
			{
				tempsum4 += tempdata4[tempi];
			}
			int tempsum = 0;
			tempsum = max_sort(tempsum1, tempsum2, tempsum3, tempsum4);
			
			double s = 1.0 / kernalsize;
			datadst[j] = s*tempsum;
			tempdata1.clear();
			tempdata2.clear();
			tempdata3.clear();
			tempdata4.clear();
		}
	}

	return;
}

最大中值滤波

void max_medianfilter(Mat src, Mat dst, int kernalsize)
{
	int ksize;
	vector<uchar> tempdata1, tempdata2, tempdata3, tempdata4;
	tempdata1.clear();
	tempdata2.clear();
	tempdata3.clear();
	tempdata4.clear();
	if (kernalsize % 2 == 0)
	{
		ksize = kernalsize / 2;
	}
	else
	{
		ksize = (kernalsize - 1) / 2;
	}
	if (kernalsize>src.rows || kernalsize>src.cols)
		cout << "核输入过大" << endl;
	/*最大中值滤波 f'=max(Z1,Z2,Z3,Z4)*/
	for (int i = ksize; i < src.rows - ksize; i++)
	{
		uchar* datadst = dst.ptr<uchar>(i);
		for (int j = ksize; j < src.cols - ksize; j++)
		{
			/*Z1*/
			for (int l = j - ksize; l <= j + ksize; l++)
			{
				tempdata1.push_back(src.at<uchar>(i, l));
			}
			//排序
			int tempsum1 = 0;
			sort(tempdata1.begin(), tempdata1.end());
			tempsum1 = tempdata1[tempdata1.size() / 2];
			

			/*Z2*/
			for (int k = i - ksize; k <= i + ksize; k++)
			{
				tempdata2.push_back(src.at<uchar>(k, j));
			}
			int tempsum2 = 0;
			sort(tempdata2.begin(), tempdata2.end());
			tempsum2 = tempdata2[tempdata2.size() / 2];

			/*Z3*/
			for (int l = i + ksize, k = j - ksize; l >= i - ksize, k <= j + ksize; --l, ++k)
			{
				tempdata3.push_back(src.at<uchar>(l, k));
			}
			int tempsum3 = 0;
			sort(tempdata3.begin(), tempdata3.end());
			tempsum3 = tempdata3[tempdata3.size() / 2];

			/*Z4*/
			for (int l = i - ksize, k = j - ksize; l <= i + ksize, k <= j + ksize; ++l, ++k)
			{
				tempdata4.push_back(src.at<uchar>(l, k));
			}
			int tempsum4 = 0;
			sort(tempdata4.begin(), tempdata4.end());
			tempsum4 = tempdata4[tempdata4.size() / 2];
			int tempsum = 0;
			tempsum = max_sort(tempsum1, tempsum2, tempsum3, tempsum4);

			datadst[j] = tempsum;
			tempdata1.clear();
			tempdata2.clear();
			tempdata3.clear();
			tempdata4.clear();
		}
	}

	return;
}

/*四个数排序 输出最大值*/
int max_sort(int a, int b, int c, int d)
{
	int max;
	max = (a>b) ? a : b;
	max = (max>c) ? max : c;
	max = (max>d) ? max : d;
	return max;

}

几何均值滤波：

void GeometricMeanfilter(Mat src, Mat dst, int kernalsize)
{
	int ksize;
	vector<uchar> tempdata;
	tempdata.clear();
	if (kernalsize % 2 == 0)
	{
		ksize = kernalsize / 2;
	}
	else
	{
		ksize = (kernalsize - 1) / 2;
	}
	if (kernalsize>src.rows || kernalsize>src.cols)
		cout << "核输入过大" << endl;

	for (int i = ksize; i < src.rows - ksize; i++)
	{
		uchar* datadst = dst.ptr<uchar>(i);
		for (int j = ksize; j < src.cols - ksize; j++)
		{

			for (int l = i - ksize; l <= i + ksize; l++)
			{
				uchar* datatemp = src.ptr<uchar>(l);
				for (int k = j - ksize; k <= j + ksize; k++)
				{
					tempdata.push_back(datatemp[k]);
				}
			}

			double tempmulti = 1;
			for (size_t tempi = 0; tempi < tempdata.size(); tempi++)
			{
				tempmulti *= tempdata[tempi];
			}

			double s = 1.0 / (kernalsize*kernalsize);

			datadst[j] = pow(tempmulti, s);
			tempdata.clear();
		}
	}

	return;
}