基于FPGA的图像处理（七）--Verilog实现均值滤波

之前一直用Xilinx公司的SysGen搭建图像处理的算法，然后进行仿真，也可以直接编译下载到FPGA开发板上直接运行。但是算法实现之后却很难和其他模块一块使用。经过一段时间的反思，决定用Verilog直接写算法。

Verilog进行图像处理的难点：

1、图片获取

    C语言或者Matlab进行图像处理，图片的文件读取获取或者摄像头读取都能 一个函数搞定，但是FPGA进行图像处理，如果从摄像头获取需要考虑很多时序问题，如果从存储区获取图片又不能太大，因为FPGA内部的RAM个数很有限，想存一张图片都比较困难。

//C
IplImage *src = cvLoandImage("lena.png",0);
//Matlab
src = imread('lena.png');

2、算法的编写

FPGA本身的并行性可以使处理速度大大提高，但是算法需要面对的时序问题很难解决

大部分的算法都需要对邻域进行操作，如中值滤波和均值滤波：

//中值滤波和均值滤波
#include<cv.h>
#include<highgui.h>

int main(){
	IplImage * image,*image2,*image3;
	image = cvLoadImage("E:\\image\\Dart.bmp",0);//以灰度图像的形式读入图片
	cvNamedWindow("image",CV_WINDOW_AUTOSIZE);
	cvNamedWindow("image2",CV_WINDOW_AUTOSIZE);
	cvNamedWindow("image3",CV_WINDOW_AUTOSIZE);
	//cvSaveImage("E:\\image\\moon.jpg",image,0);
	cvShowImage("image",image);
	//cvWaitKey(0);
	unsigned char * ptr,*dst;
	int i,j,m,n,sum,temp,r,s;
	image2 = cvCreateImage(cvGetSize(image),image->depth,1);
	image3 = cvCreateImage(cvGetSize(image),image->depth,1);
	//模板1 均值 
	int tem[9] = {1,1,1,1,1,1,1,1,1}; 
	//也可以使用改进的高斯模板，但是效果相近 
	int tem2[9] = {0};//获取中值时用于排序

	//均值滤波3*3模板的均值
	for( i = 0 ; i < image->height;i++){
		for( j = 0; j< image->width;j++){
			
			//边界处理
			if(i == 0 || i == image->height || j == 0 || j == image->width){
				ptr = (unsigned char *)image->imageData + i*image->widthStep + j;
				dst = (unsigned char *)image2->imageData+ i*image2->widthStep+ j;
			 	*dst = *ptr; //边界值赋予源图像的值
			}
			else {
				sum = 0;
				for( m = -1 ; m <= 1; m++  ){
					for( n = -1 ; n <= 1 ; n++){
						ptr = (unsigned char *)image->imageData + (i + m)*image->widthStep + j + n;
						
						sum += (*ptr) * tem[3*(m+1) + n+1];
					}
				}
				dst = (unsigned char *)image2->imageData+ i *image2->widthStep+ j;	
				*dst = (unsigned char)((sum +4)/9);//赋新值，四舍五入
			} 
		
		}
	}
//中值滤波 在去除噪声的同时，图像的模糊程度比较小，比均值滤波更加适合
//冲击噪声或者称为椒盐噪声
	for( i = 0 ; i < image->height;i++){
		for( j = 0; j< image->width;j++){

			//边界处理
			if(i == 0 || i == image->height || j == 0 || j == image->width){
				ptr = (unsigned char *)image->imageData + i*image->widthStep + j;
				dst = (unsigned char *)image3->imageData+ i*image3->widthStep+ j;
				*dst = *ptr; //边界值赋予源图像的值
			}
			else {
				temp = 0;
				//将3*3模板覆盖的值拷贝进数组，一边查找中值
				for( m = -1 ; m <= 1; m++  ){
					for( n = -1 ; n <= 1 ; n++){
						ptr = (unsigned char *)image->imageData + (i + m)*image->widthStep + j + n;
						tem2[3*(m+1) +n +1] = *ptr;
						//printf("%d",*ptr);
					
					}
				}
				//对数组进行冒泡排序
				for(r = 0 ; r <8; r ++){
					for(s = 0 ; s< r -1; s++ ){
						if(tem2[s] > tem2[s+1]){
							temp = tem2[s];
							tem2[s] = tem2[s+1];
							tem2[s+1] = temp;
						}
					}
				}
				//printf("%d",tem2[4]);
				//对新图赋予新值
				dst = (unsigned char *)image3->imageData+ i *image3->widthStep+ j;	
				*dst = (unsigned char)(tem2[4]);//赋新值
			} 

		}
	}

	cvShowImage("image2",image2);
	cvShowImage("image3",image3);
	cvWaitKey(0);
	cvSaveImage("E:\\image\\Dart2.bmp",image2,0);
	cvSaveImage("E:\\image\\Dart3.bmp",image3,0);
	return 0;
}

3、处理效果的显示

 FPGA处理速度快，但是能进行显示的方法却比较少，一般的FPGA开发板（指的是价格低廉的）虽然带有VGA接口，但是一般都是IO直驱，导致显示的颜色一般只有8种而已，都无法进行灰度图的显示

我试着写一些简单的处理算法，第一次写的是中值滤波，在解决问题的过程中发现其实并没有特别的复杂。

测试平台：黑金动力社区的FPGA开发板，cyclone IV 

1、图片的获取

虽然Verilog读取CMOS摄像头的源码网上很多，但是我还是希望算法测试阶段，图片数据是固定的。因此将图片压缩到32*32 = 1024个像素。

Cyclone IV的M9K RAM的大小刚好是1024Byte，图片大一些也是可以的，只是这里没有必要。

QuartusII提供了很多现成的模块，这里使用ROM模块来存储原始图片，ROM的初始化使用mif文件，mif文件制定了ROM的深度，位宽，以及数据等。至于mif文件怎么生成，首选当然是matlab了。

matlab生成mif文件：

%mcode to create a mif file
src = imread('lena.jpg');
gray = rgb2gray(src);
[m,n] = size( gray );                  % m行 n列

N = m*n;                               %%数据的长度，即存储器深度。
word_len = 8;                          %%每个单元的占据的位数，需自己设定
data = reshape(gray', 1, N);% 1行N列



fid=fopen('gray_image.mif', 'w');       %打开文件
fprintf(fid, 'DEPTH=%d;\n', N);
fprintf(fid, 'WIDTH=%d;\n', word_len);

fprintf(fid, 'ADDRESS_RADIX = UNS;\n'); %% 指定地址为十进制
fprintf(fid, 'DATA_RADIX = HEX;\n');    %% 指定数据为十六进制
fprintf(fid, 'CONTENT\t');
fprintf(fid, 'BEGIN\n');
for i = 0 : N-1
    fprintf(fid, '\t%d\t:\t%x;\n',i, data(i+1));
end
fprintf(fid, 'END;\n');                 %%输出结尾
fclose(fid);                            %%关闭文件

mif文件的格式大致如此：

DEPTH=1024;
WIDTH=8;
ADDRESS_RADIX = UNS;
DATA_RADIX = HEX;
CONTENT	BEGIN
	0	:	9e;
	1	:	97;
...................................
	1020	:	50;
	1021	:	65;
	1022	:	58;
	1023	:	3b;
END;

使用megaWizard生成一个ROM模块，

ROM模块的调用格式：

gray_image_ROM	gray_image_ROM_inst (
	.address ( address_sig ),
	.clock ( clock_sig ),
	.q ( q_sig )
	);

可以通过如下的方式逐个获取像素值：

	//rom 		
	reg [9:0] rd_addr = 10'b0_000_000_000;
	wire [7:0] raw_data; 
	//address increase
	always @(posedge rCLK_1Hz or negedge iRST_n)
		if(!iRST_n)
			rd_addr <= 10'b0_000_000_000;
		else if(rd_addr == 10'b1_111_111_111)
			rd_addr <= 10'b0_000_000_000;
		else rd_addr <= rd_addr + 1'b1;
	
	//read from rom
	gray_image_ROM	gray_image_ROM_inst 
	(
		.address ( rd_addr ),
		.clock ( rCLK_1Hz ),
		.q ( raw_data )
	);

raw_data就会每个周期更新一次，逐次将所有的数据流出。下面就是怎么处理了。

2、数据在ROM中，需要让数据一个一个的流出来，不能像C那样想用谁用谁了。

数据一个一个的流出，但是均值滤波需要的是邻域操作，需要每次知道一个邻域内的所有值。

假设中值滤波使用的邻域为3*3，那么就需要知道9个数据。

同一行相邻的数据可以通过设置多个寄存器获取。

同一列的相邻数据的获取可以使用一个行缓存LineBuffer获取，行缓存的头部是ROM中流出的数据，行缓存的3个末端是相邻的三行，这样就能每个周期得出相邻行的三个数据。

这样每个周期就能获取邻域内的9个数据。

如果邻域更大只需要调整行缓存的末端个数以及寄存器个数即可。

LineBuffer可以用megaWizard生成,调用格式如下：

shift_line_buffer	shift_line_buffer_inst (
	.clock ( clock_sig ),
	.shiftin ( shiftin_sig ),
	.shiftout ( shiftout_sig ),
	.taps0x ( taps0x_sig ),
	.taps1x ( taps1x_sig ),
	.taps2x ( taps2x_sig )
	);

可以通过如的方式获取邻域内的9个数据：

	wire	[7:0]	wData0;
	wire	[7:0]	wData1;
	wire	[7:0]	wData2;

	
	reg	[7:0]	wData0_d1,wData0_d2;
	reg	[7:0]	wData1_d1,wData1_d2;
	reg	[7:0]	wData2_d1,wData2_d2;
	
	//TODO 
	shift_line_buffer	S1	(
					.clock(wMeanFilter_clk),
					.shiftin(iData),
					.shiftout(),
					.taps2x(wData0),
					.taps1x(wData1),
					.taps0x(wData2)
				);
	//get data in the window
	always@(posedge wMeanFilter_clk or negedge iRST_n)
	begin
		if (!iRST_n)
			begin
				wData0_d1<=0;
				wData0_d2<=0;
				wData1_d1<=0;
				wData1_d2<=0;
				wData2_d1<=0;
				wData2_d2<=0;				
			end
		else
			begin
				{wData0_d2,wData0_d1}<={wData0_d1,wData0};
				{wData1_d2,wData1_d1}<={wData1_d1,wData1};
				{wData2_d2,wData2_d1}<={wData2_d1,wData2};
			end
	end	

此时wData0 wData1 wData2 wData0_d1 ,wData0_d2, wData1_d1,wData2_d1,wData2_d2即为邻域内的9个数据，可以随便进行处理了。

3、均值滤波算法

由于是第一次用Verilog写算法，不敢写太复杂的，上个简单的吧，均值滤波，由于FPGA不擅长算乘除法（感觉好弱啊），因此将算法稍微改进，变成加权的均值滤波，权值如下

1 2 1

2 4 2

1 2 1

乘法可以用移位代替，最后的除法（除数刚好是16哦亲）也可以用移位来代替。

算法模块：

module meanFilter
(	
	input [7:0] p00, 
	input [7:0] p01, 
	input [7:0] p02, 
	input [7:0] p10, 
	input [7:0] p11, 
	input [7:0] p12, 
	input [7:0] p20, 
	input [7:0] p21, 
	input [7:0] p22,
	output [7:0] oMeanVal
); 
	//weights
	//1 2 1
	//2 4 2
	//1 2 1
	wire [8:0] p01_w, p10_w, p12_w,p21_w;
	wire [9:0] p11_w;	
	wire [11:0] sum;
	
	wire [10:0] sum2;
	wire [10:0] sum1;
	assign p01_w = { p01, 1'b0};
	assign p10_w = { p10, 1'b0};
	assign p12_w = { p12, 1'b0};
	assign p21_w = { p21, 1'b0};	
	assign p11_w = { p11, 2'b0};	
	assign sum1 = p00 + p02 + p20 + p22 + p11_w;
	assign sum2 = p01_w + p10_w + p12_w + p21_w;
	// assign sum4 = p11_w;
	assign sum = sum1 + sum2;	
	assign oMeanVal = sum[11:4];
endmodule 	

4、处理效果的显示

本来打算用VGA或者LCD显示处理后的图片，但是由于我的板子比较屌丝，VGA接口只能显示8种颜色，LCD只能显示2种颜色，因此决定将数据发给上位机，在上位机进行显示。

串口速率比较低，可能很多数据来不及发送诶上位机，因此决定换个高端的，买了个USB2.0的模块，测试通信速度可以达到40Mb/s，这个速度我还是很满意的。

这个必须秀一下：

在算法和USB模块之间加一个FIFO，当FIFO不满时就计算并往里塞数据，当FIFO慢时就停止计算，这样就能够避免低丢数的问题。

为了随时记录算法是否在进行，加上一个数码管，显示处理之后的数据的低四位。

由于计算的频率比较高，数码管一直显示8，假如上位机不接收的话，当FIFO满时，停止计算，此时数码管就不动了。

5、对比数据

用matlab进行一次均值滤波，然后和FPGA均值滤波的结果进行比较看看效果如何：

第一行是上位机均值滤波的结果，第二行是FPGA进行均值滤波的结果。

上位机使用matlab处理的：

%mcode to create a mif file
src = imread('lena.jpg');
gray = rgb2gray(src);
imwrite(gray, 'gray.png');
[m,n] = size( gray );                  % m行 n列
dst = gray;
sum = 0;
gray = double(gray);
for i = 2 : m -1 %  i 行
    for j = 2 : n -1 %j 列
        sum = gray(i,j)*4 + gray(i, j -1)*2 + gray(i-1, j)*2 + gray(i, j + 1)*2 + gray(i +1, j) *2 + gray(i-1, j-1)+ gray(i-1,j+1) + gray(i+1, j-1) + gray(i +1, j+1);
        dst(i,j) = uint8(sum/16);
    end
end

%将数据写入文件
fid = fopen('meanFilter.txt','w');
for i = 1 : m
   for j = 1 :n
        fprintf(fid, '%x ',dst(i,j));
   end
end
fclose(fid);
imwrite(dst, 'meanFilter.png');

注意到有些数据并不一致，有两个原因，一是Matlab处理时会有舍入，二是二者对边界的处理方式不同。