精华内容
下载资源
问答
  • 关于形态学膨胀的部分代码
  • 形态学膨胀腐蚀是为了让目标物体更好的被发现,先膨胀后腐蚀是为了消除目标中可能存在的洞或孔,先腐蚀后膨胀是为了让目标外的小白点(大概是这个意思)。具体请参考: 膨胀腐蚀解释 根据这篇文章,我复现了一遍程序...

    形态学膨胀腐蚀是为了让目标物体更好的被发现,先膨胀后腐蚀是为了消除目标中可能存在的洞或孔,先腐蚀后膨胀是为了让目标外的小白点(大概是这个意思)。具体请参考:
    膨胀腐蚀解释
    根据这篇文章,我复现了一遍程序,首先找到一张合适的图像,如图所示:
    在这里插入图片描述

    复现这篇代码首先检查下你现有版本的python中是否安装了matplotlib,如果没有安装下面程序是跑不出来的。
    安装教程
    下面是安装教程中检测matplotlib是否正确安装的代码:

    # coding=gbk    用来支持中文输入
    import matplotlib.pyplot as plt
    labels='frogs','hogs','dogs','logs'
    sizes=15,20,45,10
    colors='yellowgreen','gold','lightskyblue','lightcoral'
    explode=0,0.1,0,0#表示绘制扇形图之间的距离
    plt.pie(sizes,explode=explode,labels=labels,colors=colors,autopct='%1.1f%%',shadow=True,startangle=50)#第一个参数为:每一块的比例,第二个参数为:离开中心的距离,第三个参数为标签,第四个参数为颜色。第五个参数为:控制并图内百分比设置,1.1f%的意思是小数点前后位数,第6个参数:是否在饼图下画阴影,一般为不设置阴影,这个设置了阴影,迪个参数是:绘制起始角度,一般从x轴正方向开始逆时针画,90的话是从y轴正方向开始。
    plt.axis('equal')#用来生成坐标轴,equal的意思是---xy轴坐标等长
    plt.show()
    

    下面通过对这张图片的各种操作去理解膨胀腐蚀原理。其中插值法我不是太清楚。为什么要进行图像拆分我也不清楚。
    灰度图二值化中参数的解释以及算法的选择
    具体链接在这里,经过红色阈值后的图像如图所示,白色曲线变得不是很顺滑,
    在这里插入图片描述
    接下来是经过腐蚀后的图像:
    在这里插入图片描述

    白色曲线更加细,也就是说,黑色腐蚀了白色,暗色部分占用更多的白色部分
    膨胀之后的图像:
    在这里插入图片描述
    可以发现,膨胀之后白色区域也就是白色曲线变得更加粗,膨胀也就是将亮色部分占用更多的暗色部分。
    所以膨胀腐蚀只是对目标进行了‘细化’或者‘粗化’,其他的并没有改变。如果联合起来使用应该有不一样的效果。
    代码如下:

    import cv2
    import numpy as np
    original_img = cv2.imread('shitou.jpg ')
    res = cv2.resize(original_img,None,fx= 0.5,fy= 0.5,
                     interpolation = cv2.INTER_CUBIC) #图形太大,宽和高都缩小了一半。第一个是原始图像,第二个是目标图像,第三和第四是长和宽缩小多少倍,第五是图像插入方法
    B, G, R = cv2.split(res)                    #获取红色通道
    img = R
    _,RedThresh = cv2.threshold(img,160,255,cv2.THRESH_BINARY)#将灰度图二值化,阈值最大为255,用到的算法是超过一定阈值就是白,小于这一阈值就是黑
    #OpenCV定义的结构矩形元素
    kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(3, 3))#第一个参数表示内核的形状,第二个参数是锚点位置
    eroded = cv2.erode(RedThresh,kernel)        #腐蚀图像
    dilated = cv2.dilate(RedThresh,kernel)      #膨胀图像
    
    cv2.imshow("original_img", res)             #原图像
    #cv2.imshow("R_channel_img", img)            #红色通道图
    cv2.imshow("RedThresh", RedThresh)          #红色阈值图像
    cv2.imshow("Eroded Image",eroded)           #显示腐蚀后的图像
    cv2.imshow("Dilated Image",dilated)         #显示膨胀后的图像
    
    #NumPy定义的结构元素
    #NpKernel = np.uint8(np.ones((3,3)))#用于存储各种图像的,与ff相与,,,这句是干嘛用的
    #Nperoded = cv2.erode(RedThresh,NpKernel)       #腐蚀图像
    #cv2.imshow("Eroded by NumPy kernel",Nperoded)  #显示腐蚀后的图像
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    

    接下来要对图像进行开闭运算的操作,首先明白,开运算和闭运算分别表示对图像进行什么操作
    闭运算:先膨胀后腐蚀,连接被分割成小块的图像。
    开运算:先腐蚀后膨胀,去除图像噪音形成的斑点。
    先进行一次闭运算:
    在这里插入图片描述
    进行两次闭运算后:
    在这里插入图片描述
    同时内插的值越大,得到的图像越粘连如图:
    在这里插入图片描述
    接着进行开运算,通过对图像的腐蚀,发现:
    在这里插入图片描述
    已经消除了图像外的小斑点,close1和open1并没有接连着对图片进行处理,只是说明了两个的效果。
    接下来是对图像进行骨架的描绘:
    在这里插入图片描述
    再来个其他图片进行梯度算法:
    在这里插入图片描述
    接下来进行边角的检测,现在还不清楚边角检测和梯度检测的区别。
    在这里插入图片描述
    将黑白颠倒之后:
    在这里插入图片描述
    梯度运算是对图像进行开闭运算,而边角检测对图像进行膨胀腐蚀运算。
    复现基本完成。
    通过复现这些程序,我大概清楚了检测图像大概要进行哪些操作,首先把图像灰度化,接着进行结构改造,然后根据需要对图像进行膨胀腐蚀操作,或者开闭运算操作,最后显示想要的图像。中间的具体算法可见备注,但是用的话还得接着查。代码如下:

    import cv2
    import numpy
    
    image = cv2.imread("ron.jpg ",cv2.IMREAD_GRAYSCALE)#读入的图片为灰色
    
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3, 3))
    dilate_img = cv2.dilate(image, kernel)#膨胀
    erode_img = cv2.erode(image, kernel)#腐蚀
    
    """
    我选了一张较好的图片,有的图片要去噪(高斯模糊)
    将两幅图像相减获得边;cv2.absdiff参数:(膨胀后的图像,腐蚀后的图像)
    上面得到的结果是灰度图,将其二值化以便观察结果
    反色,对二值图每个像素取反
    """
    absdiff_img = cv2.absdiff(dilate_img,erode_img)#获取差分图
    retval, threshold_img = cv2.threshold(absdiff_img, 40, 255, cv2.THRESH_BINARY)#对图像进行二值化,阈值,高于阈值时赋予的新值,操作方式是二值化即非黑即白
    result = cv2.bitwise_not(threshold_img)#将上图的图片按位反向,就是黑白颠倒过来
    
    cv2.imshow("ron",image)
    #cv2.imshow("dilate_img",dilate_img)
    #cv2.imshow("erode_img",erode_img)
    #cv2.imshow("absdiff_img",absdiff_img)
    #cv2.imshow("threshold_img",threshold_img)
    cv2.imshow("result",result)
    
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    

    接着是关于开闭运算和梯度的代码:

    #coding=utf-8
    
    """
    腐蚀
    cv2.erode(src,                     # 输入图像
    	  kernel,                  # 卷积核
    	  dst=None,
    	  anchor=None,
    	  iterations=None,         # 迭代次数,默认1
    	  borderType=None,
    	  borderValue=None)
    
    膨胀
    cv2.dilate(src,                    # 输入图像
               kernel,                 # 卷积核
               dst=None,
               anchor=None,
               iterations=None,        # 迭代次数,默认1
               borderType=None,
               borderValue=None)
    """
    
    """
    cv2.morphologyEx(src,      # 输入图片
                     op,       # 需要处理类型的函数:(cv2.MORPH_OPEN,cv2.MORPH_CLOSE,cv2.MORPH_GRADIENT)
                     kernel,   # 卷积核大小
                     dst=None, 
                     anchor=None, 
                     iterations=None,     #迭代次数,默认1次
                     borderType=None, 
                     borderValue=None)
    """
    import cv2
    import numpy as np
    original_img = cv2.imread('ron.jpg  ',0)
    gray_res = cv2.resize(original_img,None,fx=0.5,fy=0.5,
                     interpolation = cv2.INTER_CUBIC)                #图形太大了缩小一点,INTER_CUBIC的意思是双三次内插
    # B, G, img = cv2.split(res)
    # _,RedThresh = cv2.threshold(img,160,255,cv2.THRESH_BINARY)     #设定红色通道阈值160(阈值影响开闭运算效果)
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))         #定义矩形结构元素,主要是为了检测边缘
    #closed1 = cv2.morphologyEx(gray_res, cv2.MORPH_CLOSE, kernel,iterations=1)    #闭运算1,先膨胀后腐蚀,连接被分割成小块的对象
    #closed2 = cv2.morphologyEx(gray_res, cv2.MORPH_CLOSE, kernel,iterations=3)    #闭运算2
    #opened1 = cv2.morphologyEx(gray_res, cv2.MORPH_OPEN, kernel,iterations=1)     #开运算1,先腐蚀后膨胀,用于移除由图像噪音形成的斑点。
    #opened2 = cv2.morphologyEx(gray_res, cv2.MORPH_OPEN, kernel,iterations=3)     #开运算2
    gradient = cv2.morphologyEx(gray_res, cv2.MORPH_GRADIENT, kernel)             #梯度,要传入的图像,要进行改变的方式,方框的大小。
    
    #显示如下腐蚀后的图像
    cv2.imshow("gray_res", gray_res)
    #cv2.imshow("Close1",closed1)
    #cv2.imshow("Close2",closed2)
    #cv2.imshow("Open1", opened1)
    #cv2.imshow("Open2", opened2)
    cv2.imshow("gradient", gradient)
    
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    

    复现的代码来源于:OpenCV—python 形态学处理(腐蚀、膨胀、开闭运算、边缘检测)

    展开全文
  • 基于彩色和形态学膨胀的车牌定位基于彩色和形态学膨胀的车牌定位
  • 使用两种大小尺寸的形态学膨胀算子优化带内重要系数编码,并对两种膨胀方式采用不同的算术编码模型,克服了传统单一算子不能平衡膨胀速度和膨胀质量的不足。使用差分缩减方式对各小波系数聚类簇的起始位置和稀疏系数...
  • 4形态学膨胀之连通域提取

    千次阅读 2018-04-04 23:53:19
    4形态学膨胀之连通域提取 提取连通域实际上是标记连通域的过程,其算法如下: 初始点:Bo=某个连通分量中的某点(这里通过遍历图像,知道像素值为255,将此点作为种子点) 循环: (用3X3d的结构元素对种子点...

    4形态学膨胀之连通域提取

    提取连通域实际上是标记连通域的过程,其算法如下:
    这里写图片描述
    初始点:Bo=某个连通分量中的某点(这里通过遍历图像,知道像素值为255,将此点作为种子点)

    循环:

    (用3X3d的结构元素对种子点进行膨胀,然后用原图像对膨胀结果取交集)

    结束条件:知道膨胀的图像不发生变化

    在这里可以用一个模板来存储连通分量,其位置对应原图像的位置。提取完后可以修改原图像的像素值,即一个标签。

    实现过程如下:

    #include<iostream>  
    #include<opencv2\opencv.hpp>  
    using namespace std;  
    using namespace cv;  
    
    /******************************************* 
    功能:标注连通分量 
    参数:src-输入图像 
          nConn-取值4、8,表示4连通或8连通 
    ********************************************/  
    void LabelConnRgn(Mat& src, int nConn)  
    {  
        int se[3][3] = { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } };//8连通  
        if (nConn == 4)  
        {  
            se[0][0] = -1;  
            se[0][2] = -1;  
            se[2][0] = -1;  
            se[2][2] = -1;  
        }  
        int nConnRgn = 254;//连通分量的标记号  
        Mat dst = Mat::zeros(src.size(), src.type());  
        for (int i = 0; i < src.rows; i++)  
        {  
    
            uchar* srcData = src.ptr<uchar>(i);  
            uchar* dstData = dst.ptr<uchar>(i);  
            for (int j = 0; j < src.cols; j++)  
            {  
                if (srcData[j] == 255)  
                {   
                    dstData[j] = 255;  
                    while (true)  
                    {  
                        Mat temp;  
                        dst.copyTo(temp);  
                        dilate(dst, dst, se);  
                        dst= dst&src;  
                        //如果和上一次处理后的图像相同,说明连通区域已经提取完毕  
                        if (equalImg(dst, temp))  
                        {  
                            break;  
                        }  
                    }  
                    //标注刚刚找到的连通区域  
                    for (int k = 0; k < src.rows; k++)  
                    {  
                        uchar* srcData = src.ptr<uchar>(k);  
                        uchar* dstData = dst.ptr<uchar>(k);  
                        for (int l = 0; l < src.cols; l++)  
                        {  
                            if (dstData[l] == 255)  
                            {  
                                //标记原图像上的连通区域  
                                srcData[l] = nConnRgn;  
                            }  
                        }  
                    }  
                    nConnRgn-=50;//连通区域编号加1(此处为了显示的方便实际为:nConnRgn--;)  
                    if (nConnRgn <=0)  
                    {  
                        cout << "连通区域大于254个连通区域" << endl;  
                        i = src.rows;//强制跳出外循环  
                        break;  
                    }  
                }  
            }  
        }  
    }  
    
    int main()  
    {  
        Mat src= imread("test1.jpg", 0);  
        imshow("原始图像", src);  
        LabelConnRgn(src, 4);  
        imshow("连通区域",src);  
        waitKey(0);  
        return 0;  
    }  

    原图像:

    这里写图片描述

    目标图像:

    这里写图片描述

    展开全文
  • 形态学膨胀源代码

    2013-05-27 21:11:32
    形态学分析图像处理代码,实现二值图像和灰度图像的膨胀操作。
  • 基于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

     

     

     

    展开全文
  • OpenCV 形态学膨胀

    2020-01-16 19:41:59
    膨胀(dilate)是求局部最大值的操作。从数学角度讲,膨胀或腐蚀操作就是将图像(或图像的一部分区域,称之为A)与核(称之为B)进行卷积。 核可以是任何形状和大小,它拥有一个单独定义出来的参考点,我们称其为...

    1、基本概念
    膨胀(dilate)是求局部最大值的操作。从数学角度讲,膨胀或腐蚀操作就是将图像(或图像的一部分区域,称之为A)与核(称之为B)进行卷积。
    核可以是任何形状和大小,它拥有一个单独定义出来的参考点,我们称其为锚点(anchorpoint)。多数情况下,核是一个小的,中间带有参考点和实心正方形或者圆盘。其实可以将核看作模板或者掩码。
    膨胀操作就是求局部最大值的操作。核B与图形卷积,即计算核B覆盖的区域的像素点的最大值,并把这个最大值赋值给参考点指定的像素。这样就会使图像中的高亮区域逐渐增长,如图所示,这就是膨胀操作的初衷。
    在这里插入图片描述
    膨胀的数学表达式如下:
    在这里插入图片描述

    2、API函数讲解

    C++:void dilate(InputArray src,OutputArray dst,InputArray kernel,
    				Point anchor=Point(-1-1),int iterations=1,int borderType=BORDER_CONSTANT,
    				const Scalar& borderValue=morphologyDefaultBorderValue());
    参数1:输入图像
    参数2:目标图像,和原图像有相同的尺寸和类型
    参数3:膨胀操作核。当为NULL时,表示使用参考点位于中心3*3的核
    	我们一般使用函数getStructuringElement配合这个参数使用。getStructuringElement函数会返回指定形状和尺寸的结构原始(内核矩阵)。其中getStructuringElement函数的第一个参数表示内核的形状,有如下三种形状可以选择(MORPH_RECT:矩形		MORPH_CROSS:交叉形		MORPH_ELLIPSE:椭圆形)
    	而getStructuringElement函数的第二和第三个参数分别是内核的尺寸以及锚点的位置。一般在调研erode或dilate函数之前,先定义一个Mat类型的变量来获得getStructuringElement函数的返回值。
    
    参数4:锚点的位置,有默认值(-1-1),表示锚点位于中心。
    参数5:迭代使用erode()函数的次数,默认值为1.
    参数6:用于推断图像外部像素的某种边界模式。
    参数7:当边界为常数是的边界值,有默认值morphologyDefaultBorderValue(),一般不去管它。需要用到它时,可以查看官方文档。
    

    3、案例

    void dilateFun()
    {
    	Mat src = imread("img.jpg");
    
    	namedWindow("原图", 0);
    	imshow("原图", src);
    
    	//获取自定义核
    	Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));
    	Mat dst;
    
    	//进行膨胀操作
    	dilate(src, dst, element);
    
    	namedWindow("膨胀", 0);
    	imshow("膨胀", dst);
    }
    

    在这里插入图片描述

    展开全文
  • 形态学膨胀初步

    2017-01-11 13:52:00
    “A被B膨胀是所有结构元素原点位置组成的集合,其中映射并平移后的B至少与A的某些部分重叠”[Conzalez] (1)、设图像数据为a: a为一幅二值图像,1对应图像中心的亮区域。 结构元素为b: 执行膨胀:imdilate(a,b)...
  • 使用两种大小尺寸的形态学膨胀算子优化带内重要系数编码,并对两种膨胀方式采用不同的算术编码模型,克服了传统单一算子不能平衡膨胀速度和膨胀质量的不足.使用差分缩减方式对各小波系数聚类簇的起始 位置和稀疏...
  • *开运算:先对区域进行腐蚀操作,然后再进行膨胀操作 *开运算特点:防止腐蚀过度,能够很好的保持区域的形状 Opening_circle() Opening_rectangle1() *闭运算:先对区域进行膨胀操作,然后再进行腐蚀操作 *闭运算...
  • 图像处理一:形态学膨胀和腐蚀

    千次阅读 2018-12-03 20:08:10
    一、形态学概述  形态学(morphology)一词通常表示生物学的一个分支,该分支主要研究动植物的形态和结构,而图像处理中的形态学主要是指数学形态学。  数学形态学(Mathematical morphology)是一门建立在格论...
  • 与二值图像有些差异。 示例: (1)灰度膨胀 >> t=rand(7,8); >> t=ceil(t.*256)%t为灰度图像 t = 209125191916824615814 23220510111342141122136 3337168...
  • 这一讲我们介绍基于基于python的skimage包的形态学操作,主要介绍最常见的几个形态学操作,就是图像的膨胀腐蚀和开闭运算,主要利用skimage.morphology 膨胀和腐蚀很直观,膨胀就是让一个区域变大,腐蚀就是让一个...
  • 小白自己了图像处理之后,在visualstudio 2017上,配合OpenCV写了一段膨胀与腐蚀的代码,但是没有调用OpenCV的核心函数,想练练手罢了。
  • 数学形态学诞生于1964年,膨胀是在图像中目标结界周围增添图像,结构元素。 腐蚀:移除图像中目标边界的像素,结构元素B对集合A的腐蚀。 开运算与闭运算 matlab code: clc; clear all; close all; %灰度膨胀、腐蚀...
  • namedWindow("【原图】膨胀操作"); namedWindow("【效果图】膨胀操作"); //显示原图 imshow("【原图】膨胀操作", image); //获取自定义核 Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));...
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、...
  • 1.膨胀:对边界点进行扩充,填充空洞,使边界向外部扩张的过程。 2. 腐蚀:消除物体边界点,使边界向内部收缩的过程,把小于结构元素的物体去除掉。 3. 开运算:先腐蚀后膨胀的过程称为开运算,作用:去除孤立的小点,...

空空如也

空空如也

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

形态学膨胀