FPGA图像处理-线性滤波（均值，高斯，sobel算子）的实现

最新推荐文章于 2024-06-14 13:08:39 发布
最新推荐文章于 2024-06-14 13:08:39 发布
阅读量1.2k 收藏 12
点赞数
分类专栏： FPGA图像
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35608277/article/details/105922964
版权

原理

都是线性滤波器。

均值滤波

在这里插入图片描述
该点处的像素值=滤波核范围的像素值取平均

降噪

高斯滤波

平滑
该点处的像素值=滤波核范围的像素值乘上高斯系数的和

在这里插入图片描述
eg
在这里插入图片描述

sobel算子

边缘检测，
计算方式跟高斯滤波同
在这里插入图片描述

fpga实现均值滤波

直接实现
在这里插入图片描述
流水
在这里插入图片描述

步骤

  • 一维求和
  • 二维求和
  • 除法转换
  • 行缓存并实现行列像素对齐

一维求和

连续打四拍，两两并行相加，注意时序
在这里插入图片描述
增量更新法

增量更新是指在进行更新操作时，只更新需要改变的地方，不需要更新或者已经更新过的地方则不会重复更新。

假定要计算连续5个数据流的和，在上一个时刻t0，这5个待计算的数值是a0,a1,a2,a3,a4, sum=a0+(a1+a2+a3+a4),
在本时刻t1 待计算的数值是a1,a2,a3,a4,a5。sum’=(a1+a2+a3+a4)+a5
中间有4个值是相同元素。

如此如果每次计算都将5个数重新相加，就有点浪费资源。正确的做法是加上一个新值，再减去一个最老的值。

则 sum’=sum+(a5-a1)
在这里插入图片描述

`timescale 1ps/1ps

module sum_1d(
		clk,
		din,
		din_valid,
		dout_valid,
		dout
	);
   
  parameter         DW = 14;
  parameter         KSZ = 3;
  
  input             clk;
  input  [DW-1:0]   din;
  input             din_valid;
  output            dout_valid;
  output [2*DW-1:0] dout;
	
  reg    [KSZ:0]    din_valid_r;
  reg    [DW-1:0]   reg_din[0:KSZ];
  reg    [2*DW-1:0] sum;
  wire   [2*DW-1:0] sub_out;
  wire   [2*DW-1:0] diff;
  integer j;
   
  always @(posedge clk)  
	begin
	  din_valid_r <= #1 ({din_valid_r[KSZ - 1:0], din_valid});
	  reg_din[0]  <= #1 din;
	 for (j = 1; j <= KSZ; j = j + 1)
			reg_din[j] <= #1 reg_din[j - 1];
	end
  
  always @(posedge clk)   
	begin
	  if (din_valid == 1'b1 & ((~(din_valid_r[0]))) == 1'b1)
			sum <= #1 {2*DW-1+1{1'b0}};
	  else if ((din_valid_r[0]) == 1'b1)
			sum <= #1 sum + diff;
	end
  
  assign sub_out = ((din_valid_r[0] == 1'b1 & din_valid_r[KSZ] == 1'b1)) ? 
				({{DW{1'b0}},reg_din[KSZ]}) : ({2*DW{1'b0}});
				
  assign diff = ({{DW{1'b0}},reg_din[1]}) - sub_out;
   
  assign dout_valid = din_valid_r[0];
  assign dout = sum;
   
endmodule

2维求和

5行的结果，重复一行法1的做法

在这里插入图片描述

//--------------------------------------------------------------------------------------------
//
// Generated by X-HDL VHDL Translator - Version 2.0.0 Feb. 1, 2011
// ?? 3? 16 2016 10:59:46
//
//      Input file      : 
//      Component name  : sum_2d
//      Author          : 
//      Company         : 
//
//      Description     : 
//
//
//--------------------------------------------------------------------------------------------

`timescale 1ps/1ps

module sum_2d(

			rst_n,
			clk, 
			din_valid,
			din,
			dout,
			vsync,
			vsync_out,
			is_boarder,
			dout_valid
		);
   
   parameter         DW  = 8;
   parameter         KSZ = 5;
   parameter         IH  = 512;
   parameter         IW  = 640;
   
   input             rst_n;
   input             clk;
   input             din_valid;
   input  [DW-1:0]   din;
   output [2*DW-1:0] dout;
   input             vsync;
   output            vsync_out;
   reg               vsync_out;
   output            is_boarder;
   output            dout_valid;
   
   parameter         radius   = ((KSZ >> 1));
   parameter         num_all  = KSZ * KSZ;
   parameter         fifo_num = KSZ - 1;
   parameter         med_idx  = ((num_all >> 1));
   
   reg               rst_all;
   reg  [DW-1:0]     line_dinl[0:KSZ-2];
   wire [DW-1:0]     line_doutl[0:KSZ-2];
   reg  [DW-1:0]     line_dinh[0:KSZ-2];
   wire [DW-1:0]     line_douth[0:KSZ-2];
   wire [KSZ-2:0]    line_emptyl;
   wire [KSZ-2:0]    line_fulll;
   wire [KSZ-2:0]    line_rdenl;
   wire [KSZ-2:0]    line_wrenl;
   wire [KSZ-2:0]    line_emptyh;
   wire [KSZ-2:0]    line_fullh;
   wire [KSZ-2:0]    line_rdenh;
   wire [KSZ-2:0]    line_wrenh;
   wire [9:0]        line_countl[0:KSZ-2];
   wire [9:0]        line_counth[0:KSZ-2];
   wire [9:0]        line_count[0:KSZ-2];
   
   wire              din_valid_r;
   wire [2*DW-1:0]   sum;
   wire [2*DW-1:0]   sum_col;
   
   reg  [KSZ-2:0]    buf_pop_en;
   reg               valid_r;
   
   reg  [10:0]       in_line_cnt;
   reg  [15:0]       flush_cnt;
   reg               flush_line;
   reg  [15:0]       out_pixel_cnt;
   reg  [10:0]       out_line_cnt;
   reg  [2*DW-1:0]   dout_temp_r;
   reg               dout_valid_temp_r;
   wire [2*DW-1:0]   dout_temp;
   wire              dout_valid_temp;
   
   wire [2*DW-1:0]   sum_row1;
   wire [2*DW-1:0]   sum_row2;
   reg  [2*DW-1:0]   sum_1_2;
   reg  [2*DW-1:0]   sum_col_r;
   reg  [2*DW-1:0]   sum_all;
   wire              is_boarder_tmp;
   reg               is_boarder_r;
   wire              valid;
   wire              row_valid;
   
   wire [31:0]       j;
   wire [31:0]       k;
   
   reg  [10:0]       line_valid_r;
   wire [2*DW-1:0]   sum_row3;
   wire [2*DW-1:0]   sum_row4;
   reg  [2*DW-1:0]   sum_3_4;
   reg  [2*DW-1:0]   sum_0_1_2;
   reg  [2*DW-1:0]   sum_3_4_r;
   wire [2*DW-1:0]   sum_row5;
   wire [2*DW-1:0]   sum_row6;
   
   reg  [2*DW-1:0]   sum_5_6;
   reg  [2*DW-1:0]   sum_3_4_5_6;
   
   wire [2*DW-1:0]   sum_row7;
   wire [2*DW-1:0]   sum_row8;
   wire [2*DW-1:0]   sum_row9;
   wire [2*DW-1:0]   sum_row10;
   wire [2*DW-1:0]   sum_row11;
   wire [2*DW-1:0]   sum_row12;
   wire [2*DW-1:0]   sum_row13;
   wire [2*DW-1:0]   sum_row14;
   
   reg  [2*DW-1:0]   sum_7_8;
   reg  [2*DW-1:0]   sum_9_10;
   reg  [2*DW-1:0]   sum_11_12;
   reg  [2*DW-1:0]   sum_13_14;
   reg  [2*DW-1:0]   sum_7_8_9_10;
   reg  [2*DW-1:0]   sum_11_12_13_14;
   reg  [2*DW-1:0]   sum_0_to_6;
   reg  [2*DW-1:0]   sum_7_to_14;
   reg               row_valid_r;
   wire              vsync_out_tmp;
   
	 reg [DW-1:0]      xhdl4[0:KSZ-2];
   reg [DW-1:0]      xhdl5[0:KSZ-2];
   wire[DW*2-1:0]    xhdl13;
   
    assign valid = din_valid | flush_line;
   
    always @(posedge clk or negedge rst_n)
		begin
			if (rst_n == 1'b0)
				rst_all <= #1 1'b1;
			else 
			begin
				if (vsync == 1'b1)
					rst_all <= #1 1'b1;
				else
					rst_all <= #1 1'b0;
			end
		end 
   
   
    always @(posedge clk)
	  begin
	  	if (rst_all == 1'b1)
				row_valid_r <= #1 1'b1;
		  else
				row_valid_r <= #1 row_valid;
	  end
 
   
    sum_1d #(DW, KSZ)
		  row_sum(
			  .clk(clk),
			  .din(din),
			  .din_valid(valid),
			  .dout(sum_col),
			  .dout_valid(row_valid)
		  );
   
    generate
	  begin : line_buffer_inst
	 
			genvar            i;
	
			for (i = 0; i <= KSZ - 2; i = i + 1)
			begin : line_buf
				if (i == 0)
				begin : row_1st
					always @(*) line_dinl[i] <= sum_col[DW - 1:0];
					always @(*) line_dinh[i] <= sum_col[2 * DW - 1:DW];
					assign line_wrenl[i] = row_valid;
					assign line_wrenh[i] = row_valid;
				end
				
				if ((~(i == 0)))
				begin : row_others
					always @(*) line_dinl[i] <= line_doutl[i - 1];
					always @(*) line_dinh[i] <= line_douth[i - 1];
					assign line_wrenh[i] = line_rdenh[i - 1];
					assign line_wrenl[i] = line_rdenl[i - 1];
				end
				
				assign line_rdenl[i] = buf_pop_en[i] & row_valid;
				assign line_rdenh[i] = buf_pop_en[i] & row_valid;
				
				always @(posedge clk)
				begin
					if (rst_all == 1'b1)
					  buf_pop_en[i] <= #1 1'b0;
					else if (line_countl[i] == IW)
						buf_pop_en[i] <= #1 1'b1;
				end
				
				always @(*) xhdl4[i] <= line_dinl[i];
				
				line_buffer #(DW, IW)
					line_buf_l(
						.rst(rst_all),
						.clk(clk),
						.din(xhdl4[i]),
						.dout(line_doutl[i]),
						.wr_en(line_wrenl[i]),
						.rd_en(line_rdenl[i]),
						.empty(line_emptyl[i]),
						.full(line_fulll[i]),
						.count(line_countl[i])
					);
				
				always @(*) xhdl5[i] <= line_dinh[i];
				
				line_buffer #(DW, IW) 
					line_buf_h(
						.rst(rst_all),
						.clk(clk), 
						.din(xhdl5[i]),
						.dout(line_douth[i]),
						.wr_en(line_wrenh[i]),
						.rd_en(line_rdenh[i]),
						.empty(line_emptyh[i]),
						.full(line_fullh[i]),
						.count(line_counth[i])
					);
					
				end
			end
		endgenerate

    endgenerate
   
    generate
      if (KSZ == 3)
      begin : sum_ksz_3   
			
				assign sum_row1 = ({line_douth[0][DW - 1:0], line_doutl[0][DW - 1:0]});
				assign sum_row2 = (((buf_pop_en[1]) == 1'b1)) ? 
													({line_douth[1][DW - 1:0], line_doutl[1][DW - 1:0]}) : 
													 {2*DW-1+1{1'b0}};
				assign dout_valid_temp = line_valid_r[1 + 1];

				always @(posedge clk)	
				begin
					line_valid_r[2:0] <= ({line_valid_r[1:0], line_rdenl[0]});
					if ((line_rdenl[0]) == 1'b1)
						sum_col_r <= #1 sum_col;
					if ((line_rdenl[0]) == 1'b1)
						sum_1_2 <= #1 sum_row2 + sum_row1;
			  	if ((line_valid_r[0]) == 1'b1)
						sum_all <= #1 sum_1_2 + sum_col_r;
				end				
      end	
    endgenerate
   
	
  
   
endmodule

除法

换成移位操作
在这里插入图片描述
在这里插入图片描述

module Mean_2D(rst_n, clk, din_valid, din, din_delay, din_valid_delay, dout, vsync, vsync_out, is_boarder, dout_valid);
   
   parameter                DW = 14;
   parameter                KSZ = 15;
   parameter                IH = 512;
   parameter                IW = 640;
   
   input                    rst_n;
   input                    clk;
   input                    din_valid;
   input [DW-1:0]           din;
   output [DW-1:0]          din_delay;
   output                   din_valid_delay;
   output [2*DW-1:0]        dout;
   input                    vsync;
   output                   vsync_out;
   output                   is_boarder;
   output                   dout_valid;
   
   
   
   parameter                radius = ((KSZ >> 1));
   parameter                num_all = KSZ * KSZ;
   parameter                fifo_num = KSZ - 1;
   parameter                med_idx = ((num_all >> 1));
   parameter                DW_ADD = DW * 2;
   
   reg                      rst_all;
   reg [DW-1:0]             line_din[0:KSZ-2];
   wire [DW-1:0]            line_dout[0:KSZ-2];
   
   wire [KSZ-2:0]           line_empty;
   wire [KSZ-2:0]           line_full;
   wire [KSZ-2:0]           line_rden;
   wire [KSZ-2:0]           line_wren;
   wire [9:0]               line_count[0:KSZ-2];
   
   wire                     din_valid_r;
   
   reg [KSZ-2:0]            buf_pop_en;
   reg                      valid_r;
   
   reg [10:0]               in_line_cnt;
   reg [15:0]               flush_cnt;
   reg                      flush_line;
   reg [15:0]               out_pixel_cnt;
   reg [10:0]               out_line_cnt;
   reg [2*DW-1:0]           dout_temp_r;
   reg [10:0]               dout_valid_temp_r;
   wire [2*DW-1:0]          dout_temp;
   wire                     dout_valid_temp;
   
   wire [2*DW-1:0]          sum_row7;
   wire [2*DW-1:0]          sum_row8;
   wire [2*DW-1:0]          sum_row9;
   wire [2*DW-1:0]          sum_row10;
   wire [2*DW-1:0]          sum_row11;
   wire [2*DW-1:0]          sum_row12;
   wire [2*DW-1:0]          sum_row13;
   wire [2*DW-1:0]          sum_row14;
   wire [2*DW-1:0]          sum_1_2;
   wire [2*DW-1:0]          sum_col_r;
   wire [2*DW-1:0]          sum_col[0:KSZ-1];
   wire [2*DW-1:0]          sum_all;
   wire                     is_boarder_tmp;
   reg                      is_boarder_r;
   
   wire [KSZ-1:0]           sum_valid;
   reg [radius-1+10:0]      din_valid_tmp;
   reg [(radius+10)*DW-1:0] din_tmp;
   
   reg [2*DW-1:0]           sum_tmp1;
   reg [2*DW-1:0]           sum_tmp2;
   reg [2*DW-1:0]           sum_tmp6;
   reg [2*DW+1:0]           sum_tmp3;
   reg [2*DW+1:0]           sum_tmp4;
   reg [2*DW+1:0]           sum_tmp5;
   wire                     valid;
   
   wire [31:0]              j;
   
   wire                     sum_all_valid;
   wire [DW_ADD*2-1:0]      add_all;
   
   wire [DW*2*KSZ-1:0]      data_tmp1;
   wire [DW*2-1:0]          data_tmp2;
   
   wire                     dout_valid_tmp;
   assign dout_valid = dout_valid_tmp;
   assign valid = din_valid | flush_line;
   
   always @(posedge clk or posedge rst_n)
      if (((~(rst_n))) == 1'b1)
         rst_all <= #1 1'b1;
      else 
      begin
         if (vsync == 1'b1)
            rst_all <= #1 1'b1;
         else
            rst_all <= #1 1'b0;
      end
   generate
      begin : xhdl0
         genvar                   i;
         for (i = 0; i <= KSZ - 2; i = i + 1)
         begin : buf_inst
            if (i == 0)
            begin : xhdl4
               always @(*) line_din[i] <= din;
               assign line_wren[i] = valid;
            end
            
            if ((~(i == 0)))
            begin : xhdl5
               always @(*) line_din[i] <= line_dout[i - 1];
               assign line_wren[i] = line_rden[i - 1];
            end
            
            
            line_buffer line_buf_inst(.rst(rst_all), .clk(clk), .din(line_din[i]), .dout(line_dout[i]), .wr_en(line_wren[i]), .rd_en(line_rden[i]), .empty(line_empty[i]), .full(line_full[i]), .count(line_count[i]));
            assign line_rden[i] = buf_pop_en[i] & valid;
            
            always @(posedge clk)
               
               begin
                  if (rst_all == 1'b1)
                     buf_pop_en[i] <= #1 1'b0;
                  else if (line_count[i] == IW)
                     buf_pop_en[i] <= #1 1'b1;
               end
            
            
            Sum_1D #(DW, KSZ) row_sum(.clk(clk), .din(line_dout[i]), .din_valid(line_rden[i]), .dout(sum_col[i + 1]), .dout_valid(sum_valid[i + 1]));
         end
      end
   endgenerate
   
   
   Sum_1D #(DW, KSZ) row_sum_din(.clk(clk), .din(din), .din_valid(din_valid), .dout(sum_col[0]), .dout_valid(sum_valid[0]));
   
   assign sum_row7 = (((sum_valid[6]) == 1'b1)) ? sum_col[7] : 
                     {2*DW-1+1{1'b0}};
   assign sum_row8 = (((sum_valid[7]) == 1'b1)) ? sum_col[8] : 
                     {2*DW-1+1{1'b0}};
   assign sum_row9 = (((sum_valid[8]) == 1'b1)) ? sum_col[9] : 
                     {2*DW-1+1{1'b0}};
   assign sum_row10 = (((sum_valid[9]) == 1'b1)) ? sum_col[10] : 
                      {2*DW-1+1{1'b0}};
   assign sum_row11 = (((sum_valid[10]) == 1'b1)) ? sum_col[11] : 
                      {2*DW-1+1{1'b0}};
   assign sum_row12 = (((sum_valid[11]) == 1'b1)) ? sum_col[12] : 
                      {2*DW-1+1{1'b0}};
   assign sum_row13 = (((sum_valid[12]) == 1'b1)) ? sum_col[13] : 
                      {2*DW-1+1{1'b0}};
   assign sum_row14 = (((sum_valid[13]) == 1'b1)) ? sum_col[14] : 
                      {2*DW-1+1{1'b0}};
   
   assign data_tmp1 = ({sum_col[0], sum_col[1], sum_col[2], sum_col[3], sum_col[4], sum_col[5], sum_col[6], sum_row7, sum_row8, sum_row9, sum_row10, sum_row11, sum_row12, sum_row13, sum_row14});
   
   AddTree #(DW_ADD, KSZ) sum_total(.rst_n(rst_n), .clk(clk), .din_valid(sum_valid[7]), .din(data_tmp1), .dout(add_all), .dout_valid(sum_all_valid));
   assign sum_all = add_all[DW_ADD - 1:0];
   
   always @(posedge clk)
      
      begin
         if (sum_all_valid == 1'b1)
         begin
            sum_tmp1 <= ({5'b00000, sum_all[2 * DW - 1:5]} + ({3'b000, sum_all[2 * DW - 1:8]}));
            sum_tmp2 <= ({1'b0, sum_all[2 * DW - 1:1]} + ({5'b00000, sum_all[2 * DW - 1:6]}));
            sum_tmp3 <= ({sum_all[2 * DW - 1:0], 2'b00}) + ({13'b0000000000000, sum_all[2 * DW - 1:11]});
         end
         if ((dout_valid_temp_r[0]) == 1'b1)
         begin
            sum_tmp4 <= #1 sum_tmp3 + ({2'b00, sum_tmp1});
            sum_tmp6 <= #1 sum_tmp2;
         end
         if ((dout_valid_temp_r[1]) == 1'b1)
            sum_tmp5 <= sum_tmp4 + ({2'b00, sum_tmp6});
      end
   
   assign dout_temp = (((sum_tmp5[6]) == 1'b1)) ? ({5'b00000, sum_tmp5[2 * DW + 1:7]} + 1'b1) : 
                      ({5'b00000, sum_tmp5[2 * DW + 1:7]});
   assign dout_valid_temp = dout_valid_temp_r[radius + 2];
   
   assign data_tmp2 = (((is_boarder_tmp | (~(dout_valid_temp_r[radius + 2]))) == 1'b1)) ? {DW+1{1'b0}} : 
                      dout_temp;
   
   always @(posedge clk)
      
      begin
         if (rst_all == 1'b1)
         begin
            dout_temp_r <= #1 {2*DW-1+1{1'b0}};
            dout_valid_temp_r <= #1 11'b00000000000;
            valid_r <= #1 1'b0;
            is_boarder_r <= 1'b0;
         end
         else
         begin
            dout_temp_r <= #1 data_tmp2;
            dout_valid_temp_r <= #1 ({dout_valid_temp_r[9:0], sum_all_valid});
            valid_r <= #1 valid;
            is_boarder_r <= is_boarder_tmp;
         end
      end
   
   assign dout = dout_temp_r;
   assign dout_valid_tmp = dout_valid_temp_r[radius + 3];
   assign is_boarder = is_boarder_r;
   
   

   always @(posedge clk)
      
      begin
         if (rst_all == 1'b1)
         begin
            din_valid_tmp <= {radius+10{1'b0}};
            din_tmp <= {radius+10*DW-1+1{1'b0}};
         end
         else
         begin
            din_valid_tmp <= #1 ({din_valid_tmp[radius - 2 + 10:0], line_rden[radius - 1]});
            din_tmp <= #1 ({din_tmp[(radius + 10) * DW - 1 - DW:0], line_dout[radius - 1]});
         end
      end
   
   assign din_valid_delay = din_valid_tmp[radius - 1 + 10];
   assign din_delay = din_tmp[(radius + 10) * DW - 1:(radius + 9) * DW];
   assign vsync_out = line_wren[radius - 1] & (~(line_wren[radius]));
   
endmodule
rrr2
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
图像处理大集合带GUI界面-包括中值滤波-最大化滤波-最小滤波-中值滤波-自适应滤波-prewitt算子-sobel算子-Rob
09-30
这里提到的“图像处理大集合带GUI界面”是一个集成多种图像处理技术的软件工具，其中包括中值滤波、最大化滤波、最小滤波、自适应滤波、Prewitt算子、Sobel算子、Robert算子以及Canny边缘检测等经典算法。...
FPGA实现sobel边缘检测并Modelsim仿真，与MATLAB实现效果对比
H19981118的博客
06-13 5296
将根号运算近似，以提高效率。
FPGA图像处理仿真实验——sobel算子
qq_45005116的博客
12-01 1969
基于vivado的FPGA图像仿真处理实验，实现sobel算法，采用FIFO进行行缓存，边界复制。
使用Sobel算子实现的FPGA边缘检测程序，支持彩色和灰度图像的边缘检测，无需使用Matlab读取输出数据，直接将数据写入BMP文件格式，在ModelSim中实时输出边缘化图像，基于Sobel算子的
最新发布
SOMCdgHNJ的博客
06-14 338
本文将介绍一种基于Sobel算子的边缘检测FPGA程序，该程序不仅兼容彩色图像和灰度图像的边缘检测，而且无需使用Matlab读取输出数据，可以直接将输出数据按照BMP格式写入测试文件，并在ModelSim中直接输出边缘化图像。基于sobel算子的边缘检测FPGA程序，同时兼容彩色图像和灰度图像的边缘检测，而且不用将输出数据再使用matlab读取，在测试文件直接按照bmp格式将输出数据写到bmp中，直接在modelsim就可以直接输出边缘化图像。在FPGA中，彩色图像和灰度图像的边缘检测处理方式有所不同。
Python 图像滤波 代码实现 （sobel、average、gaussian、laplace）
m0_61899108的博客
10-26 5626
图像在频域里面，频率低的地方说明它是比较平滑的，因为平滑的地方灰度值变化比较小，而频率高的地方通常是边缘或者噪声，因为这些地方往往是灰度值突变的。 所谓高通滤波就是保留频率比较高的部分，即突出边缘； 低通滤波就是保留频率比较低的地方，即平滑图像，弱化边缘，消除噪声。
【计算机视觉】卷积、均值滤波、高斯滤波、Sobel算子、Prewitt算子(Python实现)
热门推荐
海贼王的博客
04-01 1万+
1.环境的搭建 Python 3.6 OpenCV Open Source Computer Vision Library.OpenCV于1999年由Intel建立，如今由Willow Garage提供支持。OpenCV是一个基于BSD许可（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows、MacOS操作系统上。它轻量级而且高效——由一系列 C 函数和少量C++...
【数字图像处理实验】中值滤波、均值滤波、灰度图像的锐化处理（包括Sobel、Prewitt、Roberts、Laplace、Canny边缘检测）（MATLAB实现）
LeavesFloating的博客
08-03 6548
目录1 原理1.1 中值滤波1.2 均值滤波1.3 图像锐化1.4 边缘检测2 实现源代码（MATLAB）2.1 中值滤波2.2 均值滤波2.3 锐化处理2.3.0 说明2.3.1 Laplace算子2.3.2 Sobel算子2.3.3 Prewitt算子2.3.4 Roberts算子2.4 边缘检测3 实验结果3.1 中值滤波（使用3*3大小模板）3.2 均值滤波（使用3*3大小模板）3.3 锐化处理（注：锐化效果未叠加到原图，展示图为轮廓图）3.3.0原图3.3.1 Laplace算子3.3.2 Sob
图像处理大集合带GUI界面包括中值滤波_最大化滤波_最小滤波_中值滤波_自适应滤波_prewitt算子_sobel算子边缘提取。
05-03
6. **Canny算子**：Canny算子是边缘检测的经典算法，它通过高斯滤波、梯度计算、非极大值抑制和双阈值检测四个步骤，力求找到图像中最清晰的边缘，同时减少假边缘的出现。 7. **MATLAB2021a**：MATLAB是一种广泛...
基础的数字图像处理软件（实现中值滤波、sobel算子等）
07-06
6. **均值、最大值和最小值滤波**：这些是常见的线性滤波器，均值滤波器通过取像素邻域的平均值来平滑图像，减少噪声；最大值滤波器和最小值滤波器则分别用于保留邻域内的最大和最小像素值，可用于增强图像的某些...
sobel-bianyuanjiance.rar_sobel算子
09-24
在C++中实现Sobel算子，通常会用到OpenCV库，这是一个强大的开源计算机视觉库，提供了许多图像处理的功能，包括Sobel算子的实现。以下是一个简单的示例： ```cpp #include #include int main() { // 读取图像 ...
数字图像处理实验（2）--中值滤波/均值滤波.7z
04-07
编程实现灰度图像的中值滤波平滑处理。滤波模板的大小自定（可为3×3、5×5、7×7...编程实现灰度图像的均值滤波平滑处理；也可尝试实现灰度图像的锐化处理，包括Sobel、Prewitt、Roberts、Laplace、Canny边缘检测等。
Sobel滤波FPGA实现代码
08-18
PC 机通过串口发送 200x200 的图像数据， FPGA 实现 Sobel 图像边缘检测算 法，并将 Sobel 处理后的结果显示在 VGA 显示器上。
sobel算子的verilog实现
09-13
基于DE2平台的sobel 算子的实现代码.其中包括了vga ,ccd 控制等程序代码。
图像分割——边缘检测——均值+Sobel算子（Matlab）
lengo的专栏
09-06 2014
clc; clear all; close all; I=im2double(imread('D:\Gray Files\10-16.tif')); [M,N]=size(I); %% %=============================边缘检测(二)================================= %对图像先进行均值处理，而后用Sobel算子 %5*5均值算子 n=...
挑战图像处理100问（15）——Sobel滤波器
qq_42662568的博客
04-13 2126
Author:Tian YJ Sobel滤波器 Sobel算子是一种典型的用于边缘检测的线性滤波器，它基于两个简单的3*3内核，滤波器按下式定义： 纵向： K=[121000−1−2−1] K=\left[ \begin{matrix} 1&2&1\\ 0&0&0\\ -1&-2&-1 \end{matrix} \right] K=⎣⎡​10−1​...
FPGA project : sobel
Meng_long2022的博客
10-09 302
算出来的Gxy与一个数据T比较大小，大于T则b2像素点赋值为黑色，小于赋值白色。想要沉浸式写代码，就要清清楚楚的画好时序图。在写代码之前就应该想清楚用到的每个信号的时序图应该是什么样的。fpga开发一大部分时间花在整体（顶层）设计上，一部分时间花在如何把想法转换为Verilog语言，一部分时间花在仿真调试上。我认为最重要的就是整体设计，以及画好时序图。或者有流程图或者相关的辅助你把想法转换为代码的图。
基于 Sobel 算子的边缘检测的FPGA 算法实现和MATLAB的实现
Vuko_Coding Zone
09-11 2188
1. 背景知识 边缘检测是图像处理和计算机视觉中的基本问题，边缘检测的目的是标识数字图像中亮度变化明显的点。图像属性中的显著变化通常反映了属性的重要事件和变化。 这些包括（i）深度上的不连续、（ii）表面方向不连续、（iii）物质属性变化和（iv）场景照明变化。 边缘检测是图像处理和计算机视觉中，尤其是特征提取中的一个研究领域。 2. 边缘检测算子 一阶：Roberts ...
soble边缘检测算法的verilog实现
笨蛋大乌龟的博客
06-23 8388
    先来说说soble算子，soble算子是一种离散性差分算子，用来运算图像亮度函数的灰度的近似值，在图像的任何一点使用这个算子，会得到对应的灰度矢量或法矢量。     SOBLE算子的卷积因子为：soble算子包含两组3*3的矩阵，分别为横向和纵向，将 Gx 和 Gy 与图像做卷积，即可分别得出横向和纵向的亮度差分近似值，如果用A表示原始图像，Gx 和 Gy 分别代表经横向和纵向边缘检测的图...
图像处理-边缘检测算法-sobel算子FPGA实现
AccFPGA的博客
04-25 2350
边缘检测简介 边缘检测是图像处理和计算机视觉中的基本问题，边缘检测的目的是标识数字图像中亮度变化明显的点。图像属性中的显著变化通常反映了属性的重要事件和变化。 这些包括深度上的不连续、表面方向不连续、物质属性变化和场景照明变化。 边缘检测是图像处理和计算机视觉中，尤其是特征提取中的一个研究领域。 边缘检测算法，常用的有Sobel算子，Canny算子以及离散傅里叶变换等，这个章节重点介绍...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值