基于FPGA的图像处理（七）--Verilog实现均值滤波 摄像头, C语言, 图片

pengpengpang

之前一直用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
#include
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处理时会有舍入，二是二者对边界的处理方式不同。

来源：机器视觉的博客