1. Toy模板网首页
  2. > Toy博客

FPGA + 图像处理（三）生成3x3像素矩阵

7月前 作者：EfunStudy 分类：Toy博客 阅读(32) 违法举报

这篇具有很好参考价值的文章主要介绍了FPGA + 图像处理（三）生成3x3像素矩阵。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言

生成NxN的像素矩阵是对图像进行各类滤波操作的基本前提，本文介绍一种通过bram生成3x3矩阵的方法。

程序

生成bram核

因为本文介绍的是基于bram生成的3x3像素矩阵，所以要先生成两个bram核，用于缓存前两行图像数据

在 IP catalog中选择Block Memory Generator

FPGA + 图像处理（三）生成3x3像素矩阵,FPGA + 图像处理,fpga开发,图像处理

FPGA + 图像处理（三）生成3x3像素矩阵,FPGA + 图像处理,fpga开发,图像处理

配置如下

FPGA + 图像处理（三）生成3x3像素矩阵,FPGA + 图像处理,fpga开发,图像处理

注意这里选择simple dual port RAM，即伪双端口，一个端口只能写，一个端口只能读

FPGA + 图像处理（三）生成3x3像素矩阵,FPGA + 图像处理,fpga开发,图像处理

端口A用于写入数据，注意数据的位宽要与图像位深相同，彩色通常为24位，灰度图为8位，数据深度为一行像素的长度，operating选择写优先，enable port type选择始终使能

FPGA + 图像处理（三）生成3x3像素矩阵,FPGA + 图像处理,fpga开发,图像处理

端口B用于读取数据，这里要注意下面的primitives output register要勾选上，勾选该选项后，数据的输出会延迟一个时钟周期，用于对齐数据。

HDMI时序生成模块

这里也用到了HDMI时序生成模块，具体作用和前面文章讲的一样，一是可以做到通过同步信号简化对图像数据的管理，二是可以让测试的数据处理模块更方便的适配用HDMI显示的图像处理工程。

具体代码如下

module hdmi_tim_gen(
    input           	clk			,
    input           	rst_n	    ,
	input   	[23:0]  data_in		,
		
    output          	hdmi_hs		,     //行同步信号
    output          	hdmi_vs		,     //场同步信号
    output          	hdmi_de		,     //数据使能
    output  	[23:0]  hdmi_data	,     //RGB888颜色数据
    output		reg		data_req 	

);

//1280*720 分辨率时序参数
parameter  H_SYNC   =  11'd40;   //行同步
parameter  H_BACK   =  11'd220;  //行显示后沿
parameter  H_DISP   =  11'd1280; //行有效数据
parameter  H_FRONT  =  11'd110;  //行显示前沿
parameter  H_TOTAL  =  11'd1650; //行扫描周期

parameter  V_SYNC   =  11'd5;    //场同步
parameter  V_BACK   =  11'd20;   //场显示后沿
parameter  V_DISP   =  11'd720;  //场有效数据
parameter  V_FRONT  =  11'd5;    //场显示前沿
parameter  V_TOTAL  =  11'd750;  //场扫描周期

//reg define
reg  [11:0] 	cnt_h;
reg  [11:0] 	cnt_v;

reg [10:0] pixel_xpos;
reg [10:0] pixel_ypos;

assign hdmi_de  = data_req;
assign hdmi_hs  = ( cnt_h < H_SYNC ) ? 1'b0 : 1'b1;  //行同步信号赋值
assign hdmi_vs  = ( cnt_v < V_SYNC ) ? 1'b0 : 1'b1;  //场同步信号赋值

//RGB888数据输出
assign hdmi_data = hdmi_de ? data_in : 24'd0;

//请求像素点颜色数据输入
always @(posedge clk or negedge rst_n) begin
	if(!rst_n)
		data_req <= 1'b0;
	else if(((cnt_h >= H_SYNC + H_BACK - 2'd2) && (cnt_h < H_SYNC + H_BACK + H_DISP - 2'd2))
                  && ((cnt_v >= V_SYNC + V_BACK) && (cnt_v < V_SYNC + V_BACK+V_DISP)))
		data_req <= 1'b1;
	else
		data_req <= 1'b0;
end

//像素点x坐标
always@ (posedge clk or negedge rst_n) begin
    if(!rst_n)
        pixel_xpos <= 11'd0;
    else if(data_req)
        pixel_xpos <= cnt_h + 2'd2 - H_SYNC - H_BACK ;
    else 
        pixel_xpos <= 11'd0;
end
    
//像素点y坐标	
always@ (posedge clk or negedge rst_n) begin
    if(!rst_n)
        pixel_ypos <= 11'd0;
    else if((cnt_v >= (V_SYNC + V_BACK)) && (cnt_v < (V_SYNC + V_BACK + V_DISP)))
        pixel_ypos <= cnt_v + 1'b1 - (V_SYNC + V_BACK) ;
    else 
        pixel_ypos <= 11'd0;
end

//行计数器对像素时钟计数
always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
        cnt_h <= 11'd0;
    else begin
        if(cnt_h < H_TOTAL - 1'b1)
            cnt_h <= cnt_h + 1'b1;
        else 
            cnt_h <= 11'd0;
    end
end

//场计数器对行计数
always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
        cnt_v <= 11'd0;
    else if(cnt_h == H_TOTAL - 1'b1) begin
        if(cnt_v < V_TOTAL - 1'b1)
            cnt_v <= cnt_v + 1'b1;
        else 
            cnt_v <= 11'd0;
    end
end

endmodule

生成3x3像素矩阵的顶层模块

module kernel_3x3_gen
(
	input					clk,  		
	input					rst_n,				

	//准备要进行处理的图像数据
	input					vs_i,
	input					de_i,
	input        [23:0]  	data_i,

	//矩阵化后的图像数据和控制信号
	output				vs_o,
	output				de_o,
	output	reg  [23:0]	mat11, 
	output	reg  [23:0]	mat12,
	output	reg  [23:0]	mat13,
	output	reg	 [23:0]	mat21, 
	output	reg  [23:0]	mat22, 
	output	reg  [23:0]	mat23,
	output	reg	 [23:0]	mat31, 
	output	reg  [23:0]	mat32, 
	output	reg  [23:0]	mat33
);

//wire define
wire  [23:0]  	row1_data;        //第一行数据
wire  [23:0]  	row2_data;        //第二行数据
wire	     	de_i_en ;

//reg define
reg  [23:0]  row3_data;         //第三行数据，即当前正在接受的数据
reg  [23:0]  row3_data_d0;
reg  [23:0]  row3_data_d1;
reg  [23:0]  row2_data_d0;
reg  [1:0]   vs_i_d;
reg  [1:0]   de_i_d;

assign	de_i_en = de_i_d[0] ;
assign	vs_o 	= vs_i_d[1];
assign	de_o  	= de_i_d[1] ;

//当前数据放在第3行
always@(posedge clk or negedge rst_n) begin
	if(!rst_n)
		row3_data <= 0;
	else begin		
		if(de_i)
			row3_data <= data_i ;
		else
			row3_data <= row3_data ;
	end
end

//用于存储列数据的RAM
line_shift  u_line_shift
(
	.clk		    (clk),
	.de_i 			(de_i),

	.data_i	    	(data_i),   //当前行的数据
	.data1_o		(row2_data),   //前一行的数据
	.data2_o		(row1_data)    //前前一行的数据
);

//将同步信号延迟两拍，用于同步化处理
always@(posedge clk or negedge rst_n) begin
	if(!rst_n) begin		
		vs_i_d <= 0;
		de_i_d <= 0;
	end
	else begin		
		vs_i_d  <= { vs_i_d[0], vs_i };
		de_i_d  <= { de_i_d[0], de_i };
	end
end

always @(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        row3_data_d1 <= 0;
        row3_data_d0 <= 0;
        row2_data_d0 <= 0;
    end
    else begin
        row3_data_d0 <= row3_data;
        row3_data_d1 <= row3_data_d0;
        row2_data_d0 <= row2_data;
    end
end

//在同步处理后的控制信号下，输出图像矩阵
always@(posedge clk or negedge rst_n) begin
	if(!rst_n) begin		
		{mat11, mat12, mat13} <= 0;
		{mat21, mat22, mat23} <= 0;
		{mat31, mat32, mat33} <= 0;
	end
	else if(de_i_en) begin				
		{mat11, mat12, mat13} <= {mat12, mat13, row1_data};
		{mat21, mat22, mat23} <= {mat22, mat23, row2_data_d0};
		{mat31, mat32, mat33} <= {mat32, mat33, row3_data_d1};
	end
	else begin		
		{mat11, mat12, mat13} <= 0;
		{mat21, mat22, mat23} <= 0;
		{mat31, mat32, mat33} <= 0;
	end
end

endmodule

行移位模块

module line_shift(
	input 			clk,
	input           de_i,

	input   [23:0]  data_i,    //当前行的数据
	output  [23:0]  data1_o,   //前一行的数据
	output  [23:0]  data2_o    //前前一行的数据
);

//reg define
reg  de_i_d0;
reg  de_i_d1;
reg  de_i_d2;
reg  [10:0]  ram_rd_addr;
reg  [10:0]  ram_rd_addr_d0;
reg  [10:0]  ram_rd_addr_d1;
reg  [23:0]  data_i_d0;
reg  [23:0]  data_i_d1;
reg  [23:0]  data_i_d2;
reg  [23:0]  data1_o_d0;

//在数据到来时，RAM的读地址累加
always@(posedge clk)begin
	if(de_i)
		ram_rd_addr <= ram_rd_addr + 1 ;	
	else
		ram_rd_addr <= 0 ;
end

//将数据使能延迟两拍
always@(posedge clk) begin
	de_i_d0 <= de_i;
	de_i_d1 <= de_i_d0;
	de_i_d2 <= de_i_d1;
end

//将RAM地址延迟2拍
always@(posedge clk ) begin
	ram_rd_addr_d0 <= ram_rd_addr;
	ram_rd_addr_d1 <= ram_rd_addr_d0;
end

//输入数据延迟3拍送入RAM
always@(posedge clk)begin
	data_i_d0 <= data_i;
	data_i_d1 <= data_i_d0;
	data_i_d2 <= data_i_d1;
end

//用于存储前一行图像的RAM
blk_mem_gen_0  u_ram_1024x8_0(
  .clka   (clk),
  .wea    (de_i_d2),
  .addra  (ram_rd_addr_d1),     //在延迟的第三个时钟周期，当前行的数据写入RAM0
  .dina   (data_i_d2),
  
  .clkb   (clk),
  .addrb  (ram_rd_addr),    
  .doutb  (data1_o)              //延迟一个时钟周期，输出RAM0中前一行图像的数据
);

//寄存前一行图像的数据
always@(posedge clk)begin
	data1_o_d0  <= data1_o;
end

//用于存储前前一行图像的RAM
blk_mem_gen_0  u_ram_1024x8_1(
	.clka   (clk),
	.wea    (de_i_d1),
	.addra  (ram_rd_addr_d0),
	.dina   (data1_o_d0),       //在延迟的第二个时钟周期，将前一行图像的数据写入RAM1

	.clkb   (clk),
	.addrb  (ram_rd_addr),
	.doutb  (data2_o)           //延迟一个时钟周期，输出RAM1中前前一行图像的数据
);

endmodule

仿真模块

`timescale 1ns/1ns

module pic_tb();

reg             clk,rst_n				;

reg [23:0]      data_in					;
wire      		hdmi_hs,hdmi_vs,hdmi_de ;
wire [23:0]  	hdmi_data  				;
wire 			data_req   				;

reg  			vs_i,de_i	;
wire 			vs_o,de_o		;
wire [23:0]		mat11, mat12, mat13 ;
wire [23:0]		mat21, mat22, mat23 ;
wire [23:0]		mat31, mat32, mat33 ;
//延迟1clk，与data同步,hdmi时序中，data比de延迟了一个时钟周期
always @(posedge clk)begin
    vs_i <= hdmi_vs;
    de_i <= hdmi_de;
end

initial begin
	clk = 1;
	rst_n = 0;
	#20 rst_n = 1;
end
always #10 clk = ~clk;

reg [23:0] img[0:1280*720-1];
reg [31:0] addr;
initial begin
    $readmemh("D:/pic/img2txt.txt",img);
end

always @(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        addr <= 0		;
        data_in <= 0	;
    end
    else if(data_req) begin
        data_in	 <= img[addr];
        addr	 <= addr + 1;
        if(addr == (1280*720-1))
			addr <= 0;
    end
end

hdmi_tim_gen u_hdmi_tim_gen(
	.clk		 	(clk),	
    .rst_n	  		(rst_n),
	//input
    .data_in	 	(data_in),
    //output
    .hdmi_hs	 	(hdmi_hs),
    .hdmi_vs	 	(hdmi_vs),
    .hdmi_de	 	(hdmi_de),
    .hdmi_data 		(hdmi_data),
    .data_req  		(data_req)
);

 kernel_3x3_gen u_kernel_3x3_gen(
    .clk        (clk), 
    .rst_n      (rst_n),
    
    //预处理灰度数据
    .vs_i    		 (vs_i),
    .de_i     		 (de_i), 
    .data_i          (hdmi_data),
    
    //输出3x3矩阵
    .vs_o   		(vs_o),
    .de_o    		(de_o),
    .mat11         (mat11),    
    .mat12         (mat12),    
    .mat13         (mat13),
    .mat21         (mat21),    
    .mat22         (mat22),    
    .mat23         (mat23),
    .mat31         (mat31),    
    .mat32         (mat32),    
    .mat33         (mat33)
);

endmodule

整体架构

FPGA + 图像处理（三）生成3x3像素矩阵,FPGA + 图像处理,fpga开发,图像处理

仿真结果

截取部分数据结果

FPGA + 图像处理（三）生成3x3像素矩阵,FPGA + 图像处理,fpga开发,图像处理

mat31、mat32、mat33是第一行数据（最先输入的那一行），mat11、mat12、mat13是第三行数据（最后输入的那一行），可以看见数据的移位满足像素矩阵的要求。文章来源地址https://www.toymoban.com/news/detail-858632.html

到了这里，关于FPGA + 图像处理（三）生成3x3像素矩阵的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • #MATLAB 利用基本矩阵产生3x3和15x8的单位阵，全1阵，全0阵，均匀分布的随机阵（[-1，1]之间），正态分布随机阵（方差4，均值1）

            利用基本矩阵产生3x3和15x8的单位阵，全1阵，全0阵，均匀分布的随机阵（[-1，1]之间），正态分布随机阵（方差4，均值1） 题解： 输出：  a1 =      1     0     0      0     1     0      0     0     1 a2 =      1     0     0     0     0     0     0     0      

    2024年02月03日
    浏览(49)
  • FPGA图像处理之Shift-RAM Core 生成卷积模板（官方手册原理分析）

    FPGA图像处理之Shift-RAM Core 生成卷积模板（官方手册原理分析）

    一、引言         当我们进行图像处理算法时，进行均值滤波、中值滤波等相关的计算操作时， 其中的核心部分应该就是矩阵运算了， 需要生成图像像素矩阵，在 C 语言中，我们可以直接用数组表示，但是在使用 FPGA 进行图像处理时， verilog 却无法实现这样的操作。 那

    2023年04月10日
    浏览(34)
  • Opencv+Python图像像素处理

    Opencv+Python图像像素处理

    目录 二值图像的像素访问、修改 单个像素访问、修改  多个像素修改 彩色图像（三维数组） 像素访问、修改 BGR模式 像素访问、修改 单个像素访问、修改 打印结果：   多个像素修改 运行结果：  BGR模式 像素访问、修改 运行效果：    对于三维数组（BGR模式） img[0,3

    2024年02月12日
    浏览(50)

  • C#图像处理-使用OpenCVSharp读取或修改图像像素值

    图像处理是计算机视觉领域的重要应用之一，而OpenCV是一个强大且广泛使用的开源计算机视觉库。在C#中，我们可以通过OpenCVSharp库来实现图像处理的各种功能，包括读取和修改图像像素值。本文将介绍如何使用OpenCVSharp来读取和修改图像像素值，并提供相应的源代码。 首先，

    2024年04月28日
    浏览(82)
  • C++结合OpenCV：图像的像素处理基础

    C++结合OpenCV：图像的像素处理基础

    像素是图像构成的基本单位，像素处理是图像处理的基本操作，可以通过位置索引的形式对图像内的元素进行访问、处理。 二值图像: 是一种特殊的灰度图像，在OPENCV中，将黑定义为0，255定义为白。 在OPENCV中，二值图像/灰度图像以二维数组形式进行存放彩色图像以三维数组

    2024年01月16日
    浏览(41)
  • 图像处理-像素位置的一阶导数和二阶导数

    图像处理-像素位置的一阶导数和二阶导数

    空间卷积是一种图像处理中常用的技术，用于计算图像中每个像素位置的一阶导数和二阶导数。在这里将解释如何使用卷积操作来实现这些导数的计算。 一阶导数和二阶导数的性质： 一阶导数通常产生粗边缘； 二阶导数对精细细节（如细线、孤立点和噪声）有更强的响应；

    2024年01月18日
    浏览(34)
  • OpenCV单通道图像按像素成倍比例放大（无高斯平滑处理）

    OpenCV单通道图像按像素成倍比例放大（无高斯平滑处理）

    OpenCV中的resize函数可以对图像做任意比例的放大(/缩小)处理，该处理过程会对图像做高斯模糊化以保证图像在进行放大（/缩小）后尽可能保留源图像所展现的具体内容（消除固定频率插值/采样带来的香农采样信息损失），但在有些场景中该方法不适用，如：部分应用场景只

    2024年04月11日
    浏览(54)
  • 图像处理复习———像素间的基本关系（邻域，邻接性，通路，连通性，距离）

    图像处理复习———像素间的基本关系（邻域，邻接性，通路，连通性，距离）

    目录 邻域 相邻像素——4邻域 相邻像素——D邻域 相邻像素——8邻域 邻接性 像素间的邻接性——4邻接 像素间的邻接性——8邻接 像素间的邻接性——m邻接 判断题助理解 通路 通路判断题——加深理解 连通性 连通分量 D邻域（ diagonal ）定义：像素p(x,y)的D邻域是： 对角上的

    2024年01月22日
    浏览(40)
  • 【计算机视觉—python 】 图像处理入门教程 —— 图像属性、像素编辑、创建与复制、裁剪与拼接【 openCV 学习笔记 005 to 010 and 255】

    【计算机视觉—python 】 图像处理入门教程 —— 图像属性、像素编辑、创建与复制、裁剪与拼接【 openCV 学习笔记 005 to 010 and 255】

    OpenCV中读取图像文件后的数据结构符合Numpy的ndarray多维数组结构，因此 ndarray 数组的属性和操作方法可用于图像处理的一些操作。数据结构如下图所示： img.ndim：查看代表图像的维度。彩色图像的维数为3，灰度图像的维度为2。 img.shape：查看图像的形状，代表矩阵的行数（高

    2024年01月19日
    浏览(70)
  • FPGA-图像处理-仿真

    FPGA-图像处理-仿真

    任务 读入一张bmp图片，对图片进行灰度处理，二值化以及边缘检测（sobel算子)，将处理后的数据写入bmp显示，全部过程以仿真形式。我这用的vivado。 在图像处理领域，要实现Sobel或者均值滤波等算法，则需要按照3*3矩阵的格式提取数据， 需要用到移位寄存器SHIFT RAM IP核。

    2024年02月02日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包