图像细化算法大全
Zhang-Suen图像细化算法python实现
Zhang-Suen图像细化算法python实现算法流程⾸先要反转原图像，因为算法之后所有的操作都将0作为前景，将1作为背景。
中⼼像素x_1(x,y)的8-近邻定义如下所⽰：考虑以下两个步骤步骤1：执⾏光栅扫描并标记满⾜以下5个条件的所有像素：这是⼀个⿊⾊像素；顺时针查看x2、x3、...、x9、x2时，从0到1的变化次数仅为1;x2、x3、...、x9中1的个数在2个以上6个以下;x2、x4、x6中⾄少有1个为1;x4、x6、x8中⾄少有1个为1;将满⾜条件的所有像素标为1步骤2：执⾏光栅扫描并标记满⾜以下5个条件的所有像素：这是⼀个⿊⾊像素；顺时针查看x2、x3、...、x9、x2时，从0到1的变化次数仅为1;x2、x3、...、x9中1的个数在2个以上6个以下;x2、x4、x8中⾄少有1个为1;x2、x6、x8中⾄少有1个为1;将满⾜条件的所有像素标为1反复执⾏步骤1和步骤2，直到没有点发⽣变化。
python实现：import cv2import numpy as npimport matplotlib.pyplot as plt# Zhang Suen thining algorythmdef Zhang_Suen_thining(img):# get shapeH, W, C = img.shape# prepare out imageout = np.zeros((H, W), dtype=np.int)out[img[..., 0] > 0] = 1# inverseout = 1 - outwhile True:s1 = []s2 = []# step 1 ( rasta scan )for y in range(1, H-1):for x in range(1, W-1):# condition 1if out[y, x] > 0:continue# condition 2f1 = 0if (out[y-1, x+1] - out[y-1, x]) == 1:f1 += 1if (out[y, x+1] - out[y-1, x+1]) == 1:f1 += 1if (out[y+1, x+1] - out[y, x+1]) == 1:f1 += 1if (out[y+1, x] - out[y+1,x+1]) == 1:f1 += 1if (out[y+1, x-1] - out[y+1, x]) == 1:f1 += 1if (out[y, x-1] - out[y+1, x-1]) == 1:f1 += 1if (out[y-1, x-1] - out[y, x-1]) == 1:f1 += 1if (out[y-1, x] - out[y-1, x-1]) == 1:f1 += 1if f1 != 1:continue# condition 3f2 = np.sum(out[y-1:y+2, x-1:x+2])if f2 < 2 or f2 > 6:continue# condition 4# x2 x4 x6if (out[y-1, x] + out[y, x+1] + out[y+1, x]) < 1 : continue# condition 5# x4 x6 x8if (out[y, x+1] + out[y+1, x] + out[y, x-1]) < 1 : continues1.append([y, x])for v in s1:out[v[0], v[1]] = 1# step 2 ( rasta scan )for y in range(1, H-1):for x in range(1, W-1):# condition 1if out[y, x] > 0:continue# condition 2f1 = 0if (out[y-1, x+1] - out[y-1, x]) == 1:f1 += 1if (out[y, x+1] - out[y-1, x+1]) == 1:f1 += 1if (out[y+1, x+1] - out[y, x+1]) == 1:f1 += 1if (out[y+1, x] - out[y+1,x+1]) == 1:f1 += 1if (out[y+1, x-1] - out[y+1, x]) == 1:f1 += 1if (out[y, x-1] - out[y+1, x-1]) == 1:f1 += 1if (out[y-1, x-1] - out[y, x-1]) == 1:f1 += 1if (out[y-1, x] - out[y-1, x-1]) == 1:f1 += 1if f1 != 1:continue# condition 3f2 = np.sum(out[y-1:y+2, x-1:x+2])if f2 < 2 or f2 > 6:continue# condition 4# x2 x4 x8if (out[y-1, x] + out[y, x+1] + out[y, x-1]) < 1 : continue# condition 5# x2 x6 x8if (out[y-1, x] + out[y+1, x] + out[y, x-1]) < 1 : continues2.append([y, x])for v in s2:out[v[0], v[1]] = 1# if not any pixel is changedif len(s1) < 1 and len(s2) < 1:breakout = 1 - outout = out.astype(np.uint8) * 255return out# Read imageimg = cv2.imread("../thin.png").astype(np.float32) # Zhang Suen thiningout = Zhang_Suen_thining(img)# Save resultcv2.imwrite("out.png", out)cv2.imshow("result", out)cv2.waitKey(0)cv2.destroyAllWindows()实验结果：。
介绍常见的图像处理算法及其应用
介绍常见的图像处理算法及其应用图像处理算法是计算机视觉领域的重要内容，它涵盖了许多不同的技术和方法。
本文将介绍一些常见的图像处理算法及其应用。
这些算法可以用于图像增强、图像分割、目标识别等领域，它们可以帮助我们更好地理解和处理图像数据。
一、图像滤波算法图像滤波是图像处理的基础算法之一，它通过对图像进行平滑处理来去除图像中的噪声或者增强图像的细节。
图像滤波算法有很多种，其中常见的有均值滤波、中值滤波和高斯滤波。
均值滤波是一种简单的滤波算法，它通过计算像素点周围领域像素的平均值来达到平滑图像的效果。
均值滤波对噪声有一定的去除效果，但是对于边缘和细节信息的保存能力较差。
中值滤波是一种非线性滤波算法，它通过对图像中的像素值进行排序，然后选择排序后的中间值作为当前像素的新值。
中值滤波对椒盐噪声有较好的去除效果，并且能够保持图像的边缘信息。
高斯滤波是一种基于高斯函数的线性滤波算法，它通过对图像中的像素进行加权平均来实现平滑效果。
高斯滤波对于去除高斯噪声以及其他类型的噪声都有较好的去除效果。
二、图像分割算法图像分割是将图像划分成具有语义信息的相互独立的区域的过程。
图像分割算法通常根据图像中的灰度值、颜色、纹理等特征将图像进行分割。
常见的图像分割算法有阈值分割、基于区域的分割和基于边缘的分割。
阈值分割是一种简单常用的分割算法，它将图像中的像素根据灰度值与阈值的关系进行分类。
通过调整阈值的大小，可以实现不同程度的图像分割。
基于区域的分割算法是根据像素之间的相似性将图像进行分割，使具有相似性质的像素聚合成为一个区域。
常见的基于区域的分割算法有K-means算法和基于区域的生长算法。
基于边缘的分割算法是根据图像中的边缘信息将图像进行分割。
边缘是图像中颜色、灰度值等发生突变的地方，基于边缘的分割算法通过检测图像中的边缘来实现分割。
三、图像特征提取算法图像特征提取是将图像中的信息转化为计算机可以理解和处理的形式的过程。
图像特征可以是图像的边缘、纹理、颜色等视觉特征，也可以是经过某种数学变换得到的特征。
Hilditch 细化算法是经典的二值图像细化算法
Hilditch 细化算法是经典的二值图像细化算法，然而，在网上却很难找到一个详细、正确的介绍和实现。
可以找到一辆个 Hilditch 算法的C实现，但缺乏注释，代码可读性也很差。
在期刊网上找到几篇论文，提及了Hilditch 算法，结果一篇说的罗哩罗嗦根本看不懂，另一篇说的说的易懂，却是错误的！拿来主义是行不通了，于是只好结合着这几个论文和代码，从头写 Hilditch 细化算法。
假设像素p的3×3邻域结构为：Hilditch 细化算法的步骤为：对图像从左向右从上向下迭代每个像素，是为一个迭代周期。
在每个迭代周期中，对于每一个像素p，如果它同时满足6个条件，则标记它。
在当前迭代周期结束时，则把所有标记的像素的值设为背景值。
如果某次迭代周期中不存在标记点（即满足6个条件的像素），则算法结束。
假设背景值为0，前景值为1，则：6个条件为：（I）：p 为1，即p不是背景；（2）：x1,x3,x5,x7不全部为1（否则把p标记删除，图像空心了）；（3）：x1-x8 中，至少有2个为1（若只有1个为1，则是线段的端点。
若没有为1的，则为孤立点）；（4）：p的8连通联结数为1；联结数指在像素p的3*3邻域中，和p连接的图形分量的个数：上图中，左图的4连通联结数是2，8连通联结数是1，而右图的4联通联结数和8联通联结数都是2。
4连通联结数计算公式是：8连通联结数计算公式是：其中，至于公式怎么来的就不管了，直接用就行了。
（5）假设x3已经标记删除，那么当x3为0时，p的8联通联结数为1；（6）假设x5已经标记删除，那么当x5为0时，p的8联通联结数为1。
======在程序中，我使用的是这样的邻域编码：为了方便计算联结数，以0作为前景，1作为背景。
程序如下（完整程序见：/svn/trunk/src/mon/UnmanagedI mage/ImageU8.cs）：/// <summary>/// 计算八联结的联结数，计算公式为：/// (p6 - p6*p7*p0) + sigma(pk - pk*p(k+1)*p(k+2)), k = {0,2,4)/// </summary>/// <param name="list"></param>/// <returns></returns>private unsafe Int32 DetectConnectivity(Int32* list){Int32 count = list[6] - list[6] * list[7] * list[0];count += list[0] - list[0] * list[1] * list[2];count += list[2] - list[2] * list[3] * list[4];count += list[4] - list[4] * list[5] * list[6];return count;}private unsafe void FillNeighbors(Byte* p, Int32* list, Int32 width, Byte foreground = 255){// list 存储的是补集，即前景点为0，背景点为1，以方便联结数的计算list[0] = p[1] == foreground ? 0 : 1;list[1] = p[1 - width] == foreground ? 0 : 1;list[2] = p[-width] == foreground ? 0 : 1;list[3] = p[-1 - width] == foreground ? 0 : 1;list[4] = p[-1] == foreground ? 0 : 1;list[5] = p[-1 + width] == foreground ? 0 : 1;list[6] = p[width] == foreground ? 0 : 1;list[7] = p[1 + width] == foreground ? 0 : 1;}/// <summary>/// 使用 hilditch 算法进行细化/// </summary>public unsafe void Thinning(Byte foreground = 255){Byte* start = this.Start;Int32 width = this.Width;Int32 height = this.Height;Int32* list = stackalloc Int32[8];Byte background = (Byte)(255 - foreground);Int32 length = this.Length;using (ImageU8 mask = new ImageU8(this.Width, this.Height)) {mask.Fill(0);Boolean loop = true;while (loop == true){loop = false;for (Int32 r = 1; r < height - 1; r++){for (Int32 c = 1; c < width - 1; c++){Byte* p = start + r * width + c;// 条件1：p 必须是前景点if (*p != foreground) continue;// p3 p2 p1// p4 p p0// p5 p6 p7// list 存储的是补集，即前景点为0，背景点为1，以方便联结数的计算FillNeighbors(p, list, width, foreground);// 条件2：p0,p2,p4,p6 不皆为前景点if (list[0] == 0 && list[2] == 0 && list[4] == 0 && list[6] == 0)continue;// 条件3: p0~p7至少两个是前景点Int32 count = 0;for (int i = 0; i < 8; i++){count += list[i];}if (count > 6) continue;// 条件4：联结数等于1if (DetectConnectivity(list) != 1) continue;// 条件5: 假设p2已标记删除，则令p2为背景，不改变p的联结数 if (mask[r - 1, c] == 1){list[2] = 1;if (DetectConnectivity(list) != 1)continue;list[2] = 0;}// 条件6: 假设p4已标记删除，则令p4为背景，不改变p的联结数 if (mask[r, c - 1] == 1){list[4] = 1;if (DetectConnectivity(list) != 1)continue;}mask[r, c] = 1; // 标记删除loop = true;}}for (int i = 0; i < length; i++){if (mask[i] == 1){this[i] = background;}}}}}。
并行图像细化算法和C代码实现
并行图像细化算法和C代码实现图像细化一般作为一种图像预处理技术出现,目的是提取源图像的骨架,即是将原图像中线条宽度大于1个象素的线条细化成只有一个象素宽,形成'骨架',形成骨架后能比较容易的分析图像,如提取图像的特征.细化分成串行细化和并行细化2中,串行细化即是一遍检测满足细化条件的点一边删除细化点,并行细化即是检测细化点的时候不进行点的删除只进行标记,而在检测完整幅图像后一次性去除要细化的点.细化基本思想是'层层剥夺',即从线条边缘开始一层一层向里剥夺,直到线条剩下一个象素的为止.进行细化算法前要先对图像进行2值化,即图像中直包含'黑'和'白'2中颜色.细化算法:在微观上取检测点的8个临域(因为是并行细化,有些模板要扩展为12临域),如下xxxxoxxxx其中o为检测点x为其相邻点以下用1代表黑色点,用0代表白色点,用x代表任意颜色的点,要剥夺(删除)的点应满足一下8个模板中的一个.模板a(向右扩大)0x1x01110x1x模板b(向右扩大) 00xx0111x11x模板c(向右扩大) x11x011100xx模板d111x1x000模板e1x01101x0模板fx00110x1x模板gx1xx00模板h(向下扩大)000x1x111x1x符合以上8个模板的点为要剥夺的点,因为符合这8个模板的点可以确认为线条边沿上的点.而试事实上经过这8个模板并行细化后还有下面2种特殊的边沿点保留了下来, 特殊边沿点1000010111特殊边沿点2001011001造成这种2种特殊点的原因扩大后的模板a和扩大后的模板h,扩大的的本意是防止偶数列(行)的线条被完全消去(并行细化并然的).解决方法是在并行细化后再进行一次串行细化,选取缩小后的模板a和模板h 模板a(缩小后)0110x1模板h(缩小后)000x1x111其中缩小后的模板a解决了特殊情况1,缩小后的模板h解决了特殊情况2,注意这次是串行细化了.一下根据这个原理用C++Builder6.0实现,关键代码如下. //--------------------------------BCB6 代码#include <vcl.h>#pragma hdrstop#include<stdio.h>#include "Unit1.h"#include"File1.h"#include<math.h>#include<time.h>#include<vector>#pragma pack(1)using namespace std;/*程序：图像细化sboom(Lingch)日期:05年1月18日*///BMP文件头struct BITMAPFILEHEADER_{short type;int bfSize;short re1,re2;int Offbits;};//BMP信息头struct BITMAPINFO_{long size;long width,height;short planes,bitCount;long p,sizeImg;long xpels,ypels;long used,important;};//------将BMP彩色表的数据校正到BCB 的TColor的数据。
图像细化（骨架化）算法分析
图像细化（⾻架化）算法分析图像细化（⾻架化）算法分析图像的细化是模式识别中很重要的⼀个技术，指的是将原本"臃肿"的像素简化为单像素相连接的⼆值图像（即类似⾻架的概念），细化的好坏直接影响到后⾯识别匹配的效率。
摘⾃某⽂章的话，细化就是经过⼀层层的剥离，从原来的图中去掉⼀些点，但仍要保持原来的形状，直到得到图像的⾻架。
⾻架，可以理解为图象的中轴，例如⼀个长⽅形的⾻架是它的长⽅向上的中轴线；正⽅形的⾻架是它的中⼼点；圆的⾻架是它的圆⼼，直线的⾻架是它⾃⾝，孤⽴点的⾻架也是⾃⾝。
下⾯先介绍经典的Zhang并⾏快速细化算法：设p1点的⼋邻域为：【 p9 p2 p3p8 p1 p4p7 p6 p5 】（其中p1为⽩点，如果以下四个条件同时满⾜，则删除p1，即令p1=0）其中迭代分为两个⼦过程：过程1 细化删除条件为：（1）、2 < =N(p1) <= 6， N(x)为x的8邻域中⿊点的数⽬（2）、A(p1)=1, A(x)指的是将p2-p8之间按序前后分别为0、1的对数（背景⾊：0）（3）、p2*p4*p6=0（4）、p4*p6*p8=0如果同时满⾜以上四个条件则该点可以删除（赋值为0）。
过程2 细化删除条件为：（1）、2 < =N(p1) <= 6， N(x)为x的8邻域中⿊点的数⽬（2）、A(p1)=1, A(x)指的是将p2-p8之间按序前后分别为0、1的对数（背景⾊：0）（3）、p2*p4*p8=0（4）、p2*p6*p8=0如果同时满⾜以上四个条件则该点可以删除。
代码如下：A.m1 function n=A(temp,i,j)2 %0->1的数⽬3 shuzu=[temp(i,j),temp(i-1,j),temp(i-1,j+1),temp(i,j+1),temp(i+1,j+1),temp(i+1,j),temp(i+1,j-1),temp(i,j-1),temp(i-1,j-1)];4 n=0;5for i=2:86if shuzu(i)==0&&shuzu(i+1)==17 n=n+1;8 end9 end主函数代码：1 test=input('Please input a digits image:','s'); %输⼊图像2 x=imread(test);3if ~isbw(x)4'请确保输⼊图像为⼆值化图像！';5else6 [height,width]=size(x);7 mark=1;8 % temp=zeros(height+2,width+2);9 % temp(2:height+1,2:width+1)=x(:,:);10 temp=x;11 imshow(temp);12while mark==113 mark=0;1415for i=2:height-116for j=2:width-117 condition=0;18 %判断P(r,c)是否为可细化像素19if temp(i,j)==120 n=0;21for ii=-1:122for jj=-1:123 n=n+temp(i+ii,j+jj);24 end25 end26if (n>=3 && n<=7)27 condition=condition+1;28 end29if A(temp,i,j)==130 condition=condition+1;31 end32if temp(i-1,j)*temp(i,j+1)*temp(i+1,j)==033 condition=condition+1;34 end35if temp(i,j+1)*temp(i+1,j)*temp(i,j-1)==036 condition=condition+1;37 end38if condition==439 mark=1;40 temp(i,j)=0;41 end42 end43 end44 end45 figure;imshow(temp);464748for i=2:height-149for j=2:width-150 condition=0;51 %判断P(r,c)是否为可细化像素52if temp(i,j)==153 n=0;54for ii=-1:155for jj=-1:156 n=n+temp(i+ii,j+jj);57 end58 end59if (n>=3 && n<=7)60 condition=condition+1;61 end62if A(temp,i,j)==163 condition=condition+1;64 end65if temp(i-1,j)*temp(i,j+1)*temp(i,j-1)==066 condition=condition+1;67 end68if temp(i,j-1)*temp(i+1,j)*temp(i,j-1)==069 condition=condition+1;70 end71if condition==472 mark=1;73 temp(i,j)=0;74 end75 end76 end77 end78 figure;imshow(temp);79 end80 end结果：。
hilditch 细化算法 python
Hilditch细化算法是一种用于二值图像细化（或骨架化）的算法。
以下是一个简单的Python实现：
def hilditch(image):
# 获取图像的宽度和高度
width, height = image.shape
# 创建一个与原图大小相同的掩模，所有值初始化为1
mask = image.copy()
# 遍历原图像
for y in range(height):
for x in range(width):
# 如果当前像素是1，则进行细化操作
if image[x][y] == 1:
# 判断上下左右四个方向是否为0
if (x > 0 and image[x-1][y] == 0) or (x < width-1 and image[x+1][y] == 0):
mask[x][y] = 0
if (y > 0 and image[x][y-1] == 0) or (y < height-1 and image[x][y+1] == 0):
mask[x][y] = 0
# 返回细化后的图像
return mask
这个函数接受一个二值图像作为输入，并返回一个细化后的图像。
在函数中，我们首先创建一个与原图大小相同的掩模，并将所有值初始化为1。
然后，我们遍历原图像中的每个像素，如果当前像素是1，则检查其上下左右四个方向是否为0。
如果是，则将当前像素的值设置为0，表示该像素应该被细化掉。
最后，我们返回细化后的图像。
图像处理中的数学算法
图像处理中的数学算法图像处理是一个复杂的过程，它需要运用数学算法来处理图像中的各种信息。
这些算法可以实现图像的去噪、平滑、增强、分割、匹配等功能。
本文将介绍一些常用的图像处理算法，包括小波变换、奇异值分解、最小二乘法、K-means算法、纹理分析等。
一、小波变换小波变换是一种将时域信号转换为频域信号的数学算法。
它可以将图像分解为不同频率范围的小波系数，从而实现对图像的去噪、平滑、特征提取等操作。
小波变换在图像处理中应用广泛，特别是在去噪方面有着独特的优势。
小波变换可以将图像矩阵分解成多组小波系数，其中较高频率的小波系数表示图像中的细节信息，较低频率的小波系数表示图像中的模糊信息。
通过对小波系数的分析和处理，可以实现对图像的特定操作。
二、奇异值分解奇异值分解（SVD）是一种将矩阵分解为三个部分的数学算法，其中一个矩阵是一个对角矩阵，它的对角线上的元素称为奇异值。
奇异值对应了原始矩阵中的主要信息，可以用来构建一个低维矩阵，从而实现图像的压缩和降噪。
奇异值分解可以实现对图像中重要信息的提取和过滤，从而实现图像的压缩和去噪。
三、最小二乘法最小二乘法是一种寻找最优曲线拟合的数学方法，它的目标是通过一个最优拟合函数来表达数据的真实规律。
在图像处理中，最小二乘法可以用来寻找图像中的相关特征，从而实现对图像的分割和特征提取。
最小二乘法可以通过对图像中的像素点进行拟合来得到相应的参数，从而实现对图像中相关特征的描述和分析。
最小二乘法在图像处理中常常用于线性回归和图像灰度直方图均衡化等操作。
四、K-means算法K-means算法是一种将数据划分为多个簇的聚类算法，它可以帮助识别图像中的不同区域，并实现对图像区域的分割和聚类。
K-means算法通常可以用来处理灰度图像、二元图像和多光谱图像等。
K-means算法通过寻找多个空间点之间的相似性，来得到一个划分簇的结果。
在图像处理中，K-means算法可以用来将图像像素划分为多个簇，从而实现对图像的分割和聚类。
opencv实现二值图像细化的算法
opencv实现⼆值图像细化的算法opencv实现⼆值图像细化的算法细化算法通常和⾻骼化、⾻架化算法是相同的意思，也就是thin算法或者skeleton算法。
虽然很多图像处理的教材上不是这么写的，具体原因可以看这篇论⽂，Louisa Lam, Seong-Whan Lee, Ching Y. Suen，“Thinning Methodologies-A Comprehensive Survey ”，IEEE TRANSACTIONS ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE, VOL. 14, NO. 9, SEPTEMBER 1992 ，总结了⼏乎所有92年以前的经典细化算法。
函数：void cvThin( IplImage* src, IplImage* dst, int iterations=1)功能：将IPL_DEPTH_8U型⼆值图像进⾏细化参数：src，原始IPL_DEPTH_8U型⼆值图像dst，⽬标存储空间，必须事先分配好，且和原图像⼤⼩类型⼀致iterations，迭代次数参考⽂献：T. Y. Zhang and C. Y. Suen, “A fast parallel algorithm for thinning digital patterns,” Comm. ACM, vol. 27, no. 3, pp. 236-239, 1984.void cvThin( IplImage* src, IplImage* dst, int iterations=1){CvSize size = cvGetSize(src);cvCopy(src, dst);int n = 0,i = 0,j = 0;for(n=0; n<iterations; n++){IplImage* t_image = cvCloneImage(dst);for(i=0; i<size.height; i++){for(j=0; j<size.width; j++){if(CV_IMAGE_ELEM(t_image,byte,i,j)==1){int ap=0;int p2 = (i==0)?0:CV_IMAGE_ELEM(t_image,byte, i-1, j);int p3 = (i==0 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,byte, i-1, j+1);if (p2==0 && p3==1){ap++;}int p4 = (j==size.width-1)?0:CV_IMAGE_ELEM(t_image,byte,i,j+1);if(p3==0 && p4==1){ap++;}int p5 = (i==size.height-1 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,byte,i+1,j+1);if(p4==0 && p5==1){ap++;}int p6 = (i==size.height-1)?0:CV_IMAGE_ELEM(t_image,byte,i+1,j);if(p5==0 && p6==1){ap++;}int p7 = (i==size.height-1 || j==0)?0:CV_IMAGE_ELEM(t_image,byte,i+1,j-1);if(p6==0 && p7==1){ap++;}int p8 = (j==0)?0:CV_IMAGE_ELEM(t_image,byte,i,j-1);if(p7==0 && p8==1){ap++;}int p9 = (i==0 || j==0)?0:CV_IMAGE_ELEM(t_image,byte,i-1,j-1);if(p8==0 && p9==1){ap++;}if(p9==0 && p2==1){ap++;}if((p2+p3+p4+p5+p6+p7+p8+p9)>1 && (p2+p3+p4+p5+p6+p7+p8+p9)<7){if(ap==1){if(!(p2 && p4 && p6)){if(!(p4 && p6 && p8)){CV_IMAGE_ELEM(dst,byte,i,j)=0;}}}}}}}cvReleaseImage(&t_image);t_image = cvCloneImage(dst);for(i=0; i<size.height; i++){for(int j=0; j<size.width; j++){if(CV_IMAGE_ELEM(t_image,byte,i,j)==1){int ap=0;int p2 = (i==0)?0:CV_IMAGE_ELEM(t_image,byte, i-1, j);int p3 = (i==0 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,byte, i-1, j+1);if (p2==0 && p3==1){ap++;}int p4 = (j==size.width-1)?0:CV_IMAGE_ELEM(t_image,byte,i,j+1);if(p3==0 && p4==1){ap++;}int p5 = (i==size.height-1 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,byte,i+1,j+1);if(p4==0 && p5==1){ap++;}int p6 = (i==size.height-1)?0:CV_IMAGE_ELEM(t_image,byte,i+1,j);if(p5==0 && p6==1){ap++;}int p7 = (i==size.height-1 || j==0)?0:CV_IMAGE_ELEM(t_image,byte,i+1,j-1); if(p6==0 && p7==1){ap++;}int p8 = (j==0)?0:CV_IMAGE_ELEM(t_image,byte,i,j-1);if(p7==0 && p8==1){ap++;}int p9 = (i==0 || j==0)?0:CV_IMAGE_ELEM(t_image,byte,i-1,j-1);if(p8==0 && p9==1){ap++;}if(p9==0 && p2==1){ap++;}if((p2+p3+p4+p5+p6+p7+p8+p9)>1 && (p2+p3+p4+p5+p6+p7+p8+p9)<7) {if(ap==1){if(p2*p4*p8==0){if(p2*p6*p8==0){CV_IMAGE_ELEM(dst, byte,i,j)=0;}}}}}}}cvReleaseImage(&t_image);}}//使⽤举例#include "cxcore.h"#include "cv.h"#include "highgui.h"int main(int argc, char* argv[]){if(argc!=2){return 0;}IplImage *pSrc = NULL,*pDst = NULL,*pTmp = NULL;//传⼊⼀个灰度图像pSrc = cvLoadImage(argv[1],CV_LOAD_IMAGE_GRAYSCALE);if(!pSrc){return 0;}pTmp = cvCloneImage(pSrc);pDst = cvCreateImage(cvGetSize(pSrc),pSrc->depth,pSrc->nChannels);cvZero(pDst);cvThreshold(pSrc,pTmp,128,1,CV_THRESH_BINARY_INV);//做⼆值处理，将图像转换成0，1格式 //cvSaveImage("c://Threshold.bmp",pTmp,0);cvThin(pTmp,pDst,8);//细化，通过修改iterations参数进⼀步细化cvNamedWindow("src",1);cvNamedWindow("dst",1);cvShowImage("src",pSrc);//将⼆值图像转换成灰度，以便显⽰int i = 0,j = 0;CvSize size = cvGetSize(pDst);for(i=0; i<size.height; i++){for(j=0; j<size.width; j++){if(CV_IMAGE_ELEM(pDst,uchar,i,j)==1){CV_IMAGE_ELEM(pDst,uchar,i,j) = 0;}else{CV_IMAGE_ELEM(pDst,uchar,i,j) = 255;}}}//cvSaveImage("c://thin.bmp",pDst);cvShowImage("dst",pDst);cvWaitKey(0);cvReleaseImage(&pSrc);cvReleaseImage(&pDst);cvReleaseImage(&pTmp);cvDestroyWindow("src");cvDestroyWindow("dst");return 0;}。
一些基本的形态学算法 细化
一些基本的形态学算法细化1.引言1.1 概述概述形态学算法是图像处理领域中的一种重要技术，主要用于图像的分析和处理。
形态学算法基于数学形态学理论，通过对图像中的形状和结构进行操作和变换，从而实现图像的特征提取、图像增强、边缘检测等目的。
形态学算法最早是由Matheron于1964年提出的，其理论基础是数学形态学，借鉴了数学中对集合的运算和变换的概念和方法。
形态学算法主要基于结构元素（也称为模板或内核）与图像进行操作，通过结构元素在图像上的移动和比较，实现图像的形态学变化。
形态学算法的基础操作包括膨胀、腐蚀、开运算和闭运算。
膨胀操作将结构元素扩张到图像中的对象区域，从而使对象的尺寸增大；腐蚀操作将结构元素侵蚀图像中的对象区域，使对象的尺寸减小。
开运算是先进行腐蚀，再进行膨胀，通常用于去除图像中的小噪点；闭运算与开运算相反，先进行膨胀，再进行腐蚀，通常用于填补图像中的小孔洞。
除了基本形态学算法外，细化算法也是形态学算法的重要内容之一。
细化算法主要用于提取图像中的骨架或轮廓线。
骨架提取算法通过连续的腐蚀操作，逐步减小图像中的对象尺寸，最终得到对象的骨架；线条细化算法则通过针对对象边界的特征点进行腐蚀和连接操作，实现对边界线条的细化。
本文将详细介绍基本形态学算法和细化算法的原理和应用，并通过实例演示其在图像处理中的作用。
同时，强调细化算法在形态学算法中的重要性和应用前景，以期对读者深入理解和应用形态学算法具有指导意义。
1.2文章结构文章结构部分的内容是对整篇文章的组织和安排进行介绍。
在本篇文章中，主要包含了引言、正文和结论三个部分。
首先是引言部分，引言部分主要包括概述、文章结构和目的三个小节。
在概述中，介绍了本篇文章要讨论的主题，即一些基本的形态学算法的细化。
在文章结构中，说明了整篇文章的目录和结构安排。
在目的小节中，阐明了撰写这篇文章的目的和意义。
接下来是正文部分，正文部分分为基本形态学算法和细化算法两个小节。
细化算法 (1)
SPTA细化算法步骤
对右边界的点，就是符合图3（a）模板的p点，即 n4· p· n0=1的p点，若式（a）为0，则为安全点。 布尔表达式中相应像素为黑且未被标记的点的布 尔量为1，否则为0. 同理，对左、上、下边界点的表达式分别如上面 的式（2）、（3）、（4）。
n3
n2
n1
n4
p
n0
n5
Hilditch细化算法的优缺点 优点：细化算法效果好
缺点：运算量大，有一些分支、处理速度慢，在实际应用中难以满足实时处理 的要求。
SPTA细化算法
SPTA细化算法一般需要经过数轮相同的检查过程，每一轮都由2次扫描组 成，每次扫描检查图像的每个像素。扫描过程可以是逐行的，也可以是 逐列的。第一次扫描检查所有的左、右边缘点，如果是非安全点则被标 记；第二次扫描检查所有的上、下边缘点，如果是非安全点则被标记。 当结束一轮扫描后，没有一点被标记，则删除所有被标记的点，算法结 束，否则进入下一轮扫描。 算法： S0=n4(n5+n6+n2+n3)(n0+n1')(n4+n3') S4=n0(n1+n2+n6+n7)(n2+n3')(n6+n5') S2=n6(n7+n0+n4+n5)(n0+n1')(n4+n3') S6=n2(n3+n4+n0+n1)(n4+n5')(n0+n7')其中’‘'’=‘ ▔’
n6
n7
SPTA细化算法优缺点
SPTA细化算法 优点：它代表了笔划的中轴线且保持了连续性 缺点：它需要分四次扫描进行，速度较慢，而且SPTA也难于克服45度 交叉畸变的问题
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
圖像細化算法大全#include "StdAfx.h"#include <stdlib.h>#include <malloc.h>void beforethin(unsigned char *ip, unsigned char *jp,unsigned long lx, unsigned long ly){unsigned long i,j;for(i=0; i<ly; i++){for(j=0; j<lx; j++){//這裡要視前景是白點還是黑點而定，可以改動//如果前景是白點，就是這樣；反之反過來if(ip[i*lx+j]>0)jp[i*lx+j]=1;elsejp[i*lx+j]=0;}}}///////////////////////////////////////////////////////////////////////////Hilditch細化算法//功能：對圖像進行細化//參數：image：代表圖像的一維數組// lx：圖像寬度// ly：圖像高度// 無返回值void ThinnerHilditch(void *image, unsigned long lx, unsigned long ly) {char *f, *g;char n[10];unsigned int counter;short k, shori, xx, nrn;unsigned long i, j;long kk, kk11, kk12, kk13, kk21, kk22, kk23, kk31, kk32, kk33, size;size = (long)lx * (long)ly;g = (char *)malloc(size);if(g == NULL){printf("error in allocating memory!/n");return;}f = (char *)image;for(i=0; i<lx; i++){for(j=0; j<ly; j++){kk=i*ly+j;if(f[kk]!=0){f[kk]=1;g[kk]=f[kk];}}}counter = 1;do{printf("%4d*",counter);counter++;shori = 0;for(i=0; i<lx; i++){for(j=0; j<ly; j++){kk = i*ly+j;if(f[kk]<0)f[kk] = 0;g[kk]= f[kk];}}for(i=1; i<lx-1; i++){for(j=1; j<ly-1; j++){kk=i*ly+j;if(f[kk]!=1)kk11 = (i-1)*ly+j-1;kk12 = kk11 + 1;kk13 = kk12 + 1;kk21 = i*ly+j-1;kk22 = kk21 + 1;kk23 = kk22 + 1;kk31 = (i+1)*ly+j-1;kk32 = kk31 + 1;kk33 = kk32 + 1;if((g[kk12]&&g[kk21]&&g[kk23]&&g[kk32])!=0) continue;nrn = g[kk11] + g[kk12] + g[kk13] + g[kk21] + g[kk23] + g[kk31] + g[kk32] + g[kk33];if(nrn <= 1){f[kk22] = 2;continue;}n[4] = f[kk11];n[3] = f[kk12];n[2] = f[kk13];n[5] = f[kk21];n[1] = f[kk23];n[6] = f[kk31];n[7] = f[kk32];n[8] = f[kk33];n[9] = n[1];xx = 0;for(k=1; k<8; k=k+2){if((!n[k])&&(n[k+1]||n[k+2]))xx++;}if(xx!=1){f[kk22] = 2;}if(f[kk12] == -1){f[kk12] = 0;n[3] = 0;xx = 0;for(k=1; k<8; k=k+2){if((!n[k])&&(n[k+1]||n[k+2]))xx++;}if(xx != 1){f[kk12] = -1;continue;}f[kk12] = -1;n[3] = -1;}if(f[kk21]!=-1){f[kk22] = -1;shori = 1;continue;}f[kk21] = 0;n[5] = 0;xx = 0;for(k=1; k<8; k=k+2){if((!n[k])&&(n[k+1]||n[k+2])){xx++;}}{f[kk21] = -1;f[kk22] = -1;shori =1;}elsef[kk21] = -1;}}}while(shori);free(g);}///////////////////////////////////////////////////////////////////////////Pavlidis細化算法//功能：對圖像進行細化//參數：image：代表圖像的一維數組// lx：圖像寬度// ly：圖像高度// 無返回值void ThinnerPavlidis(void *image, unsigned long lx, unsigned long ly) {char erase, n[8];char *f;unsigned char bdr1,bdr2,bdr4,bdr5;short c,k,b;unsigned long i,j;long kk,kk1,kk2,kk3;f = (char*)image;for(i=1; i<lx-1; i++){for(j=1; j<ly-1; j++){kk = i*ly + j;if(f[kk])f[kk] = 1;}}for(i=0, kk1=0, kk2=ly-1; i<lx; i++, kk1+=ly, kk2+=ly){f[kk1]=0;f[kk2]=0;}for(j=0, kk=(lx-1)*ly; j<ly; j++,kk++) {f[j]=0;f[kk]=0;}c=5;erase =1;while(erase){c++;for(i=1; i<lx-1; i++){for(j=1; j<ly-1; j++){kk=i*ly+j;if(f[kk]!=1)continue;kk1 = kk-ly -1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[3] = f[kk1];n[2] = f[kk2];n[1] = f[kk3];kk1 = kk - 1;kk3 = kk + 1;n[4] = f[kk1];n[0] = f[kk3];kk1 = kk + ly -1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[5] = f[kk1];n[6] = f[kk2];n[7] = f[kk3];bdr1 =0;for(k=0; k<8; k++){bdr1|=0x80>>k;}if((bdr1&0252)== 0252)continue;f[kk] = 2;b=0;for(k=0; k<=7; k++){b+=bdr1&(0x80>>k);}if(b<=1)f[kk]=3;if((bdr1&0160)!=0&&(bdr1&07)!=0&&(bdr1&0210)==0)f[kk]=3;else if((bdr1&&0301)!=0&&(bdr1&034)!=0&&(bdr1&042)==0) f[kk]=3;else if((bdr1&0202)==0 && (bdr1&01)!=0)f[kk]=3;else if((bdr1&0240)==0 && (bdr1&0100)!=0)f[kk]=3;else if((bdr1&050)==0 && (bdr1&020)!=0)f[kk]=3;else if((bdr1&012)==0 && (bdr1&04)!=0)f[kk]=3;}}for(i=1; i<lx-1; i++){for(j=1; j<ly-1; j++){kk = i*ly + j;if(!f[kk])continue;kk1 = kk - ly -1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[3] = f[kk1];n[1] = f[kk3];kk1 = kk - 1;kk2 = kk + 1;n[4] = f[kk1];n[0] = f[kk3];kk1 = kk + ly -1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[5] = f[kk1];n[6] = f[kk2];n[7] = f[kk3];bdr1 = bdr2 =0;for(k=0; k<=7; k++){if(n[k]>=1)bdr1|=0x80>>k;if(n[k]>=2)bdr2|=0x80>>k;}if(bdr1==bdr2){f[kk] = 4;continue;}if(f[kk]!=2)continue;if((bdr2&0200)!=0 && (bdr1&010)==0 && ((bdr1&0100)!=0 &&(bdr1&001)!=0 ||((bdr1&0100)!=0 ||(bdr1 & 001)!=0) &&(bdr1&060)!=0 &&(bdr1&06)!=0)){f[kk] = 4;}else if((bdr2&040)!=0 && (bdr1&02)==0 && ((bdr1&020)!=0 && (bdr1&0100)!=0 ||((bdr1&020)!=0 || (bdr1&0100)!=0) &&(bdr1&014)!=0 && (bdr1&0201)!=0)) {}else if((bdr2&010)!=0 && (bdr1&0200)==0 &&((bdr1&04)!=0 && (bdr1&020)!=0 ||((bdr1&04)!=0 || (bdr1&020)!=0) &&(bdr1&03)!=0 && (bdr1&0140)!=0)){f[kk] = 4;}else if((bdr2&02)!=0 && (bdr1&040)==0 &&((bdr1&01)!=0 && (bdr1&04)!=0 ||((bdr1&01)!=0 || (bdr1&04)!=0) &&(bdr1&0300)!=0 && (bdr1&030)!=0)){f[kk] = 4;}}}for(i=1; i<lx-1; i++){for(j=1; j<ly-1; j++){kk = i*ly + j;if(f[kk]!=2)continue;kk1 = kk - ly -1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[3] = f[kk1];n[2] = f[kk2];n[1] = f[kk3];kk1 = kk - 1;kk2 = kk + 1;n[4] = f[kk1];n[0] = f[kk3];kk1 = kk + ly -1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[5] = f[kk1];n[6] = f[kk2];n[7] = f[kk3];for(k=0; k<=7; k++){if(n[k]>=4)bdr4|=0x80>>k;if(n[k]>=5)bdr5|=0x80>>k;}if((bdr4&010) == 0){f[kk] = 5;continue;}if((bdr4&040) == 0 && bdr5 ==0){f[kk] = 5;continue;}if(f[kk]==3||f[kk]==4)f[kk] = c;}}erase = 0;for(i=1; i<lx-1; i++){for(j=1; j<ly-1; j++){kk = i*ly +j;if(f[kk]==2||f[kk] == 5){erase = 1;f[kk] = 0;}}}}}///////////////////////////////////////////////////////////////////////////Rosenfeld細化算法//功能：對圖像進行細化//參數：image：代表圖像的一維數組// lx：圖像寬度// ly：圖像高度// 無返回值void ThinnerRosenfeld(void *image, unsigned long lx, unsigned long ly) {char *f, *g;char n[10];char a[5] = {0, -1, 1, 0, 0};char b[5] = {0, 0, 0, 1, -1};char nrnd, cond, n48, n26, n24, n46, n68, n82, n123, n345, n567, n781;short k, shori;unsigned long i, j;long ii, jj, kk, kk1, kk2, kk3, size;size = (long)lx * (long)ly;g = (char *)malloc(size);if(g==NULL){printf("error in alocating mmeory!/n");return;}f = (char *)image;for(kk=0l; kk<size; kk++){g[kk] = f[kk];}do{shori = 0;for(k=1; k<=4; k++){for(i=1; i<lx-1; i++){ii = i + a[k];for(j=1; j<ly-1; j++){kk = i*ly + j;if(!f[kk])continue;jj = j + b[k];if(f[kk1])continue;kk1 = kk - ly -1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[3] = f[kk1];n[2] = f[kk2];n[1] = f[kk3];kk1 = kk - 1;kk3 = kk + 1;n[4] = f[kk1];n[8] = f[kk3];kk1 = kk + ly - 1;kk2 = kk1 + 1;kk3 = kk2 + 1;n[5] = f[kk1];n[6] = f[kk2];n[7] = f[kk3];nrnd = n[1] + n[2] + n[3] + n[4]+n[5] + n[6] + n[7] + n[8];if(nrnd<=1)continue;cond = 0;n48 = n[4] + n[8];n26 = n[2] + n[6];n24 = n[2] + n[4];n46 = n[4] + n[6];n68 = n[6] + n[8];n82 = n[8] + n[2];n123 = n[1] + n[2] + n[3];n345 = n[3] + n[4] + n[5];n567 = n[5] + n[6] + n[7];n781 = n[7] + n[8] + n[1];if(n[2]==1 && n48==0 && n567>0) {if(!cond)continue;g[kk] = 0;continue;}if(n[6]==1 && n48==0 && n123>0) {if(!cond)continue;g[kk] = 0;shori = 1;continue;}if(n[8]==1 && n26==0 && n345>0) {if(!cond)continue;g[kk] = 0;shori = 1;continue;}if(n[4]==1 && n26==0 && n781>0) {if(!cond)continue;g[kk] = 0;shori = 1;continue;}if(n[5]==1 && n46==0){if(!cond)continue;g[kk] = 0;shori = 1;continue;}if(n[7]==1 && n68==0){if(!cond)continue;shori = 1;continue;}if(n[1]==1 && n82==0){if(!cond)continue;g[kk] = 0;shori = 1;continue;}if(n[3]==1 && n24==0){if(!cond)continue;g[kk] = 0;shori = 1;continue;}cond = 1;if(!cond)continue;g[kk] = 0;shori = 1;}}for(i=0; i<lx; i++){for(j=0; j<ly; j++){kk = i*ly + j;f[kk] = g[kk];}}}}while(shori);free(g);}///////////////////////////////////////////////////////////////////////////基於索引表的細化細化算法//功能：對圖像進行細化//參數：lpDIBBits：代表圖像的一維數組// lWidth：圖像高度// lHeight：圖像寬度// 無返回值BOOL WINAPI ThiningDIBSkeleton (LPSTR lpDIBBits, LONG lWidth, LONG lHeight){//循環變量long i;long j;long lLength;unsigned char deletemark[256] = {0,0,0,0,0,0,0,1, 0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0, 0,0,1,1,1,0,1,1,0,0,0,0,0,0,0,0, 1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0, 1,0,1,1,1,0,1,1,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, 1,0,0,0,1,0,1,1,1,0,0,0,0,0,0,0, 1,0,1,1,1,0,1,1,0,0,1,1,0,0,1,1, 0,0,0,1,0,0,1,1,0,0,0,0,0,0,0,0, 0,0,0,1,0,0,1,1,1,1,0,1,0,0,0,1, 0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,1, 1,1,0,0,1,0,0,0,0,1,1,1,0,0,1,1, 0,0,0,1,0,0,1,1,0,0,0,0,0,0,0,0, 0,0,0,0,0,1,1,1,1,1,1,1,0,0,1,1, 1,1,0,0,1,1,0,0,1,1,1,1,0,0,1,1, 1,1,0,0,1,1,0,0};//索引表unsigned char p0, p1, p2, p3, p4, p5, p6, p7;unsigned char *pmid, *pmidtemp;unsigned char sum;int changed;bool bStart = true;lLength = lWidth * lHeight;unsigned char *pTemp = (unsigned char *)malloc(sizeof(unsigned char) * lWidth * lHeight);// P0 P1 P2// P7 P3// P6 P5 P4while(bStart){bStart = false;changed = 0;//首先求邊緣點(並行)pmid = (unsigned char *)lpDIBBits + lWidth + 1;memset(pTemp, (BYTE) 0, lLength);pmidtemp = (unsigned char *)pTemp + lWidth + 1;for(i = 1; i < lHeight -1; i++){for(j = 1; j < lWidth - 1; j++){if( *pmid == 0){pmid++;pmidtemp++;continue;}p3 = *(pmid + 1);p2 = *(pmid + 1 - lWidth);p1 = *(pmid - lWidth);p0 = *(pmid - lWidth -1);p7 = *(pmid - 1);p6 = *(pmid + lWidth - 1);p5 = *(pmid + lWidth);p4 = *(pmid + lWidth + 1);sum = p0 & p1 & p2 & p3 & p4 & p5 & p6 & p7;if(sum == 0){*pmidtemp = 1;}pmid++;pmidtemp++;}pmid++;pmid++;pmidtemp++;pmidtemp++;}//現在開始串行刪除pmid = (unsigned char *)lpDIBBits + lWidth + 1; pmidtemp = (unsigned char *)pTemp + lWidth + 1;for(i = 1; i < lHeight -1; i++){for(j = 1; j < lWidth - 1; j++){if( *pmidtemp == 0){pmid++;pmidtemp++;continue;}p3 = *(pmid + 1);p2 = *(pmid + 1 - lWidth);p1 = *(pmid - lWidth);p0 = *(pmid - lWidth -1);p7 = *(pmid - 1);p6 = *(pmid + lWidth - 1);p5 = *(pmid + lWidth);p4 = *(pmid + lWidth + 1);p1 *= 2;p2 *= 4;p3 *= 8;p4 *= 16;p5 *= 32;p6 *= 64;p7 *= 128;sum = p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7;if(deletemark[sum] == 1){*pmid = 0;bStart = true;}pmid++;pmidtemp++;}pmid++;pmid++;pmidtemp++;pmidtemp++;}}return true;}。