图像处理腐蚀原理_图像处理 腐蚀和膨胀原理 - CSDN
  • 图像处理腐蚀与膨胀的原理

    千次阅读 2019-04-11 20:58:06
    腐蚀原理: 二值图像前景物体为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

    展开全文
  • 图像腐蚀与膨胀算法原理

    千次阅读 2017-07-31 09:27:22
    结构元素:设两幅图像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. 形态学图像处理(一): 膨胀与腐蚀

    展开全文
  • 图像腐蚀原理

    千次阅读 2014-08-04 09:03:33
    先来定义一些基本符号和关系。 1.元素 设有一幅图象X,若点a在X的区域以内,则称a为X的元素,记作a∈X,如图6.1所示。 2.B包含于X 设有两幅图象B,X。对于B中所有的元素ai,都有ai∈X,则称B包含于(included in)...
    
    

    先来定义一些基本符号和关系。

    1.元素

    设有一幅图象X,若点a在X的区域以内,则称a为X的元素,记作a∈X,如图6.1所示。
    2.B包含于X
    设有两幅图象B,X。对于B中所有的元素ai,都有ai∈X,则称B包含于(included in)X,记作B⊂X,如图6.2所示。
    3.B击中X
    设有两幅图象B,X。若存在这样一个点,它即是B的元素,又是X的元素,则称B击中(hit)X,记作B↑X,如图6.3所示。
    4.B不击中X

    设有两幅图象B,X。若不存在任何一个点,它即是B的元素,又是X的元素,即B和X的交集是空,则称B不击中(miss)X,记作B∩X=Ф;其中∩是集合运算相交的符号,Ф表示空集。如图6.4所示。


    5.补集

    设有一幅图象X,所有X区域以外的点构成的集合称为X的补集,记作X^c,如图6.5所示。显然,如果B∩X=Ф,则B在X的补集内,即B⊂X^c。


    6.结构元素
    设有两幅图象B,X。若X是被处理的对象,而B是用来处理X的,则称B为结构元素(structure element),又被形象地称做刷子。结构元素通常都是一些比较小的图象。
    7.对称集
    设有一幅图象B,将B中所有元素的坐标取反,即令(x,y)变成(-x,-y),所有这些点构成的新的集合称为B的对称集,记作Bv,如图6.6所示。
    8.平移
    设有一幅图象B,有一个点a(x0,y0),将B平移a后的结果是,把B中所有元素的横坐标加x0,纵坐标加y0,即令(x,y)变成(x+x0,y+y0),所有这些点构成的新的集合称为B的平移,记作Ba,如图6.7所示。

    好了,介绍了这么多基本符号和关系,现在让我们应用这些符号和关系,看一下形态学的基本运算。


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

    图6.8中X是被处理的对象,B是结构元素。不难知道,对于任意一个在阴影部分的点a,Ba包含于X,所以X被B腐蚀的结果就是那个阴影部分。阴影部分在X的范围之内,且比X小,就象X被剥掉了一层似的,这就是为什么叫腐蚀的原。
    值得注意的是,上面的B是对称的,即B的对称集Bv=B,所以X被B腐蚀的结果和X被Bv腐蚀的结果是一样的。如果B不是对称的,让我们看看图6.9,就会发现X被B腐蚀的结果和X被Bv腐蚀的结果不同。

    图6.8和图6.9都是示意图,让我们来看看实际上是怎样进行腐蚀运算的。


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


    下面给出源码:

    #include "stdafx.h"
    #include "cv.h"
    #include "highgui.h"
    #include "cxcore.h"
    
    
    int main(int argc, char* argv[])
    {
    
    #if 1
    	//创建原图像
    	IplImage* src=cvCreateImage(cvSize(11,10),8,1);
    	//创建图像 用于保存腐蚀的结果
    	IplImage* dst = cvCreateImage(cvGetSize(src),8,1);
    	//将图像清零
    	cvZero(dst);
    	cvZero(src);
    	//下面的代码 是将 源图像赋初始值
    	int x,y;
    	//(1,6)-->(1,9)
    	//(2,6)-->(2,9)
    	//(3,6)-->(3,9)
    	for( y=1;y<4;y++)
    	{
    		for(x=6;x<10;x++)
    		{
    			cvSetReal2D(src,y,x,255);
    		}
    	}
    	//(4,4)-->(4,7)
    	//(5,4)-->(4,7)
    	for(y=4;y<6;y++)
    	{
    		for(x=4;x<8;x++)
    		{
    			cvSetReal2D(src,y,x,255);
    		}
    	}
    	//(6,1)-->(6,7)
    	for(x=1;x<8;x++)
    	{
    		cvSetReal2D(src,6,x,255);
    	}
    	//(7,1)-->(7,4)
    	//(8,1)-->(8,4)
    	for(y=7;y<9;y++)
    	{
    		for(x=1;x<5;x++)
    		{
    			cvSetReal2D(src,y,x,255);
    		}
    	}
    	/*
    	cvSetReal2D(src,0,0,1);
    	cvSetReal2D(src,0,1,2);
    	cvSetReal2D(src,1,0,3);
    	cvSetReal2D(src,1,2,4);
    	*/
    
    	//输出源图像
    	printf("src is \n");
    	for(y=0;y<src->height;y++)
    	{
    		for(x=0;x<src->width;x++)
    		{
    			float value = cvGetReal2D(src,y,x);
    
    			printf("%3d ",(int)(value));
    		}
    		printf("\n");
    	}
    
    	//声明结构元素变量
    	IplConvKernel * element =0;
    	//结构元素的取值情况 
    	int values[16]={ 
    		0,0,0,0,
    		0,0,1,0,
    		0,1,1,0,
    		0,0,0,0
    	};
    	//声明结构元素的列数 行数 锚点坐标
    	int cols = 4, rows = 4, anchor_x = 2, anchor_y = 2;
    	//创建结构元素
    	element = cvCreateStructuringElementEx(cols,rows,anchor_x,anchor_y,CV_SHAPE_CUSTOM,values);
    	//使用自定义结构元素 对图像进行腐蚀
    	cvErode(src,dst,element,1);
    	//输出腐蚀的结果
    	printf("dst is \n");
    	for(y=0;y<dst->height;y++)
    	{
    		for(x=0;x<dst->width;x++)
    		{
    			float value = cvGetReal2D(dst,y,x);
    
    			printf("%3d ",(int)(value));
    		}
    		printf("\n");
    	}
    
    #endif
    
    }

    ---------------本文转自www.opencvchina.com------------------


    展开全文
  • 图像的膨胀与腐蚀--确认这个大牛的才是正确的

    万次阅读 多人点赞 2018-04-16 11:48:18
    图像的膨胀与腐蚀、细化原理:在特殊领域运算形式——结构元素(Sturcture Element),在每个像素位置上与二值图像对应的区域进行特定的逻辑运算。运算结构是输出图像的相应像素。运算效果取决于结构元素大小内容...
  • 腐蚀与膨胀基本原理:就是用一个特定的结构元素来与待处理图像按像素做逻辑操作;可以理解成拿一个带孔的网格板(结构元素矩阵中元素为1的为孔)盖住图像的某一部分,然后按照各种不同的观察方式来确定操作类型。 ...
  • 而我们图像处理中指的形态学,往往表示的是数学形态学。下面一起来了解数学形态学的概念。 数学形态学(Mathematical morphology) 是一门建立在格论和拓扑学基础之上的图像分析学科,是数学形态学图像处理的基本...
  • 图像腐蚀 膨胀 细化的基本原理

    千次阅读 2014-04-28 21:00:45
    数字图像处理中的形态学处理是指将数字形态学作为工具从图像中提取对于表达和描绘区域形状有用处的图像分量,比如边界、骨架以及凸壳,还包括用于预处理或后处理的形态学过滤、细化和修剪等。图像形态学处理中我们感...
  • 数学形态学是一种应用于图像处理和模式识别的方法,基本思想是用具有一定形态的结构元素去度量和提取图像中对应的形状以达到对图像分析和识别的目的,利用数学形态学对物体的几何结构分析过程就是把主体和客体相互...
  • 图像处理之——膨胀、腐蚀算法详解

    万次阅读 多人点赞 2015-12-30 16:48:39
    原理:在特殊领域运算形式——结构元素(Sturcture Element),在每个像素位置上与二值图像对应的区域进行特定的逻辑运算。运算结构是输出图像的相应像素。运算效果取决于结构元素大小内容以及逻辑运算性质。 ...
  • 参考:【数字图像处理学习笔记之四】图像腐蚀、膨胀:https://blog.csdn.net/zhougynui/article/details/51834725 1 背景知识 结构元素:二维结构元素可以理解成一个二维矩阵,矩阵元素的值为0或者1;通常结构元素...
  • 图像形态学,腐蚀,膨胀操作原理

    千次阅读 2018-09-27 23:05:08
    形态学腐蚀操作的原理:使用已经获得的结构B,沿着原始图像A边缘遍历一圈。以B的中心缩小原始图像A的区域。 使用结构元素B,对原始图像A进行腐蚀,其过程如下: (1)、使用结构元素B的锚点,扫描图像A的每一个...
  • 图像处理 腐蚀 膨胀 细化

    千次阅读 2015-10-24 13:28:34
    图像处理 腐蚀 膨胀 细化
  •  形态学(morphology)一词通常表示生物学的一个分支,该分支主要研究动植物的形态和结构,而图像处理中的形态学主要是指数学形态学。  数学形态学(Mathematical morphology)是一门建立在格论和拓扑学基础之上...
  • 图像处理技术中,有一些的操作会对图像的形态发生改变,这些操作一般称之为形态学操作(phology)。数学形态学是基于集合论的图像处理方法,最早出现在生物学的形态与结构中,图像处理中的形态学操作用于图像与...
  • 图像形态学操作是基于形状的一系列图像处理操作的合集,主要针对二值图像(二值图像前景物体为1,背景为0)进行处理。 形态学有四个基本操作:腐蚀,膨胀,开,闭。 本文主要记录膨胀和腐蚀。 膨胀 膨胀跟卷积操作...
  • 通常结构元素要小于待处理图像腐蚀: 把结构元素B平移a后得到Ba,若Ba包含于X,我们记下这个a点,所有满足上述条件的a点组成的集合称做X被B腐蚀(Erosion)的结果。 图中有个错误:第三个图,也就是腐蚀的结果...
  • 图像膨胀与腐蚀 作用区域:腐蚀与膨胀是对白色部分(高亮部分)而言,不是黑色部分。膨胀类似于“领域扩张”,腐蚀类似于“领域被蚕食”。 元素:设X是一个图像,B是一个矩阵。X是被处理的对象,而B是用来处理X的...
1 2 3 4 5 ... 20
收藏数 2,388
精华内容 955
关键字:

图像处理腐蚀原理