johnllon

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

0赞
发表于 2015/11/9 12:48:09 阅读（3051）

原文地址：http://blog.csdn.net/renshengrumenglibing/article/details/8872805

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


Verilog进行图像处理的难点：

1、图片获取

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

[cpp]view plaincopy

[cpp]view plaincopy

  1. //C

  2. IplImage *src = cvLoandImage("lena.png",0);

  3. //Matlab

  4. src = imread('lena.png');


2、算法的编写

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

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

[cpp]view plaincopy

  1. //中值滤波和均值滤波

  2. #include

  3. #include

  5. int main(){

  6. IplImage * image,*image2,*image3;

  7. image = cvLoadImage("E:\\image\\Dart.bmp",0);//以灰度图像的形式读入图片

  8. cvNamedWindow("image",CV_WINDOW_AUTOSIZE);

  9. cvNamedWindow("image2",CV_WINDOW_AUTOSIZE);

  10. cvNamedWindow("image3",CV_WINDOW_AUTOSIZE);

  11. //cvSaveImage("E:\\image\\moon.jpg",image,0);

  12. cvShowImage("image",image);

  13. //cvWaitKey(0);

  14. unsigned char * ptr,*dst;

  15. int i,j,m,n,sum,temp,r,s;

  16. image2 = cvCreateImage(cvGetSize(image),image->depth,1);

  17. image3 = cvCreateImage(cvGetSize(image),image->depth,1);

  18. //模板1 均值

  19. int tem[9] = {1,1,1,1,1,1,1,1,1};

  20. //也可以使用改进的高斯模板，但是效果相近

  21. int tem2[9] = {0};//获取中值时用于排序

  23. //均值滤波3*3模板的均值

  24. for( i = 0 ; i < image->height;i++){

  25. for( j = 0; j< image->width;j++){

  27. //边界处理

  28. if(i == 0 || i == image->height || j == 0 || j == image->width){

  29. ptr = (unsigned char *)image->imageData + i*image->widthStep + j;

  30. dst = (unsigned char *)image2->imageData+ i*image2->widthStep+ j;

  31. *dst = *ptr; //边界值赋予源图像的值

  32. }

  33. else {

  34. sum = 0;

  35. for( m = -1 ; m <= 1; m++ ){

  36. for( n = -1 ; n <= 1 ; n++){

  37. ptr = (unsigned char *)image->imageData + (i + m)*image->widthStep + j + n;

  39. sum += (*ptr) * tem[3*(m+1) + n+1];

  40. }

  41. }

  42. dst = (unsigned char *)image2->imageData+ i *image2->widthStep+ j;

  43. *dst = (unsigned char)((sum +4)/9);//赋新值，四舍五入

  44. }

  46. }

  47. }

  48. //中值滤波 在去除噪声的同时，图像的模糊程度比较小，比均值滤波更加适合

  49. //冲击噪声或者称为椒盐噪声

  50. for( i = 0 ; i < image->height;i++){

  51. for( j = 0; j< image->width;j++){

  53. //边界处理

  54. if(i == 0 || i == image->height || j == 0 || j == image->width){

  55. ptr = (unsigned char *)image->imageData + i*image->widthStep + j;

  56. dst = (unsigned char *)image3->imageData+ i*image3->widthStep+ j;

  57. *dst = *ptr; //边界值赋予源图像的值

  58. }

  59. else {

  60. temp = 0;

  61. //将3*3模板覆盖的值拷贝进数组，一边查找中值

  62. for( m = -1 ; m <= 1; m++ ){

  63. for( n = -1 ; n <= 1 ; n++){

  64. ptr = (unsigned char *)image->imageData + (i + m)*image->widthStep + j + n;

  65. tem2[3*(m+1) +n +1] = *ptr;

  66. //printf("%d",*ptr);

  68. }

  69. }

  70. //对数组进行冒泡排序

  71. for(r = 0 ; r <8; r ++){

  72. for(s = 0 ; s< r -1; s++ ){

  73. if(tem2[s] > tem2[s+1]){

  74. temp = tem2[s];

  75. tem2[s] = tem2[s+1];

  76. tem2[s+1] = temp;

  77. }

  78. }

  79. }

  80. //printf("%d",tem2[4]);

  81. //对新图赋予新值

  82. dst = (unsigned char *)image3->imageData+ i *image3->widthStep+ j;

  83. *dst = (unsigned char)(tem2[4]);//赋新值

  84. }

  86. }

  87. }

  89. cvShowImage("image2",image2);

  90. cvShowImage("image3",image3);

  91. cvWaitKey(0);

  92. cvSaveImage("E:\\image\\Dart2.bmp",image2,0);

  93. cvSaveImage("E:\\image\\Dart3.bmp",image3,0);

  94. return 0;

  95. }


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文件：

[cpp]view plaincopy

  1. %mcode to create a mif file

  2. src = imread('lena.jpg');

  3. gray = rgb2gray(src);

  4. [m,n] = size( gray ); % m行 n列

  6. N = m*n; %%数据的长度，即存储器深度。

  7. word_len = 8; %%每个单元的占据的位数，需自己设定

  8. data = reshape(gray', 1, N);% 1行N列

  12. fid=fopen('gray_image.mif', 'w'); %打开文件

  13. fprintf(fid, 'DEPTH=%d;\n', N);

  14. fprintf(fid, 'WIDTH=%d;\n', word_len);

  16. fprintf(fid, 'ADDRESS_RADIX = UNS;\n'); %% 指定地址为十进制

  17. fprintf(fid, 'DATA_RADIX = HEX;\n'); %% 指定数据为十六进制

  18. fprintf(fid, 'CONTENT\t');

  19. fprintf(fid, 'BEGIN\n');

  20. for i = 0 : N-1

  21. fprintf(fid, '\t%d\t:\t%x;\n',i, data(i+1));

  22. end

  23. fprintf(fid, 'END;\n'); %%输出结尾

  24. fclose(fid); %%关闭文件


mif文件的格式大致如此：

[cpp]view plaincopy

  1. DEPTH=1024;

  2. WIDTH=8;

  3. ADDRESS_RADIX = UNS;

  4. DATA_RADIX = HEX;

  5. CONTENT BEGIN

  6. 0 : 9e;

  7. 1 : 97;

  8. ...................................

  9. 1020 : 50;

  10. 1021 : 65;

  11. 1022 : 58;

  12. 1023 : 3b;

  13. END;


使用megaWizard生成一个ROM模块，

ROM模块的调用格式：

[cpp]view plaincopy

  1. gray_image_ROM gray_image_ROM_inst (

  2. .address ( address_sig ),

  3. .clock ( clock_sig ),

  4. .q ( q_sig )

  5. );


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

[cpp]view plaincopy

  1. //rom

  2. reg [9:0] rd_addr = 10'b0_000_000_000;

  3. wire [7:0] raw_data;

  4. //address increase

  5. always @(posedge rCLK_1Hz or negedge iRST_n)

  6. if(!iRST_n)

  7. rd_addr <= 10'b0_000_000_000;

  8. else if(rd_addr == 10'b1_111_111_111)

  9. rd_addr <= 10'b0_000_000_000;

  10. else rd_addr <= rd_addr + 1'b1;

  12. //read from rom

  13. gray_image_ROM gray_image_ROM_inst

  14. (

  15. .address ( rd_addr ),

  16. .clock ( rCLK_1Hz ),

  17. .q ( raw_data )

  18. );


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



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

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

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

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

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

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

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

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

[cpp]view plaincopy

  1. shift_line_buffer shift_line_buffer_inst (

  2. .clock ( clock_sig ),

  3. .shiftin ( shiftin_sig ),

  4. .shiftout ( shiftout_sig ),

  5. .taps0x ( taps0x_sig ),

  6. .taps1x ( taps1x_sig ),

  7. .taps2x ( taps2x_sig )

  8. );

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

[cpp]view plaincopy

  1. wire [7:0] wData0;

  2. wire [7:0] wData1;

  3. wire [7:0] wData2;

  6. reg [7:0] wData0_d1,wData0_d2;

  7. reg [7:0] wData1_d1,wData1_d2;

  8. reg [7:0] wData2_d1,wData2_d2;

  10. //TODO

  11. shift_line_buffer S1 (

  12. .clock(wMeanFilter_clk),

  13. .shiftin(iData),

  14. .shiftout(),

  15. .taps2x(wData0),

  16. .taps1x(wData1),

  17. .taps0x(wData2)

  18. );

  19. //get data in the window

  20. always@(posedge wMeanFilter_clk or negedge iRST_n)

  21. begin

  22. if (!iRST_n)

  23. begin

  24. wData0_d1<=0;

  25. wData0_d2<=0;

  26. wData1_d1<=0;

  27. wData1_d2<=0;

  28. wData2_d1<=0;

  29. wData2_d2<=0;

  30. end

  31. else

  32. begin

  33. {wData0_d2,wData0_d1}<={wData0_d1,wData0};

  34. {wData1_d2,wData1_d1}<={wData1_d1,wData1};

  35. {wData2_d2,wData2_d1}<={wData2_d1,wData2};

  36. end

  37. end

[cpp]view plaincopy

此时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哦亲）也可以用移位来代替。

算法模块：

[cpp]view plaincopy

  1. module meanFilter

  2. (

  3. input [7:0] p00,

  4. input [7:0] p01,

  5. input [7:0] p02,

  6. input [7:0] p10,

  7. input [7:0] p11,

  8. input [7:0] p12,

  9. input [7:0] p20,

  10. input [7:0] p21,

  11. input [7:0] p22,

  12. output [7:0] oMeanVal

  13. );

  14. //weights

  15. //1 2 1

  16. //2 4 2

  17. //1 2 1

  18. wire [8:0] p01_w, p10_w, p12_w,p21_w;

  19. wire [9:0] p11_w;

  20. wire [11:0] sum;

  22. wire [10:0] sum2;

  23. wire [10:0] sum1;

  24. assign p01_w = { p01, 1'b0};

  25. assign p10_w = { p10, 1'b0};

  26. assign p12_w = { p12, 1'b0};

  27. assign p21_w = { p21, 1'b0};

  28. assign p11_w = { p11, 2'b0};

  29. assign sum1 = p00 + p02 + p20 + p22 + p11_w;

  30. assign sum2 = p01_w + p10_w + p12_w + p21_w;

  31. // assign sum4 = p11_w;

  32. assign sum = sum1 + sum2;

  33. assign oMeanVal = sum[11:4];

  34. endmodule


4、处理效果的显示

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

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

这个必须秀一下：


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

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

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


5、对比数据

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

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



上位机使用matlab处理的：

[cpp]view plaincopy

  1. %mcode to create a mif file

  2. src = imread('lena.jpg');

  3. gray = rgb2gray(src);

  4. imwrite(gray, 'gray.png');

  5. [m,n] = size( gray ); % m行 n列

  6. dst = gray;

  7. sum = 0;

  8. gray = double(gray);

  9. for i = 2 : m -1 % i 行

  10. for j = 2 : n -1 %j 列

  11. 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);

  12. dst(i,j) = uint8(sum/16);

  13. end

  14. end

  16. %将数据写入文件

  17. fid = fopen('meanFilter.txt','w');

  18. for i = 1 : m

  19. for j = 1 :n

  20. fprintf(fid, '%x ',dst(i,j));

  21. end

  22. end

  23. fclose(fid);

  24. imwrite(dst, 'meanFilter.png');


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


Copyright © 2005-2020 kaiyun官方注册版权所有京ICP备10017138号

Baidu
map