精华内容
下载资源
问答
  • 图像处理入门C源码分析 图像腐蚀膨胀和细化
  • OpenCV图像腐蚀膨胀算法的Python模拟实现.rar
  • 基于FPGA的图像腐蚀膨胀及实现

    千次阅读 2020-04-10 10:20:38
    图像腐蚀膨胀的FPGA实现项目简述腐蚀膨胀原理图像腐蚀代码图像膨胀代码下板现象总结 项目简述 膨胀是将与物体接触的所有背景点合并到该物体中,使边界向外部扩张的过程。可以用来填补物体中的空洞。腐蚀是一种消除...

    项目简述

    膨胀是将与物体接触的所有背景点合并到该物体中,使边界向外部扩张的过程。可以用来填补物体中的空洞。腐蚀是一种消除边界点,使边界向内部收缩的过程。可以用来消除小且无意义的物体。图像的腐蚀与膨胀在图像处理中是非常常见的操作。本次项目的简述是:PC机通过千兆网发送一幅图片经过膨胀或腐蚀之后转存到DDR3中,然后经过USB3.0发送到上位机显示。

    本次实验所用到的软硬件环境如下:
    1、VIVADO2019.1软件环境
    2、Modelsim10.7c仿真环境
    3.米联客MA7035FA(100T)开发板
    4、米联客USB3.0上位机软件

    腐蚀膨胀原理

    根据演示, 背景为白色, 即为 1。 0 为图像。
    在这里插入图片描述
    在此种情况下, 可采取 9 个元素相与的操作。
    在这里插入图片描述
    在此种情况下, 可采取 9 个元素相或的操作。

    从上面我们可以看出,如果背景与图像的颜色互换,那么只需要将图像膨胀与腐蚀的与或运算相互颠倒即可。注意这种方法只适应于二值图像,膨胀和腐蚀, 都是针对于二值图像而言。

    图像腐蚀代码

    从前面图像腐蚀的原理部分,我们可以发现图像腐蚀的关键还是构建3*3的矩阵,但是我们前面图像处理的文章已经进行了讲解,所以这里不再进行赘述。因为图像的与或操作在我们8位的图像中难以实施,所以我们将与或操作变成了加操作,具体的可以观看如下代码:

    `timescale 1ns / 1ps
    // *********************************************************************************
    // Project Name : OSXXXX
    // Author       : zhangningning
    // Email        : nnzhang1996@foxmail.com
    // Website      : 
    // Module Name  : sobel.v
    // Create Time  : 2020-04-08 08:32:02
    // Editor       : sublime text3, tab size (4)
    // CopyRight(c) : All Rights Reserved
    //
    // *********************************************************************************
    // Modification History:
    // Date             By              Version                 Change Description
    // -----------------------------------------------------------------------
    // XXXX       zhangningning          1.0                        Original
    //  
    // *********************************************************************************
    
    module sobel(
        //System Interfaces
        input                   sclk            ,
        input                   rst_n           ,
        //Communication Interfaces
        input           [ 7:0]  rx_data         ,
        input                   pi_flag         ,
        output  reg     [ 7:0]  tx_data         ,
        output  reg             po_flag         
    );
     
    //========================================================================================\
    //**************Define Parameter and  Internal Signals**********************************
    //========================================================================================/
    parameter           COL_NUM     =   1024    ;
    parameter           ROW_NUM     =   768     ;
    parameter           VALUE       =   80      ;
    
    wire                [ 7:0]  mat_row1        ;
    wire                [ 7:0]  mat_row2        ;
    wire                [ 7:0]  mat_row3        ;
    wire                        mat_flag        ; 
    reg                 [ 7:0]  mat_row1_1      ;
    reg                 [ 7:0]  mat_row2_1      ;
    reg                 [ 7:0]  mat_row3_1      ;
    reg                 [ 7:0]  mat_row1_2      ;
    reg                 [ 7:0]  mat_row2_2      ;
    reg                 [ 7:0]  mat_row3_2      ;
    reg                         mat_flag_1      ; 
    reg                         mat_flag_2      ; 
    reg                         mat_flag_3      ; 
    reg                         mat_flag_4      ; 
    reg                         mat_flag_5      ; 
    reg                         mat_flag_6      ; 
    reg                         mat_flag_7      ;
         
    
    reg                         mat_row1_flag   ;
    reg                         mat_row2_flag   ;
    reg                         mat_row3_flag   ; 
    reg                         mat_row1_1_flag ;
    reg                         mat_row2_1_flag ;
    reg                         mat_row3_1_flag ;
    reg                         mat_row1_2_flag ;
    reg                         mat_row2_2_flag ;
    reg                         mat_row3_2_flag ; 
    
     
    //========================================================================================\
    //**************     Main      Code        **********************************
    //========================================================================================/
    always @(posedge sclk)
        begin
            mat_row1_1          <=          mat_row1;
            mat_row2_1          <=          mat_row2;
            mat_row3_1          <=          mat_row3;
            mat_row1_2          <=          mat_row1_1;
            mat_row2_2          <=          mat_row2_1;
            mat_row3_2          <=          mat_row3_1;
        end
        
    always @(posedge sclk)
        begin
            mat_flag_1          <=          mat_flag;      
            mat_flag_2          <=          mat_flag_1;      
            mat_flag_3          <=          mat_flag_2;      
            mat_flag_4          <=          mat_flag_3;      
            mat_flag_5          <=          mat_flag_4;      
            mat_flag_6          <=          mat_flag_5;      
            mat_flag_7          <=          mat_flag_6;      
        end
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row1_flag       <=          1'b0;
        else if(mat_row1 == 8'd255)
            mat_row1_flag       <=          1'b1;
        else
            mat_row1_flag       <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row2_flag       <=          1'b0;
        else if(mat_row2 == 8'd255)
            mat_row2_flag       <=          1'b1;
        else
            mat_row2_flag       <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row3_flag       <=          1'b0;
        else if(mat_row3 == 8'd255)
            mat_row3_flag       <=          1'b1;
        else
            mat_row3_flag       <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row1_1_flag     <=          1'b0;  
        else if(mat_row1_1 == 8'd255)
            mat_row1_1_flag     <=          1'b1;
        else
            mat_row1_1_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row2_1_flag     <=          1'b0;  
        else if(mat_row2_1 == 8'd255)
            mat_row2_1_flag     <=          1'b1;
        else
            mat_row2_1_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row3_1_flag     <=          1'b0;  
        else if(mat_row3_1 == 8'd255)
            mat_row3_1_flag     <=          1'b1;
        else
            mat_row3_1_flag     <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row1_2_flag     <=          1'b0;  
        else if(mat_row1_2 == 8'd255)
            mat_row1_2_flag     <=          1'b1;
        else
            mat_row1_2_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row2_2_flag     <=          1'b0;  
        else if(mat_row2_2 == 8'd255)
            mat_row2_2_flag     <=          1'b1;
        else
            mat_row2_2_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row3_2_flag     <=          1'b0;  
        else if(mat_row2_2 == 8'd255)
            mat_row3_2_flag     <=          1'b1;
        else
            mat_row3_2_flag     <=          1'b0;
               
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            tx_data             <=          8'd0; 
        else if(mat_row1_flag + mat_row2_flag + mat_row3_flag + mat_row1_1_flag + mat_row2_1_flag + mat_row3_1_flag + mat_row1_2_flag + mat_row2_2_flag + mat_row3_2_flag >= 'd9)
            tx_data             <=          8'd255;
        else 
            tx_data             <=          8'd0; 
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            po_flag             <=          1'b0;
        else if(mat_flag_2 == 1'b1 && mat_flag_4 == 1'b1) 
            po_flag             <=          1'b1;
        else
            po_flag             <=          1'b0;      
            
    
    mat_3x3 mat_3x3_inst(
        //System Interfaces
        .sclk                   (sclk                   ),
        .rst_n                  (rst_n                  ),
        //Communication Interfaces
        .rx_data                (rx_data                ),
        .pi_flag                (pi_flag                ),
        .mat_row1               (mat_row1               ),
        .mat_row2               (mat_row2               ),
        .mat_row3               (mat_row3               ),
        .mat_flag               (mat_flag               )
    
    );
     
    
    endmodule
    
    

    相信同学们从上面的代码,再结合原理可以学会图像的腐蚀操作。同样,这里说明一下为了文章的简洁性,我们这里不再给出整个工程的代码,知识给出了中值滤波部分的程序。具体的项目工程代码查看前面的文章***基于FPGA的图像边缘检测***,至于要把这篇论文种的sobel模块换成上面的sobel便可以完成图像的中值滤波,至于这里取名字sobel也只是因为偷懒没改模块名。

    图像膨胀代码

    图像腐蚀与膨胀的操作几乎一模一样,这里不加赘述。直接给出相应的源码。

    `timescale 1ns / 1ps
    // *********************************************************************************
    // Project Name : OSXXXX
    // Author       : zhangningning
    // Email        : nnzhang1996@foxmail.com
    // Website      : 
    // Module Name  : sobel.v
    // Create Time  : 2020-04-08 08:32:02
    // Editor       : sublime text3, tab size (4)
    // CopyRight(c) : All Rights Reserved
    //
    // *********************************************************************************
    // Modification History:
    // Date             By              Version                 Change Description
    // -----------------------------------------------------------------------
    // XXXX       zhangningning          1.0                        Original
    //  
    // *********************************************************************************
    
    module sobel(
        //System Interfaces
        input                   sclk            ,
        input                   rst_n           ,
        //Communication Interfaces
        input           [ 7:0]  rx_data         ,
        input                   pi_flag         ,
        output  reg     [ 7:0]  tx_data         ,
        output  reg             po_flag         
    );
     
    //========================================================================================\
    //**************Define Parameter and  Internal Signals**********************************
    //========================================================================================/
    parameter           COL_NUM     =   1024    ;
    parameter           ROW_NUM     =   768     ;
    parameter           VALUE       =   80      ;
    
    wire                [ 7:0]  mat_row1        ;
    wire                [ 7:0]  mat_row2        ;
    wire                [ 7:0]  mat_row3        ;
    wire                        mat_flag        ; 
    reg                 [ 7:0]  mat_row1_1      ;
    reg                 [ 7:0]  mat_row2_1      ;
    reg                 [ 7:0]  mat_row3_1      ;
    reg                 [ 7:0]  mat_row1_2      ;
    reg                 [ 7:0]  mat_row2_2      ;
    reg                 [ 7:0]  mat_row3_2      ;
    reg                         mat_flag_1      ; 
    reg                         mat_flag_2      ; 
    reg                         mat_flag_3      ; 
    reg                         mat_flag_4      ; 
    reg                         mat_flag_5      ; 
    reg                         mat_flag_6      ; 
    reg                         mat_flag_7      ;
         
    
    reg                         mat_row1_flag   ;
    reg                         mat_row2_flag   ;
    reg                         mat_row3_flag   ; 
    reg                         mat_row1_1_flag ;
    reg                         mat_row2_1_flag ;
    reg                         mat_row3_1_flag ;
    reg                         mat_row1_2_flag ;
    reg                         mat_row2_2_flag ;
    reg                         mat_row3_2_flag ; 
    
     
    //========================================================================================\
    //**************     Main      Code        **********************************
    //========================================================================================/
    always @(posedge sclk)
        begin
            mat_row1_1          <=          mat_row1;
            mat_row2_1          <=          mat_row2;
            mat_row3_1          <=          mat_row3;
            mat_row1_2          <=          mat_row1_1;
            mat_row2_2          <=          mat_row2_1;
            mat_row3_2          <=          mat_row3_1;
        end
        
    always @(posedge sclk)
        begin
            mat_flag_1          <=          mat_flag;      
            mat_flag_2          <=          mat_flag_1;      
            mat_flag_3          <=          mat_flag_2;      
            mat_flag_4          <=          mat_flag_3;      
            mat_flag_5          <=          mat_flag_4;      
            mat_flag_6          <=          mat_flag_5;      
            mat_flag_7          <=          mat_flag_6;      
        end
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row1_flag       <=          1'b0;
        else if(mat_row1 == 8'd255)
            mat_row1_flag       <=          1'b1;
        else
            mat_row1_flag       <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row2_flag       <=          1'b0;
        else if(mat_row2 == 8'd255)
            mat_row2_flag       <=          1'b1;
        else
            mat_row2_flag       <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row3_flag       <=          1'b0;
        else if(mat_row3 == 8'd255)
            mat_row3_flag       <=          1'b1;
        else
            mat_row3_flag       <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row1_1_flag     <=          1'b0;  
        else if(mat_row1_1 == 8'd255)
            mat_row1_1_flag     <=          1'b1;
        else
            mat_row1_1_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row2_1_flag     <=          1'b0;  
        else if(mat_row2_1 == 8'd255)
            mat_row2_1_flag     <=          1'b1;
        else
            mat_row2_1_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row3_1_flag     <=          1'b0;  
        else if(mat_row3_1 == 8'd255)
            mat_row3_1_flag     <=          1'b1;
        else
            mat_row3_1_flag     <=          1'b0;
              
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row1_2_flag     <=          1'b0;  
        else if(mat_row1_2 == 8'd255)
            mat_row1_2_flag     <=          1'b1;
        else
            mat_row1_2_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row2_2_flag     <=          1'b0;  
        else if(mat_row2_2 == 8'd255)
            mat_row2_2_flag     <=          1'b1;
        else
            mat_row2_2_flag     <=          1'b0;
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            mat_row3_2_flag     <=          1'b0;  
        else if(mat_row2_2 == 8'd255)
            mat_row3_2_flag     <=          1'b1;
        else
            mat_row3_2_flag     <=          1'b0;
               
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            tx_data             <=          8'd0; 
        else if(mat_row1_flag + mat_row2_flag + mat_row3_flag + mat_row1_1_flag + mat_row2_1_flag + mat_row3_1_flag + mat_row1_2_flag + mat_row2_2_flag + mat_row3_2_flag >= 'd1)
            tx_data             <=          8'd255;
        else 
            tx_data             <=          8'd0; 
    
    always @(posedge sclk or negedge rst_n)
        if(rst_n == 1'b0)
            po_flag             <=          1'b0;
        else if(mat_flag_2 == 1'b1 && mat_flag_4 == 1'b1) 
            po_flag             <=          1'b1;
        else
            po_flag             <=          1'b0;      
            
    
    mat_3x3 mat_3x3_inst(
        //System Interfaces
        .sclk                   (sclk                   ),
        .rst_n                  (rst_n                  ),
        //Communication Interfaces
        .rx_data                (rx_data                ),
        .pi_flag                (pi_flag                ),
        .mat_row1               (mat_row1               ),
        .mat_row2               (mat_row2               ),
        .mat_row3               (mat_row3               ),
        .mat_flag               (mat_flag               )
    
    );
     
    
    endmodule
    
    

    对比两种操作的代码,可以发现,我们只是将标志累加和从9换成了1。

    下板现象

    原图:
    在这里插入图片描述
    FPGA腐蚀之后的图像:
    在这里插入图片描述
    FPGA膨胀之后的图像:
    在这里插入图片描述
    从上面直观的观察可以发现我们处理的正确性。

    总结

    创作不易,认为文章有帮助的同学们可以关注、点赞、转发支持。(txt文件、图片文件在群中)对文章有什么看法或者需要更近一步交流的同学,可以加入下面的群:
    在这里插入图片描述

    展开全文
  • 数字图像处理,实现图像增强(包括线性增强,邻域平均,中值滤波等),图像变换(平移,镜像等),二值,灰度图像腐蚀膨胀,开闭等,霍夫变换检测直线,大津阈值分割等,连通域个数及面积求取等
  • 本文基于《OpenCV-Python图像矩阵不扩充边界腐蚀膨胀函数处理算法探究》介绍算法的基础上,用Python 的矩阵操作模拟实现了OpenCV灰度图的腐蚀和膨胀的自定义函数,并在图像处理中,使用OpenCV的膨胀和腐蚀函数和...

    ☞ ░ 前往老猿Python博客 https://blog.csdn.net/LaoYuanPython

    一、引言

    在《OpenCV-Python图像矩阵不扩充边界腐蚀膨胀函数处理算法探究:https://blog.csdn.net/LaoYuanPython/article/details/109283825》介绍了OpenCV图像腐蚀膨胀具体实现算法,在本节我们将用Python模拟实现OpenCV的图像腐蚀膨胀,结合相关代码,有助于大家更加清晰的理解腐蚀膨胀以及图像卷积的具体原来和算法。

    本文是老猿关于图像腐蚀与膨胀系列博文之一,也是最后一篇,该系列包括如下博文:

    1. OpenCV-Python图像处理:腐蚀和膨胀原理及erode、dilate函数介绍:https://blog.csdn.net/LaoYuanPython/article/details/109441709
    2. OpenCV-Python腐蚀膨胀函数erode、dilate使用详解:https://blog.csdn.net/LaoYu
    展开全文
  • 关于二值图像处理的c源程序,包括图像腐蚀膨胀、细化等内容。
  • 图像腐蚀 膨胀 细化的基本原理

    千次阅读 2011-09-30 13:48:32
    一、图像腐蚀 膨胀 细化的基本原理 1.图像细化的基本原理 ⑴ 图像形态学处理的概念 数字图像处理中的形态学处理是指将数字形态学作为工具从图像中提取对于表达和描绘区域形状有用处的图像分量,比如边界...
      
    

    一、图像腐蚀 膨胀 细化的基本原理

    1.图像细化的基本原理
    ⑴ 图像形态学处理的概念
    数字图像处理中的形态学处理是指将数字形态学作为工具从图像中提取对于表达和描绘区域形状有用处的图像分量,比如边界、骨架以及凸壳,还包括用于预处理或后处理的形态学过滤、细化和修剪等。图像形态学处理中我们感兴趣的主要是二值图像。
    在二值图像中,所有黑色像素的集合是图像完整的形态学描述,二值图像的各个分量是Z2的元素。假定二值图像A和形态学处理的结构元素B是定义在笛卡儿网格上的集合,网格中值为1的点是集合的元素,当结构元素的原点移到点(x,y)时,记为Sxy,为简单起见,结构元素为3x3,且全都为1,在这种限制下,决定输出结果的是逻辑运算。

    ⑵ 二值图像的逻辑运算
    逻辑运算尽管本质上很简单,但对于实现以形态学为基础额图像处理算法是一种有力的补充手段。在图像处理中用到的主要逻辑运算是:与、或和非(求补),它们可以互相组合形成其他逻辑运算。

    ⑶ 膨胀和腐蚀
    膨胀和腐蚀这两种操作是形态学处理的基础,许多形态学算法都是以这两种运算为基础的。
    ① 膨胀
    是以得到B的相对与它自身原点的映像并且由z对映像进行移位为基础的。A被B膨胀是所有位移z的集合,这样, 和A至少有一个元素是重叠的。我们可以把上式改写为:
    结构元素B可以看作一个卷积模板,区别在于膨胀是以集合运算为基础的,卷积是以算术运算为基础的,但两者的处理过程是相似的。
    ⑴ 用结构元素B,扫描图像A的每一个像素
    ⑵ 用结构元素与其覆盖的二值图像做“与”操作
    ⑶ 如果都为0,结果图像的该像素为0。否则为1

    ② 腐蚀
    对Z中的集合A和B,B对A进行腐蚀的整个过程如下:
    ⑴ 用结构元素B,扫描图像A的每一个像素
    ⑵ 用结构元素与其覆盖的二值图像做“与”操作
    ⑶ 如果都为1,结果图像的该像素为1。否则为0
    腐蚀处理的结果是使原来的二值图像减小一圈。

    ⑷ 击中(匹配)或击不中变换
    假设集合A是由3个子集X,Y和Z组成的集合,击中(匹配)的目的是要在A中找到X的位置,我们设X被包围在一个小窗口W中,与W有关的X的局部背景定义为集合的差(W-X),则X在A内能得到精确拟合位置集合是由X对A的腐蚀后由(W-X)对A的补集Ac腐蚀的交集,这个交集就是我们要找的位置,我们用集合B来表示由X和X的背景构成的集合,我们可以令B=(B1,B2),这里B1=X,B2=(W-X),则在A中对B进行匹配可以表示为:
    A⊙B
    我们称为形态学上的击中或击不中变换。

     

    ⑸ 开闭操作
    开操作是先腐蚀、后膨胀处理。

    闭操作是先膨胀、后腐蚀处理。

     

    (6) 细化
    图像细化一般作为一种图像预处理技术出现,目的是提取源图像的骨架,即是将原图像中线条宽度大于1个像素的线条细化成只有一个像素宽,形成“骨架”,形成骨架后能比较容易的分析图像,如提取图像的特征。
    细化基本思想是“层层剥夺”,即从线条边缘开始一层一层向里剥夺,直到线条剩下一个像素的为止。图像细化大大地压缩了原始图像地数据量,并保持其形状的基本拓扑结构不变,从而为文字识别中的特征抽取等应用奠定了基础。细化算法应满足以下条件:
    ① 将条形区域变成一条薄线;
    ② 薄线应位与原条形区域的中心;
    ③ 薄线应保持原图像的拓扑特性。
    细化分成串行细化和并行细化,串行细化即是一边检测满足细化条件的点,一边删除细化点;并行细化即是检测细化点的时候不进行点的删除只进行标记,而在检测完整幅图像后一次性去除要细化的点。
    常用的图像细化算法有hilditch算法,pavlidis算法和rosenfeld算法等。
    注:进行细化算法前要先对图像进行二值化,即图像中只包含“黑”和“白”两种颜色。

    具体详细的图像形态学资料参考:http://wenku.baidu.com/view/1923d18fcc22bcd126ff0ccc.html

     

    二、OpenCv形态学操作相关函数

    1、MorphologyEx         高级形态学变换

    void cvMorphologyEx( const CvArr* src, CvArr* dst, CvArr* temp,
    IplConvKernel* element, int operation, int iterations=1 );
    src
    输入图像.
    dst
    输出图像.
    temp
    临时图像,某些情况下需要
    element
    结构元素
    operation
    形态操作的类型:
    CV_MOP_OPEN - 开运算
    CV_MOP_CLOSE - 闭运算
    CV_MOP_GRADIENT - 形态梯度
    CV_MOP_TOPHAT - "顶帽"
    CV_MOP_BLACKHAT - "黑帽"
    iterations
    膨胀和腐蚀次数.
    函数 cvMorphologyEx 在膨胀和腐蚀基本操作的基础上,完成一些高级的形态变换:

    开运算
    dst=open(src,element)=dilate(erode(src,element),element)
    闭运算
    dst=close(src,element)=erode(dilate(src,element),element)
    形态梯度
    dst=morph_grad(src,element)=dilate(src,element)-erode(src,element)
    "顶帽"
    dst=tophat(src,element)=src-open(src,element)
    "黑帽"
    dst=blackhat(src,element)=close(src,element)-src
    临时图像 temp 在形态梯度以及对“顶帽”和“黑帽”操作时的 in-place 模式下需要。

    2、Dilate    使用任意结构元素膨胀图像

    void cvDilate( const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1 );
    src
    输入图像.
    dst
    输出图像.
    element
    用于膨胀的结构元素。若为 NULL, 则使用 3×3 长方形的结构元素
    iterations
    膨胀的次数
    函数 cvDilate 对输入图像使用指定的结构元进行膨胀,该结构决定每个具有最小值象素点的邻域形状:
    dst=dilate(src,element): dst(x,y)=max((x',y') in element))src(x+x',y+y')
    函数支持(in-place)模式。膨胀可以重复进行 (iterations) 次. 对彩色图像,每个彩色通道单独处理。

    3、Erode    使用任意结构元素腐蚀图像

    void cvErode( const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1 );
    src
    输入图像.
    dst
    输出图像.
    element
    用于腐蚀的结构元素。若为 NULL, 则使用 3×3 长方形的结构元素
    iterations
    腐蚀的次数
    函数 cvErode 对输入图像使用指定的结构元素进行腐蚀,该结构元素决定每个具有最小值象素点的邻域形状:
    dst=erode(src,element): dst(x,y)=min((x',y') in element))src(x+x',y+y')
    函数可能是本地操作,不需另外开辟存储空间的意思。腐蚀可以重复进行 (iterations) 次. 对彩色图像,每个彩色通道单独处理。

    注:CreateStructuringElementEx  创建结构元素;ReleaseStructuringElement 删除结构元素。

     

    三、OpenCv形态学实例代码:

    1、腐蚀、膨胀、开运算、闭运算

    内容参考:http://blog.csdn.net/gnuhpc/archive/2009/06/21/4286177.aspx

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

    数学形态运算,最常见的基本运算有七种, 

    分别为:腐蚀、膨胀、开运算、闭运算、击中、细化和粗化, 

    它们是全部形态学的基础。 

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

    #include "cv.h"  

    #include "highgui.h"  

    #include <stdlib.h>  

    #include <stdio.h>  

    IplImage *src=0;  

    IplImage *dst=0;  

    IplConvKernel *element=0;//声明一个结构元素  

    int element_shape=CV_SHAPE_RECT;//长方形形状的元素  

    int max_iters=10;  

    int open_close_pos=0;  

    int erode_dilate_pos=0;  

    void OpenClose(int pos)  

    {  

        int n=open_close_pos-max_iters;  

        int an=n>0?n:-n;  

        element = cvCreateStructuringElementEx(an*2+1,   an*2+1,an,an,element_shape,0);//创建结构元素  

         

        if (n<0)  

        {  

            cvErode(src,dst,element,1);//腐蚀图像  

            cvDilate(dst,dst,element,1);//膨胀图像  

        }  

        else 

        {         

            cvDilate(dst,dst,element,1);//膨胀图像  

            cvErode(src,dst,element,1);//腐蚀图像  

        }  

        cvReleaseStructuringElement(&element);  

        cvShowImage("Open/Close",dst);  

    }  

    void ErodeDilate(int pos)  

    {  

        int n=erode_dilate_pos-max_iters;  

        int an=n>0?n:-n;  

        element = cvCreateStructuringElementEx(an*2+1,an*2+1,an,an,element_shape,0);  

        if (n<0)  

        {  

            cvErode(src,dst,element,1);  

        }  

        else 

        {  

            cvDilate(src,dst,element,1);  

        }  

        cvReleaseStructuringElement(&element);  

        cvShowImage("Erode/Dilate",dst);  

    }  

    int main(int argc,char **argv)  

    {  

        char *filename =argc ==2?argv[1]:(char *)"lena.jpg";      

        if( (src = cvLoadImage(filename,1)) == 0 )  

            return -1;  

        dst=cvCloneImage(src);  

        cvNamedWindow("Open/Close",1);  

        cvNamedWindow("Erode/Dilate",1);  

        open_close_pos = erode_dilate_pos = max_iters;  

        cvCreateTrackbar("iterations","Open/Close",&open_close_pos,max_iters*2+1,OpenClose);  

        cvCreateTrackbar("iterations","Erode/Dilate",&erode_dilate_pos,max_iters*2+1,ErodeDilate);  

        for (;;)  

        {  

            int c;  

            OpenClose(open_close_pos);  

            ErodeDilate(erode_dilate_pos);  

            c= cvWaitKey(0);  

            if (c==27)  

            {  

                break;  

            }  

            switch(c) {  

            case 'e':  

                element_shape=CV_SHAPE_ELLIPSE;  

                break;  

            case 'r':  

                element_shape=CV_SHAPE_RECT;  

                break;  

            case '/r':  

                element_shape=(element_shape+1)%3;  

                break;  

            default:  

                break;   

            }  

        }  

        cvReleaseImage(&src);  

        cvReleaseImage(&dst);  

         

        cvDestroyWindow("Open/Close");  

        cvDestroyWindow("Erode/Dilate");  

        return 0;  

    }  

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

    腐蚀和膨胀,看上去好像是一对互逆的操作,实际上,这两种操作不具有互逆的关系。 

    开运算和闭运算正是依据腐蚀和膨胀的不可逆性,演变而来的。 

    先腐蚀后膨胀的过程就称为开运算。 

    闭运算是通过对腐蚀和膨胀的另一种不同次序的执行而得到的, 

    闭运算是先膨胀后腐蚀的过程,其功能是用来填充物体内细小空洞、连接邻近物体、平滑其边界, 

    同时不明显改变不明显改变其面积。 

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

    2、opencv实现二值图像细化

    内容参考:http://blog.csdn.net/byxdaz/archive/2010/06/02/5642669.aspx

    展开全文
  • 膨胀腐蚀属于形态学的操作, 简单来说就是基于形状的一系列图像处理操作 膨胀腐蚀是基于高亮部分(白色)操作的,膨胀是対高亮部分进行膨胀,类似“领域扩张”,腐蚀是高亮部分被腐蚀,类似“领域被蚕食” 膨胀腐蚀的应用...
    膨胀腐蚀概述:
    膨胀、腐蚀属于形态学的操作, 简单来说就是基于形状的一系列图像处理操作
    膨胀腐蚀是基于高亮部分(白色)操作的,膨胀是対高亮部分进行膨胀,类似“领域扩张”,腐蚀是高亮部分被腐蚀,类似“领域被蚕食”
    膨胀腐蚀的应用和功能:  

        消除噪声

       分割独立元素或连接相邻元素

       寻找图像中的明显极大值、极小值区域

       求图像的梯度

    其他相关:

        开运算、闭运算

       帽、黒帽

       形态学梯度  

    1)膨胀---dilate()

        膨胀就是求局部最大值的操作,从数学角度上来讲,膨胀或腐蚀就是将图像(或区域)A

    与核B进行卷积。

       核可以是任意大小和形状, 它有一个独立定义的参考点(锚点), 多数情况下,

    核是一个小的中间带参考点和实心正方形或者圆盘,可以看做是一个模板或掩码。

        膨胀是求局部最大值的操做, 核B与图形卷积,即核B覆盖的区域的像素点的最大值,

    并把这个最大值复制给参考点指定的像素,这样就会使图像中的高亮区域逐渐增长,

    如下图所示:



    函数原型



    src:输入原图像(建议为二值图)

    dst:输出图像要求和src一样的尺寸和类型

    kernel:膨胀操作的核,当为NULL,表示使用参考点位于中心的3x3的核

        一般使用getStructuringElement获得指定形状和尺寸的结构元素()


    可选以下三种形状: 矩形、交叉形、椭圆形

        ksize和anchor分别表示内核尺寸和锚点位置

    anchor:锚的位置,默认值Point(-1,-1),表示位于中心
    interations:膨胀的次数
    borderType:边界模式,一般采用默认值
    borderValue:边界值,一般采用默认值

    2)腐蚀---erode()

    腐蚀和膨胀相反,是取局部最小值,高亮区域逐渐减小,如下图所示


    函数原型:


    #include"opencv2/opencv.hpp"
    using namespace cv;
     
    void main()
    {
    	Mat src = imread("1.jpg");
    	Mat dst1, dst2;
    	Mat element = getStructuringElement(MORPH_RECT,Size(9,9));
    	dilate(src,dst1,element,Point(-1,-1),1,BORDER_CONSTANT);
    	erode(src,dst2,element,Point(-1,-1),2);
    	imshow("原图",src);
    	imshow("膨胀后图像",dst1);
    	imshow("腐蚀后图像",dst2);
    	waitKey(0);
    
    }





    展开全文
  • 函数说明 函数官方文档说明 Performs advanced morphological transformations. 使用OpenCV当中的morphologyEx函数,函数官方文档说明地址: ... 函数实现: import cv2 import numpy as np ...#读取本地图像(此处图像
  • 人民邮电出版社出版的《精通Visual C++数字图像处理典型算法及实现》第七章的源代码
  • cl;img_gray=imread('fupeng.jpg');img_erzhi=imread('erzhi_fupeng.jpg');imshow(img_gray)figure,imshow(img_erzhi)[m n]=size(img_gray);img_gray_fu=zeros(m,n);img_gray_peng=zeros(m,n);img_erzhi_fu=zeros(.....
  • 图像进行膨胀腐蚀操作,简单验证膨胀腐蚀功能
  • 原标题:Python图像处理:图像腐蚀与图像膨胀一. 基础知识图像的膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮...
  • 二值图像腐蚀膨胀操作样例

    万次阅读 多人点赞 2017-06-26 23:59:26
    目录 操作方法简要说明 腐蚀操作 结构元素原点在结构元素内部 原点在结构元素外部 二值图像膨胀操作 点在结构元素内部 原点在结构元素外部
  • 图像腐蚀膨胀

    2018-04-09 20:23:57
    图像腐蚀膨胀案例,引用c
  • [Python图像处理] 八.图像腐蚀与图像膨胀

    万次阅读 多人点赞 2018-10-31 15:11:11
    图像膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮区域或白色部分进行扩张,其运行结果图比原图的高亮区域更...
  • 本程序是中国科学技术大学谭立湘老师GPU并行计算最后大作业的实验程序。主要内容是利用CUDA全局和共享内存实现了对图像腐蚀膨胀的优化加速。可用作学习参考。
  • 主要介绍了opencv 图像腐蚀和图像膨胀的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 图像处理 腐蚀膨胀算法
  • opencv编程中的图像处理代码 图像腐蚀膨胀 平台opencv2.4.9
  • 内容索引:VC/C++源码,图形处理,图像腐蚀,图像膨胀,细化算法 基于C程序的图像腐蚀,图像膨胀,细化算法代码,较简陋那种,甚至还有些不完善,仅供参考吧。
  • 图像腐蚀和图像膨胀Matlab代码

    热门讨论 2008-12-28 22:10:16
    该代码首先实现了图像腐蚀处理和图像膨胀处理。然后,经过先腐蚀(Erosion)处理,后膨胀(Dilation)处理得到了Opening Image;又经过先膨胀(Dilation)处理,后腐蚀(Erosion)处理得到了Closing Image。 程序执行后...
  • 图像膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮区域或白色部分进行扩张,其运行结果图比原图的高亮区域更...
  • 本程序是关于图像腐蚀膨胀以获得轮廓的简短程序段
  • Qt编写的图像腐蚀膨胀,可以打开图像,选择结构元素腐蚀、膨胀,以及保存图像。
  • 图像处理 腐蚀 膨胀 细化

    千次阅读 2015-10-24 13:28:34
    图像处理 腐蚀 膨胀 细化

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,910
精华内容 4,364
关键字:

图像腐蚀膨胀