FPGA图像处理基础----实现缓存卷积窗口

最新推荐文章于 2023-03-06 11:28:56 发布
最新推荐文章于 2023-03-06 11:28:56 发布
阅读量5.5k 收藏 130
点赞数 17
分类专栏： FPGA图像处理 文章标签： FPGA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41332806/article/details/107385545
版权

像素行与像素窗口

  一幅图像是由一个个像素点构成的，对于一幅480*272大小的图片来说，其宽度是480，高度是272。在使用FPGA进行图像处理时，最关键的就是使用FPGA内部的存储资源对像素行进行缓存与变换。由于在图像处理过程中，经常会使用到卷积，因此需要对图像进行开窗，然后将开窗得到的局部图像与卷积核进行卷积，从而完成处理。
  图像数据一般按照一定的格式和时序进行传输，在我进行实验的时候，处理图像时，让其以VGA的时序来进行工作，这样能够为我处理行缓存提供便利。

基于FIFO的行缓存结构

在这里插入图片描述
  在FPGA中对图像的一行数据进行缓存时，可以采用FIFO这一结构，如上图所示，新一行图像数据流入到FIFO1中，FIFO1中会对图像数据进行缓存，当FIFO1中缓存有一行图像数据时，在下一行图像数据来临的时候，将FIFO1中缓存的图像数据读出，并传递给下一个FIFO，于此同时，将新一行的图像数据缓存到FIFO1中，这样就能完成多行图像的缓存。
  若要缓存多行图像，下面的菊花链式的结果更能够直观地表现图像数据地流向。
在这里插入图片描述
  新输入地图像缓存到FIFO1当中，当FIFO中缓存有一行数据的时候，下一个输入像素来临的时候，会将数据从本FIFO中读出，并给到下一个FIFO，来形成类似于一个流水线的结构。
  上面的图中，就是实现一个5X5大小的窗口的一个结构图。

代码设计

  实现一个可以生成任意尺寸大小的开窗的模块，需要注意参数的使用，可以通过调节KSZ来调整窗口的大小。最终将窗口中的图像像素，转换成一个一维的数据输出给到下一个模块。
  在设计的时候，对于FIFO要选择精准计数模式，这样才能让流水正常工作起来。
  在代码中通过generate语句来实现多个line_buffer的例化，line buffer的个数可以根据卷积窗口的大小来选择，例如3X3大小的卷积窗口需要缓存两行，5X5大小的卷积窗口需要缓存4行，可以通过设置参数来选择要例化多少个line_buffer。
在这里插入图片描述

时序设计

在这里插入图片描述
  在设计FIFO的菊花链结构时，需要根据当前FIFO中存储的数据个数来判断，这时候使用到精准计数模式，可以反应FIFO中的存储的数据。当FIFO中存储有一行数据的时候，使能pop_en信号，表示当前可以将数据从FIFO中读出。
  在将数据写入到FIFO中的时候，需要对数据进行扩充，也即需要对输入的图像的边界补充数据，因为进行卷积之后的图像将会比原始图像数据尺寸减少，因此在形成卷积窗口时，将图像扩充，能够让图像处理完成之后，保持原来的尺寸，只是会在边界出现黑边。
  win_buf这个模块的最终输出，就是一个矩阵内的所有像素，组成一个信号输出到外部，供进行卷积的处理。

/*============================================
#
# Author: Wcc - 1530604142@qq.com
#
# QQ : 1530604142
#
# Last modified: 2020-07-08 20:02
#
# Filename: win_buffer.v
#
# Description: 
#
============================================*/
`timescale 1ns / 1ps
module win_buf #(
	//==========================================
	//parameter define
	//==========================================
	parameter	KSZ 		= 3			,//卷积核大小
	parameter	IMG_WIDTH 	= 128		,//图像宽度,每个Line_buffer需要缓存的数据量
	parameter	IMG_HEIGHT	= 128		 //图像高度
	)(
	input 	wire 				clk 		,
	input	wire				rst 		,
	input	wire				pi_hs		,
	input	wire				pi_vs		,
	input	wire				pi_de		,
	input	wire				pi_dv		,
	input	wire	[7: 0]		pi_data		,
	//输出图像新有效信号
	output 	wire				po_dv		,
	input	wire				po_hs		,
	input	wire				po_vs		,
	input	wire				po_de		,
	//输出3X3图像矩阵
	output	wire	[8*KSZ*KSZ - 1: 0]		image_matrix			
    );
//==========================================
//internal signals
//==========================================
reg 							frame_flag		;//当前处于一帧图像所在位置

//==========================================
//linebuffer 缓存数据
//==========================================
//KSZ * KSZ 大小的卷积窗口,需要缓存(KSZ - 1行)
wire 	[7:0]	wr_buf_data	[KSZ-2: 0]	;//写入每个buffer的数据
wire 			wr_buf_en  	[KSZ-2: 0]	;//写每个buffer的使能
wire 			full 		[KSZ-2: 0]	;//每个buffer的空满信号
wire 			empty 		[KSZ-2: 0]	;	
wire 	[11:0]	rd_data_cnt [KSZ-2: 0]	;//每个bufeer的内存数据个数
wire			rd_buf_en	[KSZ-2: 0]	;//读出每个buffer的使能信号
wire 	[7:0]	rd_buf_data	[KSZ-2: 0]	;//读出每个buffer的数据
reg 			pop_en 		[KSZ-2: 0]	;//每个buffer可以读出数据信号

reg 			pi_dv_dd [KSZ-2 : 0]	;//输入有效数据延时
wire			line_vld				;//行图像数据有效信号
wire 	[7:0]	in_line_data			;
reg 	[7:0]	pi_data_dd [KSZ-2 : 0]	;
reg 	[1:0]	pi_vs_dd				;
			
reg 	[KSZ-2 : 0]		po_dv_dd				;
reg 	[KSZ-2 : 0]		po_de_dd				;
reg 	[KSZ-2 : 0]		po_hs_dd				;
reg 	[KSZ-2 : 0]		po_vs_dd				;

reg 	[0 : 0]			po_dv_r				;
reg 	[0 : 0]			po_de_r				;
reg 	[0 : 0]			po_hs_r				;
reg 	[0 : 0]			po_vs_r				;

reg 	[12:0]	cnt_col 	;//行列计数器
wire			add_cnt_col	;
wire			end_cnt_col	;
reg 	[12:0]	cnt_row 	;
wire			add_cnt_row	;
wire			end_cnt_row ;

localparam	MATRIX_SIZE = KSZ * KSZ;

//输出列数据延时，形成矩阵
reg		[7:0]	matrix_data	[MATRIX_SIZE - 1: 0];
reg 	[8*KSZ*KSZ - 1: 0]		image_matrix_r	;


assign  image_matrix = image_matrix_r;
assign 	po_dv = po_dv_r;
assign 	po_hs = po_hs_r;
assign 	po_vs = po_vs_r;
assign 	po_de = po_de_r;


//----------------pi_vs_dd------------------
always @(posedge clk) begin
	if (rst==1'b1) begin
		pi_vs_dd <= 'd0;
	end
	else begin
		pi_vs_dd <= {pi_vs_dd[0], pi_vs};
	end
end

//----------------frame_flag------------------
always @(posedge clk) begin
	if (rst==1'b1) begin
		frame_flag <= 1'b0;
	end
	//检测到上升沿，结束上一帧
	else if (pi_vs_dd[0] == 1'b1 && pi_vs_dd[1] == 1'b0) begin
		frame_flag <= 1'b0;
	end
	//检测到下降沿，开始本帧
	else if(pi_vs_dd[0] == 1'b0 && pi_vs_dd[1] == 1'b1) begin
		frame_flag <= 1'b1;
	end
end

//==========================================
//pi_dv_dd
//进行边界的扩充，以3X3的窗口为例,需要在图像的
//外围各边添加一行一列的的空白像素
//若是5X5的窗口，需要在图像的外围各边，添加2行2列
//==========================================
generate
	genvar i;
	//对于KSZ*KSZ的卷积核，每一行需要延时(KSZ-1)拍
	for (i = 0; i < KSZ-1; i = i + 1)
	begin:Expand_the_boundary_dv
		if (i == 0) begin
			always @(posedge clk) begin
				if (rst==1'b1) begin
					pi_dv_dd[i] <= 1'b0;
					pi_data_dd[i] <= 'd0;
				end
				else begin
					pi_dv_dd[i] <= pi_dv;
					pi_data_dd[i] <= pi_data;				
				end
			end
		end
		else begin
			always @(posedge clk) begin
				if (rst==1'b1) begin
					pi_dv_dd[i] <= 1'b0;
					pi_data_dd[i] <= 'd0;
				end
				else begin
					pi_dv_dd[i] <= pi_dv_dd[i - 1];
					pi_data_dd[i] <= pi_data_dd[i - 1];
				end
			end
		end
	end
endgenerate

assign line_vld = pi_dv_dd[KSZ-2] | pi_dv;
assign in_line_data = pi_data_dd[(KSZ>>1) - 1];

//==========================================
//行列计数器
//==========================================
//----------------cnt_col------------------
always @(posedge clk) begin
	if (rst == 1'b1) begin
		cnt_col <= 'd0;
	end
	else if (add_cnt_col) begin
		if(end_cnt_col)
			cnt_col <= 'd0;
		else
			cnt_col <= cnt_col + 1'b1;
	end
	else begin
		cnt_col <= 'd0;
	end
end

assign add_cnt_col = frame_flag == 1'b1 && line_vld == 1'b1;
assign end_cnt_col = add_cnt_col &&	cnt_col == (IMG_WIDTH + KSZ-1) - 1;

//----------------cnt_row------------------
always @(posedge clk) begin
	if (rst == 1'b1) begin
		cnt_row <= 'd0;
	end
	else if (add_cnt_row) begin
		if(end_cnt_row)
			cnt_row <= 'd0;
		else
			cnt_row <= cnt_row + 1'b1;
	end
end

assign add_cnt_row = end_cnt_col == 1'b1 ;
assign end_cnt_row = add_cnt_row &&	cnt_row == IMG_HEIGHT - 1;

//==========================================
//输入到line_buffer,构成对齐的列
//通过例化FIFO的方式,来完成行缓存
//当FIFO缓存有一行数据时，将数据读出，并填充到下一个FIFO中
//==========================================
generate
	genvar j;
	for (j = 0; j < KSZ - 1; j = j + 1)
	begin:multi_line_buffer
		//第一个 line_buffer
		if (j == 0) begin : first_buffer
			//写入第一个line_buffer的数据是从外部输入的数据
			assign wr_buf_data[j] = in_line_data;
			assign wr_buf_en[j] = line_vld;
		end
		//其他line_buffer
		else begin : other_buffer
			//写入其他line_buffer的数据是上一个line_buffer中输出的数据
			assign wr_buf_en[j] = rd_buf_en[j - 1] ;
			assign wr_buf_data[j] = rd_buf_data[j - 1] ;
		end

		//----------------rd_buf_en------------------	
		//从buffer中读出数据
		//pop_en是当前FIFO中已经缓存了一行的图像数据的指示信号
		//wr_buf_en是当前新一行写入的有效数据指示信号
		assign rd_buf_en[j] = pop_en[j] & wr_buf_en[j];

		always @(posedge clk) begin
			if (rst==1'b1) begin
				pop_en[j] <= 0;
			end
			//当前不处于图像有效数据区域
			else if (frame_flag == 1'b0) begin
				pop_en[j] <= 1'b0;
			end
			//当buffer中缓存有一行图像数据时(扩充的图像行)
			else if (rd_data_cnt[j] >= IMG_WIDTH+2) begin
				pop_en[j] <= 1'b1;
			end
		end

		line_buf line_buffer (
		  	.wr_clk(clk),                // input wire wr_clk
		  	.rd_clk(clk),                // input wire rd_clk
		  	.din(wr_buf_data[j]),        // input wire [7 : 0] din
		  	.wr_en(wr_buf_en[j]),        // input wire wr_en
		  	.rd_en(rd_buf_en[j]),                  // input wire rd_en
		  	.dout(rd_buf_data[j]),                    // output wire [7 : 0] dout
		  	.full(full[j]),                    // output wire full
		  	.empty(empty[j]),                  // output wire empty
		  	.rd_data_count(rd_data_cnt[j])  // output wire [11 : 0] rd_data_count
		);	
	end
endgenerate

//==========================================
//得到矩阵中的每一行的第一个数据
//==========================================
generate
	genvar k;
	for (k = 0; k < KSZ; k = k + 1)
	begin:matrix_data_first_col
		if (k == KSZ -1) begin
			//最后一行数据为刚输入的数据
			always @(*) begin
				matrix_data[KSZ * k] = in_line_data;
			end
		end
		else begin
			//从buffer中读取出来的图像书籍
			//以3X3为例，buffer是菊花链的结果
			//最开始输入的数据，在最后一个buffer中被读出
			//最后输入的数据，在第一个buffer中被读出
			always @(*) begin
			 	matrix_data[KSZ * k] = rd_buf_data[(KSZ -2) - k];
			end	
		end
	end
endgenerate
//==========================================
//延时得到矩阵数据
//以3X3为例
//matrix[0]~[2] ==>p13,p12,p11
//matrix[3]~[5] ==>p23,p22,p21
//matrix[6]~[8] ==>p33,p32,p31
//KSZ-1 clk
//==========================================
generate
	genvar r,c;
	for (r = 0; r < KSZ; r = r + 1)
	begin:row
		for (c = 1; c < KSZ; c = c + 1)
		begin:col
			always @(posedge clk) begin
				if (rst==1'b1) begin
					matrix_data[r*KSZ + c] <= 'd0;
				end
				else begin
					matrix_data[r*KSZ + c] <= matrix_data[r*KSZ + (c-1)];
				end
			end
		end
	end
endgenerate

//==========================================
//输出图像矩阵
//以3X3为例
//image_matrix [7:0] ==> p13
//image_matrix [15:8] ==> p12
//image_matrix [23:16] ==> p11
//1 clk
//==========================================
generate
	genvar idx;
	for (idx = 0; idx < KSZ*KSZ; idx = idx + 1)
	begin:out_put_data
		always @(posedge clk) begin
			if (rst==1'b1) begin
				po_dv_r <= 1'b0;
				po_de_r <= 1'b0;
				po_hs_r <= 1'b0;
				po_vs_r <= 1'b0;
				image_matrix_r[8*(idx+1) -1 : 8*(idx)] <= 'd0;
			end
			else begin
				po_dv_r <= po_dv_dd[KSZ-2] & line_vld;
				po_de_r <= po_de_dd[KSZ-2] & line_vld;
				po_hs_r <= po_hs_dd[KSZ-2] ;
				po_vs_r <= po_vs_dd[KSZ-2] ;
				if (po_dv_dd[KSZ-2] & line_vld == 1'b1) begin
					image_matrix_r[8*(idx+1) -1 : 8*(idx)] <= matrix_data[idx];
				end
				else begin
					image_matrix_r[8*(idx+1) -1 : 8*(idx)] <= 'd0;
				end
			end
		end 
	end
endgenerate
//==========================================
//(KSZ-1) clk
//==========================================

always @(posedge clk) begin
	if (rst==1'b1) begin
		po_vs_dd <= 'd0;
		po_hs_dd <= 'd0;
		po_de_dd <= 'd0;
		po_dv_dd <= 'd0;
	end
	else begin
		po_vs_dd <= {po_vs_dd[KSZ-3:0], pi_vs};
		po_hs_dd <= {po_hs_dd[KSZ-3:0], pi_hs};
		po_de_dd <= {po_de_dd[KSZ-3:0], pi_de};
		po_dv_dd <= {po_dv_dd[KSZ-3:0], pi_dv};
	end
end
endmodule

仿真验证

3X3开窗

在这里插入图片描述
输入的第三行数据的前三个数据是：0x00，0x78，0x7c
输入的第二行数据的前三个数据是：0x00，0x7d，0x7d
输入的第一行数据的前三个数据是：0x00，0x7e，0x7f
输出的第一个矩阵的值是：0x0078_7c00_7d7d_007e_7f
输入行数据第一个数据是0x00这是因为扩充了边界的原因。
  可以看到，设置KSZ为3,可以得到一个位宽为72bit的输出数据，该数据包含了一个窗口中的9个数据。

5X5开窗

  设置开窗大小为5x5之后，也可以看到输出信号的位宽变为了8*25=200bit，也就是一个5X5大小的矩阵中的数据。
在这里插入图片描述
输入的第5行数据的前5个数据是：0x00，0x00，0x7e，0x7c，0x7f
输入的第4行数据的前5个数据是：0x00，0x00，0x7e，0x7e，0x7e，
输入的第3行数据的前5个数据是：0x00，0x00，0x78，0x7c，0x7c
输入的第2行数据的前5个数据是：0x00，0x00，0x7d，0x7d，0x7a
输入的第1行数据的前5个数据是：0x00，0x00，0x7e，0x7f，0x7d
从输出结果看，输出的矩阵数据，刚好是这5行的前5数据，并且前两个数据是0x00，这是因为在每一行前面补充了两个0的原因。
  经过测试，这种开窗算子是能够完成任意此村的开窗的。

实际应用

  在实际应用中，我也将这个模块正确地使用上了，完成了一个3x3的sobel算子和5x5的均值滤波。

原始图像

在这里插入图片描述

3x3 Sobel

在这里插入图片描述

参考：《基于FPGA的数字图像处理原理及应用》牟新刚

black_pigeon
关注
  • 17
    点赞
  • 踩
  • 130
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Python-在TensorFlow中实现实现图像卷积网络
08-11
在TensorFlow中实现实现图像卷积网络
卷积实现：使用FIFO/线性缓冲区、双缓冲区、循环缓冲区和双循环缓冲区的卷积-matlab开发
06-01
这段代码是关于使用线性缓冲区（FIFO）、双缓冲区、循环缓冲区和双循环缓冲区实现卷积
图像处理中图像窗口的缩放大小
qq_42612717的博客
05-25 887
如果直接使用imshow(“a”,img);a为图像标签名，img为目标图片。默认显示原图大小，不能进行图片缩放。 nameWindow（“test”，窗口类型），test为图像标签明，该方法可以新建一个显示窗口，通过指定窗口类型为： CV_WINDOW_AUTOSIZE：自动大小，默认图像大小，不能缩放。 CV_WINDOW_NORMAL：可以鼠标拖动缩放。 实例代码： import cv2 img = cv2.imread(“C:\lena.jpg”) def on_mouse(event,x,y,fl
FPGA学习-图像处理基础实现缓存卷积窗口
HackEle的博客
05-12 1089
像素行与像素窗口  一幅图像是由一个个像素点构成的，对于一幅480*272大小的图片来说，其宽度是480，高度是272。在使用FPGA进行图像处理时，最关键的就是使用FPGA内部的存储资源对像素行进行缓存与变换。由于在图像处理过程中，经常会使用到卷积，因此需要对图像进行开窗，然后将开窗得到的局部图像与卷积核进行卷积，从而完成处理。  图像数据一般按照一定的格式和时序进行传...
一种基于FPGA的卷积算法
qq_40268672的博客
02-18 2983
使用FIFO实现二维卷积 如上图，共有三组寄存器，每组寄存器可存储三个数据，第一个时钟周期，Buffer1读入第一行的前三个数据，Buffer2读入第二行的前三个数据，Buffer3读入第三行的前三个数据，之后，各个寄存器组左移K-1次，这里K=3，之后，寄存器组1从寄存器组2的FIFO中读取一行数据(0,11,12)，寄存器组2从寄存器组3的FIFO中读取一行数据(0,21,22),而最右边的...
FPGA图像算法实现——卷积、窗口运算之滑动窗口模块设计
MmikerR的专栏
08-11 5790
在图像处理中，卷积、窗口运算是非常基础且常用的操作。这些基于图像滑动窗口的运算非常适合在FPGA中进行流水线实时高效处理，也是FPGA图像算法实现的一个热点。其中，最基础的工作就是在FPGA中设计一个滑动窗口模块。 设计一个完备的滑动窗口模块首先要解决以下3个问题：图像行缓存机制；行、场等同步信号的延迟；图像边界的扩展。
图像处理：生成3×3的窗口
m0_46830519的博客
07-22 699
生成3×3的窗口
FPGA与数字图像处理技术
weixin_30836759的博客
09-14 562
数字图像处理方法的重要性源于两个主要应用领域： 改善图像信息以便解释。 为存储、传输和表示而对图像数据进行处理，以便于机器自动理解。 图像处理(image processing)： 用计算机对图像进行分析，以达到所需结果的技术。又称影像处理。一般指数字图像处理。数字图像是指用工业相机、摄像机、扫描仪等设备经过拍摄得到的一个大的二维...
XILINX FPGA数字信号处理——14、数字图像处理原理及实现
weixin_45878159的博客
06-15 284
均值滤波：在像素领域内求局部均值。 中值滤波：把领域按照灰度级排列，选择该组中间值作为输出像素值。与均值滤波及其他线性滤波器相比，能去除噪声的同时，不会模糊图像边缘，较好保持图像的清晰度。 ...
LeNet-5，卷积神经网络模型
06-05
LeNet-5手写字识别实验：LeNet-5是一个经典的卷积神经网络模型，由Yann LeCun等人于1998年提出。它是首个广泛应用于手写数字识别任务的卷积神经网络模型，并在该任务上取得了很好的性能。LeNet-5模型使用了sigmoid作为激活函数，并通过反向传播算法进行训练，使用随机梯度下降（SGD）进行参数优化。在训练过程中，LeNet-5使用了交叉熵损失函数作为目标函数。
人工智能-基于卷积神经网络的图像分类算法研究.pdf
06-28
人工智能-基于卷积神经网络的图像分类算法研究.pdf
实验五-使用matlab实现卷积的运算.pdf
11-24
实验五-使用matlab实现卷积的运算.pdf
RNN-LSTM卷积神经网络Matlab实现.zip
09-07
RNN卷积神经网络，LSTM，使用matlab实现，简单的数据拟合
CIFAR-10数据集-卷积神经网络的Tensorflow实现
01-30
文件夹包括data子文件夹（里面是用于训练卷积神经网络的CIFAR-10数据集）、CIFAR-10.ipynb（里面是卷积神经网络的实现代码，在jupyter里运行它便可以训练自己的卷积神经网络）。文件夹中其他文件是写代码时我做测试用，不影响对最后的结果，可以不看。代码准确无误，下载后直接运行，不需要改动。
基于卷积神经网络的Fashion-MNIST图像识别
02-27
基于卷积神经网络的Fashion-MNIST图像识别，Fashion-MNIST是一个用来进行机器学习和深度学习的测试数据集，它由类似于MNIST的手写数字图像数据集演变而来，但是每一张图像都代表了10类服装类型之一，包括T恤、裤子、...
pytorch-deform-conv：变形卷积的PyTorch实现
02-05
可变形卷积的PyTorch实现 魏欧阳@巴斯德研究所 感谢Felix Lau的Keras / TensorFlow实现： （ ） 待办事项清单 在pytorch中实现偏移量映射 所有测试通过 变形卷积模块 微调可变形卷积模块 大规模mnist演示 使用...
FPGA大赛【四】具体模块设计--图像缓存
weixin_42905573的博客
05-06 3428
FPGA大赛【四】具体模块设计--图像缓存 【注】该项目是我们团队参加2019届全国大学生FPGA大赛的作品，系统主要实现视频任意角度旋转。该项目最终晋级决赛，并获得紫光同创企业特别奖。该系列文章介绍我们团队的作品。关注公众号“数字积木”对话框回复 FPGA2019 ，即可获得该项目的工程源代码，详细的文档说明，MATLAB仿真代码。 图像缓存设计 本文讲述下利用ddr缓存从摄像头...
行缓冲、全缓冲、无缓冲以及用户缓冲区、内核缓冲区介绍
m0_51429770的博客
03-06 2586
可以理解为：内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区。后面讲到的内核缓冲区以及用户缓冲区能够更好理解缓冲区的作用。缓冲区其实可以算是保护我们的硬件的，所有的磁盘都是有寿命限制的（读写的次数不是无限的），到了一定的程度就坏了。所以就将我们要读写的内容都放在缓冲区中，统一进行读写，减少次数。缓冲区就是一块内存区，它用在输入输出设备和CPU之间，用来缓存数据。
以窗口形式进行数字图像处理时，在图像边界处对超出图像边界的窗口内容的映射（对称）处理
m0_50714865的博客
04-09 2505
在数字图像处理时，我们经常会以窗口的形式进行相关的运算，如滤波处理，而在图像边界处，窗口可能太大以至于超出边界，这时候我们可以做一个映射（对称）处理，来补齐窗口中超出图像边界的部分。如下图，窗口大小是3*3大小，中间黄色像素为窗口中心像素，其位于图像左上角，对于窗口内超出图像边界的部分，分别将其赋值为以中心像素为对称中心的，与其对称的图像内像素的值。 现以InSAR中计算干涉图的相位标准差（PSD）的matlab代码来说明这个映射处理怎么用代码实现。（代码是我自己编写的，不一定效率最优）。 functio
FPGA 图像处理卷积
最新发布
11-18
FPGA图像处理中的卷积操作是一种常见的操作，可以通过数据通路状态机的设计以及对应数据的运算来实现。下面是一个简单的FPGA图像处理卷积的例子： ```verilog module conv(input clk, input rst, input signed [7:0] indata, output signed [7:0] outdata); reg signed [7:0] data[0:2][0:2]; reg signed [7:0] kernel[0:2][0:2] = {{1, 2, 1}, {2, 4, 2}, {1, 2, 1}}; reg signed [15:0] sum; integer i, j; always @(posedge clk) begin if (rst) begin for (i = 0; i < 3; i = i + 1) begin for (j = 0; j < 3; j = j + 1) begin data[i][j] <= 0; end end end else begin data[0][0] <= data[0][1]; data[0][1] <= data[0][2]; data[0][2] <= data[1][0]; data[1][0] <= data[1][1]; data[1][1] <= data[1][2]; data[1][2] <= data[2][0]; data[2][0] <= data[2][1]; data[2][1] <= data[2][2]; data[2][2] <= indata; sum <= 0; for (i = 0; i < 3; i = i + 1) begin for (j = 0; j < 3; j = j + 1) begin sum <= sum + data[i][j] * kernel[i][j]; end end outdata <= sum[15:8]; end end endmodule ``` 上述代码实现了一个3x3的卷积操作，使用了一个3x3的卷积核，对输入的像素进行卷积运算，输出卷积后的像素值。在实际的FPGA图像处理中，卷积操作可以通过数据通路状态机的设计以及对应数据的运算来实现，具体实现方式可以根据具体的需求进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值