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

ゞ浴缸里的玫瑰 2022-03-01 06:53 1247阅读 0赞

之前一直用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就会每个周期更新一次，逐次将所有的数据流出。下面就是怎么处理了。

![20130501200451072][]

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，这个速度我还是很满意的。

这个必须秀一下：

![20130501201746672][]

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

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

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

5、对比数据

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

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

![20130501203228988][]

上位机使用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处理时会有舍入，二是二者对边界的处理方式不同。

[20130501200451072]: /images/20220301/7676e3d89e39468697dd7c4e11646a54.png
[20130501201746672]: /images/20220301/cda5ee5ceb3249efbc5320907b37f22e.png
[20130501203228988]: /images/20220301/b640549587c64062a47972deb6eb3816.png