导向滤波的Verilog （GuidedFilter.v）

原创 已于 2025-08-08 16:49:13 修改 · 175 阅读 · 0 ·
CC 4.0 BY-SA版权
By - A29850706
文章标签：

#fpga开发

于 2025-08-01 14:23:56 首次发布
红外热成像技术交流QQ群 ： 1051855150

/**********************************************************************************************************************
 *FileName          : GuidedFilter.sv  
 *Version           : D20230616R1321V01 
 *Description       : GuidedFilter
 *History           :
 *      Date          Author    Modification
 *  1.  2023.06.16    Y.L       
 **********************************************************************************************************************/
 
`timescale 1ns/1ps

module GuidedFilter #( 
	parameter IMAGE_WIDTH   = 640   ,
	parameter IMAGE_HEIGHT  = 512   ,
    parameter DATA_WIDTH    = 14    ,
    parameter NUMTAPS       = 5
)(
	input   wire                                			clock				, 
	input   wire                                			rstn            	, 
										
	input	wire											GuidedFilterEn		,
	input	wire    [15:0]            						GuidedEps			,
									
    input   wire                                			video_ifval	    	,
    input   wire                                			vedeo_ilval	    	,
    input   wire    [DATA_WIDTH-1:0]            			video_idata	    	,
									
    output  reg                                 			video_ofval	    	,
    output  reg                                 			vedeo_olval	    	,
    output  reg     [DATA_WIDTH-1:0]            			video_odata			,
    output  reg     [DATA_WIDTH-1:0]            			Shifter_DataO		
); 
reg   	[15:0]												GuidedEps_r; 
	
wire                                     					guide_ofval, guide_olval, guide_odval;
wire    [DATA_WIDTH*NUMTAPS*NUMTAPS-1:0]					guide_odat2;   
wire    [DATA_WIDTH-1:0]                 					guide_odat2_w  [NUMTAPS*NUMTAPS-1:0];
	
reg		[39:0]												guide_ofval_r, guide_olval_r, guide_odval_r;
reg		[DATA_WIDTH-1:0] 									guide_odat1_r [39:0];
	
reg		[DATA_WIDTH+$clog2(NUMTAPS)-1:0]					guide_meanI_w1sum1, guide_meanI_w1sum2, guide_meanI_w1sum3, guide_meanI_w1sum4, guide_meanI_w1sum5/*synthesis preserve*/;
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS)-1:0]			guide_meanI_w2sum1, guide_meanI_w2sum2; 
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS)-1:0]			sum_I; 
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS)-1:0]			sum_I_d  [35:0];
	
wire	[39:0]												dsp48_out1	[(NUMTAPS*NUMTAPS)-1:0];
reg		[DATA_WIDTH*2+$clog2(NUMTAPS)-1:0]					guide_meanIP_w1sum1, guide_meanIP_w1sum2, guide_meanIP_w1sum3, guide_meanIP_w1sum4, guide_meanIP_w1sum5/*synthesis preserve*/;
reg		[DATA_WIDTH*2+$clog2(NUMTAPS*NUMTAPS)-1:0]			sum_Ip;
	
wire	[(DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS))*2-1:0]		sum_I_w;
reg		[(DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS))*2-1:0]		sum_I_r;
reg		[DATA_WIDTH*2+$clog2(NUMTAPS*NUMTAPS)+6:0]			sum_Ip_r;
	
reg   	[(DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS))*2-1:0]		cov_Ip;
	
reg 	[55:0]												numer;
reg		[39:0]												denom;
wire	[55:0]												quotient;
reg		[DATA_WIDTH-1:0]									ax, ax1, ax_; 
reg		[47:0]												dsp48_out3;
wire	[47:0]												dsp48_out3_w;
reg		[DATA_WIDTH-1:0]									a, b; 
wire	[DATA_WIDTH-1:0]									a_w, b_w; 

wire														mean_a_ofval, mean_a_olval, mean_a_odval; 
wire    [DATA_WIDTH*NUMTAPS*NUMTAPS-1:0]					mean_a_odat2;
wire    [DATA_WIDTH-1:0]                 					mean_a_odat2_w  [NUMTAPS*NUMTAPS-1:0];
		
wire    [DATA_WIDTH*NUMTAPS*NUMTAPS-1:0]					mean_b_odat2;
wire    [DATA_WIDTH-1:0]                 					mean_b_odat2_w  [NUMTAPS*NUMTAPS-1:0];
		
reg		[7:0]												mean_a_ofval_r, mean_a_olval_r, mean_a_odval_r;
		
reg		[DATA_WIDTH+$clog2(NUMTAPS):0]						mean_a_w1sum1, mean_a_w1sum2, mean_a_w1sum3, mean_a_w1sum4, mean_a_w1sum5; 
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS):0]				mean_a_w2sum1, mean_a_w2sum2;
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS):0]				mean_a_w3sum1; 
		
reg		[DATA_WIDTH+$clog2(NUMTAPS)-1:0]					mean_b_w1sum1, mean_b_w1sum2, mean_b_w1sum3, mean_b_w1sum4, mean_b_w1sum5; 
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS)-1:0]			mean_b_w2sum1, mean_b_w2sum2;
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS)-1:0]			mean_b_w3sum1;
reg		[DATA_WIDTH+$clog2(NUMTAPS*NUMTAPS)+7:0]			mean_b_w3sum1_r; 
		
wire  	[DATA_WIDTH-1:0]  									taps;
reg		[DATA_WIDTH-1:0]  									taps_r1 	[9:0]	; 
reg		[47:0]												result1, result2	;	
wire	[47:0]												result1_w, result2_w;

reg     [3:0]												video_ifval_r;
reg															video_ifval_pos;

reg		[3:0]												video_ifval_r1;
reg		[3:0]												vedeo_ilval_r1;
reg    	[DATA_WIDTH-1:0]            						video_idata_r1 	[3:0];
 
always @(posedge clock) begin
	video_ifval_r1 <= {video_ifval_r1[2:0], video_ifval};
    vedeo_ilval_r1 <= {vedeo_ilval_r1[2:0], vedeo_ilval};
end 

generate
genvar SRCDLY;
for(SRCDLY=0; SRCDLY<4; SRCDLY=SRCDLY+1) begin
	if (SRCDLY == 0) begin
		always @(posedge clock) begin 
			video_idata_r1[0] <= video_idata;
		end 
	end else begin 
		always @(posedge clock) begin
			video_idata_r1[SRCDLY] <= video_idata_r1[SRCDLY-1];
		end 
	end 
end
endgenerate

always @(posedge clock) begin
	video_ifval_r   <= {video_ifval_r[2:0], video_ifval};
	video_ifval_pos <= (/*video_ifval_r == 4'h3 || */ !rstn) ? 1'b1 : 1'b0;
end

always @(posedge clock) begin
	GuidedEps_r <= GuidedEps;
end 

Matrix5x5 #(
	.IMAGE_WIDTH   ( IMAGE_WIDTH 	),
	.IMAGE_HEIGHT  ( IMAGE_HEIGHT 	),
	.DATA_WIDTH    ( DATA_WIDTH    	),
	.NUMTAPS       ( NUMTAPS  		)
)u_Matrix5x5(
/*input   wire                                      */.clock           	( clock				), 
/*input   wire                                      */.rstn            	( !video_ifval_pos	), 
/*													*/
/*input   wire                                      */.video_ifval	    ( video_ifval_r1[3]	),
/*input   wire                                      */.vedeo_ilval	    ( vedeo_ilval_r1[3]	),
/*input   wire    [DATA_WIDTH-1:0]                  */.video_idata	    ( video_idata_r1[3]	),
/*													*/	
/*output  wire                                      */.video_ofval	    ( guide_ofval		),
/*output  wire                                      */.vedeo_olval	    ( guide_olval		), 
/*output  wire                                      */.vedeo_odval	    ( guide_odval		), 
/*output  wire    [DATA_WIDTH-1:0]                  */.video_odat1     	( 					),
/*output  wire    [DATA_WIDTH*NUMTAPS*NUMTAPS-1:0]  */.video_odat2      ( guide_odat2		)
);

generate
genvar m;
    for(m=0; m<=(NUMTAPS*NUMTAPS-1); m=m+1) begin
		assign guide_odat2_w[m] = guide_odat2[m*DATA_WIDTH+:DATA_WIDTH];
    end
endgenerate

always @(posedge clock) begin 
	guide_ofval_r <= {guide_ofval_r[38:0], guide_ofval};
	guide_olval_r <= {guide_olval_r[38:0], guide_olval};
	guide_odval_r <= {guide_odval_r[38:0], guide_odval};
end

generate
genvar dly;
for(dly=0; dly<40; dly=dly+1) begin
	if (dly == 0) begin
		always @(posedge clock) begin 
			guide_odat1_r[0] <= guide_odat2_w[(NUMTAPS*NUMTAPS-1)/2];
		end 
	end else begin 
		always @(posedge clock) begin
			guide_odat1_r[dly] <= guide_odat1_r[dly-1];
		end 
	end 
end
endgenerate

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* mean_p、mean_I & mean_Ip */ 
// DLY0
always @(posedge clock) begin 
	guide_meanI_w1sum1 <= guide_odat2_w[23] + guide_odat2_w[22] + guide_odat2_w[21] + guide_odat2_w[20];
	guide_meanI_w1sum2 <= guide_odat2_w[19] + guide_odat2_w[18] + guide_odat2_w[17] + guide_odat2_w[16] + guide_odat2_w[15];
	guide_meanI_w1sum3 <= guide_odat2_w[14] + guide_odat2_w[13] + guide_odat2_w[12] + guide_odat2_w[11] + guide_odat2_w[10];
	guide_meanI_w1sum4 <= guide_odat2_w[9]  + guide_odat2_w[8]  + guide_odat2_w[7]  + guide_odat2_w[6]  + guide_odat2_w[5];
	guide_meanI_w1sum5 <= guide_odat2_w[4]  + guide_odat2_w[3]  + guide_odat2_w[2]  + guide_odat2_w[1]  + guide_odat2_w[0];
end

generate
genvar num;
for(num=0; num<NUMTAPS*NUMTAPS; num=num+1) begin
	 multidsp48 u_mean_Ip(.sysclk(clock),.dsp48_inA1({5'b0, guide_odat2_w[num]}),.dsp48_inB1({4'b0, guide_odat2_w[num]}),.dsp48_out1(dsp48_out1[num]));
end
endgenerate 

// DLY1
always @(posedge clock) begin 
	guide_meanI_w2sum1 <= guide_meanI_w1sum1 + guide_meanI_w1sum2;
	guide_meanI_w2sum2 <= guide_meanI_w1sum3 + guide_meanI_w1sum4 + guide_meanI_w1sum5;
end

always @(posedge clock) begin 
	guide_meanIP_w1sum1 <= dsp48_out1[20] + dsp48_out1[21] + dsp48_out1[22] + dsp48_out1[23];	
	guide_meanIP_w1sum2 <= dsp48_out1[15] + dsp48_out1[16] + dsp48_out1[17] + dsp48_out1[18] + dsp48_out1[19];
	guide_meanIP_w1sum3 <= dsp48_out1[10] + dsp48_out1[11] + dsp48_out1[12] + dsp48_out1[13] + dsp48_out1[14];
	guide_meanIP_w1sum4 <= dsp48_out1[ 5] + dsp48_out1[ 6] + dsp48_out1[ 7] + dsp48_out1[ 8] + dsp48_out1[ 9];
	guide_meanIP_w1sum5 <= dsp48_out1[ 0] + dsp48_out1[ 1] + dsp48_out1[ 2] + dsp48_out1[ 3] + dsp48_out1[ 4];			
end

// DLY2
always @(posedge clock) begin
	sum_I <= guide_meanI_w2sum1 + guide_meanI_w2sum2;
end

generate
genvar MDLY;
for(MDLY=0; MDLY<36; MDLY=MDLY+1) begin
	if (MDLY == 0) begin
		always @(posedge clock) begin
			sum_I_d[0] <= sum_I;
		end
	end else begin
		always @(posedge clock) begin
			sum_I_d[MDLY] <= sum_I_d[MDLY-1];
		end
	end
end
endgenerate

always @(posedge clock) begin
	sum_Ip <= guide_meanIP_w1sum1 + guide_meanIP_w1sum2 + guide_meanIP_w1sum3 + guide_meanIP_w1sum4 + guide_meanIP_w1sum5;
end

// DLY3
assign sum_I_w = sum_I * sum_I;

always @(posedge clock) begin
	sum_I_r <= sum_I_w;
end

always @(posedge clock) begin
	sum_Ip_r <= {sum_Ip, 4'b0} + {sum_Ip, 3'b0}; 
end

// DLY4
always @(posedge clock) begin
	cov_Ip <= ( sum_Ip_r > sum_I_r) ? ( sum_Ip_r - sum_I_r) : 0; 
end

assign numer = cov_Ip * 16383;
assign denom = cov_Ip + GuidedEps_r*576;   //

div_covIp u_div_covIp //DLY32 
(    
    .reset  	( 1'b0  	), //( cov_Ip * 16384) / (cov_Ip + GuidedEps_r*25)    
	.clk 		( clock 	),
    .clken  	( 1'b1  	),
    .numer  	( numer 	),//56
    .denom  	( denom 	),//40
    .quotient 	( quotient 	),
    .remain 	(   		)
);

//DLY29 
always @(posedge clock) begin
	ax  <= (quotient >= 16383) ? 16383 : quotient[13:0];
	ax_ <= (quotient >= 16383) ? 0     : (16383 - quotient[13:0]);
end

//DLY30
always @(posedge clock) begin
	ax1 <= ax;
end 

always @(posedge clock) begin
	dsp48_out3 <= sum_I_d[34] * ax_;
end

assign dsp48_out3_w = (dsp48_out3[47:3] + dsp48_out3[2]) / 3;

//DLY31
always @(posedge clock) begin
	a <= ax1;
	b <= (dsp48_out3_w[47:14] > 16383) ? 16383 : (dsp48_out3_w[47:14] + dsp48_out3_w[13]);
end

assign a_w = (guide_odval_r[39]) ? a : 0;
assign b_w = (guide_odval_r[39]) ? b : guide_odat1_r[39];

/*********************************************************************************************************************************/
//
/*********************************************************************************************************************************/

// `define _TEST
 
myshift_taps #(
    .number_of_taps ( 1     			),
    .tap_distance   ( IMAGE_WIDTH*2   	),
    .width          ( DATA_WIDTH    	)
)u_myshift_taps(                    	
    .aclr           ( video_ifval_pos	),
    .clock          ( clock         	),
`ifdef _TEST
    .clken          ( vedeo_ilval	  	),
    .shiftin        ( video_idata	  	),
`else
    .clken         	( guide_olval_r[39]	),
    .shiftin       	( guide_odat1_r[39]	),
`endif
    .shiftout       (               	),
    .taps           ( taps          	) //0:new  IMAGE_WIDTH:old
);

generate
genvar n;
for(n=0; n<=9; n=n+1) begin : DLY1
	if (n == 0) begin
		always @(posedge clock) begin 
			taps_r1[0] <= taps;
		end 
	end else begin 
		always @(posedge clock) begin 
			taps_r1[n] <= taps_r1[n-1];
		end 
	end 
end
endgenerate
 
Matrix5x5 #(
	.IMAGE_WIDTH   ( IMAGE_WIDTH 	),
	.IMAGE_HEIGHT  ( IMAGE_HEIGHT 	),
	.DATA_WIDTH    ( DATA_WIDTH    	),
	.NUMTAPS       ( NUMTAPS  		)
)u_mean_a(
/*input   wire                                      */.clock           	( clock				), 
/*input   wire                                      */.rstn            	( !video_ifval_pos	), 
`ifdef _TEST
/*input   wire                                      */.video_ifval	    ( video_ifval	  	),
/*input   wire                                      */.vedeo_ilval	    ( vedeo_ilval	  	),
/*input   wire    [DATA_WIDTH-1:0]                  */.video_idata	    ( video_idata	  	),
`else
/*input   wire                                      */.video_ifval	    ( guide_ofval_r[39]	),
/*input   wire                                      */.vedeo_ilval	    ( guide_olval_r[39]	),
/*input   wire    [DATA_WIDTH-1:0]                  */.video_idata	    ( a_w 				),
`endif
/*output  wire                                      */.video_ofval	    ( mean_a_ofval		), // 与 taps_r1[3]
/*output  wire                                      */.vedeo_olval	    ( mean_a_olval		), 
/*output  wire                                      */.vedeo_odval	    ( mean_a_odval		), 
/*output  wire    [DATA_WIDTH-1:0]                  */.video_odat1     	(  					),
/*output  wire    [DATA_WIDTH*NUMTAPS*NUMTAPS-1:0]  */.video_odat2      ( mean_a_odat2		)
);

Matrix5x5 #(
	.IMAGE_WIDTH   ( IMAGE_WIDTH 	),
	.IMAGE_HEIGHT  ( IMAGE_HEIGHT 	),
	.DATA_WIDTH    ( DATA_WIDTH    	),
	.NUMTAPS       ( NUMTAPS  		)
)u_mean_b(
/*input   wire                                      */.clock           	( clock				), 
/*input   wire                                      */.rstn            	( !video_ifval_pos	), 
`ifdef _TEST	
/*input   wire                                      */.video_ifval	    ( video_ifval	  	),
/*input   wire                                      */.vedeo_ilval	    ( vedeo_ilval	  	),
/*input   wire    [DATA_WIDTH-1:0]                  */.video_idata	    ( video_idata	  	),
`else
/*input   wire                                      */.video_ifval	   	( guide_ofval_r[39]	),
/*input   wire                                      */.vedeo_ilval	   	( guide_olval_r[39]	),
/*input   wire    [DATA_WIDTH-1:0]                  */.video_idata	   	( b_w 				),
`endif
/*output  wire                                      */.video_ofval	    (  					),
/*output  wire                                      */.vedeo_olval	    (  					), 
/*output  wire                                      */.vedeo_odval	    (  					), 
/*output  wire    [DATA_WIDTH-1:0]                  */.video_odat1     	(  					),
/*output  wire    [DATA_WIDTH*NUMTAPS*NUMTAPS-1:0]  */.video_odat2      ( mean_b_odat2		) 
);

always @(posedge clock) begin 
	mean_a_ofval_r <= {mean_a_ofval_r[6:0], mean_a_ofval};
	mean_a_olval_r <= {mean_a_olval_r[6:0], mean_a_olval};
	mean_a_odval_r <= {mean_a_odval_r[6:0], mean_a_odval};
end

generate
genvar i;
    for(i=0; i<=(NUMTAPS*NUMTAPS-1); i=i+1) begin : col_11
		assign mean_a_odat2_w[i] = mean_a_odat2[i*DATA_WIDTH+:DATA_WIDTH];
		assign mean_b_odat2_w[i] = mean_b_odat2[i*DATA_WIDTH+:DATA_WIDTH];
    end
endgenerate

//DLY1
always @(posedge clock) begin 
	mean_a_w1sum1 <= mean_a_odat2_w[23] + mean_a_odat2_w[22] + mean_a_odat2_w[21] + mean_a_odat2_w[20];
	mean_a_w1sum2 <= mean_a_odat2_w[19] + mean_a_odat2_w[18] + mean_a_odat2_w[17] + mean_a_odat2_w[16] + mean_a_odat2_w[15];
	mean_a_w1sum3 <= mean_a_odat2_w[14] + mean_a_odat2_w[13] + mean_a_odat2_w[12] + mean_a_odat2_w[11] + mean_a_odat2_w[10];
	mean_a_w1sum4 <= mean_a_odat2_w[9]  + mean_a_odat2_w[8]  + mean_a_odat2_w[7]  + mean_a_odat2_w[6]  + mean_a_odat2_w[5];
	mean_a_w1sum5 <= mean_a_odat2_w[4]  + mean_a_odat2_w[3]  + mean_a_odat2_w[2]  + mean_a_odat2_w[1]  + mean_a_odat2_w[0];
end

always @(posedge clock) begin 
	mean_b_w1sum1 <= mean_b_odat2_w[23] + mean_b_odat2_w[22] + mean_b_odat2_w[21] + mean_b_odat2_w[20];
	mean_b_w1sum2 <= mean_b_odat2_w[19] + mean_b_odat2_w[18] + mean_b_odat2_w[17] + mean_b_odat2_w[16] + mean_b_odat2_w[15];
	mean_b_w1sum3 <= mean_b_odat2_w[14] + mean_b_odat2_w[13] + mean_b_odat2_w[12] + mean_b_odat2_w[11] + mean_b_odat2_w[10];
	mean_b_w1sum4 <= mean_b_odat2_w[9]  + mean_b_odat2_w[8]  + mean_b_odat2_w[7]  + mean_b_odat2_w[6]  + mean_b_odat2_w[5];
	mean_b_w1sum5 <= mean_b_odat2_w[4]  + mean_b_odat2_w[3]  + mean_b_odat2_w[2]  + mean_b_odat2_w[1]  + mean_b_odat2_w[0];
end

//DLY2
always @(posedge clock) begin 
	mean_a_w2sum1 <= mean_a_w1sum1 + mean_a_w1sum5;
	mean_a_w2sum2 <= mean_a_w1sum2 + mean_a_w1sum3 + mean_a_w1sum4;
end

always @(posedge clock) begin 
	mean_b_w2sum1 <= mean_b_w1sum1 + mean_b_w1sum5;
	mean_b_w2sum2 <= mean_b_w1sum2 + mean_b_w1sum3 + mean_b_w1sum4;
end

//DLY3
always @(posedge clock) begin 
	mean_a_w3sum1 <= mean_a_w2sum1 + mean_a_w2sum2;
end

always @(posedge clock) begin 
	mean_b_w3sum1   <= mean_b_w2sum1 + mean_b_w2sum2; 
end

//DLY4 
assign result1_w = mean_a_w3sum1 * taps_r1[6];

always @(posedge clock) begin 
	result1 <= result1_w;
end

always @(posedge clock) begin  
	mean_b_w3sum1_r <= mean_b_w3sum1;
end

//DLY5
always @(posedge clock) begin 
	result2 <= result1 + {mean_b_w3sum1_r, 14'b0};
end 

assign result2_w = (result2[47:3] + result2[2]) / 3;

always @(posedge clock) begin
	video_ofval 	<= mean_a_ofval_r[6] | mean_a_ofval_r[7];	
	vedeo_olval 	<= mean_a_olval_r[4];
	video_odata 	<= ( mean_a_odval_r[4] & GuidedFilterEn) ? ((result2_w[47:14] > 16383) ? 16383 : (result2_w[47:14] + result2_w[13])) : taps_r1[8]; 
	Shifter_DataO 	<= taps_r1[8];		
end

endmodule
精选资源
verilog实现中值滤波算法及仿真median.rar
08-14
在“median”这个文件中，可能包含了以下内容：Verilog源代码文件（.v），可能命名为“median_filter.v”，它定义了中值滤波器的结构；测试平台文件，用于生成输入信号并验证输出；还有可能包含 Quartus II 项目的...
取滤波 cic3s32.v
06-16
在数字信号处理领域，"取滤波 cic3s32.v" 可能是指一个用于数字信号抽取（Downsampling）的滤波器设计，其中"CIC"代表积分梳状滤波器（Cumulative Integration and Comb Filter）。CIC滤波器是一种特殊的数字滤波器...
导向滤波小结：从导向滤波（guided filter）到快速导向滤波（fast guide filter）的原理，应用及opencv实现代码
热门推荐
生命在于折腾！
10-29 4万+
1. 导向滤波简介 导向滤波是何凯明在学生时代提出的一个保边滤波（edge-preserving smoothing）算法。何凯明在cv圈应该算是名人了，学生时代关于图像去雾的研究就以第一作者的身份获得Best Paper Award（CVPR 2009），而且今年刚刚又斩获Marr Prize（ICCV 2017）。更多关于何凯明的最新研究动态可以点击以下链接何凯明。 导向滤波顾名思义，就是
数字IC经典电路（4）——经典滤波器的实现（滤波器简介及Verilog实现）
HFUT90S的博客
04-23 9858
数字滤波器是数字信号处理中最常用的一种工具，可用于滤波、降噪和频率分析等应用。与模拟滤波器相比，数字滤波器具有以下优点： 精度高：数字滤波器可以使用更多位的定点数和浮点算法进行计算，从而提高精度。 稳定性强：数字滤波器不会受到元器件的漂移和偏差的影响，因此具有较高的稳定性。 可编程性强：数字滤波器通过改变系数或程序代码来实现不同的滤波器特性，因此具有更高的可编程性。 易于集成：数字滤波器的硬件电路结构简单，易于实现集成和小型化。 数字滤波器广泛应用于通讯、音频处理、图像处理、自动控制、生物医学工程
基于FPGA的引导滤波并行加速实现
CrazyBingo的博客
07-31 3855
前面一篇文章中，已经详细的分析了引导滤波的理论，公式的推导，以及和双边滤波的对比分析，即在边缘的处理上双边滤波会引起人为的黑/白边。我们已经知道何博士引导滤波的优秀之处，那么本篇文章，我带你推演，如何用FPGA并行高速运算，最小的代码实现实时的引导滤波算法。 首先，给出上篇中最后的matlab 引导滤波的代码，如下所示。 其中框框中为主要的计算过程，下一图为计算a/b的最后的公式（引导图=本身）。 双边滤波由于其只是在空间距离及像...
基于FPGA的图像去雾算法实现与优化
weixin_42612405的博客
09-07 1217
图像去雾技术旨在通过算法去除图像中由于大气散射导致的模糊与颜色失真，从而恢复场景的清晰细节与真实色彩。该技术广泛应用于计算机视觉、智能监控、无人机导航及自动驾驶等领域，对提升图像识别与感知系统的鲁棒性具有重要意义。根据实现方式，去雾算法主要分为三类：基于物理模型（如暗通道先验算法）、基于图像增强（如直方图均衡化）以及基于深度学习（如CNN、GAN等模型）。随着算法的演进，图像质量评估标准如PSNR、SSIM也成为衡量去雾效果的重要依据。
导向滤波（guided filter）的数字电路/FPGA实现
yangyuf012的博客
02-04 2735
导向滤波（guide filter）的数字电路实现导向滤波介绍数字电路框架滤波效果 导向滤波介绍 在图像处理中（比如图像的H.264压缩），经常需要对图像进行2D滤波以进一步提高H.264的压缩效果。以前常用的均值滤波，高斯滤波虽然能滤除图像噪声但是对图像原本的边缘也进行了模糊，滤波效果较差。后来在算法上提出了一些保边滤波算法，比如双边滤波，导向滤波。这些算法在滤除噪声的同时，能很好的保持图像原本...
这个何同学不一般——导向滤波
zcg1942的博客
08-29 2745
首先，导向滤波可以在滤波的同时保留图像边缘。双边滤波，导向滤波，最小二乘滤波被称为三大保持 边缘滤波器。导向滤波其实是何恺明为了解决暗通道去雾的一个计算过程提出的一种滤波方法。 如果我们想要滤波的同时保留边缘，很自然地会想到先使用边缘检测器得到边缘图，滤波的时候就可以以此作为参考。导向滤波其实也一样，需要一幅guidance image，特别地，可以将原图作为guidance image，此时的结果输出就是保留边缘的平滑结果，在这个过程中其实就利用了guidance image中的结构信息。作为边缘保持滤
基于FPGA的数字滤波FFT仿真验证.pdf
07-13
根据给定文件信息，本篇文档主要介绍了在FPGA（现场可编程门阵列）上实现数字滤波和快速傅里叶变换（FFT）的仿真验证过程。以下是该文档中包含的相关知识点： 1. FPGA与数字信号处理 FPGA是一种可以通过编程配置其...
基于FPGA的中值滤波算法的实现.pdf
07-13
基于FPGA的中值滤波算法实现涉及到多项IT技术和数字图像处理领域的知识点。首先，FPGA作为本文技术实现的硬件平台，具有以下几个核心知识点： 1. FPGA简介：FPGA（Field-Programmable Gate Array）是现场可编程...
FPGA教程系列-Vivado Aurora 8B／10B IP核设置
fantasygwh2015的博客
12-11 1077
时钟计算按照图中的配置：3.125 Gbps / 2 Bytes (16 bits) / 10 (8B/10B编码效率) =156.25 MHz。​user_clk​是 156.25 MHz。所有 AXI 接口逻辑（读写 FIFO、状态机）都必须在这个时钟频率下工作。两端一致性FPGA A 和 FPGA B 通信，它们的 Line Rate、Lane Width、Scrambler、Interface (Framing/Streaming)必须一模一样，否则channel_up永远起不来。
【FPGA】Verilog HDL编辑、RTL仿真、网表生成主流软件
工业电子技术研读及分享
12-10 501
本文介绍了Verilog HDL开发中常用的文本编辑器、RTL仿真工具和网表综合软件。在文本编辑器方面，GVIM以其高效的快捷键操作和高度可定制性著称，而Notepad++则以简约界面和快速启动见长。RTL仿真工具部分对比了VCS和ModelSim，VCS在仿真速度和功能丰富性上占优，ModelSim则在脚本化仿真和代码覆盖率方面表现突出。最后介绍了Synopsys公司的Design Compiler，作为主流的网表综合工具，可将RTL代码转换为门级网表，支持图形界面和命令行两种操作模式。这些工具各有特点，
FPGA中同步与异步复位
s0907136的博客
12-15 974
本文对比了FPGA设计中同步复位与异步复位的特性差异。同步复位依赖时钟边沿生效，时序分析简单但存在延迟；异步复位立即生效但不依赖时钟，但释放时可能引发亚稳态。最佳实践是采用"异步复位，同步释放"方案，通过两级触发器同步复位释放信号，兼具响应速度和可靠性。文章建议在复杂系统中优先使用这种复位策略，并避免直接使用纯异步复位。
集成电路基础知识经典问答（面向 FPGA 工程师版）
12-11 869
本文精选整理了FPGA工程师必备的15个模拟电路知识点，采用问答形式解答实际工程中的常见问题。内容涵盖电源设计（多路供电方案）、信号接口（ADC连接方式）、信号完整性（时钟走线、阻抗控制）、保护电路（TVS/ESD应用）等核心场景，特别强调FPGA与模拟电路的协同设计要点。文章指出，FPGA工程师必须掌握模拟基础才能解决电源噪声、信号失真、地干扰等典型问题，并列举了新手常见的设计陷阱，如ADC量程错误、时钟驱动不当等。这些实用知识点能帮助工程师从"数字逻辑设计"升级为"完整系统
探索 AD9364：模拟IC设计中的射频收发机宝藏
2508_94229148的博客
12-10 344
模拟ic设计，AD9364，adi的射频收发机模块的reserve电路，可用于基站应用，规模较大，是综合性能较好的射频收发机芯片。芯片正常在70MHz-6.2GHZ工作，电路规模非常大，有adc，PLL，NX，RX等等模块，可以长期参考学习使用，适合有一定经验的模拟设计工程师，电路可以直接导入到cadence查看结构和宽长比等参数。在模拟IC设计的领域里，ADI的AD9364射频收发机模块犹如一颗璀璨的明星，尤其是它的reserve电路，在基站应用方面大放异彩。
双端口RAM IP核
Punchline_c的博客
12-11 214
端口A、端口B都是独立的使能端口、时钟ADDRA：数据写入对应地址WEA：读写控制信号ENA:使能端口，高电平有效RSTB：复位端口REGCEB：寄存器使能端口DOUTB：读出数据红杠端口：ECC功能错误纠正，单比特纠正，双比特检错。
FPGA基础知识（二十）：Xilinx Block Memory IP核（5）--ROM 详解
最新发布
FPGA_小田老师的博客
12-16 583
本文介绍了Xilinx FPGA平台上Block Memory IP核中ROM的配置与使用方法。重点讲解了ROM初始化文件(.coe)的格式规范，包括radix参数设置和数据vector的编写方式。通过实例演示了如何创建8bit位宽、16bit深度的单端口ROM，并详细说明了在IP核配置界面中编辑和导入.coe文件的具体步骤。文章还展示了ROM的仿真结果验证，确认读取数据与写入数据一致。最后建议对于大数据量情况，可使用Matlab等工具辅助生成.coe文件。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

#＞木易

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值