C 图像的膨胀和腐蚀
OpenCV图像的腐蚀与膨胀
![OpenCV图像的腐蚀与膨胀](https://img.taocdn.com/s3/m/9103886dcaaedd3383c4d391.png)
《OpenCV图像处理》---上机实验报告 31.实验题目:腐蚀与膨胀操作2.实验目的:(1)如何使用opencv提供的两种最基本的形态学操作,腐蚀与膨胀;(2)掌握opencv运行环境及腐蚀与膨胀的基本运行过程。
3.实验原理:(1)形态学操作:形态学操作就是基于形状的一系列图像处理操作,通过将结构元素作用于输入图像来产生输出图像。
基本的形态学操作有腐蚀与膨胀,他们的应运广泛:消除噪声,分割独立的图像元素,以及连接相邻的元素;寻找图像中明显的极大值区域或极小值区域。
(2)膨胀:此操作将图像A与任意形状的内核(B),通常为正方形或圆形,进行卷积;内核有一个可定义的锚点,通常定义为内核中心点;进行膨胀操作时,将内核B画过图像,将内核B覆盖区域的最大像素值提取,并代替锚点位置的像素。
显然这一最大化操作会导致图像中的亮区开始“扩展”。
(3)腐蚀:它在形态学操作家族里是膨胀操作的孪生姐妹。
它提取的是内核覆盖下的像素最小值;进行腐蚀操作时,将内核B画过图像,将内核B覆盖区域的最小像素值提取,并代替锚点位置像素,腐蚀操作的结果是图片亮区变细,黑色区域变大。
4.实验结果:5.源程序:#include<stdafx.h>#include<opencv2/imgproc/imgproc.hpp> #include<opencv2/highgui/highgui.hpp> #include<highgui.h>#include<stdlib.h>#include<stdio.h>using namespace std;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;void Erosion(int ,void*);void Dilation(int ,void*);int main(int argc,char** argv){src=imread("na.jpg");if(!src.data){return -1;}namedWindow("Erosion Demo", CV_WINDOW_AUTOSIZE );namedWindow("Dilation Demo", CV_WINDOW_AUTOSIZE );cvMoveWindow("Dilation Demo",src.cols,0);createTrackbar("Element:\n0:Rect\n1:Cross\n2:Ellipse","E rosion Demo",&erosion_elem,max_elem,Erosion);createTrackbar("Kernel size:\n 2n +1","Erosion Demo", &erosion_size,max_kernel_size,Erosion);createTrackbar("Element:\n0:Rect\n1:Cross\n2:Ellipse","Dila tion Demo",&dilation_elem,max_elem,Dilation);createTrackbar("Kernel size:\n 2n +1","Dilation Demo",&dilation_size,max_kernel_size,Dilation);Erosion(0,0);Dilation(0,0);waitKey(0);return 0;}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;} Matelement=getStructuringElement(erosion_type,Size(2*erosion_s ize+1,2*erosion_size+1),Point(erosion_size,erosion_size));erode(src,erosion_dst,element);imshow("Eerosion Demo",erosion_dst);}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;} Matelement=getStructuringElement(dilation_type,Size(2*dilation _size+1,2*dilation_size+1),Point(dilation_size,dilation_size));erode(src,dilation_dst,element);imshow("Dilation Demo",dilation_dst);}实验总结:通过本次实验,我再一次学到了一种图像处理的方法,了解并使用OpenCV提供的两种最基本的形态学操作,腐蚀与膨胀及腐蚀和膨胀的基本原理,学习对输入的图片进行腐蚀(Erosion)和膨胀(Dilation)操作,我熟悉了对图片的腐蚀与膨胀的的操作和具体代码,写代码期间遇到过很多问题,通过查阅书籍和资料都一一改正了过来,总之,代码还是不太熟悉,还有待于进一步提高。
腐蚀膨胀算法原理
![腐蚀膨胀算法原理](https://img.taocdn.com/s3/m/00b96efe81eb6294dd88d0d233d4b14e85243e89.png)
腐蚀膨胀算法原理
腐蚀膨胀算法(Erosion-DilationAlgorithm,缩写为EDA)是图像处理中最常用的算法之一。
它主要应用于图像的二值化处理,可以有效地消除图像中的噪声,以及实现图像中文字和物体的分割。
EDA是一种分水岭算法(Watershed Algorithm),该算法包括两个步骤,腐蚀和膨胀。
腐蚀步骤将从图像中提取图像对象的轮廓,而膨胀步骤将对象的轮廓填充,从而实现对图像对象的分割。
一般来说,EDA算法可以分为以下两步:
(1)腐蚀:腐蚀是图像处理中常用的技术,它的目的是去除图像中的噪声,消除图像中的噪点,并实现对图像中的文字或物体的轮廓提取。
腐蚀的基本原理是:使用一个结构元素(structuring element),它可以是不同类型的形状,如圆形、菱形、矩形等,将图像中某像素的非零元素替换为零。
(2)膨胀:膨胀是EDA算法中另一个重要的步骤,它是腐蚀的反向过程。
膨胀的基本原理是:使用一个结构元素将图像中某像素的零元素替换为非零元素,如果临近的像素是非零元素,则认为此像素属于某个对象的轮廓。
EDA算法的优点在于它既可以去除噪声,又可以实现文字或物体的分割。
此外,EDA算法还性能卓越,比一般算法要快得多,是图像处理中用到较多的算法之一。
但EDA算法也存在缺点:结构元素的选择不当,会影响到最终的结果;由于腐蚀操作的迭代,会导致目标图像的误差及失真问题;同
样,膨胀操作也会null影响图像的体积及精度。
总而言之,腐蚀膨胀算法是一种有效的图像处理算法,在图像的噪声消除、文字分割等应用中均有良好的效果,但也有一定的缺点,应该合理选择结构元素,以保证算法的正确性和最佳效果。
数学形态学腐蚀膨胀运算的快速算法
![数学形态学腐蚀膨胀运算的快速算法](https://img.taocdn.com/s3/m/c0215ced5ebfc77da26925c52cc58bd6318693ab.png)
数学形态学腐蚀膨胀运算的快速算法
数学形态学,又称形态学,是一种以数学方法和地理空间分析技术为基础,用来表征和分析地理空间形状与空间相关性的有用工具。
腐蚀和膨胀是数学形态学中最重要的概念。
腐蚀是指一种减小形状等功能而不改变其形状的图像处理技术,而膨胀是指一种扩大形状等功能而不改变其形状的图像处理技术。
腐蚀和膨胀的快速算法给数学形态学带来了极大的效率提升,可以有效地解决计算量大的问题。
腐蚀和膨胀运算的快速算法为数学形态学提供了一种有效的图像处理方式,它能够有效地完成空间图形的腐蚀和膨胀操作,以及形状分析,检测和填补,修复和识别等等操作。
快速的腐蚀和膨胀运算能够有效地将计算量大的图像处理过程变得更简单便捷,大大提高效率,减少运行时间。
此外,腐蚀和膨胀的快速算法还可以为图像处理提供显著的收益。
它能有效地处理和估计图像中的各种尺度,如轮廓,边缘,特征点等,并且能够完成大规模图像中细节级别特征结构的建模和识别,这对于计算机视觉有重大意义。
另外,腐蚀和膨胀运算的快速算法还可以为图像分类提供支持。
它可以分析图像中的形状特征,用于提取标准图像,从而支持小规模图像分类任务。
特别是,腐蚀和膨胀算法可以运用到基于结构的图像分类中,它可以自动学习可以描述图像的最佳结构和规律,进而改善分类性能。
总之,腐蚀和膨胀运算的快速算法为数学形态学提供了极大的优势。
它能够有效地减少计算复杂度和算法运行时间,提高图像处理的效率,同时还可以支持图像处理和分类的客观任务,从而提高数学形态学的实用性和研究价值。
图像形态学腐蚀与膨胀方法研究讲解
![图像形态学腐蚀与膨胀方法研究讲解](https://img.taocdn.com/s3/m/e95bdbcf240c844769eaee5e.png)
摘要伴随着电子计算机技术的进步,通信技术日新月异的更新与发展,图像处理技术近年来得到突飞猛进的发展,并成功的应用到几乎所有与成像有关的领域,并发挥着相当重要的作用。
它利用计算机对数字图像进行一系列的操作,从而获得某种预期的结果,对图像进行处理时,经常运用图像处理技术以改善图像的质量。
现在图像处理仍然在不断的发展,延伸出更多的应用领域,相信数字图像处理技术的逐步发展定会让我们的信息生活变得更好。
在图像处理中,数学形态学的理论基础在数字图像信号处理领域中得到广泛应用,图像形态学的用途主要是获取物体拓扑和结构信息,通过物体和结构元素相互作用的某些运算,得到物体更本质的形态。
在图像处理中形态学主要应用是:(1)利用形态学的基本运算,对图像进行观察和处理,从而达到改善图像质量的目的;(2)描述和定义图像的几何参数和特征,如面积、周长、连通度、颗粒度、骨架和方向性等。
而腐蚀与膨胀是数学形态学最基本的算法,使得腐蚀与膨胀方法的研究价值得到更大的提升。
图像形态学腐蚀与膨胀方法在很多方面被应用,本文以图像的腐蚀与膨胀方法的理论分析为重点,围绕着其在众多图像处理方案中的出色表现,逐渐联系到图像的内容。
用多层次的介绍手法展现出图像腐蚀与膨胀方法研究的重要内涵。
本文主要的工作包括:(1)掌握Visual C++6.0软件的使用。
(2)深入学习图像形态学腐蚀与膨胀的基础理论,研究腐蚀与膨胀在图像处理中的应用。
(3)针对图像形态学腐蚀与膨胀方法进行研究,通过Visual C++6.0软件实现腐蚀与膨胀算法,掌握腐蚀与膨胀算法的实现过程。
本文集中阐述腐蚀与膨胀是如何进行水平腐蚀、垂直腐蚀、全方位腐蚀、水平膨胀、垂直膨胀、全方位膨胀、开运算以及闭运算的完成原理、步骤和它们的具体实现过程。
通过一系列的研究才能更加明确腐蚀与膨胀方法处理在图像信息处理的发展历程中发挥了不可替代的作用。
关键词:图像处理;数学形态学;腐蚀;膨胀AbstractWith the advance in computer technology, communication technology changes rapidly updated and developed, image processing technology has make a spurt of progress of development in recent years, and successfully applied to almost all domains related to the formation of image, and play a very important role. It uses the computer to carry out a series of operation on the digital image, so as to obtain some expected results, image processing often using image processing technology to improve the quality of the image. Now the image processing is still in constant development, extending more application fields, believe that the gradual development of the digital image processing technology will make our life better.In image processing, the theory foundation of mathematical morphology is applied widely in the field of digital image signal processing, use of image morphology is the main access to the object topology and structure information, some operational through the object and the structural elements of interaction, obtained the object state of nature. In image processing, morphological main applications are: (1) by using basic operation of morphology, were observed and the processing of the image, so as to achieve the purpose of improving the image quality. (2)The definition and description of image geometric parameters and characteristics, such as area, perimeter, connectivity, particle size, frame and direction etc.. The corrosion and expansion is the basic algorithm of mathematical morphology which makes the research value of corrosion and expansion method for the greater increase. Method of image morphology of corrosion and expansion is used in many aspects, this paper with the method of image corrosion expansion theory analysis as the key point, around its excellent performance in many images processing scheme, gradually linked to the content of the image. To show the image of corrosion and expansion method research important content of multi-level presentation techniques. The main work of this paper includes: (1) using Visual C++6.0 Software. (2) Study the basic theory and the expansion of the image morphology of corrosion depth, application and expansion of research in image processing corrosion. (3) According to a study on the method of image morphology of corrosion and expansion, realization of erosion and dilation algorithm by Visual C++6.0 Software, master the implementation process of erosion and dilation algorithm. This paper focuses on how the level of corrosion andexpansion of corrosion, a full range of vertical horizontal expansion, vertical expansion, a full range expansion, open operation and close operation to complete the principle, steps and their realization.Through the research to a series of more clear corrosion and expansion method has played an irreplaceable role in the development of image processing.Key words: Image processing; mathematical morphology; corrosion; expansion目录1 绪论 (1)1.1引言 (1)1.2课题研究现状 (1)1.3课题目的和意义 (2)2 开发环境VISUAL C++介绍 (3)2.1V ISUAL C++6.0介绍 (3)2.2V ISUAL C++软件平台介绍 (4)2.2.1单文档格式 (4)2.2.2界面板部分 (5)2.2.3程序控制部分 (5)2.3设计中的MFC介绍 (5)3 腐蚀与膨胀的基本原理 (7)3.1图像的腐蚀 (7)3.2图像的膨胀 (8)3.3开运算 (10)3.4闭运算 (11)4 图像腐蚀与膨胀处理 (12)4.1CDIB类库的建立 (12)4.1.1CDIB类库的功能 (12)4.1.2CDIB类的构造 (12)4.2图像腐蚀与膨胀处理的实现 (15)4.2.1水平腐蚀处理实现 (15)4.2.2垂直腐蚀处理实现 (17)4.2.3全方向腐蚀处理实现 (19)4.2.4水平膨胀处理实现 (22)4.2.5垂直膨胀处理实现 (24)4.2.6全方位膨胀处理实现 (26)5 实验结果及讨论 (29)5.1腐蚀处理结果 (29)5.2膨胀处理结果 (31)5.3开闭运算处理结果 (32)5.3结果讨论 (34)结论 (35)致谢 (37)参考文献 (38)附录A 英文原文 (39)附录B 汉语翻译 (47)1 绪论1.1 引言随着计算机技术的日益发展,图像信息已成为人类认识世界的重要知识来源,人们研究发现,人类从外界获得的信息约有75%来自图像。
计算机视觉实验报告-对图像进行腐蚀和膨胀
![计算机视觉实验报告-对图像进行腐蚀和膨胀](https://img.taocdn.com/s3/m/ad28c89048649b6648d7c1c708a1284ac85005bc.png)
1实验目的选取一张自己的生活照,实现:任选两种结构对图像进行腐蚀和膨胀。
边缘检测(分别使用Prewitt,两种大小的Sobel算子,不同参数的Canny算子,LoG算子),并对比各个算子实现差异及不同参数条件下的实验效果。
2实验过程2.1图像腐蚀和膨胀实验图片所用代码import cv2import numpy as npdef threshold(image, threshold):out = image.copy()out[out < threshold] = 0out[out > threshold] = 1out = out.astype(np.uint8)return out# 1. 读取图像文件image = cv2.imread('img/in.jpeg', cv2.IMREAD_GRAYSCALE)# 2. 缩放图像print('Shape: {}'.format(image.shape))image = cv2.resize(image, (256, 256), cv2.INTER_LINEAR)print('Shape: {}'.format(image.shape))# 3. 均一阈值分割binary = threshold(image, threshold=200)# 4. 腐蚀kernel_size = 5erode = cv2.erode(binary, kernel=np.ones((kernel_size, kernel_size)))# 5. 膨胀dilate = cv2.dilate(binary, kernel=np.ones((kernel_size, kernel_size)))# 6. 显示图像cv2.imshow('Image', image)cv2.imshow('Binary', binary * 255)cv2.imshow('Erode', erode * 255)cv2.imshow('Dilate', dilate * 255) cv2.waitKey(0)实验效果Kernel=5Kernel=25代码分析及现象腐蚀,消除连通的边界,使边界向内收缩。
图像膨胀和腐蚀
![图像膨胀和腐蚀](https://img.taocdn.com/s3/m/b26a0f37640e52ea551810a6f524ccbff121ca05.png)
图像膨胀和腐蚀图像二值形态学——腐蚀和膨胀的C语言实现数学形态学是法国和德国科学家在研究岩石结构时建立的一门科学。
形态学的用途主要是获取物体拓扑和结构信息,通过物体和结构元素相互作用的某些运算,得到物体更本质的形态。
在图像处理中的应用主要是:利用形态学的基本运算,对图像进行观察和处理,从而达到改善图像质量的目的;描述和定义图像的各种几何参数和特征,如面积、周长、连通度、颗粒度、骨架和方向性等。
关于形态学的具体描述和数学形式化的定义可以从文章底部的参考资料中获得。
最近的实验中需要对二值图像进行减噪处理,图像形态学中的腐蚀和膨胀能很好的解决此问题。
如果在腐蚀和膨胀操作前,对灰度图像做一次滤波,减噪效果将更明显。
腐蚀的具体操作是:用一个结构元素(一般是3×3的大小)扫描图像中的每一个像素,用结构元素中的每一个像素与其覆盖的像素做“与”操作,如果都为1,则该像素为1,否则为0。
膨胀的具体操作是:用一个结构元素(一般是3×3的大小)扫描图像中的每一个像素,用结构元素中的每一个像素与其覆盖的像素做“与”操作,如果都为0,则该像素为0,否则为1。
腐蚀的作用是消除物体边界点,使目标缩小,可以消除小于结构元素的噪声点;膨胀的作用是将与物体接触的所有背景点合并到物体中,使目标增大,可添补目标中的空洞。
开运算是先腐蚀后膨胀的过程,可以消除图像上细小的噪声,并平滑物体边界。
闭运算时先膨胀后腐蚀的过程,可以填充物体内细小的空洞,并平滑物体边界。
以下是一段在OpenCV中实现的C语言程序,分别是图像腐蚀和膨胀函数,输入的参数依次为:当前二值图像数据指针、图像宽度、图像高度。
通过这两个函数的组合使用(开闭运算),可以对图像进行有效减噪。
一、图像腐蚀膨胀细化的基本原理1.图像细化的基本原理⑴图像形态学处理的概念数字图像处理中的形态学处理是指将数字形态学作为工具从图像中提取对于表达和描绘区域形状有用处的图像分量,比如边界、骨架以及凸壳,还包括用于预处理或后处理的形态学过滤、细化和修剪等。
先膨胀后腐蚀的运算_解释说明以及概述
![先膨胀后腐蚀的运算_解释说明以及概述](https://img.taocdn.com/s3/m/56637020001ca300a6c30c22590102020740f2c8.png)
先膨胀后腐蚀的运算解释说明以及概述1. 引言1.1 概述在图像处理和形态学图像分析领域,先膨胀后腐蚀的运算被广泛应用。
该运算是一种基于形态学思想的操作,它通过对图像进行膨胀和腐蚀两个步骤的组合操作,能够改变图像的形状、大小、结构等特征。
这种运算方法具有一定的特点和优势,已被证明在许多应用场景中具有重要价值。
1.2 文章结构本文将首先介绍先膨胀后腐蚀的运算的定义和原理,在此基础上详细解释其具体步骤,并提供实例进行说明。
接着,将探讨该运算在图像处理、形态学图像分析以及模式识别等领域中的应用。
同时,本文还会与其他相关运算进行比较分析,并对不同尺寸结构元素对先膨胀后腐蚀结果影响进行深入研究。
最后,通过总结与展望来评估先膨胀后腐蚀运算的局限性和未来发展趋势。
1.3 目的本文旨在深入探讨先膨胀后腐蚀的运算,全面了解其原理、特点和应用领域,以及与其他相关运算的比较分析。
通过本文的阐述,读者将能够理解并掌握先膨胀后腐蚀运算,并能在实际应用中灵活运用该方法。
对于图像处理、形态学图像分析以及模式识别等领域的研究人员和工程师而言,本文将为他们提供有价值的参考和指导。
以上是“1. 引言”部分的内容,请根据需要进行修改和补充。
2. 先膨胀后腐蚀的运算解释说明:2.1 膨胀操作定义与原理:膨胀是形态学图像处理中的基本运算之一,它可以用来增强图像中亮度较高的区域。
膨胀操作基于结构元素,通过将结构元素沿着图像的每个像素进行平移,并找出覆盖范围内的最大值作为输出像素的灰度值。
这意味着,通过膨胀操作,图像中亮度较高的区域将会逐渐扩展。
膨胀操作可以用数学形式描述如下:D = A ⊕B其中,D表示进行膨胀后所得到的图像,A表示待处理的原始图像,B表示结构元素。
2.2 腐蚀操作定义与原理:与膨胀相反,腐蚀是一种可以去除图像中亮度较低区域的操作。
它同样依赖于结构元素,并根据在覆盖范围内找出最小值作为输出像素的灰度值。
因此,通过连续进行多次腐蚀操作,亮度较低或细小的细节将会不断被消除。
形态学中的腐蚀与膨胀
![形态学中的腐蚀与膨胀](https://img.taocdn.com/s3/m/92e6b169852458fb770b565c.png)
数学形态学运算——腐蚀、膨胀、开运算、闭运算腐蚀简单说:就是以结构B的原点为基点沿着将要被腐蚀的图像A中的所有点移动,如果此时结构B中的所有点(包括原点)被A包含,那么被B原点沿着的A中的该点就保留,否则,该点就被抛弃。
可以看出,执行完该腐蚀指令后,A中突出部分,以及外围至少减少了结构B的一半(假设B的原点为B的中心)。
膨胀简单说:就是以结构B的原点为基点沿着将要被膨胀前的图像A中的所有点移动,如果此时结构B中至少有一个点(包括原点)被A包含,那么被沿着的A中的该点及周围就被B扩充,扩充范围为B的整个区域。
可以看出,膨胀后,原A沿着边缘外围被扩充了B的一半(假设B的原点为B的中心)。
数学形态学操作可以分为二值形态学和灰度形态学,灰度形态学由二值形态学扩展而来。
数学形态学有2个基本的运算,即腐蚀和膨胀,而腐蚀和膨胀通过结合又形成了开运算和闭运算。
开运算就是先腐蚀再膨胀,闭运算就是先膨胀再腐蚀。
腐蚀粗略的说,腐蚀可以使目标区域范围“变小”,其实质造成图像的边界收缩,可以用来消除小且无意义的目标物。
式子表达为:该式子表示用结构B腐蚀A,需要注意的是B中需要定义一个原点,【而B的移动的过程与卷积核移动的过程一致,同卷积核与图像有重叠之后再计算一样】当B的原点平移到图像A的像元(x,y)时,如果B在(x,y)处,完全被包含在图像A重叠的区域,(也就是B中为1的元素位置上对应的A图像值全部也为1)则将输出图像对应的像元(x,y)赋值为1,否则赋值为0。
我们看一个演示图。
B依顺序在A上移动(和卷积核在图像上移动一样,然后在B的覆盖域上进行形态学运算),当其覆盖A的区域为[1,1;1,1]或者[1,0;1,1]时,(也就是B中‘1’是覆盖区域的子集)对应输出图像的位置才会为1。
膨胀粗略地说,膨胀会使目标区域范围“变大”,将于目标区域接触的背景点合并到该目标物中,使目标边界向外部扩张。
作用就是可以用来填补目标区域中某些空洞以及消除包含在目标区域中的小颗粒噪声。
腐蚀膨胀算法原理
![腐蚀膨胀算法原理](https://img.taocdn.com/s3/m/a2f8bb92c67da26925c52cc58bd63186bceb923c.png)
腐蚀膨胀算法原理
腐蚀膨胀算法是一种基于形态学的图像处理技术,它的基本原理是:在按照给定的模板尺寸,以一定的步长,沿图像的边界线滑动,将边界线上的像素点变为白色(1),并随着滑动的过程不断扩大腐蚀的面积,使边界线逐渐消失,被腐蚀的图像越来越小;而膨胀过程则是将腐蚀后的图像恢复到原有大小,并使边界线重新出现。
腐蚀膨胀算法的基本步骤是:首先,根据图像的尺寸,设置模板大小,并以一定的步长沿着图像的边界线滑动;其次,在滑动的过程中,将边界线上的像素点变为0,进行腐蚀;然后,腐蚀过程结束后,将腐蚀后的图像进行膨胀,使图像恢复原有尺寸,并让边界线重新出现;最后,将膨胀后的图像进行保存,完成整个腐蚀膨胀算法处理过程。
腐蚀膨胀算法在图像处理中有着重要的应用,它可以用来实现图像的提取、分割和连通区域检测等。
例如,在图像提取过程中,首先将图像进行腐蚀处理,以消除噪声;然后膨胀处理,以恢复图像的原始状态;最后,不断重复腐蚀膨胀处理,以提取出感兴趣的物体。
此外,腐蚀膨胀算法还可以用于图像分割,通过腐蚀和膨胀,可以将图像分割成不同的连通区域,从而实现图像的分割。
腐蚀膨胀算法是一种基于形态学的图像处理技术,它的基本原理是:在按照给定的模板尺寸,以一定的步长,沿图像的边界线滑动,将
边界线上的像素点变为0,并随着滑动的过程不断扩大腐蚀的面积,使边界线逐渐消失,被腐蚀的图像越来越小;而膨胀过程则是将腐蚀后的图像恢复到原有大小,并使边界线重新出现。
它可以用于图像的提取、分割和连通区域检测等,是图像处理中非常重要的一种技术。
图像处理——灰度化、二值化、膨胀算法、腐蚀算法以及开运算和闭运算
![图像处理——灰度化、二值化、膨胀算法、腐蚀算法以及开运算和闭运算](https://img.taocdn.com/s3/m/16bd01e4988fcc22bcd126fff705cc1755275ffc.png)
图像处理——灰度化、⼆值化、膨胀算法、腐蚀算法以及开运算和闭运算⼀、RGBRGB模式使⽤为图像中每个的RGB分量分配⼀个0~255范围内的强度值。
RGB仅仅使⽤三种颜⾊,R(red)、G(green)、B(blue),就能够使它们依照不同的⽐例混合,在上呈现16777216(256 * 256 * 256)种颜⾊。
在电脑中,RGB的所谓“多少”就是指亮度,并使⽤整数来表⽰。
通常情况下,RGB各有256级亮度,⽤数字表⽰为从0、1、2...直到255。
⼆、ARGB⼀种,也就是⾊彩模式附加上Alpha()通道,常见于32位的。
ARGB---Alpha,Red,Green,Blue.三、灰度化在RGB模型中,假设R=G=B时,则彩⾊表⽰⼀种灰度颜⾊,当中R=G=B的值叫灰度值,因此,灰度图像每⼀个像素仅仅需⼀个字节存放灰度值(⼜称强度值、亮度值),灰度范围为0-255。
⼀般有下⾯四种⽅法对彩⾊图像进⾏灰度化,详细⽅法參考: 四、⼆值化⼀幅图像包含⽬标物体、背景还有噪声,要想从多值的数字图像中直接提取出⽬标物体,最经常使⽤的⽅法就是设定⼀个全局的阈值T,⽤T 将图像的数据分成两部分:⼤于T的像素群和⼩于T的像素群。
将⼤于T的像素群的像素值设定为⽩⾊(或者⿊⾊),⼩于T的像素群的像素值设定为⿊⾊(或者⽩⾊)。
⽐⽅:计算每个像素的(R+G+B)/3,假设>127,则设置该像素为⽩⾊,即R=G=B=255;否则设置为⿊⾊,即R=G=B=0。
C#实现代码例如以下:public Bitmap binarization(){Bitmap bitImage = new Bitmap(pictureBox1.Image);//⼆值化pictureBox1中的图⽚Color c;int height = pictureBox1.Image.Height;int width = pictureBox1.Image.Width;for (int i = 0; i < height; i++){for (int j = 0; j < width; j++){c = bitImage.GetPixel(j,i);int r = c.R;int g = c.G;int b = c.B;if ((r + g + b) / 3 >= 127){bitImage.SetPixel(j, i, Color.FromArgb(255, 255, 255));}else{bitImage.SetPixel(j, i, Color.FromArgb(0,0,0));}}}return bitImage;}执⾏结果如图:左边为处理前,右边为⼆值化后效果。
膨胀与腐蚀,radon,hough变换
![膨胀与腐蚀,radon,hough变换](https://img.taocdn.com/s3/m/64a8ebd8bb68a98270fefa22.png)
一般来说对于二值图像,膨胀运算后图像中物体 “加
长”或“变粗”;腐蚀运算后图像中物体“收缩” 或“细
化”。下面先通过一些例题观察分析膨胀与腐蚀后 的
效果,总结二值图像膨胀与腐蚀运算的方法与原则, 最后给出二值图像膨胀与腐蚀运算的准确描述以及
简单的应用。
1 二值图像膨胀运算
先通过下面例题观察分析编辑几课个件 二值图像膨胀算子的 1
数imclose用来完成两个图像的闭运算。
编辑课件
17
【例3-20】对图像实施开闭运算。 设计如下程序:
A= imread('D:\125.jpg'); B=rgb2gray(A); M=strel('diamond',2); C1=imopen(B,M); C2=imclose(B,M); subplot(1,3,1); imshow(B) subplot(1,3,2); imshow(C1) subplot(1,3,3); imshow(C2)
编辑课件
14
【例3-19】对灰度图像实施膨胀腐蚀运算。 设计下面程序
A=imread('D:\flower1.bmp'); A1=rgb2gray(A);
se=strel('square',3);
A2=imdilate(A1,se); A3=imerode(A1,se);
subplot(1,3,1),imshow(A1);
图3-17 二值图像bc.bmp的颜色数据
编辑课件
4
为了节省篇幅,这里只研究字母b被膨胀后的变化情况。下 图中的4个图像都是字母b的变化情况。
(b)
(a)
结 果使
用
编程实现膨胀运算或者腐蚀运算
![编程实现膨胀运算或者腐蚀运算](https://img.taocdn.com/s3/m/455696f9f61fb7360b4c659b.png)
数字图像处理实验编程实现膨胀运算或者腐蚀运算姓名:学好:0904210239指导老师:王韬时间:2012年5月编程实现膨胀运算或者腐蚀运算一、实验原理腐蚀:是一种消除连通域的边界点,使边界向内收缩的处理。
设计一个结构元素,结构元素的原点定位在待处理的目标像素上,通过判断是否覆盖,来确定是否该点被腐蚀掉。
膨胀:是将与目标区域的背景点合并到该目标物中,使目标物边界向外部扩张的处理。
设计一个结构元素,结构元素的原点定位在背景像素上,判断是否覆盖有目标点,来确定是否该点被膨胀为目标点。
二、实验步骤腐蚀:1)扫描原图,找到第一个像素值为1的目标点;2)将预先设定好形状以及原点位置的结构元素的原点移到该点;3)判断该结构元素所覆盖范围内的像素值是否全部为1:如果是,则腐蚀后图像中的相同位置上的像素值为1;如果不是,则腐蚀后图像中的相同位置上的像素值为0;4)重复2)和3),直到所有原图中像素处理完成。
膨胀:1)扫描原图,找到第一个像素值为0的背景点;2)将预先设定好形状以及原点位置的结构元素的原点移到该点;3)判断该结构元素所覆盖范围内的像素值是否存在为1的目标点:如果是,则膨胀后图像中的相同位置上的像素值为1;如果不是,则膨胀后图像中的相同位置上的像素值为0;4)重复2)和3),直到所有原图中像素处理完成。
三、实验程序# include <afxwin.h># include <windows.h># include <iostream.h># include <stdlib.h># include <math.h># define PI 3.14159265typedef struct{double re;double im;}COMPLEX;COMPLEX Add(COMPLEX c1,COMPLEX c2){COMPLEX c;c.re=c1.re+c2.re;c.im=c1.im+c2.im;return c;}COMPLEX Sub(COMPLEX c1,COMPLEX c2){COMPLEX c;c.re=c1.re-c2.re;c.im=c1.im-c2.im;return c;}COMPLEX Mul(COMPLEX c1,COMPLEX c2){COMPLEX c;c.re=c1.re*c2.re-c1.im*c2.im;c.im=c1.re*c2.im+c2.re*c1.im;return c;}int nWidth;int nHeight;int nColorBits;int nColor;int nLen;int nByteWidth;BYTE * lpBitmap;BYTE * lpBits;void OpenFile(CString FileName);void SaveFile(CString FileName);void fushi();void pengzhang();void OpenFile(CString FileName){HANDLE hFile= ::CreateFile(FileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EX ISTING,FILE_ATTRIBUTE_NORMAL,NULL);if(hFile==0){printf("不能调开文件,请重新选择! \n");return;}DWORD WriteNum;BITMAPFILEHEADER BFH;ReadFile(hFile,&BFH,14,&WriteNum,NULL);if((BFH.bfType!='MB')||(WriteNum!=sizeof(BITMAPFILEHEADER))){printf("不是BMP位图文件或数据有误! \n");return;}nLen = GetFileSize(hFile,NULL)-sizeof(BITMAPFILEHEADER);lpBitmap= new BYTE[nLen];ReadFile(hFile,lpBitmap,nLen,&WriteNum,NULL);BITMAPINFOHEADER * BIH = ((BITMAPINFOHEADER*)lpBitmap);nWidth = BIH ->biWidth;nHeight = BIH ->biHeight;nColorBits= BIH ->biBitCount;nByteWidth= (nWidth*nColorBits+31)/32*4;nColor = (nColorBits>8)?0:(1<<nColorBits);lpBits = lpBitmap + sizeof(BITMAPINFOHEADER) +sizeof(RGBQUAD)*nColor;CloseHandle(hFile);}void SaveFile(CString FileName){HANDLE hFile= ::CreateFile(FileName,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREAT E_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);if(hFile ==0){printf("不能创建文件,请重新选择! \n");return;}unsigned long WriteNum;BITMAPFILEHEADER BFH;BFH.bfType = 'MB';BFH.bfSize = nLen + sizeof(BITMAPFILEHEADER);BFH.bfOffBits = sizeof(BITMAPFILEHEADER) +sizeof(BITMAPINFOHEADER) + nColor * sizeof(RGBQUAD);BFH.bfReserved1 = BFH.bfReserved2 = 0;WriteFile(hFile,&BFH,sizeof(BITMAPFILEHEADER),&WriteNum,NULL);WriteFile(hFile,(BITMAPINFOHEADER* )lpBitmap,nLen,&WriteNum,NULL);CloseHandle(hFile);}void fushi(){unsigned char * data,* lpDst,* temp ;//分别指向源图像和缓存图像的指针temp=new BYTE[256*256];//暂时分配内存,以保存新图像for (int i=1;i<nHeight-1;i++){for (int j=1;j<nWidth-1;j++){data=(lpBits+nByteWidth*j+i);//指向原图像第j行第i个像素的指针lpDst=(temp+nByteWidth*j+i);//指向目标图像第j行第i个像素的指针*lpDst=255;//目标图像中的当前点先赋成白色if(*data==255){if( *(data-1)==0 || *(data+1)==0 ||*(data-nByteWidth)==0 || *(data+nByteWidth)==0 ||*(data-nByteWidth-1)==0 || *(data-nByteWidth+1)==0 ||*(data+nByteWidth-1)==0 || *(data+nByteWidth+1)==0)*lpDst=0;}else*lpDst=0;}}for(i=0;i<nHeight;i++){for(int j=0;j<nWidth;j++){data=(lpBits+nByteWidth*j+i);lpDst=(temp+nByteWidth*j+i);* data = * lpDst;}delete temp;//释放空间}void pengzhang(){unsigned char * data,* lpDst,* temp ;//分别指向源图像和缓存图像的指针temp=new BYTE[256*256];//暂时分配内存,以保存新图像for (int i=1;i<nHeight-1;i++){for (int j=1;j<nWidth-1;j++){data=(lpBits+nByteWidth*j+i);//指向原图像第j行第i个像素的指针lpDst=(temp+nByteWidth*j+i);//指向目标图像第j行第i个像素的指针*lpDst=0;//目标图像中的当前点先赋成黑色if(*data==0){if( *(data-1)==255 || *(data+1)==255 ||*(data-nByteWidth)==255 || *(data+nByteWidth)==255 ||*(data-nByteWidth-1)==255 || *(data-nByteWidth+1)==255 ||*(data+nByteWidth-1)==255 || *(data+nByteWidth+1)==255)*lpDst=255;}else*lpDst=255;}}for(i=0;i<nHeight;i++){for(int j=0;j<nWidth;j++){data=(lpBits+nByteWidth*j+i);lpDst=(temp+nByteWidth*j+i);* data = * lpDst;}}delete temp;//释放空间}{char OpenFileName[100];char SaveFileName[100];printf("输入待处理的图像路径: \n");gets(OpenFileName);printf("保存处理图像结果的路径: \n");gets(SaveFileName);OpenFile(OpenFileName);cout<<"选择:1腐蚀,2膨胀"<<endl;int n;cin>>n;switch(n){case 1:fushi();break;case 2:pengzhang();break;}SaveFile(SaveFileName);return 0;}四、实验结果原图像:腐蚀后:膨胀后:。
腐蚀,膨胀,细化算法
![腐蚀,膨胀,细化算法](https://img.taocdn.com/s3/m/0f375e3b6c85ec3a87c2c538.png)
第6章腐蚀,膨胀,细化算法今天所讲的内容属于一门新兴的学科:数学形态学(Mathematical Morphology)。
说起来很有意思,它是法国和德国的科学家在研究岩石结构时建立的一门学科。
形态学的用途主要是获取物体拓扑和结构信息,它通过物体和结构元素相互作用的某些运算,得到物体更本质的形态。
在图象处理中的应用主要是:(1)利用形态学的基本运算,对图象进行观察和处理,从而达到改善图象质量的目的;(2)描述和定义图象的各种几何参数和特征,如面积、周长、连通度、颗粒度、骨架和方向性等。
限于篇幅,我们只介绍二值图象的形态学运算,对于灰度图象的形态学运算,有兴趣的读者可以阅读有关的参考书。
在程序中,为了处理的方便,还是采用256级灰度图,不过只用到了调色板中的0和255两项。
先来定义一些基本符号和关系。
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所示。
图6.1 元素图6.2 包含图6.3 击中图6.4 不击中5.补集设有一幅图象X,所有X区域以外的点构成的集合称为X的补集,记作X c,如图6.5所示。
显然,如果B∩X=Ф,则B在X的补集内,即B X c。
图6.5 补集的示意图6.结构元素设有两幅图象B,X。
若X是被处理的对象,而B是用来处理X的,则称B为结构元素(structure element),又被形象地称做刷子。
腐蚀膨胀算法原理
![腐蚀膨胀算法原理](https://img.taocdn.com/s3/m/e7f70e457f21af45b307e87101f69e314332fa8c.png)
腐蚀膨胀算法原理腐蚀膨胀算法(Erosion-Dilation)是形态学处理图像基础操作之一,它可以有效地提取图像中更容易区分的特征,也可以帮助连接图像中的像素或者单元,从而实现图像处理更精确、更有效率。
腐蚀膨胀算法通常用于图像处理技术中,比如:物体提取、对象识别、图像分割等,所以它在图像处理中起着重要的作用。
腐蚀膨胀算法的原理基于形态学的基本概念,它有两个基本操作:腐蚀(Erosion)和膨胀(Dilation),腐蚀和膨胀的组合,可以用来提取图像的特征形状,这种基于形态学的处理可以有效提取图像中的更容易区分的特征,可以帮助连接图像中的像素或者单元。
腐蚀是一种基于结构元素的图像处理方式,它通过改变像素点的颜色或者亮度,来改变图像的形状,它主要是将图像中的边缘信息向内部收缩,让图像看起来更加清晰,同时可以把图像中一些不重要的噪声去除,比如白色点、小线条等,这些信息对图像的提取没有任何帮助,但是可以使图像的外形变得更加清晰。
膨胀是一种基于结构元素的图像处理方式,它和腐蚀刚好相反,它主要是将图像中的边缘信息向外部膨胀,它可以帮助填补图像中凹陷的区域,从而实现对象的连接,同时它也可以增强图像中的轮廓,从而更准确的提取物体的形状特征,以及更好的划分不同的物体。
腐蚀膨胀算法的核心是结构元素,它由一个结构元素的模板定义。
这个模板的大小和形状,都会影响图像的处理结果,一般来说,结构元素的形状应该和要提取的物体的形状有关,可以通过不断调整结构元素的大小和形状,来获得更准确的图像处理结果。
腐蚀膨胀算法可以有效地提取出图像中更容易区分的特征,也可以帮助连接图像中的像素或者单元,使图像处理更精确、更有效率。
腐蚀膨胀算法一般都是建立在形态学基础操作之上,它有两个基本操作:腐蚀和膨胀,腐蚀和膨胀的组合,可以用来提取图像的特征形状,它的应用非常的广泛,可以用于图像处理技术中的物体提取、对象识别、图像分割等。
总之,腐蚀膨胀算法是一种有效的图像处理方式,它的思想也可以应用到其他的图像处理中去,它可以帮助解决许多图像处理中的问题,也可以帮助图像处理变得更加准确。
opencv腐蚀膨胀函数
![opencv腐蚀膨胀函数](https://img.taocdn.com/s3/m/8af8f14630b765ce0508763231126edb6e1a7679.png)
opencv腐蚀膨胀函数OpenCV是一个开源的计算机视觉库,提供了很多图像处理函数,其中包括腐蚀和膨胀函数。
这两个函数是形态学图像处理的基本操作,可以用于去除噪声、填充空白区域、分离物体等。
腐蚀函数可以将图像的边界腐蚀掉,使边界变窄,而保留图像中的大致形状和结构。
它的作用类似于用边缘像素覆盖物体的边缘部分,从而使物体变得更小。
腐蚀函数可以通过调整腐蚀的次数和腐蚀的邻域大小来控制腐蚀的程度。
在OpenCV中,可以使用函数cv2.erode(image, kernel, iterations)来进行腐蚀操作。
其中,image是输入图像,kernel是腐蚀操作的结构化元素,iterations是腐蚀的次数。
结构化元素是腐蚀操作的一个重要参数,它决定了腐蚀的效果。
通常情况下,可以使用函数cv2.getStructuringElement(shape, ksize)来生成结构化元素。
其中,shape可以是cv2.MORPH_RECT矩形、cv2.MORPH_ELLIPSE椭圆或cv2.MORPH_CROSS十字形,ksize是结构化元素的大小。
膨胀函数与腐蚀函数相反,可以将图像的边界扩张,使边界变宽,从而填充空白区域,连接物体。
膨胀函数可以通过调整膨胀的次数和膨胀的邻域大小来控制膨胀的程度。
在OpenCV中,可以使用函数cv2.dilate(image, kernel, iterations)来进行膨胀操作。
与腐蚀函数一样,膨胀函数也需要指定输入图像、结构化元素和膨胀的次数。
结构化元素的生成方法和腐蚀函数相同。
腐蚀和膨胀函数在实际图像处理中经常被联合使用,以达到更好的效果。
常见的操作包括开运算和闭运算。
开运算是先进行腐蚀操作,再进行膨胀操作。
它可以用于去除图像中的小的噪点和毛刺,同时保持物体的整体形状和结构。
开运算的代码如下:```pythonimport cv2image = cv2.imread("image.jpg", 0)kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))opened = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel)cv2.imshow("Opened Image", opened)cv2.waitKey(0)```闭运算是先进行膨胀操作,再进行腐蚀操作。
膨胀和腐蚀运算的优缺点
![膨胀和腐蚀运算的优缺点](https://img.taocdn.com/s3/m/b83a976abf23482fb4daa58da0116c175e0e1e43.png)
膨胀和腐蚀运算的优缺点
膨胀和腐蚀运算是数字图像处理中经常使用的基本形态学运算。
它们可以用来改善图像的质量、去除噪声、分割目标等。
但是,它们也存在一些优缺点,下面就来详细介绍一下。
优点:
1. 增强图像的边缘和轮廓:膨胀和腐蚀运算可以增强图像的边缘和轮廓,使目标更加突出,更容易进行后续的图像处理。
2. 去除噪声:膨胀和腐蚀运算可以去除图像中一些小的噪声,使图像更加清晰。
3. 分割目标:膨胀和腐蚀运算可以将图像中的目标进行分割,使得后续处理更加容易。
缺点:
1. 信息丢失:膨胀和腐蚀运算会导致一些信息的丢失,使得图像的细节变得模糊。
2. 形态学运算的复杂度:膨胀和腐蚀运算的复杂度比较高,需要耗费较多的计算资源和时间。
3. 影响图像质量:如果膨胀和腐蚀运算的参数设置不合理,可能会导致图像质量下降,从而影响后续的图像处理结果。
总的来说,膨胀和腐蚀运算在数字图像处理中具有重要的作用,但需要根据具体的情况进行合理的参数设置和运算处理,才能达到最佳的效果。
- 1 -。
opencv之膨胀与腐蚀
![opencv之膨胀与腐蚀](https://img.taocdn.com/s3/m/9a6e3e10b6360b4c2e3f5727a5e9856a561226fa.png)
opencv之膨胀与腐蚀腐蚀和膨胀 Erosion/Dilationerosion/dilation,⽤⽩话说,就是让图像亮的区域收缩和扩张.原理我们定义⼀个卷积核矩阵.这个矩阵可以是任何形状的,但通常⽽⾔,是矩形或者圆形的.同时要定义⼀个锚点位置.⽤这个卷积核矩阵挨个地划过原始图像矩阵,同时更改锚点位置的像素值.锚点位置的像素值更改为卷积核矩阵覆盖的有效像素值中的最⼤值/最⼩值(分别对应膨胀/腐蚀).什么叫"有效"像素值呢?就是卷积核中不为0的那些位置.⽤公式表达的话,即:膨胀和腐蚀,说⽩了就是个求"卷积核所表⽰的局部"的最⼤值最⼩值的过程.我们来看⼀个例⼦:import cv2import numpy as npdef test1():img = np.zeros((10,10,1),np.uint8)img[3:7,3:7,:] = 255img[4:6,4:6,:] = 200kernel1 = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))erosion_dst = cv2.erode(img, kernel1)print(erosion_dst)⾸先我们创建⼀个10 x 10的图像,像素如下:[[ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 255 255 255 255 0 0 0][ 0 0 0 255 200 200 255 0 0 0][ 0 0 0 255 200 200 255 0 0 0][ 0 0 0 255 255 255 255 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0]]我们创建⼀个卷积核:kernel1 = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))三个参数分别为卷积核的形状/⼤⼩/锚点位置. 默认锚点在矩阵的中⼼位置.形状有三种上⾯代码中我们创建的3 x 3矩形卷积核如下⽤这个卷积核对原始图像做腐蚀后得到的矩阵如下即矩阵有如下变化:[ 0 0 0 255 200 200 255 0 0 0][ 0 0 0 255 200 200 255 0 0 0][ 0 0 0 255 255 255 255 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0]]-->[[ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 200 200 0 0 0 0][ 0 0 0 0 200 200 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0]]我们考虑第三⾏第四列img[2,3,:]这个像素.当我们的卷积核矩阵的锚点位置与该像素重合时,我们取周边所有像素的最⼩值.最⼩值为0.所以该位置的像素值变为0. 其余位置的像素值同理可求.我们稍微改⼀下我们的代码,然后再看⼀下不同卷积核作⽤下的不同结果,会理解的更清楚import cv2import numpy as npdef test1():img = np.zeros((10,10,1),np.uint8)img[3:7,3:7,:] = 255img[4:6,4:6,:] = 200kernel1 = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))print(kernel1)erosion_dst = cv2.erode(img, kernel1)print(erosion_dst)def test2():img = np.zeros((10,10,1),np.uint8)img[3:7,3:7,:] = 255img[4:6,4:6,:] = 200img[2,4,:] = 100kernel1 = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))erosion_dst = cv2.erode(img, kernel1)print(erosion_dst)kernel2 = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))erosion_dst2 = cv2.erode(img, kernel2)print(erosion_dst2)test2()我们把原始图像矩阵改为[ 0 0 0 255 200 200 255 0 0 0][ 0 0 0 255 200 200 255 0 0 0][ 0 0 0 255 255 255 255 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0][ 0 0 0 0 0 0 0 0 0 0]]⽤kernal1时,kernal1如下:以第四⾏,第五列的像素为例,⽤卷积核的锚点与之对应,此时计算的是其周围⼋个像素的最⼩值,最⼩值为0.所以我们得到的矩阵为当我们⽤kernal2时,kernal2如下:对第四⾏,第五列的像素,⽤卷积核的锚点与之对应,此时计算的不再是周围⼋个像素的最⼩值,⽽是其正上⽅,正下⽅,正左边,正右边的四个像素的最⼩值.该值为100.所以我们得到的矩阵为opencv⽰例from __future__ import print_functionimport cv2 as cvimport numpy as npimport argparseerosion_size = 0max_elem = 2max_kernel_size = 21title_trackbar_element_type = 'Element:\n 0: Rect \n 1: Cross \n 2: Ellipse'title_trackbar_kernel_size = 'Kernel size:\n 2n +1'title_erosion_window = 'Erosion Demo'title_dilatation_window = 'Dilation Demo'def erosion(val):erosion_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_erosion_window)erosion_type = 0val_type = cv.getTrackbarPos(title_trackbar_element_type, title_erosion_window)if val_type == 0:erosion_type = cv.MORPH_RECTelif val_type == 1:erosion_type = cv.MORPH_CROSSelif val_type == 2:erosion_type = cv.MORPH_ELLIPSEelement = cv.getStructuringElement(erosion_type, (2*erosion_size + 1, 2*erosion_size+1), (erosion_size, erosion_size))erosion_dst = cv.erode(src, element)cv.imshow(title_erosion_window, erosion_dst)def dilatation(val):dilatation_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_dilatation_window)dilatation_type = 0val_type = cv.getTrackbarPos(title_trackbar_element_type, title_dilatation_window)if val_type == 0:dilatation_type = cv.MORPH_RECTelif val_type == 1:dilatation_type = cv.MORPH_CROSSelif val_type == 2:dilatation_type = cv.MORPH_ELLIPSEelement = cv.getStructuringElement(dilatation_type, (2*dilatation_size + 1, 2*dilatation_size+1), (dilatation_size, dilatation_size)) dilatation_dst = cv.dilate(src, element)cv.imshow(title_dilatation_window, dilatation_dst)src = cv.imread("/home/sc/disk/keepgoing/opencv_test/j.png")dWindow(title_erosion_window)cv.createTrackbar(title_trackbar_element_type, title_erosion_window , 0, max_elem, erosion)cv.createTrackbar(title_trackbar_kernel_size, title_erosion_window , 0, max_kernel_size, erosion)dWindow(title_dilatation_window)cv.createTrackbar(title_trackbar_element_type, title_dilatation_window , 0, max_elem, dilatation)cv.createTrackbar(title_trackbar_kernel_size, title_dilatation_window , 0, max_kernel_size, dilatation)erosion(0)dilatation(0)cv.waitKey()通过在窗⼝上创建两个bar,⽅便我们看不同种类不同⼤⼩的卷积核的影响.cv.createTrackbar(title_trackbar_element_type, title_erosion_window , 0, max_elem, erosion)cv.createTrackbar(title_trackbar_kernel_size, title_erosion_window , 0, max_kernel_size, erosion)原始图⽚:处理效果:opencv实现。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
C++图像的膨胀和腐蚀
二值图像是一种简单的图像格式,它只有两个灰度级,即"0"表示黑色的像素点,"255"表示白色的像素点,至于如何从一幅普通的图像获得二值图像,请参考我近期在天极网上发表的《Visual C++编程实现图像的分割》一文。
二值图像处理在图像处理领域占据很重要的位置,在具体的图像处理应用系统中,往往需要对于获得的二值图像再进一步进行处理,以有利于后期的识别工作。
二值图像处理运算是从数学形态学下的集合论方法发展起来的,尽管它的基本运算很简单,但是却可以产生复杂的效果。
常用的二值图像处理操作有许多方法,如腐蚀、膨胀、细化、开运算和闭运算等等。
本文对这些内容作些研究探讨,
希望对爱好图像处理的朋友有所帮助。
一、腐蚀和膨胀形态学是一门新兴科学,它的用途主要是获取物体拓扑和结果信息,它通过物体和结构元素相互作用的某些运算,得到物体更本质的形态。
它在图像处理中的应用主要是: 1.利用形态学的基本运算,对图像进行观察和处理,从而达到改善图像质量的目的; 2.描述和定义图像的各种几何参数和特征,如面积,周长,连通度,颗粒度,骨架和方向性。
限于篇幅,我们只介绍简单二值图像的形态学运算,对于灰度图像的形态学运算,有兴趣的读者可以看有关的参考书。
二值图像基本的形态学运算是腐蚀和膨胀,简单的腐蚀是消除物体的所有边界点的一种过程,其结果是使剩下的物体沿其周边比原物体小一个像素的面积。
如果物体是圆的,它的直径在每次腐蚀后将减少两个像素,如果物体在某一点处任意方向上连通的像素小于三个,那么该物体经过一次腐蚀后将在该点处分裂为二个物体。
简单的膨胀运算是将与某物体接触的所有背景点合并到该物体中的过程。
过程的结果是使物体的面积增大了相应数量的点,如果物体是圆的,它的直径在每次膨胀后将增大两个像素。
如果两个物体在某一点的任意方向相隔少于三个像素,它们将在该点连通起来。
下面给出具体的实现腐蚀和膨胀的函数代码:
////////////////////////////////二值图像腐蚀操作函数
BOOL ImageErosion(BYTE *pData,int Width,int Height)
{//pData为图像数据的指针,Width和Height为图像的宽和高;
BYTE* pData1;
int m,n,i,j,sum,k,sum1;
BOOL bErosion;
if(pData==NULL)
{
AfxMessageBox("图像数据为空,请读取图像数据"); return FALSE;
}
//申请空间,pData1存放处理后的数据;
pData1=(BYTE*)new
char[WIDTHBYTES(Width*8)*Height];
if(pData1==NULL)
{
AfxMessageBox("图像缓冲数据区申请失败,请重新申请图
像数据缓冲区");
return FALSE ;
}
memcpy(pData1,pData,WIDTHBYTES(Width*8)*Height); for(i=10;i<Height-10;i++)
for(j=32;j<Width-32;j++)
{
bErosion=FALSE;
sum=*(pData+WIDTHBYTES(Width*8)*i+j);
if(sum==255)
{
//求像素点八邻域的灰度均值;
for(m=-1;m<2;m++)
{
for(n=-1;n<2;n++)
{
sum1=*(pData+WIDTHBYTES(Width*8)*(i+m)+j+n); if(sum1==0)
{
*(pData1+WIDTHBYTES(Width*8)*i+j)=0; bErosion=TRUE;
break;
}
}
if(bErosion)
{
bErosion=FALSE;
break;
}
}
}
}
memcpy(pData,pData1,WIDTHBYTES(Width*8)*Height);
}
////////////////////////////////////二值图像的膨胀操作
BOOL ImageDilation(BYTE *pData,int Width,int Height) {
BYTE* pData1;
int m,n,i,j,sum,k,sum1;
BOOL bDilation;
if(pData==NULL)
{
AfxMessageBox("图像数据为空,请读取图像数据");
}
//申请空间,pData1存放处理后的数据;
pData1=(BYTE*)new
char[WIDTHBYTES(Width*8)*Height];
if(pData1==NULL)
{
AfxMessageBox("图像缓冲数据区申请失败,请重新申请图像数据缓冲区");
return FALSE ;
}
memcpy(pData1,pData,WIDTHBYTES(Width*8)*Height);
for(i=10;i<Height-10;i++)
for(j=32;j<Width-32;j++)
{
bDilation=FALSE;
sum=*(pData+WIDTHBYTES(Width*8)*i+j); if(sum==0)
{
//求像素点八邻域的灰度值;
for(m=-1;m<2;m++)
{
for(n=-1;n<2;n++)
{
sum1=*(pData+WIDTHBYTES(Width*8)*(i+m)+j+n); if(sum1==255)
{
*(pData1+WIDTHBYTES(Width*8)*i+j)=255; bDilation=TRUE;
break;
}
}
if(bDilation)
{
bDilation=FALSE;
break;
}
}
}
}
memcpy(pData,pData1,WIDTHBYTES(Width*8)*Height); return TRUE;
}。