改进zhang方法图像细化（单像素）

最新推荐文章于 2024-02-04 17:57:44 发布
最新推荐文章于 2024-02-04 17:57:44 发布
阅读量7.8k 收藏 58
点赞数 13
分类专栏： 图像处理 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011941438/article/details/54628836
版权

本文主要实现实现了和讲解图像细化算法，引用论文 “牟少敏,杜海洋,苏平,查绪恒,陈光艺.一种改进的快速并行细化算法[J].微电子学与计算机,2013,(第1期)” ，免费下载地址点击打开链接（直接在http://www.ucdrs.superlib.net/中搜索也可）。

zhang的算法是经典的细化算法，具有速度快、保持细化后 曲线的连通性和无毛刺产生等优点，但它细化后的结果不能保证曲线纹路为单一像素，细化不彻底。

先介绍几个基本概念：

1.目标点和背景点：目标点指像素值为1的点，与此对应，背景点像素值为0.

2.8邻域：如图所示，设有任意像素点 P，P的8邻点即以P为中心的 3×3 区域中除了 P 点以外的P2到P的8个点。

   

3.边界点：属于目标点，且其8领域中至少有一个为背景点。

4.端点：属于边界点，且其8领域中至少有一个为目标点。

Zhang快速并行细化算法执行过程对边界点进行如下操作：



经过细化后的图像并非是单像素的。


牟少敏,杜海洋等提出了对zhang算法的改进，以实现单像素化。

经过分析 Zhang 算法 的原理和细化后的图像 ，发现导致细化后纹路非单一像素原 因是因为部分该删除的点由于不满足 Zhang 细化算法删除条件 1．2S (P ) 一1 而被遗漏掉 ，将这些点分为三类． 如图 3～图 5 所 示




为了易于识别和计算这类点，将8领域点进行二进制编码，从P2到P9进行二进制编码，如下如所示



对所有遗漏目标点的8领域进行编码，并转为十进制，第一类点转化结果为65、5、20和80，第二类点转化结果为:13、97、22、208、67、88、52和133，第三类点转化结果为141、99、54和216。

在扫描过程中上述16种目标点不能全部删除，否则会出现断点。适当选取删除点，已达到最好的细化结果。实验发现删除以下组合中的10个点最为良好。第一类4种全部删除，编码组合为{65,5,20,80}，第二类中选择4种删除，编码组合为{13,22,52,133},第三类种删除2个，编码组合为{141,54}，总的删除点集合为{65,5,20,80,13,22,52,133,141,54}

改进后的算法描述如下



实现代码如下：

void zhang_thinimage_improve(Mat &srcimage)//单通道、二值化后的图像  
{  
    vector<Point> deletelist1;  
    int Zhangmude[9];  
    int nl = srcimage.rows;  
    int nc = srcimage.cols;  
    while (true)  
    {  
        for (int j = 1; j<(nl - 1); j++)  
        {  
            uchar* data_last = srcimage.ptr<uchar>(j - 1);  
            uchar* data = srcimage.ptr<uchar>(j);  
            uchar* data_next = srcimage.ptr<uchar>(j + 1);  
            for (int i = 1; i<(nc - 1); i++)  
            {  
                if (data[i] == 255)  
                {  
                    Zhangmude[0] = 1;  
                    if (data_last[i] == 255) Zhangmude[1] = 1;  
                    else  Zhangmude[1] = 0;  
                    if (data_last[i + 1] == 255) Zhangmude[2] = 1;  
                    else  Zhangmude[2] = 0;  
                    if (data[i + 1] == 255) Zhangmude[3] = 1;  
                    else  Zhangmude[3] = 0;  
                    if (data_next[i + 1] == 255) Zhangmude[4] = 1;  
                    else  Zhangmude[4] = 0;  
                    if (data_next[i] == 255) Zhangmude[5] = 1;  
                    else  Zhangmude[5] = 0;  
                    if (data_next[i - 1] == 255) Zhangmude[6] = 1;  
                    else  Zhangmude[6] = 0;  
                    if (data[i - 1] == 255) Zhangmude[7] = 1;  
                    else  Zhangmude[7] = 0;  
                    if (data_last[i - 1] == 255) Zhangmude[8] = 1;  
                    else  Zhangmude[8] = 0;  
                    int whitepointtotal = 0;  
                    for (int k = 1; k < 9; k++)  
                    {  
						//得到1的个数
                        whitepointtotal = whitepointtotal + Zhangmude[k];  
                    }  
                    if ((whitepointtotal >= 2) && (whitepointtotal <= 6))  
                    {  
						//得到01的个数
                        int ap = 0;  
                        if ((Zhangmude[1] == 0) && (Zhangmude[2] == 1)) ap++;  
                        if ((Zhangmude[2] == 0) && (Zhangmude[3] == 1)) ap++;  
                        if ((Zhangmude[3] == 0) && (Zhangmude[4] == 1)) ap++;  
                        if ((Zhangmude[4] == 0) && (Zhangmude[5] == 1)) ap++;  
                        if ((Zhangmude[5] == 0) && (Zhangmude[6] == 1)) ap++;  
                        if ((Zhangmude[6] == 0) && (Zhangmude[7] == 1)) ap++;  
                        if ((Zhangmude[7] == 0) && (Zhangmude[8] == 1)) ap++;  
                        if ((Zhangmude[8] == 0) && (Zhangmude[1] == 1)) ap++;  
			//计算bp
			int bp=0;
			bp+=Zhangmude[1];
			bp+=Zhangmude[2]<<1;
			bp+=Zhangmude[3]<<2;
			bp+=Zhangmude[4]<<3;
			bp+=Zhangmude[5]<<4;
			bp+=Zhangmude[6]<<5;
			bp+=Zhangmude[7]<<6;
			bp+=Zhangmude[8]<<7;

                        if (ap == 1||bp==65||bp==5||bp==20||bp==80||bp==13||bp==22||bp==52||bp==133||bp==141||bp==54)  
                        {  
                            if ((Zhangmude[1] * Zhangmude[7] * Zhangmude[5] == 0) && (Zhangmude[3] * Zhangmude[5] * Zhangmude[7] == 0))  
                            {  
                                deletelist1.push_back(Point(i, j));  //满足条件，去除该点
                            }  
                        }  
                    }  
                }  
            }  
        }  
        if (deletelist1.size() == 0) break;  
        for (size_t i = 0; i < deletelist1.size(); i++)  
        {  
            Point tem;  
            tem = deletelist1[i];  
            uchar* data = srcimage.ptr<uchar>(tem.y);  
            data[tem.x] = 0;  
        }  
        deletelist1.clear();  
  
		
        for (int j = 1; j<(nl - 1); j++)  
        {  
            uchar* data_last = srcimage.ptr<uchar>(j - 1);  
            uchar* data = srcimage.ptr<uchar>(j);  
            uchar* data_next = srcimage.ptr<uchar>(j + 1);  
            for (int i = 1; i<(nc - 1); i++)  
            {  
                if (data[i] == 255)  
                {  
                    Zhangmude[0] = 1;  
                    if (data_last[i] == 255) Zhangmude[1] = 1;  
                    else  Zhangmude[1] = 0;  
                    if (data_last[i + 1] == 255) Zhangmude[2] = 1;  
                    else  Zhangmude[2] = 0;  
                    if (data[i + 1] == 255) Zhangmude[3] = 1;  
                    else  Zhangmude[3] = 0;  
                    if (data_next[i + 1] == 255) Zhangmude[4] = 1;  
                    else  Zhangmude[4] = 0;  
                    if (data_next[i] == 255) Zhangmude[5] = 1;  
                    else  Zhangmude[5] = 0;  
                    if (data_next[i - 1] == 255) Zhangmude[6] = 1;  
                    else  Zhangmude[6] = 0;  
                    if (data[i - 1] == 255) Zhangmude[7] = 1;  
                    else  Zhangmude[7] = 0;  
                    if (data_last[i - 1] == 255) Zhangmude[8] = 1;  
                    else  Zhangmude[8] = 0;  
                    int whitepointtotal = 0;  
                    for (int k = 1; k < 9; k++)  
                    {  
                        whitepointtotal = whitepointtotal + Zhangmude[k];  
                    }  
                    if ((whitepointtotal >= 2) && (whitepointtotal <= 6))  
                    {  
                        int ap = 0;  
                        if ((Zhangmude[1] == 0) && (Zhangmude[2] == 1)) ap++;  
                        if ((Zhangmude[2] == 0) && (Zhangmude[3] == 1)) ap++;  
                        if ((Zhangmude[3] == 0) && (Zhangmude[4] == 1)) ap++;  
                        if ((Zhangmude[4] == 0) && (Zhangmude[5] == 1)) ap++;  
                        if ((Zhangmude[5] == 0) && (Zhangmude[6] == 1)) ap++;  
                        if ((Zhangmude[6] == 0) && (Zhangmude[7] == 1)) ap++;  
                        if ((Zhangmude[7] == 0) && (Zhangmude[8] == 1)) ap++;  
                        if ((Zhangmude[8] == 0) && (Zhangmude[1] == 1)) ap++;  
			int bp=0;
			bp+=Zhangmude[1];
			bp+=Zhangmude[2]<<1;
			bp+=Zhangmude[3]<<2;
			bp+=Zhangmude[4]<<3;
			bp+=Zhangmude[5]<<4;
			bp+=Zhangmude[6]<<5;
			bp+=Zhangmude[7]<<6;
			bp+=Zhangmude[8]<<7;				
                        if (ap == 1||bp==65||bp==5||bp==20||bp==80||bp==13||bp==22||bp==52||bp==133||bp==141||bp==54)  
                        {  
                            if ((Zhangmude[1] * Zhangmude[3] * Zhangmude[5] == 0) && (Zhangmude[3] * Zhangmude[1] * Zhangmude[7] == 0))  
                            {  
                                deletelist1.push_back(Point(i, j));  
                            }  
                        }  
                    }  
                }  
            }  
        }  
        if (deletelist1.size() == 0) break;  
        for (size_t i = 0; i < deletelist1.size(); i++)  
        {  
            Point tem;  
            tem = deletelist1[i];  
            uchar* data = srcimage.ptr<uchar>(tem.y);  
            data[tem.x] = 0;  
        }  
        deletelist1.clear(); 
    }  
}

zhang方法


改进方法


改进方法剔除的点


如有对论文作者造成侵权，请与我联系删除


Wu_Patrick
关注
专栏目录
zhang 快速并行细化方法_一种改进的Zhang并行图像细化算法的制作方法
weixin_42422648的博客
02-22 1496
本发明涉及图像处理技术，具体涉及一种改进的Zhang并行图像细化算法。背景技术：图像细化是将图像的线条从多像素宽度减少到单位像素宽度，简称骨架化。细化效果的好坏直接影响后期图像处理的效果。对于二值图像已经有不少细化算法，对比文件1(Zhang TY,Suen C Y.A fast parallel algorithm for thinning digital patterns[J].Comm AC...
图像处理之Zhang Suen细化算法
weixin_34116110的博客
08-07 2086
在二值图像处理特别是OCR识别与匹配中，都要通过对字符进行细化以便获得图像的骨架，通过zhang-suen细化算法获得图像，作为图像的特征之一，常用来作为识别或者模式匹配。 一：算法介绍 Zhang-Suen细化算法通常是一个迭代算法，整个迭代过程分为两步： Step One：循环所有前景像素点，对符合如下条件的像素点标记为删除： 1.2 &...
zhang 快速并行细化方法_Zhang快速并行细化算法概要1.docx
weixin_32157619的博客
02-11 290
Zhang快速并行细化算法概要1Zhang快速并行细化算法最近的研究涉及获取二值图像骨架(图象的中轴线)，网上找到许多方法，Zhang快速并行细化算法是出现次数最多的算法，看了几篇博客，又下载了提出这个算法的文献，感觉这个方法很容易理解，编程也容易，其实最后也没花多少时间就成功了，VB6.0编写的程序，用到了函数库MatrixVB，这里分享一下心得。算法简介图1 8邻域系统图1表示以P1为中心的...
zhang 快速并行细化方法_图像基本处理算法的简单实现（二）
weixin_34884417的博客
12-31 378
图像基本处理算法的简单实现(二)4)膨胀腐蚀属于什么心态学==，膨胀、腐蚀、击中/击不中变换、细化…(又晕了T^T)。简单点好像就是集合运算，图像与一结构元素的交差补什么的。图像一点的周围是否符合结构元素，然后该怎么处理。结构元素(B)由0和1组成，用于扫描比较二值化图像(A)。膨胀：1、用结构元素B，扫描图像A的每一个像素2、用结构元素与其覆盖的二值图像做“与”操作3、如果都为0，结果图像的该像...
zhang 快速并行细化方法_Zhang快速并行细化算法.docx
weixin_32701893的博客
12-31 1082
《Zhang快速并行细化算法.docx》由会员分享，提供在线免费全文阅读可下载，此文档格式为docx，更多相关《Zhang快速并行细化算法.docx》文档请在天天文库搜索。1、Zhang快速并行细化算法最近的研究涉及获取二值图像骨架(图象的中轴线)，网上找到许多方法，Zhang快速并行细化算法是出现次数最多的算法，看了几篇博客，又下载了提出这个算法的文献，感觉这个方法很容易理解，编程也容易，其实...
zhang 快速并行细化方法_一种改进的快速并行细化算法.pdf
weixin_34982726的博客
12-31 390
一种改进的快速并行细化算法３０卷第１期２０１３年１月微 电 子 学 与 计 算 机ＭＩＣＲＯＥＬＥＣＴＲＯＮＩＣＳ＆ＣＯＭＰＵＴＥＲＶｏｌ．３０Ｎｏ．１Ｊａｎｕａｒｙ２０１３收稿日期：２０１２－０５－２０；修回日期：２０１２－０６－１８基金项目：国家自然科学基金()；国家ＳＲＴ项目(１０１０４３４２１)；山东农业大学青年科技创新基金项目(２００９２３６４７)一种改进的快速并行细化算法牟少敏，杜海洋...
一种新的二值图像细化算法1
08-04
总结来说，本文提出的新算法提供了一种不同于传统方法的二值图像细化策略，其核心是基于像素连接度的分析，旨在优化细化过程，提高图像处理的准确性和效率。这一算法的创新性和实用性为图像分析领域带来了新的解决...
zhang 快速并行细化方法_Zhang快速并行细化算法
weixin_39611008的博客
02-22 526
Zhang快速并行细化算法 Zhang快速并行细化算法 最近的研究涉及获取二值图像骨架(图象的中轴线)，网上找到许多方法，Zhang快速并行细化算法是出现次数最多的算法，看了几篇博客，又下载了提出这个算法的文献，感觉这个方法很容易理解，编程也容易，其实最后也没花多少时间就成功了，VB6.0编写的程序，用到了函数库MatrixVB，这里分享一下心得。 1. 算法简介 图1 8邻域系统 图1表示以P1...
zhang 细化算法 （matlab）
03-07
zhang-suen的快速并行算法，程序的输入必须是2值矩阵（0为背景点，1为前景点）
zhang 快速并行细化方法_技术 | 提高水泥粉磨系统精细化管理的探讨
weixin_30520491的博客
01-05 184
前言精细化管理是管理者用来调整产品、服务和运营过程的技术方法。“精”就是切中要点，抓住运营管理中的关键环节；“细”就是管理标准的具体量化、考核、督促和执行。精细化管理的“化”指的是过程和程度，当然强调改善，改善强调持续性。某公司2016年P·O42.5水泥工序电耗为30.22kWh/t，工序电耗较高，以开展降低电耗进行以下精细化管理措施，取得了2018年电耗为24.24kWh/t，降低约...
OpenCV c++细化算法
08-12
普通的OpenCV C++细化算法. 已封装成C++函数，可直接调用使用。也可用于参考, 根据需要也可自行修改源码。
zhang快速并行细化算法
m0_37964922的博客
07-26 3547
相关介绍 http://www.doc88.com/p-7724593025971.html 比较好的介绍 https://www.cnblogs.com/xianglan/archive/2011/01/01/1923779.html https://www.cnblogs.com/Summerio/p/8284602.html https://blog.csdn.net/weixin...
SSE图像算法优化系列三十二：Zhang\Guo图像细化算法的C语言以及SIMD指令优化
PixelDemon的博客
05-27 870
二值图像的细化算法也有很多种，比较有名的比如Hilditch细化、Rosenfeld细化、基于索引表的细化、还有Opencv自带的THINNING_ZHANGSUEN、THINNING_GUOHALL喜欢等等。这些都属于迭代的细化方式，当然还有一种是基于二值图像距离变换的细化方法，二值想比较，我个人认为是基于迭代的效果稳定、可靠，但是速度较慢，且速度和图片的内容有关，基于距离变换的...
Zhang-shasha算法
AI蜗牛之家
08-25 2180
之前毕业设计用的主要算法，是树编辑算法中的一种，一直犯懒癌，没有上传，今天整理东西同步到博客！！！   目前因为国内几乎没有关于这个算法的文章，只能通过Zhang-Shasha当时89年的paper来了解这个算法，不过这篇paper写的相当详细，所以理解起来问题也不大！！！    相关理论基础还会另做博文介绍。   这里有我整理的Zhang-Shasha算法的实现，当时学的时候只有Java和
Zhang-Suen细化算法提取中轴线（Python）
热门推荐
jiiiiiaaaa的博客
01-24 1万+
骨架 表示一个平面区域的结构形状的一种重要方法是将它简化为图形，这种简化可以通过一种细化（也称为骨架化）算法得到该区域的骨架来实现。细化是一种形态学变形，在提取中轴线的图像处理问题中，细化起着核心作用。为了产生一个区域的中轴的表示，提出了许多典型的算法，这些算法都是通过迭代一个区域的边界点的细化过程，删除这些点时需要服从如下约束条件：（1）不能删除端点，（2）不能破坏连接性，（3）不能导致区域的...
《图像处理》 图像细化
最新发布
dyk4ever的博客
02-04 1216
图像骨架提取
Zhang二值圖像細化算法
I am Rocky
11-03 2098
[函數名稱]   二值圖像細化算法      WriteableBitmap ThinningProcess(WriteableBitmap src) [算法說明]   圖像細化（Image Thinning），一般指二值圖像的骨架化（Image Skeletonization）的一種操作運算。所謂的細化就是經過一層層的剝離，從原來的圖中去掉一些點，但仍要保持原來的形狀，直到得到圖像的骨架。
73.图像细化
twnkie的博客
08-10 202
Zhang细化算法是一种常用的二值图像细化算法，用于将图像中的粗线条细化为单像素宽度的骨架。该算法可以有效地保持原始图像的形状和拓扑结构，并提取出图像中的主要特征。初始化：将输入二值图像复制到输出图像。p1为当前像素。迭代细化过程：从左上角开始遍历输出图像的所有像素。如果当前像素为背景（像素值为0），则跳过。根据该像素的邻域情况，判断是否满足以下条件：像素周围8个邻域中的黑色像素数量大于等于2且小于等于6。顺时针前后两个像素是黑色和白色的对数为1。第2、4、6个邻域有黑色像素。
python图像线条提取_python3 图像细化（提取骨架线）
weixin_39861955的博客
12-11 3201
图像细化_八连通法图像细化图像细化的方法八连通-查表法zhang的快速并行细化算法八连通-查表法的改进附上参考链接：https://www.cnblogs.com/xianglan/archive/2011/01/01/1923779.html这个链接的博主写的很清楚图像细化图像的细化主要是针对二值图而言所谓骨架，可以理解为图像的中轴，长方形的骨架，是它的长方向上的中轴线，圆的骨架是它的圆心，直线...
c++ 二值图像细化
09-06
二值图像细化是一种图像处理方法，通过对二值图像进行迭代操作，使得边缘线变得更加细长，并且不改变图像的几何形状。二值图像细化通常用于目标识别、图像分析和图像压缩等领域。 二值图像细化算法中常使用的方法有Zhang-Suen细化算法和Guo-Hall细化算法。这些算法的基本原理是通过迭代操作，将边缘线上的点逐渐消除，直到只剩下一个像素表示边缘。 Zhang-Suen细化算法是一种迭代算法，每次迭代分别对图像的奇数次和偶数次迭代进行操作。在奇数次迭代中，通过满足边缘点周围像素的条件来消除边缘点。而在偶数次迭代中，则通过满足边缘点四周像素的条件来消除边缘点。经过多次迭代操作，直到没有需要删除的边缘点为止，即得到细化后的二值图像。 Guo-Hall细化算法也是一种迭代算法，该算法通过分别对图像的四个子图像进行操作，不断消除边缘点。每次迭代操作会遍历子图像的所有像素，满足一定条件的边缘点会被删除。通过重复迭代操作，直到没有需要删除的边缘点为止，最终获得细化后的二值图像。 细化算法的目标是尽可能地保留图像的几何形状，同时使得边缘线更加细长。在实际应用中，合适的细化算法可以提高图像的分析和识别效果。与其他图像处理方法相比，细化算法对计算资源的需求较低，可以实现快速且准确的图像细化。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值