• 腐蚀原理: 二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去腐蚀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取...

    腐蚀的原理:

    二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去腐蚀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有像素的最小值,用这个最小值替换当前像素值。由于二值图像最小值就是0,所以就是用0替换,即变成了黑色背景。从而也可以看出,如果当前结构元素覆盖下,全部都是背景,那么就不会对原图做出改动,因为都是0.如果全部都是前景像素,也不会对原图做出改动,因为都是1.只有结构元素位于前景物体边缘的时候,它覆盖的区域内才会出现0和1两种不同的像素值,这个时候把当前像素替换成0就有变化了。因此腐蚀看起来的效果就是让前景物体缩小了一圈一样。对于前景物体中一些细小的连接处,如果结构元素大小相等,这些连接处就会被断开。

    膨胀的原理:

    二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去膨胀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有像素的最大值,用这个最大值替换当前像素值。由于二值图像最大值就是1,所以就是用1替换,即变成了白色前景物体。从而也可以看出,如果当前结构元素覆盖下,全部都是背景,那么就不会对原图做出改动,因为都是0.如果全部都是前景像素,也不会对原图做出改动,因为都是1.只有结构元素位于前景物体边缘的时候,它覆盖的区域内才会出现0和1两种不同的像素值,这个时候把当前像素替换成1就有变化了。因此膨胀看起来的效果就是让前景物体胀大了一圈一样。对于前景物体中一些细小的断裂处,如果结构元素大小相等,这些断裂的地方就会被连接起来。

    下篇文章附上底层源码
    原文:https://blog.csdn.net/woainishifu/article/details/60778033

    展开全文
  • 结构元素:设两幅图像X、B,若X是被处理对象,B是用来处理X的,那么则把B称为结构元素。 腐蚀:用结构元素B腐蚀X,过程如下: 1.用结构元素B扫描图像X的所有像素点(以B的原点为坐标,对应A的各个像素点进行扫描),...

    结构元素:设两幅图像X、B,若X是被处理对象,B是用来处理X的,那么则把B称为结构元素。

    腐蚀:用结构元素B腐蚀X,过程如下:

    1.用结构元素B扫描图像X的所有像素点(以B的原点为坐标,对应A的各个像素点进行扫描),用结构元素B与X覆盖的二值X图像做 “与”操作(也就是B覆盖X的这一区域每个相对应的点做与操作)。

    2.如果结构元素B为黑色的点,图像A相对应的点都为黑色,则该点的像素为黑色,否则为白色。

    腐蚀的结果使得原来的图像缩小一圈

    图像腐蚀示例:X为原图像,B为结构元素

    B腐蚀A的结果如下所示

    以上过程大致是使用B扫描X的每一个像素点,如果B覆盖A的区域相对应的黑色像素点都为黑色,则该扫描点为黑色,否则为白色。


    膨胀:用结构元素B膨胀X

    1.用结构元素B,扫描图像X的每一个像素点

    2.如果B覆盖A的区域有一个点A为黑色对应的点B也为黑色,则该扫描点为黑色,否则为白色。




    展开全文
  •  数字图像处理中的形态学处理是指将数字形态学作为工具从图像中提取对于表达描绘区域形状有用处的图像分量,比如边界、骨架以及凸壳,还包括用于预处理或后处理的形态学过滤、细化修剪等。图像形态学处理中我们...

    图像的腐蚀与膨胀

    一、原理:

    ⑴ 图像形态学处理的概念
            数字图像处理中的形态学处理是指将数字形态学作为工具从图像中提取对于表达和描绘区域形状有用处的图像分量,比如边界、骨架以及凸壳,还包括用于预处理或后处理的形态学过滤、细化和修剪等。图像形态学处理中我们感兴趣的主要是二值图像。

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

    ⑶ 膨胀和腐蚀

            膨胀和腐蚀这两种操作是形态学处理的基础,许多形态学算法都是以这两种运算为基础的。

    定义结构元素B为:

    1 1
    1 0
    图像元素与结构元素相乘,从而求得右下角元素值
    (i-1,j+1) (i,j+1)
    (i-1,j) 所求此点(i,j)

    ① 膨胀
    ⑴ 用结构元素B,扫描图像A的每一个像素
    ⑵ 用结构元素与其覆盖的二值图像做“或”操作
    ⑶ 如果有一个元素为0,结果图像的该像素为0。否则为255

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

    腐蚀处理的结果是使原来的二值图像减小一圈。

    二、我再加一个轮廓提取,非常简单的方法:用的是9X9的模板;

    (i-1,j+1) (i,j+1) (i+1,j+1)
    (i-1,j) 所求此点(i,j) (i+1,j)
    (i-1,j-1) (i,j-1) (i+1,j_1)
    三、代码

    #include<opencv2/opencv.hpp>
    #include<iostream>
    using  namespace cv;
    using namespace std;
    
    Mat srcImage, grayImage, binarygray, erosion, dilation, outline;
    
    
    static void g_erosion(int, void*);
    static void g_dilation(int, void*);
    static void g_outline(int, void*);
    static void ShowHelpText();
    
    int main()
    {
    	system("color 3f");
    	ShowHelpText();
    
    	srcImage = imread("D://vvoo//cell.jpg");
    	cvtColor(srcImage, grayImage, CV_RGB2GRAY);
    
    	int threshold;
    	cout << "input threshold: " << endl;
    	cin >> threshold;
    
    	//二值化
    	binarygray = Mat::zeros(grayImage.rows, grayImage.cols, grayImage.type());
    	{
    		for (int i = 0; i <grayImage.rows; i++)
    		{
    			for (int j = 0; j < grayImage.cols; j++)
    			{
    				if (grayImage.data[i*grayImage.step + j] > threshold)
    				{
    					binarygray.data[i*binarygray.step + j] = 255;
    				}
    				else
    				{
    					binarygray.data[i*binarygray.step + j] = 0;
    				}
    			}
    		}
    	}
    	//腐蚀
    	g_erosion(0, 0);
    	//膨胀
    	g_dilation(0, 0);
    	//轮廓提取
    	g_outline(0, 0);
    
    	imshow("原图", srcImage);
    	imshow("binarygray", binarygray);
    
    	waitKey(0);
    	return 0;
    }
    static void g_erosion(int, void*)
    {
    	erosion = Mat::zeros(binarygray.rows, binarygray.cols, binarygray.type());
    	{
    		for (int i = 1; i < binarygray.rows; i++)
    		{
    			for (int j = 1; j < binarygray.cols; j++)
    			{
    				if (binarygray.data[(i - 1)*binarygray.step + j] + binarygray.data[(i - 1)*binarygray.step + j + 1] + binarygray.data[i*binarygray.step + j + 1] == 0)
    				{
    					erosion.data[i*erosion.step + j] = 0;
    				}
    				else
    				{
    					erosion.data[i*erosion.step + j] = 255;
    				}
    			}
    
    		}
    
    	}
    	imshow("erosion_1", erosion);
    }
    static void g_dilation(int, void*)
    {
    	dilation = Mat::zeros(binarygray.rows, binarygray.cols, binarygray.type());
    
    	for (int i = 1; i < binarygray.rows; i++)
    	{
    		for (int j = 1; j < binarygray.cols; j++)
    		{
    			if (binarygray.data[(i - 1)*binarygray.step + j] == 0 || binarygray.data[(i - 1)*binarygray.step + j - 1] == 0 || binarygray.data[i*binarygray.step + j + 1] == 0)
    			{
    				dilation.data[i*dilation.step + j] = 0;
    			}
    			else
    			{
    				dilation.data[i*dilation.step + j] = 255;
    			}
    		}
    
    	}
    
    	imshow("dilation_1", dilation);
    }
    static void g_outline(int, void*)
    {
    	outline = Mat::zeros(binarygray.rows, binarygray.cols, binarygray.type());
    
    	for (int i = 1; i < binarygray.rows; i++)
    	{
    		for (int j = 1; j < binarygray.cols; j++)
    		{
    			if (binarygray.data[i*binarygray.step + j + 1] + binarygray.data[(i - 1)*binarygray.step + j]
    				+ binarygray.data[i*binarygray.step + j - 1] + binarygray.data[(i - 1)*binarygray.step + j - 1]
    				+ binarygray.data[(i + 1)*binarygray.step + j - 1] + binarygray.data[(i + 1)*binarygray.step + j]
    				+ binarygray.data[(i - 1)*binarygray.step + j + 1] + binarygray.data[(i + 1)*binarygray.step + j + 1] == 2040)
    			{
    				outline.data[i*erosion.step + j] = 255;
    			}
    			if (binarygray.data[i*binarygray.step + j + 1] + binarygray.data[(i - 1)*binarygray.step + j]
    				+ binarygray.data[i*binarygray.step + j - 1] + binarygray.data[(i - 1)*binarygray.step + j - 1]
    				+ binarygray.data[(i + 1)*binarygray.step + j - 1] + binarygray.data[(i + 1)*binarygray.step + j]
    				+ binarygray.data[(i - 1)*binarygray.step + j + 1] + binarygray.data[(i + 1)*binarygray.step + j + 1] == 0)
    			{
    				outline.data[i*erosion.step + j] = 255;
    			}
    		}
    
    
    	}
    	imshow("outline", outline);
    }
    static void ShowHelpText()
    {
    	cout << "\n\n本程序涉及到:"<<"腐蚀(erosion)、膨胀(dilation)、轮廓提取(outline)。\n\n" << endl;
    }
    四、运行结果




    五、调用Opencv的erode()函数和dilate()函数实现腐蚀和膨胀功能

    1)erode函数,使用像素邻域内的局部极小运算符来腐蚀一张图片,从src输入,由dst输出。支持就地(in-place)操作。

    看一下函数原型:

     void erode(
      InputArray src,
      OutputArray dst,
      InputArray kernel,
      Point anchor=Point(-1,-1),
      int iterations=1,
      int borderType=BORDER_CONSTANT,
      const Scalar& borderValue=morphologyDefaultBorderValue()
     );

    参数原型

    • 第一个参数,InputArray类型的src,输入图像,即源图像,填Mat类的对象即可。图像通道的数量可以是任意的,但图像深度应为CV_8U,CV_16U,CV_16S,CV_32F或 CV_64F其中之一。
    • 第二个参数,OutputArray类型的dst,即目标图像,需要和源图片有一样的尺寸和类型。
    • 第三个参数,InputArray类型的kernel,腐蚀操作的内核。若为NULL时,表示的是使用参考点位于中心3x3的核。我们一般使用函数 getStructuringElement配合这个参数的使用。getStructuringElement函数会返回指定形状和尺寸的结构元素(内核矩阵)。(具体看上文中浅出部分dilate函数的第三个参数讲解部分)
    • 第四个参数,Point类型的anchor,锚的位置,其有默认值(-1,-1),表示锚位于单位(element)的中心,我们一般不用管它。
    • 第五个参数,int类型的iterations,迭代使用erode()函数的次数,默认值为1。
    • 第六个参数,int类型的borderType,用于推断图像外部像素的某种边界模式。注意它有默认值BORDER_DEFAULT。
    • 第七个参数,const Scalar&类型的borderValue,当边界为常数时的边界值,有默认值morphologyDefaultBorderValue(),一般我们不用去管他。需要用到它时,可以看官方文档中的createMorphologyFilter()函数得到更详细的解释。

    同样的,使用erode函数,一般我们只需要填前面的三个参数,后面的四个参数都有默认值。而且往往结合getStructuringElement一起使用。

    2)dilate函数原型

    函数原型:

    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() 
    );

    参数详解:

    • 第一个参数,InputArray类型的src,输入图像,即源图像,填Mat类的对象即可。图像通道的数量可以是任意的,但图像深度应为CV_8U,CV_16U,CV_16S,CV_32F或 CV_64F其中之一。
    • 第二个参数,OutputArray类型的dst,即目标图像,需要和源图片有一样的尺寸和类型。
    • 第三个参数,InputArray类型的kernel,膨胀操作的核。若为NULL时,表示的是使用参考点位于中心3x3的核。

    我们一般使用函数 getStructuringElement配合这个参数的使用。getStructuringElement函数会返回指定形状和尺寸的结构元素(内核矩阵。其中,getStructuringElement函数的第一个参数表示内核的形状,我们可以选择如下三种形状之一:

    矩形: MORPH_RECT

      • 交叉形: MORPH_CROSS
      • 椭圆形: MORPH_ELLIPSE

    而getStructuringElement函数的第二和第三个参数分别是内核的尺寸以及锚点的位置。

    3)代码实现

    #include<opencv2/opencv.hpp>
    #include<iostream>
    using  namespace cv;
    using namespace std;
    
    #define WINDOWN_NAME_1 "原图"
    #define WINDOWN_NAME_2 "腐蚀图"
    #define WINDOWN_NAME_3 "膨胀图"
    
    int main()
    {
    	Mat srcImage = imread("D://vvoo//cell.jpg");
    
    	//获取自定义核
    	Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));
    	Mat out_erosion, out_dilate;
    
    	//进行膨胀操作
    	erode(srcImage, out_erosion, element);
    	dilate(srcImage, out_dilate, element);
    
    	imshow(WINDOWN_NAME_1, srcImage);
    	imshow(WINDOWN_NAME_2, out_erosion);
    	imshow(WINDOWN_NAME_3, out_dilate);
    
    	waitKey(0);
    	return 0;
    
    }

    4)运行结果



    和自己写的比较下比较一下,差别比较大,主要是因为结构元素大小的关系,我的是2*2,Opencv是15*15的。

    我也是初学者,欢迎纠正!



    六、参考资料

    1.system("color 3f");//输出窗口和字体颜色可变化,3代表窗口颜色(绿色),f代表窗口里字体颜色(白色)

    全部颜色为:


    2.图像腐蚀、膨胀、细化基本原理

    3. 形态学图像处理(一): 膨胀与腐蚀

    展开全文
  • 腐蚀膨胀基本原理:就是用一个特定的结构元素来与待处理图像按像素做逻辑操作;可以理解成拿一个带孔的网格板(结构元素矩阵中元素为1的为孔)盖住图像的某一部分,然后按照各种不同的观察方式来确定操作类型。 ...

    背景知识

    结构元素:二维结构元素可以理解成一个二维矩阵,矩阵元素的值为0或者1;通常结构元素要小于待处理的图像。

    腐蚀与膨胀基本原理:就是用一个特定的结构元素来与待处理图像按像素做逻辑操作;可以理解成拿一个带孔的网格板(结构元素矩阵中元素为1的为孔)盖住图像的某一部分,然后按照各种不同的观察方式来确定操作类型。

    比如:腐蚀操作就是拿这个结构元素的中心位置(假设参与逻辑计算的元素对应与二维矩阵中元素为1的点,即网格板上的孔),在图像上移动时,如果透过所有的孔都能看到底下的图像,那么这个中心点处的图像就保留,否则去除。

    腐蚀

           把结构元素B平移a后得到Ba,若Ba包含于X,我们记下这个a点,所有满足上述条件的a点组成的集合称做X被B腐蚀(Erosion)的结果。用公式表示为:E(X)={a| Ba∈X}=XB。原理图如下:


           实际使用时示意图:


          说明:左边是被处理的图象X(二值图象,我们针对的是黑点),中间是结构元素B,那个标有origin的点是中心点,即当前处理元素的位置,我们在介绍模板操作时也有过类似的概念。腐蚀的方法是,拿B的中心点和X上的点一个一个地对比,如果B上的所有点都在X的范围内,则该点保留,否则将该点去掉;右边是腐蚀后的结果。可以看出,它仍在原来X的范围内,且比X包含的点要少,就象X被腐蚀掉了一层。


    膨胀

              膨胀(dilation)可以看做是腐蚀的对偶运算,其定义是:把结构元素B平移a后得到Ba,若Ba击中X,我们记下这个a点。所有满足上述条件的a点组成的集合称做XB膨胀的结果。用公式表示为:D(X)={a | BaX}=X  B,如图6.13所示。图6.13X是被处理的对象,B是结构元素,不难知道,对于任意一个在阴影部分的点aBa击中X,所以XB膨胀的结果就是那个阴影部分。阴影部分包括X的所有范围,就象X膨胀了一圈似的,这就是为什么叫膨胀的原因。原理图如下:


    实际使用时示意图:



    说明:左边是被处理的图象X(二值图象,我们针对的是黑点),中间是结构元素B。膨胀的方法是,拿B的中心点和X上的点及X周围的点一个一个地对,如果B上有一个点落在X的范围内,则该点就为黑;右边是膨胀后的结果。可以看出,它包括X的所有范围,就象X膨胀了一圈似的。


    展开全文
  • 图像形态学操作是基于形状的一系列图像处理操作的合集,主要针对二值图像(二值图像前景物体为1,背景为0)进行处理。 形态学有四个基本操作:腐蚀膨胀,开,闭。 本文主要记录膨胀和腐蚀膨胀 膨胀跟卷积操作...

    形态学操作

    图像形态学操作是基于形状的一系列图像处理操作的合集,主要针对二值图像(二值图像前景物体为1,背景为0)进行处理。
    形态学有四个基本操作:腐蚀,膨胀,开,闭。
    本文主要记录膨胀和腐蚀。
    原图

    膨胀

    膨胀跟卷积操作类似。
    假设有图像A任意形状的内核B(与卷积不同的是,B可以是线、矩形、圆形或者十字等形状。但是通常B为正方形或者圆形),结构元素B在A上面移动遍历所有像素点。B的内核中心点被定义为锚点,进行膨胀操作时,将内核 B划过图像,将内核 B覆盖区域的最大像素值提取,并代替锚点位置的像素。由于二值图像最大值就是1,所以就是用1替换,即变成了白色前景物体。显然,这一最大化操作将会导致图像中的亮区开始扩展。因此膨胀看起来的效果就是让前景物体胀大了一圈一样。对于前景物体中一些细小的断裂处,如果结构元素大小相等,这些断裂的地方就会被连接起来。于是图像高亮部分被进行“领域扩张”,效果图拥有比原图更大的高亮区域。

    膨胀处理

    腐蚀

    腐蚀跟膨胀操作刚好相反。
    腐蚀看起来的效果就是让前景物体缩小了一圈一样。对于前景物体中一些细小的连接处,如果结构元素大小相等,这些连接处就会被断开。
    以与膨胀相同的图像作为样本,我们使用腐蚀操作。从下面的结果图我们看到亮区(背景)变细,而黑色区域(字母)则变大了。
    腐蚀操作

    源码实现
    #include "opencv2/imgproc/imgproc.hpp"
    #include "opencv2/highgui/highgui.hpp"
    #include "highgui.h"
    #include <stdlib.h>
    #include <stdio.h>
    
    using namespace cv;
    
    /// 全局变量
    Mat src, erosion_dst, dilation_dst;
    
    int erosion_elem = 0;
    int erosion_size = 0;
    int dilation_elem = 0;
    int dilation_size = 0;
    int const max_elem = 2;
    int const max_kernel_size = 21;
    
    /** Function Headers */
    void Erosion( int, void* );
    void Dilation( int, void* );
    
    /** @function main */
    int main( int argc, char** argv )
    {
      /// Load 图像
      src = imread( argv[1] );
    
      if( !src.data )
      { return -1; }
    
      /// 创建显示窗口
      namedWindow( "Erosion Demo", CV_WINDOW_AUTOSIZE );
      namedWindow( "Dilation Demo", CV_WINDOW_AUTOSIZE );
      cvMoveWindow( "Dilation Demo", src.cols, 0 );
    
      /// 创建腐蚀 Trackbar
      createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse", "Erosion Demo",
                      &erosion_elem, max_elem,
                      Erosion );
    
      createTrackbar( "Kernel size:\n 2n +1", "Erosion Demo",
                      &erosion_size, max_kernel_size,
                      Erosion );
    
      /// 创建膨胀 Trackbar
      createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse", "Dilation Demo",
                      &dilation_elem, max_elem,
                      Dilation );
    
      createTrackbar( "Kernel size:\n 2n +1", "Dilation Demo",
                      &dilation_size, max_kernel_size,
                      Dilation );
    
      /// Default start
      Erosion( 0, 0 );
      Dilation( 0, 0 );
    
      waitKey(0);
      return 0;
    }
    
    /**  @function Erosion  */
    void Erosion( int, void* )
    {
      int erosion_type;
      if( erosion_elem == 0 ){ erosion_type = MORPH_RECT; }
      else if( erosion_elem == 1 ){ erosion_type = MORPH_CROSS; }
      else if( erosion_elem == 2) { erosion_type = MORPH_ELLIPSE; }
    
      Mat element = getStructuringElement( erosion_type,
                                           Size( 2*erosion_size + 1, 2*erosion_size+1 ),
                                           Point( erosion_size, erosion_size ) );
    
      /// 腐蚀操作
      erode( src, erosion_dst, element );//src原图像,erosion_dst输出图像,element服饰操作的内核,如果不指定,默认为一个简单的3X3矩阵。否则就需要我们利用getStructuringElement函数来明确指出它的形状。然后,我们还需要指定内核大小,以及 锚点 位置。不指定锚点位置,则默认锚点在内核中心位置。
      imshow( "Erosion Demo", erosion_dst );
    }
    
    /** @function Dilation */
    void Dilation( int, void* )
    {
      int dilation_type;
      if( dilation_elem == 0 ){ dilation_type = MORPH_RECT; }
      else if( dilation_elem == 1 ){ dilation_type = MORPH_CROSS; }
      else if( dilation_elem == 2) { dilation_type = MORPH_ELLIPSE; }
    
      Mat element = getStructuringElement( dilation_type,
                                           Size( 2*dilation_size + 1, 2*dilation_size+1 ),
                                           Point( dilation_size, dilation_size ) );
      ///膨胀操作
      dilate( src, dilation_dst, element );
      imshow( "Dilation Demo", dilation_dst );
    }
    

    更改Trackbars的位置就会产生不一样的输出图像。
    还可以通过增加第三个Trackbar来控制膨胀或腐蚀的次数。

    展开全文
  • 图像膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮区域或白色部分进行扩张,其运行结果图比原图的高亮区域更...
  • 图像腐蚀膨胀

    2018-10-11 14:15:46
    图像腐蚀膨胀 结构元素 设有两幅图象B,X。若X是被处理的对象,而B是用来处理X的,则称B为结构元素(structure element),又被形象地称做刷子。结构元素通常都是一些比较小的图象。 腐蚀 把结构元素B平...
  • opencv腐蚀和膨胀原理

    2018-01-24 12:20:37
    假设原图像中有一个前景物体,那么我们用一个结构元素去腐蚀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有...
  •  二值图像的腐蚀和膨胀图像数字处理中应用相当广泛,代码处理也很简单,只不过一些资料在介绍腐蚀和膨胀原理时,用一些形态学、集合上的概念术语,搞得也有些”高深莫测“了。  从图像处理角度看,二值图像的...
  • 数学形态学是一种应用于图像处理和模式识别的方法,基本思想是用具有一定形态的结构元素去度量提取图像中对应的形状以达到对图像分析识别的目的,利用数学形态学对物体的几何结构分析过程就是把主体客体相互...
  • 该代码首先实现了图像腐蚀处理和图像膨胀处理。然后,经过先腐蚀(Erosion)处理,后膨胀(Dilation)处理得到了Opening Image;又经过先膨胀(Dilation)处理,后腐蚀(Erosion)处理得到了Closing Image。 程序执行后...
  • 图像处理 腐蚀 膨胀 细化
  • 膨胀(dilation)能够看做是腐蚀的对偶运算,其定义是:把结构元素B平移a后得到Ba,若Ba击中X,我们记下这个a点。全部满足上述条件的a点组成的集合称做X被B膨胀的结果。用公式表示为:D(X)={a | Ba↑X}=XB,例如以下图...
  • 图像形态学即数学形态学(Mathematical morphology)是一门建立在格伦拓扑学基础上的图像分析学科,是数学形态学图像处理的基本理论; 常见图像形态学运算:腐蚀膨胀、开运算、闭运算、骨架抽取、极线腐蚀、击中...
  • 参考:【数字图像处理学习笔记之四】图像腐蚀膨胀:https://blog.csdn.net/zhougynui/article/details/51834725 1 背景知识 结构元素:二维结构元素可以理解成一个二维矩阵,矩阵元素的值为0或者1;通常结构元素...
  • 结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,
1 2 3 4 5 ... 20
收藏数 1,948
精华内容 779