精华内容
下载资源
问答
  • 膨胀算法
  • 绍了膨胀算法的Matlab+FPGA实现的编写源程序代码
  • 图像处理 腐蚀膨胀算法
  • 为了解决传统去噪方法对灰度图象效果不佳的问题,采用形态学算法中的腐蚀与膨胀算法,设计了不同的结构元,以应对不同的噪声。传统的腐蚀膨胀算法会在一定层度上改变图像,为消除这一影响,在该算法基础上又设计了一...
  • 数字图像处理形态学算法中膨胀算法基于MATLAB实现(自己编写),不是调用库函数
  • 为了解决传统去噪方法对灰度图像效果不佳的问题,采用形态学算法中的腐蚀与膨胀算法,设计了不同的结构元,以应对不同的噪声。传统的腐蚀膨胀算法会在一定程度上改变图像,为消除这一影响,在该算法基础上又设计了一...
  • 本篇文章我要写的是基于的腐蚀膨胀算法实现腐蚀膨胀是形态学图像处理的基础 腐蚀在二值图像的基础上做收缩或细化操作膨胀在二值图像的基础上做加长 或变粗的操作那么什么是二值图像呢把一幅图片看做成一个二维的数组...
  • 数字图像处理中,基于MATLAB的形态学处理中的膨胀算法实现(自己编写),不是调用MATLAB的库函数实现
  • 膨胀算法的matlab代码#Fast Food SVM 将 Fast Food 核扩展算法应用于 SVM 和 Elastic Net。 从 MATLAB 实现移植的代码: 季兆,孟德宇。 FastMMD:用于高效两样本测试的圆差集合。 神经计算,2015 年。 包含以下论文...
  • 改进的膨胀算法在红外图像弱小目标检测中的应用,谷稳稳,刘建国,本文针对红外序列图像中弱小目标的检测问题,提出一种基于数学形态学膨胀算法的小目标检测方法。首先,利用弱小目标区域的不连续
  • 本篇文章要分享的是基于MATLAB的腐蚀膨胀算法实现,腐蚀膨胀是形态学图像处理的基础,腐蚀在二值图像的基础上做“收缩”或“细化”操作,膨胀在二值图像的基础上做“加长”或“变粗”的操作。 什么是二值图像呢?把...

    本篇文章要分享的是基于MATLAB的腐蚀膨胀算法实现,腐蚀膨胀是形态学图像处理的基础,腐蚀在二值图像的基础上做“收缩”或“细化”操作,膨胀在二值图像的基础上做“加长”或“变粗”的操作。

      什么是二值图像呢?把一幅图片看做成一个二维的数组,那么二值图像是一个只有0和1的逻辑数组,我们前面Sobel边缘检测后的图像输出边缘效果,设置个阈值,大于阈值输出为1,小于阈值输出为0,最后输出就是一幅二维图像了。

    腐蚀

      腐蚀是一种消除边界点,使边界向内部收缩的过程。可以用来消除小且无意义的物体。用3X3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作,如果都为1,结果图像的该像素为1。否则为0。结果会使二值图像小一圈。

      有一个形象的比喻来可以说明该运算,用0表示蛀虫,1表示大米。蛀虫腐蚀大米的过程便是腐蚀运算,

    v2-fae8aec3c2738c29068dc0c51c38990d_b.jpg

    腐蚀

    如图所示,对于一个像素矩阵而言,只要有蛀虫(0)的存在,大米(1)就会被腐蚀掉了,即使只存在一个蛀虫(0),但是还是会被蛀虫腐蚀完毕,最后一幅图上面由于没有蛀虫(0)所以大米完好无损。

    关于算法的实现,可以用下式子来表示,即3x3像素的运算:

    P = P11 & P12 & P13 & P21 & P22 & P23 & P31 & P32 & P33

    在FPGA中,为了通过面积去换速度,我们将上式改变如下:                       

    P1 = P11 & P12 & P13

    P2 = P21 & P22 & P23

    P3 = P31 & P32 & P33

    P = P1 & P2 & P3

    MATLAB中可以直接写一个按位或运算。


    膨胀

      膨胀是将与物体接触的所有背景点合并到该物体中,使边界向外部扩张的过程。可以用来填补物体中的空洞。用3X3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作,如果都为0,结果图像的该像素为0,。否则为1。结果使二值图像扩大一圈。

      先腐蚀后膨胀的过程称为开运算。用来消除小物体、在纤细点处分离物体、平滑较大物体的边界的同时并不明显的改变其面积。先膨胀后腐蚀的过程称为比运算,用来填充物体内细小空间、连接邻近物体、平滑其边界的同时并不明显改变其面积。

      膨胀算法用最简单的比喻来描述:0表示害虫,1表示青蛙,青蛙吃了害虫表示膨胀运算,我们用3*3像素阵列来解释:

    v2-dea1ffba01bf049cbf70e712bc62cd68_b.jpg

    膨胀

    如图所示,图左只有害虫(0),所以害虫都活着,中间那个图,虽然只有一个害虫,但是还是会被青蛙全部吃掉,最右边的那幅图,都是青蛙,所以青蛙始终是青蛙。

    关于算法的实现,可以用下式子来表示,即3x3像素的运算:

    P = P11 | P12 | P13 | P21 | P22 | P23 | P31 | P32 | P33

    在HDL中,为了通过面积去换速度,我们将上式改变如下:                             

    P1 = P11 | P12 | P13

    P2 = P21 | P22 | P23

    P3 = P31 | P32 | P33

    P = P1 | P2 | P3

    MATLAB中可以直接写一个按位与运算。

    开运算闭运算

      先腐蚀后膨胀叫开运算,开运算的作用是清除图像边缘周围非边缘的细小的点。先膨胀后腐蚀为闭运算,闭运算的作用是清除图像内部的空洞,

      如果我们的目标物体外面有很多无关的小区域,就用开运算去除掉;如果物体内部有很多小黑洞,就用闭运算填充掉。

    MATLAB逻辑运算函数

    bitand(), 对十进制数进行逐位逻辑与运算:先将十进制数转换成二进制数,然后逐位与运算,其运算结果转换为十进制。

    bitor(), 对十进制数进行逐位逻辑或运算:先将十进制数转换成二进制数,然后逐位与运算,其运算结果转换为十进制。

    MATLAB代码实现

    需要了解代码的私聊我,发你。(这就不再复制了)

    处理后结果对比

    为了可以清晰的看到图像边缘的变化,我们把黑色作为背景,白色作为边缘。


    v2-21d008ade544ce5a55e3c68a50c145d7_b.jpg

    Sobel边缘检测后的lena

    v2-352feb115898c62f837c6f392e12d72f_b.jpg

    腐蚀后的lena


    v2-929f1cf9f430902dc17f2106f9712846_b.jpg

    膨胀后的lena


    v2-c6e930ecac632267be000747728e19e4_b.jpg

    先腐蚀后膨胀开运算lena


    v2-826b83ecfba777b11e0bd3d61b9d6fbb_b.jpg

    先膨胀后腐蚀闭运算lena

      从上面两幅图可以看出,腐蚀后的图像边缘明显变细,消除了更多假边缘,在腐蚀基础上使用膨胀算法的lena将腐蚀后的边缘扩大、加粗,这样看起来更清楚。

    展开全文
  • 灰度图象的膨胀算法c语言版的,有需要的可以下载去看看
  • 基于FPGA灰度图像的膨胀算法的实现

    千次阅读 2018-05-21 17:39:37
    基于FPGA灰度图像的膨胀算法的实现 1 背景知识 腐蚀与膨胀是形态学滤波的两个基本运算,通过腐蚀和膨胀两种运算可以实现多种功能,主要如下: (1) 消除噪声; (2)分割出独立的图像元素; (3)在图像中...

    基于FPGA灰度图像的膨胀算法的实现

    1 背景知识

        腐蚀与膨胀是形态学滤波的两个基本运算,通过腐蚀和膨胀两种运算可以实现多种功能,主要如下:

    (1) 消除噪声;

    (2)分割出独立的图像元素;

    (3)在图像中连接相邻的元素;

    (4)寻找图像中明显的极大值和极小值区域;

    (5)求出图像的梯度。

    图1 腐蚀膨胀示意图

    图1 a为大小为448X425像素的灰度级X射线图像;b使用半径为2个像素的圆盘形结构元对图像的腐蚀结果;c用相同的结构元对图像的膨胀结果。原图有Lixi公司提供。

    1)形态学滤波之膨胀

       膨胀(dialate)就是求局部最大值的操作。

       从数学角度来看就是将图像f和核(结构元)b进行卷积的一个过程。

       当b的原点位于(x,y)处时,用一个平坦的结构元b在(x,y)处对图像f的膨胀,定义为图像f中与b重合区域的最大值,即:

         

       为了方便起见,将膨胀操作记为:

     

    (x,y)表示当前输入图像的行列坐标;

    f(x,y)表示坐标点(x,y)处的图像像素值;

    g(x,y)表示坐标点(x,y)处的滤波结果;

    (s,t)表示作用域。

    2 matlab仿真灰度图像的膨胀

    Matlab膨胀源码:

    %%imagedilate

    clc

    clearall

    img_a= imread('flower.bmp');

    figure,imshow(img_a);

    title('img_a rgb');

    img_b= rgb2gray(img_a);

    figure,imshow(img_b);

    title('img_b gary');

    a= [1,1,1;

         1,1,1;

         1,1,1]; %structural element

    b= [1,1,1,1,1;

         1,1,1,1,1;

         1,1,1,1,1;

         1,1,1,1,1;

         1,1,1,1,1];

     c = [1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1];

    img_c= imdilate(img_b,a);

    figure,imshow(img_c);

    title('img_c 3x3');

    img_d= imdilate(img_b,b);

    figure,imshow(img_d);

    title('img_d 5x5');

    img_e= imdilate(img_b,c);

    figure,imshow(img_e);

    title('img_e 7x7');

     

     

     

    3.1 膨胀模块的设计

    1)比较子模块

    2)一维形态学膨胀子模块

    3)二维形态学膨胀子模块

    (1) 比较子模块

    为了代码更好的移植,我们将比较子模块设计为独立的子模块。

    Erode:输出俩个数据的较小值。

    比较子模块源码:

    /*

    Module name:  minmax.v

    Description: 

                 

    Data:         2018/03/14

    Engineer:     lipu

    e-mail:       137194782@qq.com

    */

    `timescale1ns/1ps

    moduleminmax(

          clk,  //pixel clock

             rst_n,

             data_valid,

             din,

             din_r,

             dout_min,

             dout_max

             );

    parameterWIDTH = 8;       // data width 8 bit  

    parameterUSE_REG = 1; // USE_REG = 1Data delay 1ns output.  USE_REG = 0 Don'tdelay.  

    input               clk;  //pixel clock

    input               rst_n;

    input               data_valid;

    input  [WIDTH-1:0] din;

    input  [WIDTH-1:0] din_r;

    output[WIDTH-1:0] dout_min;

    output[WIDTH-1:0] dout_max;    

    wireminmax_flag;

    wire[WIDTH-1:0] min_temp;

    wire[WIDTH-1:0] max_temp;

    reg  [WIDTH-1:0] min_reg;

    reg  [WIDTH-1:0] max_reg;

    // min or max flag

    assignminmax_flag = (din > din_r) ? 1'b1:1'b0;

    // min

    assignmin_temp = (minmax_flag == 1'b1) ? din_r : din;

    // max

    assignmax_temp = (minmax_flag == 1'b1) ? din : din_r;

    // USE_REG == 1

    generate

    if(USE_REG== 1)

    begin: MAP0

      always @(posedge clk) begin

        if(data_valid) begin

            min_reg <= #1 min_temp;

            max_reg <= #1 max_temp;

           end

      end

      assign dout_min = min_reg;

      assign dout_max = max_reg;

    end

    endgenerate

    //USE_REG == 0

    generate

    if(~(USE_REG== 1))

    begin: MAP1

      assign dout_min = min_temp;

      assign dout_max = max_temp;

    end

    endgenerate

    endmodule

    比较子模块仿真源码:

    /*

    Module name:  minmax_tb.v

    Description:            

    */

    `timescale1ns/1ps

    `defineWIDTH 8

    `defineCLK_PERIOD 10

    moduleminmax_tb();

           reg               clk;  //pixel clock

             reg               rst_n;

             reg               data_valid;

             reg  [`WIDTH-1:0] din;

             reg  [`WIDTH-1:0] din_r;

             wire [`WIDTH-1:0] dout_min;

             wire [`WIDTH-1:0] dout_max;

    minmaxminmax_inst(

            .clk(clk),  //pixel clock

              .rst_n(rst_n),

              .data_valid(data_valid),

              .din(din),

                  .din_r(din_r),

              .dout_min(dout_min),

              .dout_max(dout_max)

             );

             initial begin

               clk = 0;

                   rst_n = 0;

                   data_valid = 0;

                   #(`CLK_PERIOD*10);

                   rst_n = 1;

               #(`CLK_PERIOD*10);

                   data_valid = 1;

                   #(`CLK_PERIOD*100);

                   data_valid = 0;

                   #(`CLK_PERIOD*10);

                   $stop;

             end

    always#(`CLK_PERIOD/2)       clk = ~clk; 

    always@(posedge clk or negedge rst_n) begin

      if(!rst_n)

        din <= 8'd0;

      else if(data_valid)

        din <= {$random}%255;

      else

        din <= 8'b0;

    end

    always@(posedge clk or negedge rst_n) begin

      if(!rst_n)

        din_r <= 8'd0;

      else if(data_valid)

        din_r <= din;

      else

        din_r <= 8'b0;

    end

    Endmodule

    比较子模块仿真波形

     

    t

    t+1

    t+2

    t+3

    t+4

    t+5

    t+6

    t+7

    t+8

    t+9

    t+10

    din

    128

    42

    232

    92

    72

    77

    95

    37

    216

    184

    198

    din_r

    X

    128

    42

    232

    92

    72

    77

    95

    37

    216

    184

    dout_min

    X

    X

    42

    42

    92

    72

    72

    77

    37

    37

    184

    dout_max

    X

    X

    128

    232

    232

    92

    77

    95

    95

    216

    216

    当我们需要做膨胀算法时,数据取dout_max;当我们需要做腐蚀算法时,数据取dout_min。

     

    (2)一维形态学膨胀模块设计

    我们要完成对nxn窗口的腐蚀或者膨胀首先我们要做图像行的一维腐蚀或膨胀。例如我们要做3x3窗口的腐蚀或膨胀,一维形态学腐蚀或膨胀如图所示:

    (3) 二维形态学腐蚀与膨胀子模块设计

    形态学膨胀结果演示:

    顶层源码:

    wire[15:0] rgb;

    wire hs;

    wirevs;

    wirede; 

     

    wireo_hs;

    wireo_vs;

    wireo_de;                                

    wire[7 : 0]            o_y_8b;

    wire[7 : 0]            o_cb_8b;

    wire[7 : 0]            o_cr_8b;

    wire[7 : 0]      dout;

     

    //assign TFT_rgb ={o_y_8b[7:3],o_y_8b[7:2],o_y_8b[7:3]};    //Y

    //assign TFT_rgb = {o_cb_8b[7:3],o_cb_8b[7:2],o_cb_8b[7:3]};  //cb

    //assign TFT_rgb ={o_cr_8b[7:3],o_cr_8b[7:2],o_cr_8b[7:3]}; //cr

     

    tft_ctrltft_ctrl(

           .Clk9M(clk9M),    //系统输入时钟9MHZ

           .Rst_n(Rst_n),     //复位输入,低电平复位

           .data_in({Rd_data[7:0],Rd_data[15:8]}),  //待显示数据

           .hcount(),             //TFT行扫描计数器

           .vcount(),             //TFT场扫描计数器

           .TFT_RGB(rgb),  //TFT数据输出

           .TFT_HS(hs),             //TFT行同步信号

           .TFT_VS(vs),              //TFT场同步信号

           .TFT_CLK(TFT_clk),         //TFT像素时钟

           .TFT_DE(de),             //TFT数据使能

           .TFT_begin(tft_begin),

           .TFT_PWM(TFT_pwm)            //TFT背光控制

           );

    rgb_to_ycbcr  rgb_to_ycbcr_inst(

                                  .clk(TFT_clk),

                                  .i_r_8b({rgb[15:11],3'b0}),

                                  .i_g_8b({rgb[10:5],2'b0}),

                                  .i_b_8b({rgb[4:0],3'b0}),

                                            

                                  .i_h_sync(hs),

                                  .i_v_sync(vs),

                                  .i_data_en(de),

                                             

                                  .o_y_8b(o_y_8b),

                                  .o_cb_8b(o_cb_8b),

                                  .o_cr_8b(o_cr_8b),

                                             

                                  .o_h_sync(o_hs),

                                  .o_v_sync(o_vs),                                                                                                 

                                  .o_data_en(o_de)                                                                                               

                                              );

    /*                                       

    erode erode_inst(

         .clk(TFT_clk),

                  .rst_n(Rst_n),

                  .hs_in(o_hs),

                  .vs_in(o_vs),

                  .din(o_y_8b),

                  .din_valid(o_de),

                  .dout(dout),

                  .dout_valid(TFT_de),

                  .hs_out(TFT_hs),

                  .vs_out(TFT_vs)

                  );    

    */

    dilatedilate_inst(

          .clk(TFT_clk),

                  .rst_n(Rst_n),

                  .hs_in(o_hs),

                  .vs_in(o_vs),

                  .din(o_y_8b),

                  .din_valid(o_de),

                  .dout(dout),

                  .dout_valid(TFT_de),

                  .hs_out(TFT_hs),

                  .vs_out(TFT_vs)

                  );           

    assignTFT_rgb = {dout[7:3],dout[7:2],dout[7:3]};    //Y

    //assign TFT_rgb ={o_y_8b[7:3],o_y_8b[7:2],o_y_8b[7:3]};    //Y     

     

    FPGA自习学院将不断更新和总结FPGA相关学习资料,书籍,实例工程和视频。

    欢迎大家加入FPGA自习学院,一起学习一起成长。

    欢迎大家关注我的微信公众号:FPGA开源工作室:

     

    展开全文
  • 图像处理,用于腐蚀与膨胀算法,希望对大家会有帮助
  • 形态学运算中腐蚀膨胀开运算和闭运算 (针对二值图而言 ) 6.1 腐蚀 腐蚀是一种消除边界点使边界向内部收缩的过程可以用来消除小且无意义的物体 腐蚀的算法 用 3x3 的结构元素扫描图像的每一个像素 用结构元素与其...
  • 基于FPGA灰度图像的形态学膨胀算法的实现1 背景知识腐蚀与膨胀是形态学滤波的两个基本运算,通过腐蚀和膨胀两种运算可以实现多种功能,主要如下:(1)消除噪声;(2)分割出独立的...

    基于FPGA灰度图像的形态学膨胀算法的实现

    1 背景知识

        腐蚀与膨胀是形态学滤波的两个基本运算,通过腐蚀和膨胀两种运算可以实现多种功能,主要如下:

    (1) 消除噪声;

    (2)分割出独立的图像元素;

    (3)在图像中连接相邻的元素;

    (4)寻找图像中明显的极大值和极小值区域;

    (5)求出图像的梯度。

     

    图1 腐蚀膨胀示意图

    图1 a为大小为448X425像素的灰度级X射线图像;b使用半径为2个像素的圆盘形结构元对图像的腐蚀结果;c用相同的结构元对图像的膨胀结果。原图有Lixi公司提供。

    1)形态学滤波之膨胀

       膨胀(dialate)就是求局部最大值的操作。

       从数学角度来看就是将图像f和核(结构元)b进行卷积的一个过程。

       当b的原点位于(x,y)处时,用一个平坦的结构元b在(x,y)处对图像f的膨胀,定义为图像f中与b重合区域的最大值,即:

          

       为了方便起见,将膨胀操作记为:

      

    (x,y)表示当前输入图像的行列坐标;

    f(x,y)表示坐标点(x,y)处的图像像素值;

    g(x,y)表示坐标点(x,y)处的滤波结果;

    (s,t)表示作用域。

    2 matlab仿真灰度图像的腐蚀与膨胀

    Matlab膨胀源码:

    %%image dilate

    clc

    clear all

    img_a = imread('flower.bmp');

    figure,imshow(img_a);

    title('img_a rgb');

    img_b = rgb2gray(img_a);

    figure,imshow(img_b);

    title('img_b gary');

    a = [1,1,1;

         1,1,1;

         1,1,1]; %structural element

    b = [1,1,1,1,1;

         1,1,1,1,1;

         1,1,1,1,1;

         1,1,1,1,1;

         1,1,1,1,1];

     c = [1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1;

          1,1,1,1,1,1,1];

    img_c = imdilate(img_b,a);

    figure,imshow(img_c);

    title('img_c 3x3');

    img_d = imdilate(img_b,b);

    figure,imshow(img_d);

    title('img_d 5x5');

    img_e = imdilate(img_b,c);

    figure,imshow(img_e);

    title('img_e 7x7');

     

    3.1 膨胀模块的设计

    1)比较子模块

    2)一维形态学膨胀子模块

    3)二维形态学腐蚀子模块

    (1) 比较子模块

    为了代码更好的移植,我们将比较子模块设计为独立的子模块。

    Erode:输出俩个数据的较小值。

     

    比较子模块源码:

    /*

    Module name:  minmax.v

    Description:  

                  

    Data:         2018/03/14

    Engineer:     lipu

    e-mail:       137194782@qq.com

    */

    `timescale 1ns/1ps

    module minmax(

          clk,  //pixel clock

       rst_n,

       data_valid,

       din,

       din_r,

       dout_min,

       dout_max

       );

    parameter WIDTH = 8; // data width 8 bit  

    parameter USE_REG = 1; // USE_REG = 1 Data delay 1ns output.  USE_REG = 0 Don't delay.   

    input               clk;  //pixel clock

    input               rst_n;

    input               data_valid;

    input  [WIDTH-1:0] din;

    input  [WIDTH-1:0] din_r;

    output [WIDTH-1:0] dout_min;

    output [WIDTH-1:0] dout_max;     

    wire minmax_flag;

    wire [WIDTH-1:0] min_temp;

    wire [WIDTH-1:0] max_temp;

    reg  [WIDTH-1:0] min_reg;

    reg  [WIDTH-1:0] max_reg;

    // min or max flag

    assign minmax_flag = (din > din_r) ? 1'b1:1'b0;

    // min

    assign min_temp = (minmax_flag == 1'b1) ? din_r : din;

    // max

    assign max_temp = (minmax_flag == 1'b1) ? din : din_r;

    // USE_REG == 1

    generate

    if(USE_REG == 1)

    begin : MAP0

      always @(posedge clk) begin

        if(data_valid) begin

      min_reg <= #1 min_temp;

      max_reg <= #1 max_temp;

    end

      end

      assign dout_min = min_reg;

      assign dout_max = max_reg;

    end

    endgenerate

    //USE_REG == 0

    generate

    if(~(USE_REG == 1))

    begin : MAP1

      assign dout_min = min_temp;

      assign dout_max = max_temp;

    end

    endgenerate

    endmodule

    比较子模块仿真源码:

    /*

    Module name:  minmax_tb.v

    Description:             

    */

    `timescale 1ns/1ps

    `define WIDTH 8

    `define CLK_PERIOD 10

    module minmax_tb();

           reg               clk;  //pixel clock

       reg               rst_n;

       reg               data_valid;

       reg  [`WIDTH-1:0] din;

       reg  [`WIDTH-1:0] din_r;

       wire [`WIDTH-1:0] dout_min;

       wire [`WIDTH-1:0] dout_max;

    minmax minmax_inst(

            .clk(clk),  //pixel clock

        .rst_n(rst_n),

        .data_valid(data_valid),

        .din(din),

    .din_r(din_r),

        .dout_min(dout_min),

        .dout_max(dout_max)

       );

       initial begin

         clk = 0;

     rst_n = 0;

     data_valid = 0;

     #(`CLK_PERIOD*10);

     rst_n = 1;

         #(`CLK_PERIOD*10);

     data_valid = 1;

     #(`CLK_PERIOD*100);

      data_valid = 0;

     #(`CLK_PERIOD*10);

     $stop;

       end

    always #(`CLK_PERIOD/2)clk = ~clk;  

    always @(posedge clk or negedge rst_n) begin

      if(!rst_n)

        din <= 8'd0;

      else if(data_valid)

        din <= {$random}%255;

      else

        din <= 8'b0;

    end

    always @(posedge clk or negedge rst_n) begin

      if(!rst_n)

        din_r <= 8'd0;

      else if(data_valid)

        din_r <= din;

      else

        din_r <= 8'b0;

    end

    Endmodule

    比较子模块仿真波形

     

    t

    t+1

    t+2

    t+3

    t+4

    t+5

    t+6

    t+7

    t+8

    t+9

    t+10

    din

    128

    42

    232

    92

    72

    77

    95

    37

    216

    184

    198

    din_r

    X

    128

    42

    232

    92

    72

    77

    95

    37

    216

    184

    dout_min

    X

    X

    42

    42

    92

    72

    72

    77

    37

    37

    184

    dout_max

    X

    X

    128

    232

    232

    92

    77

    95

    95

    216

    216

     

    当我们需要做膨胀算法时,数据取dout_max;当我们需要做腐蚀算法时,数据取dout_min。

     

    (2)一维形态学腐蚀膨胀模块设计

    我们要完成对nxn窗口的腐蚀或者膨胀首先我们要做图像行的一维腐蚀或膨胀。例如我们要做3x3窗口的腐蚀或膨胀,一维形态学腐蚀或膨胀如图所示:

     

    (3) 二维形态学腐蚀与膨胀子模块设计

     

    形态学膨胀结果演示:

    顶层源码:

    wire [15:0] rgb;

    wire hs;

    wire vs;

    wire de;

     

    wire o_hs;

    wire o_vs;

    wire o_de;

    wire [7 : 0]o_y_8b;

    wire [7 : 0]o_cb_8b;

    wire [7 : 0]o_cr_8b;

    wire [7 : 0]      dout;

     

    //assign TFT_rgb = {o_y_8b[7:3],o_y_8b[7:2],o_y_8b[7:3]};     //Y

    //assign TFT_rgb = {o_cb_8b[7:3],o_cb_8b[7:2],o_cb_8b[7:3]};  //cb

    //assign TFT_rgb = {o_cr_8b[7:3],o_cr_8b[7:2],o_cr_8b[7:3]};  //cr

     

    tft_ctrl tft_ctrl(

    .Clk9M(clk9M),//系统输入时钟9MHZ

    .Rst_n(Rst_n),//复位输入,低电平复位

    .data_in({Rd_data[7:0],Rd_data[15:8]}),//待显示数据

    .hcount(),//TFT行扫描计数器

    .vcount(),//TFT场扫描计数器

    .TFT_RGB(rgb),//TFT数据输出

    .TFT_HS(hs),//TFT行同步信号

    .TFT_VS(vs),//TFT场同步信号

    .TFT_CLK(TFT_clk),//TFT像素时钟

    .TFT_DE(de),//TFT数据使能

    .TFT_begin(tft_begin),

    .TFT_PWM(TFT_pwm)//TFT背光控制

    );

    rgb_to_ycbcr  rgb_to_ycbcr_inst(

      .clk(TFT_clk),

      .i_r_8b({rgb[15:11],3'b0}),

      .i_g_8b({rgb[10:5],2'b0}),

      .i_b_8b({rgb[4:0],3'b0}),

      

      .i_h_sync(hs),

      .i_v_sync(vs),

      .i_data_en(de),

      .o_y_8b(o_y_8b),

      .o_cb_8b(o_cb_8b),

      .o_cr_8b(o_cr_8b),

      .o_h_sync(o_hs),

      .o_v_sync(o_vs),                                                                                                  

      .o_data_en(o_de)                                                                                                

    );

    /*

    erode erode_inst(

          .clk(TFT_clk),

    .rst_n(Rst_n),

    .hs_in(o_hs),

    .vs_in(o_vs),

    .din(o_y_8b),

    .din_valid(o_de),

    .dout(dout),

    .dout_valid(TFT_de),

    .hs_out(TFT_hs),

    .vs_out(TFT_vs)

    );

    */

    dilate dilate_inst(

          .clk(TFT_clk),

    .rst_n(Rst_n),

    .hs_in(o_hs),

    .vs_in(o_vs),

    .din(o_y_8b),

    .din_valid(o_de),

    .dout(dout),

    .dout_valid(TFT_de),

    .hs_out(TFT_hs),

    .vs_out(TFT_vs)

    );

    assign TFT_rgb = {dout[7:3],dout[7:2],dout[7:3]};     //Y

    //assign TFT_rgb = {o_y_8b[7:3],o_y_8b[7:2],o_y_8b[7:3]};     //Y

     

     

     

    展开全文
  • 基于FPGA的二值图像的膨胀算法的实现1 背景知识二值图像(Binary Image)是指将图像上的每一个像素只有两种可能的取值或灰度等级状态,人们经常用黑白、B&W、单色图像表...

    基于FPGA的二值图像的膨胀算法的实现

    1 背景知识

    二值图像(Binary Image)是指将图像上的每一个像素只有两种可能的取值或灰度等级状态,人们经常用黑白、B&W、单色图像表示二值图像。二值图像是指在图像中,灰度等级只有两种,也就是说,图像中的任何像素不是0就是1,再无其他过渡的灰度值。

    二值图像经常出现在数字图像处理中作为图像掩码或者在图像分割、二值化和dithering的结果中出现。一些输入输出设备,如激光打印机、传真机、单色计算机显示器等都可以处理二值图像。

    二值图像经常使用位图格式存储。

    二值图像可以解释为二维整数格,图像变形处理领域很大程度上就是受到这个观点启发。

    膨胀与腐蚀是形态学滤波的两个基本运算,能实现多种多样的功能,主要功能如下:

    (1)消除噪声;

    (2)分割出独立的图像元素;

    (3)在图像中连接相邻的元素;

    (4)寻找图像中明显的极大值和极小值区域;

    (5)求出图像的梯度。

    膨胀数学模型:

      

    (1)

     

    图1 具有断裂文字的低分辨率样品文字(见放大的视图)

    如图1所示,a为具有断裂文字的低分辨率样品文字(见放大的视图),b为结构元,c为图b对a的膨胀。断裂线段被连接起来了。

    2 膨胀算法

    在这里我们演示黑色膨胀过程。

     

                          

     

    图2 膨胀演示

    在二值图像的膨胀算法过程中我们使用二值图像3x3图像矩阵,由图1可知,当九个格子中只要出现一个‘0’,经过膨胀算法后(x,y)点的值都会是‘0’。

    只有(x,y)点以及相邻的八个点都是‘1’f(x,y)的值才是‘1’。这样就完成了二值图像的膨胀。

    3 FPGA膨胀算法实现

     

    图3 二值图像膨胀FPGA模块架构

    图3中我们使用串口传图传入的是二值图像。

    FPGA源码:

      /*

    Module name:  binary_image_swell.v

    Description:  binary image swell.

     */

    `timescale 1ns/1ps

     

    module binary_image_swell(

           input             clk,  //pixel clk

     input             rst_n,

     

     input [15:0]      data_in,

     input             data_in_en,

     

     output  reg [15:0]    data_out,

     output            data_out_en

     );

     

    wire [15:0] line0;

    wire [15:0] line1;

    wire [15:0] line2;

     

    reg [15:0] line0_data0;

    reg [15:0] line0_data1;

    reg [15:0] line0_data2;

     

    reg [15:0] line1_data0;

    reg [15:0] line1_data1;

    reg [15:0] line1_data2;

     

    reg [15:0] line2_data0;

    reg [15:0] line2_data1;

    reg [15:0] line2_data2;

     

    reg        data_out_en0;

    reg        data_out_en1;

    reg        data_out_en2;

     

    line3x3 line3x3_inst(

            .clken(data_in_en),

         .clock(clk),

         .shiftin(data_in),

         .shiftout(),

         .taps0x(line0),

         .taps1x(line1),

         .taps2x(line2)

      );

    //----------------------------------------------------------------------------

    // Form an image matrix of three multiplied by three

    //---------------------------------------------------------------------------

    always @(posedge clk or negedge rst_n) begin

      if(!rst_n) begin

        line0_data0 <= 16'b0;

     line0_data1 <= 16'b0;

     line0_data2 <= 16'b0;

     

     line1_data0 <= 16'b0;

     line1_data1 <= 16'b0;

     line1_data2 <= 16'b0;

     

     line2_data0 <= 16'b0;

     line2_data1 <= 16'b0;

     line2_data2 <= 16'b0;

     

     data_out_en0 <= 1'b0;

     data_out_en1 <= 1'b0;

     data_out_en2 <= 1'b0;

      end

      else if(data_in_en) begin

        line0_data0 <= line0;

     line0_data1 <= line0_data0;

     line0_data2 <= line0_data1;

     

     line1_data0 <= line1;

     line1_data1 <= line1_data0;

     line1_data2 <= line1_data1;

     

     line2_data0 <= line2;

     line2_data1 <= line2_data0;

     line2_data2 <= line2_data1;

     

     data_out_en0 <= data_in_en;

     data_out_en1 <= data_out_en0;

     data_out_en2 <= data_out_en1; 

      end

    end

     

    always @(posedge clk or negedge rst_n) begin

      if(!rst_n)

        data_out <= 16'h0000;

      else if(data_out_en1)

        if((line0_data0 == 16'h0000) && (line0_data1 == 16'h0000) && (line0_data2 == 16'h0000) && (line1_data0 == 16'h0000) && (line1_data1 == 16'h0000) && (line1_data2 == 16'h0000) && (line2_data0 == 16'h0000) && (line2_data1 == 16'h0000) && (line2_data2 == 16'h0000))

          data_out <= line1_data1;

        else if((line0_data0 == 16'hffff) && (line0_data1 == 16'hffff) && (line0_data2 == 16'hffff) && (line1_data0 == 16'hffff) && (line1_data1 == 16'hffff) && (line1_data2 == 16'hffff) && (line2_data0 == 16'hffff) && (line2_data1 == 16'hffff) && (line2_data2 == 16'hffff))

          data_out <= line1_data1;

        else

          data_out <= 16'h0000; 

    end

    endmodule

     

    4实验结果

     

    图4 实验原图

     

     

    图5 实验原图显示结果图

     

    图6 膨胀后的结果图

    结果分析:

    由图5和图6来看,明显线条被加粗,膨胀算法实现。

    至此,有兴趣的同学可以使用FPGA开发板自己来实验一下下面这个过程,已达到自我的理解和贯通。

    RGB图像->sobel算子边缘检测->二值图像的腐蚀->二值图像的膨胀。

     

     

    展开全文
  • 对草绘建模曲面膨胀算法的理解

    千次阅读 2017-06-30 20:18:37
    而曲面膨胀算法就是对该多边形进行操作,其大致流程为:1)对该2D多边形进行Delaunay三角剖分;2)根据文献[18]所介绍的玄齿轴的方法确定该多边形的嵴线;3)所有的处于该嵴线上的顶点在该多边形法矢方向上抬升,...
  • Matlab 基于腐蚀和膨胀的边缘检测 文/天神 一.课题背景 形态学运算只针对二值图像二进制图像并依据数学形态学Mathermatical Morphogy集合论方法发展起来 的图像处理方法起源于岩相对岩石结构的定量描述工作在数字...
  • 图像处理——灰度化、二值化、膨胀算法、腐蚀算法以及开运算和闭运算的的C#代码实现
  • 本文基于《OpenCV-Python图像矩阵不扩充边界腐蚀膨胀函数处理算法探究》介绍算法的基础上,用Python 的矩阵操作模拟实现了OpenCV灰度图的腐蚀和膨胀的自定义函数,并在图像处理中,使用OpenCV的膨胀和腐蚀函数和...
  • 基于一维级联快速腐蚀与膨胀算法

    千次阅读 2017-04-30 23:26:34
    基于一维级联快速膨胀与腐蚀算法一:基本原理膨胀与腐蚀是图像形态学两个基本操作之一,传统的代码实现都是基于二维窗口卷积模式,对于正常的3x3窗口要八次与运算,而基于一维级联方式先X方向后Y方向只需要4次与运算...
  • 图像腐蚀、膨胀算法

    千次阅读 2016-11-21 18:47:03
    腐蚀运算的含义:每当在目标图像中找到一个与结构元素相同的子图像时,就把该子图像中与结构元素的原点位置...算法描述: 1.获得源图像每行像素的宽度 2.创建一幅大小与源图像相同,所有像素置黑的目标图像 3.为
  • 图像的腐蚀与膨胀算法原理

    万次阅读 2017-07-25 16:08:25
    结构元素 ...用结构元素B膨胀X 1.用结构元素B,扫描图像X的每一个像素点 2.如果B覆盖A的区域有一个点A为黑色对应的点B也为黑色,则该扫描点为黑色,否则为白色。
  • 下面是使用膨胀算法处理经过二值化后的图像的C#实现代码: [csharp]   view plain   copy   print ? public   bool [] getRoundPixel(Bitmap bitmap,  int  x,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,388
精华内容 555
关键字:

膨胀算法