OpenCV二值图细化，骨骼化，求端点、交叉点

最新推荐文章于 2024-05-11 23:41:05 发布
最新推荐文章于 2024-05-11 23:41:05 发布
阅读量6.2k 收藏 86
点赞数 2
分类专栏： OpenCV 文章标签： opencv 计算机视觉 c++
原文链接：https://blog.csdn.net/xukaiwen_2016/article/details/53135866
版权
OpenCV 专栏收录该内容
89 篇文章 88 订阅 ¥69.90 ¥99.00
订阅专栏

所谓细化就是经过一层层的剥离，从原来的图中去掉一些点，但仍要保持原来的形状，直到得到图像的骨架。骨架，可以理解为物体的中轴，例如一个长方形的骨架是它的长方向上的中轴线；正方形的骨架是它的中心点；圆的骨架是它的圆心，直线的骨架是它自身，孤立点的骨架也是自身。得到了骨架，就相当于突出物体的主要结构和形状信息，去除了多余信息，根据这些信息可以实现图像上特征点的检测，如端点，交叉点和拐点。

下面先介绍经典的Zhang并行快速细化算法：

    设p1点的八邻域为：

p9 p2 p3

p8 p1 p4

p7 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）、p2p4p6=0
（4）、p4p6p8=0
如果同时满足以上四个条件则该点可以删除（赋值为0）。

过程2 细化删除条件为：
（1）、2 <=N(p1) <= 6， N(x)为x的8邻域中黑点的数目
（2）、A(p1)=1,A(x)指的是将p2-p8之间按序前后分别为0、1的对数（背景色：0）
（3）、p2p4p8=0
（4）、p2p6p8=0
如果同时满足以上四个条件则该点可以删除。这样反复迭代，直到获取细化图像为止。

过滤部分较为简单：

如果p2+p3+p8+p9>=1,则该点可以删除（赋值为0）。实现每两个白点之间不能紧靠在一起

检测部分比较复杂需要反复实验：
过程1 确定卷积邻域范围：

p25 p10 p11 p12 p13

p24 p9 p2 p3 p14

p23 p8 p1 p4 p15

p22 p7 p6 p5 p16

p21 p20 p19 p18 p17

（这里是使用5x5，实际上为了更好的检测需要至少6x6的卷积且为圆形）

过程2 统计卷积范围内白点个数：

如果白点个数较多，则说明p1为交叉点。

如果白点个数较少，则说明p1为端点。

过程3 对检测出的点进行合并：

如果两个点之间距离太近，取平均值。（下面代码没有实现该功能）

所有程序源代码：

#include <opencv2/opencv.hpp>  
#include <opencv2/core/core.hpp>  
#include <iostream>  
#include <vector>  
using namespace cv;
using namespace std;
 
/**
* @brief 对输入图像进行细化,骨骼化
* @param src为输入图像,用cvThreshold函数处理过的8位灰度图像格式，元素中只有0与1,1代表有元素，0代表为空白
* @param maxIterations限制迭代次数，如果不进行限制，默认为-1，代表不限制迭代次数，直到获得最终结果
* @return 为对src细化后的输出图像,格式与src格式相同，元素中只有0与1,1代表有元素，0代表为空白
*/
cv::Mat thinImage(const cv::Mat & src, const int maxIterations = -1)
{
	assert(src.type() == CV_8UC1);
	cv::Mat dst;
	int width = src.cols;
	int height = src.rows;
	src.copyTo(dst);
	int count = 0;  //记录迭代次数  
	while (true)
	{
		count++;
		if (maxIterations != -1 && count > maxIterations) //限制次数并且迭代次数到达  
			break;
		std::vector<uchar *> mFlag; //用于标记需要删除的点  
		//对点标记  
		for (int i = 0; i < height; ++i)
		{
			uchar * p = dst.ptr<uchar>(i);
			for (int j = 0; j < width; ++j)
			{
				//如果满足四个条件，进行标记  
				//  p9 p2 p3  
				//  p8 p1 p4  
				//  p7 p6 p5  
				uchar p1 = p[j];
				if (p1 != 1) continue;
				uchar p4 = (j == width - 1) ? 0 : *(p + j + 1);
				uchar p8 = (j == 0) ? 0 : *(p + j - 1);
				uchar p2 = (i == 0) ? 0 : *(p - dst.step + j);
				uchar p3 = (i == 0 || j == width - 1) ? 0 : *(p - dst.step + j + 1);
				uchar p9 = (i == 0 || j == 0) ? 0 : *(p - dst.step + j - 1);
				uchar p6 = (i == height - 1) ? 0 : *(p + dst.step + j);
				uchar p5 = (i == height - 1 || j == width - 1) ? 0 : *(p + dst.step + j + 1);
				uchar p7 = (i == height - 1 || j == 0) ? 0 : *(p + dst.step + j - 1);
				if ((p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) >= 2 && (p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) <= 6)
				{
					int ap = 0;
					if (p2 == 0 && p3 == 1) ++ap;
					if (p3 == 0 && p4 == 1) ++ap;
					if (p4 == 0 && p5 == 1) ++ap;
					if (p5 == 0 && p6 == 1) ++ap;
					if (p6 == 0 && p7 == 1) ++ap;
					if (p7 == 0 && p8 == 1) ++ap;
					if (p8 == 0 && p9 == 1) ++ap;
					if (p9 == 0 && p2 == 1) ++ap;
 
					if (ap == 1 && p2 * p4 * p6 == 0 && p4 * p6 * p8 == 0)
					{
						//标记  
						mFlag.push_back(p + j);
					}
				}
			}
		}
 
		//将标记的点删除  
		for (std::vector<uchar *>::iterator i = mFlag.begin(); i != mFlag.end(); ++i)
		{
			**i = 0;
		}
 
		//直到没有点满足，算法结束  
		if (mFlag.empty())
		{
			break;
		}
		else
		{
			mFlag.clear();//将mFlag清空  
		}
 
		//对点标记  
		for (int i = 0; i < height; ++i)
		{
			uchar * p = dst.ptr<uchar>(i);
			for (int j = 0; j < width; ++j)
			{
				//如果满足四个条件，进行标记  
				//  p9 p2 p3  
				//  p8 p1 p4  
				//  p7 p6 p5  
				uchar p1 = p[j];
				if (p1 != 1) continue;
				uchar p4 = (j == width - 1) ? 0 : *(p + j + 1);
				uchar p8 = (j == 0) ? 0 : *(p + j - 1);
				uchar p2 = (i == 0) ? 0 : *(p - dst.step + j);
				uchar p3 = (i == 0 || j == width - 1) ? 0 : *(p - dst.step + j + 1);
				uchar p9 = (i == 0 || j == 0) ? 0 : *(p - dst.step + j - 1);
				uchar p6 = (i == height - 1) ? 0 : *(p + dst.step + j);
				uchar p5 = (i == height - 1 || j == width - 1) ? 0 : *(p + dst.step + j + 1);
				uchar p7 = (i == height - 1 || j == 0) ? 0 : *(p + dst.step + j - 1);
 
				if ((p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) >= 2 && (p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) <= 6)
				{
					int ap = 0;
					if (p2 == 0 && p3 == 1) ++ap;
					if (p3 == 0 && p4 == 1) ++ap;
					if (p4 == 0 && p5 == 1) ++ap;
					if (p5 == 0 && p6 == 1) ++ap;
					if (p6 == 0 && p7 == 1) ++ap;
					if (p7 == 0 && p8 == 1) ++ap;
					if (p8 == 0 && p9 == 1) ++ap;
					if (p9 == 0 && p2 == 1) ++ap;
 
					if (ap == 1 && p2 * p4 * p8 == 0 && p2 * p6 * p8 == 0)
					{
						//标记  
						mFlag.push_back(p + j);
					}
				}
			}
		}
 
		//将标记的点删除  
		for (std::vector<uchar *>::iterator i = mFlag.begin(); i != mFlag.end(); ++i)
		{
			**i = 0;
		}
 
		//直到没有点满足，算法结束  
		if (mFlag.empty())
		{
			break;
		}
		else
		{
			mFlag.clear();//将mFlag清空  
		}
	}
	return dst;
}
 
/**
* @brief 对骨骼化图数据进行过滤，实现两个点之间至少隔一个空白像素
* @param thinSrc为输入的骨骼化图像,8位灰度图像格式，元素中只有0与1,1代表有元素，0代表为空白
*/
void filterOver(cv::Mat thinSrc)
{
	assert(thinSrc.type() == CV_8UC1);
	int width = thinSrc.cols;
	int height = thinSrc.rows;
	for (int i = 0; i < height; ++i)
	{
		uchar * p = thinSrc.ptr<uchar>(i);
		for (int j = 0; j < width; ++j)
		{
			// 实现两个点之间至少隔一个像素
			//  p9 p2 p3  
			//  p8 p1 p4  
			//  p7 p6 p5  
			uchar p1 = p[j];
			if (p1 != 1) continue;
			uchar p4 = (j == width - 1) ? 0 : *(p + j + 1);
			uchar p8 = (j == 0) ? 0 : *(p + j - 1);
			uchar p2 = (i == 0) ? 0 : *(p - thinSrc.step + j);
			uchar p3 = (i == 0 || j == width - 1) ? 0 : *(p - thinSrc.step + j + 1);
			uchar p9 = (i == 0 || j == 0) ? 0 : *(p - thinSrc.step + j - 1);
			uchar p6 = (i == height - 1) ? 0 : *(p + thinSrc.step + j);
			uchar p5 = (i == height - 1 || j == width - 1) ? 0 : *(p + thinSrc.step + j + 1);
			uchar p7 = (i == height - 1 || j == 0) ? 0 : *(p + thinSrc.step + j - 1);
			if (p2 + p3 + p8 + p9 >= 1)
			{
				p[j] = 0;
			}
		}
	}
}
 
/**
* @brief 从过滤后的骨骼化图像中寻找端点和交叉点
* @param thinSrc为输入的过滤后骨骼化图像,8位灰度图像格式，元素中只有0与1,1代表有元素，0代表为空白
* @param raudis卷积半径，以当前像素点位圆心，在圆范围内判断点是否为端点或交叉点
* @param thresholdMax交叉点阈值，大于这个值为交叉点
* @param thresholdMin端点阈值，小于这个值为端点
* @return 为对src细化后的输出图像,格式与src格式相同，元素中只有0与1,1代表有元素，0代表为空白
*/
std::vector<cv::Point> getPoints(const cv::Mat &thinSrc, unsigned int raudis = 4, unsigned int thresholdMax = 6, unsigned int thresholdMin = 4)
{
	assert(thinSrc.type() == CV_8UC1);
	int width = thinSrc.cols;
	int height = thinSrc.rows;
	cv::Mat tmp;
	thinSrc.copyTo(tmp);
	std::vector<cv::Point> points;
	for (int i = 0; i < height; ++i)
	{
		for (int j = 0; j < width; ++j)
		{
			if (*(tmp.data + tmp.step * i + j) == 0)
			{
				continue;
			}
			int count=0;
			for (int k = i - raudis; k < i + raudis+1; k++)
			{
				for (int l = j - raudis; l < j + raudis+1; l++)
				{
					if (k < 0 || l < 0||k>height-1||l>width-1)
					{
						continue;
						
					}
					else if (*(tmp.data + tmp.step * k + l) == 1)
					{
						count++;
					}
				}
			}
 
			if (count > thresholdMax||count<thresholdMin)
			{
				Point point(j, i);
				points.push_back(point);
			}
		}
	}
	return points;
}
 
 
int main(int argc, char*argv[])
{
	cv::Mat src;
	//获取图像  
	if (argc != 2)
	{
		src = cv::imread("src.jpg", cv::IMREAD_GRAYSCALE);
	}
	else
	{
		src = cv::imread(argv[1], cv::IMREAD_GRAYSCALE);
	}
	if (src.empty())
	{
		std::cout << "读取文件失败！" << std::endl;
		return -1;
	}
 
	//将原图像转换为二值图像  
	cv::threshold(src, src, 128, 1, cv::THRESH_BINARY);
	//图像细化，骨骼化  
	cv::Mat dst = thinImage(src);
	//过滤细化后的图像
	filterOver(dst);
	//查找端点和交叉点  
	std::vector<cv::Point> points = getPoints(dst,6,9,6);
	//二值图转化成灰度图，并绘制找到的点
	dst = dst * 255;
	src = src * 255;
	vector<cv::Point>::iterator it = points.begin();
	for (;it != points.end(); it++)
	{
		circle(dst, *it,4,255, 1);
	}
	imwrite("dst.jpg", dst);
	//显示图像  
	cv::namedWindow("src1", CV_WINDOW_AUTOSIZE);
	cv::namedWindow("dst1", CV_WINDOW_AUTOSIZE);
	cv::imshow("src1", src);
	cv::imshow("dst1", dst);
	cv::waitKey(0);
}

测试结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
细化及检测结果

整个程序运行时间大约需要0.02秒，不会占用什么资源，代码还可以进一步优化，检测出的点也没有过滤合并。对于拐点的检测可以使用局部求导，多点拟合或者傅里叶变换。有实现的朋友大家可以共享代码。

转载至：https://blog.csdn.net/xukaiwen_2016/article/details/53135866

thequitesunshine007
关注
  • 2
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
订阅专栏
Python，OpenCV骨架化图像并显示（skeletonize）
qq_40985985的博客
07-11 3297
Python，OpenCV骨架化图像并显示（skeletonize）
opencv 二值化 细化
07-10
通过学习和理解这些例子，你可以更深入地掌握OpenCV在图像处理中的应用，尤其是如何对图像进行二值化处理和细化操作，从而为你的项目或研究提供强有力的支持。记得实践是检验真理的唯一标准，动手操作这些代码，你会...
skeleton 端点和交叉点的查找
08-27
用matlab实现的骨架化端点和交叉点的查找，适合数字图像处理的初学者。
基于OpenCV实现二值图细化，骨骼化并求出端点和交叉点
热门推荐
晴堂嬴上
11-12 3万+
所谓细化就是经过一层层的剥离，从原来的图中去掉一些点，但仍要保持原来的形状，直到得到图像的骨架。骨架，可以理解为物体的中轴，例如一个长方形的骨架是它的长方向上的中轴线；正方形的骨架是它的中心点；圆的骨架是它的圆心，直线的骨架是它自身，孤立点的骨架也是自身。得到了骨架，就相当于突出物体的主要结构和形状信息，去除了多余信息，根据这些信息可以实现图像上特征点的检测，如端点，交叉点和拐点。 下面先介绍经
数字图像处理上机实验之医学骨骼增强（OpenCv+Python）
最新发布
m0_73962294的博客
05-11 1292
利用OpenCv对医学骨骼图像进行增强操作，欢迎大家阅读！
OpenCV-Python系列（二）—— 图像处理（灰度图、二值化、边缘检测、高斯模糊、轮廓检测）
云霄IT的博客
02-26 7037
第四步：使用cv2.findContours 找出图片的轮廓值。第二步：使用cv2.cvtcolor() 将图片转换为灰度图。第五步：使用cv2.drawContours在图片上画上轮廓。第三步，高斯去噪 cv2.GaussianBlur()第五步，寻找轮廓 cv2.findContours()第六步，绘画轮廓 cv2.drawContours()第二步，转灰度图 cv2.cvtColor()第一步，读入照片 cv2.imread()第四步，边缘检测 cv2.Canny()
【youcans 的 OpenCV 例程200篇】128. 形态算法之骨架 (skimage)
youcans的博客
03-17 5279
形态骨架（morphological skeleton）是一种细化的结构，指图像的骨骼部分，用于描述物体的几何形状和拓扑结构，是目标物体重要的拓扑描述。图像的细化是对二值图像进行骨架提取，删除不需要的轮廓点，只保留其骨架点。 skimage 中提供了函数 **skimage.morphology.skeletonize** 可以获取图像的骨骼。
CV2逐步学习-3:cv2.threshold()二值化详解
sunjintaoxxx的博客
11-22 1万+
1.官方文档： 从官方文档分析： 2.函数定义 cv2.threshold (src, thresh, maxval, type) 3.Args： src：源图像矩阵，必须是单通道，8 位或 32 位浮点数据 thresh：阈值，取值范围0～255 maxval：与阈值类型配合使用的最大值，可理解为填充色，取值范围0～255 type：阈值类型 4.返回值 ret：即我们设置的阈值，此处并没有没有使用，但在自适应二值化中会使用到 dst：二值化后的像素矩阵，与原像素矩阵同规格 4.函数解释（官方）
opencv实现二值图像细化的算法
深之JohnChen的专栏
06-02 2万+
opencv 图像细化
Opencv：图像二值化 cv2.threshold()
weixin_40522801的博客
06-03 6252
1cv2.threshold() 用于获取二元值的灰度图像 。 cv2.threshold(src, thresh, maxval, type) 参数 描述 返回 src 源图片，必须是单通道，即灰度图 返回两个值：阈值、二值图 thresh 用于对像素值进行分类的阈值，取值范围0～255 maxval 填充色，如果像素值大于（有时小于）阈值则要给出的值，取值范围0～255 type 阈值类型 阈值类型表： 阈值 用数字表示 .
python opencv 二值化 计算白色像素点的实例
09-19
本文将详细介绍如何使用Python和OpenCV进行二值化操作，并计算图像中的白色像素点数量。 首先，我们需要导入必要的库，如`cv2`用于OpenCV操作，`numpy`用于数值计算，以及`PIL`（Python Imaging Library）用于图像...
基于opencv的骨架提取代码
12-25
基于opencv的骨架提取代码，利用击中不击中变化实现细化操作。
opencv3.0 图像二值化与细化
12-03
本主题聚焦于OpenCV 3.0版本中的两个关键功能：图像二值化和细化。这两个技术对于图像预处理至关重要，它们可以提高后续图像分析和识别的效率。 **图像二值化**是将图像转化为黑白两色调的过程，即图像中的每个像素...
Python+OpenCV图像处理——图像二值化的实现
12-16
简介：图像二值化就是将图像上的像素点的灰度值设置为0或255，也就是将整个图像呈现出明显的黑白效果的过程。 普通图像二值化 代码如下： import cv2 as cv import numpy as np #全局阈值 def threshold_demo(image...
OpenCV-Python: 图像二值化/去噪 cv2.threshold()、cv2.inRange()函数详解
要相信光
06-17 3203
文章目录参考依据API参数示例 参考依据 官网接口文档： https://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html?highlight=threshold#cv2.threshold API参数 cv2.threshold(src, thresh, maxval, type[, dst]) 返回两个值：retval， dst ，返回阈值和处理后的图像 作用：将固定的阈值应用到每个像素元素 参数详解：
OpenCV-细化算法(thinning algorithm)算法详解——提取二值图的骨架
郡酱的博客~
07-22 1万+
昨天不是说同学问我怎么绘制出轮廓的中心线。然后我上网查了一下其实这个有专门的算法叫做细化算法。用专业术语去描述绘制出轮廓的中心线叫做（提取图像的骨架）。然后这一篇博客呢是我对这个细化算法的解读与实操~ 一、thinning algorithm算法描述 图像细化(Image Thinning)，一般指二值图像的骨架化(Image Skeletonization)的一种操作运算。切记：前提条件一定是二...
python3 OpenCV cv2 图像的细化(骨架抽取)_图像处理作业
hehedadaq的博客
05-13 1万+
参考链接：http://www.cnblogs.com/xianglan/archive/2011/01/01/1923779.html主思路和程序基本上都是参考博主的，只是在思路理解上和Python3的一些小修改.首先是算法原理介绍：图像细化：图像细化主要是针对二值图而言，所谓骨架，可以理解为图像的中轴，，一个长方形的骨架，是它的长方向上的中轴线，圆的骨架是它的圆心，直线的骨架是它自身，孤立点的...
【7】OPencv骨架细化算法
qq_33612665的博客
08-01 3952
1 骨架细化原理 思想： 公式: y = p0*2^0 + p1*2^1+ p2*2^2 + p3*2^3 + p4*2^4 + p5*2^5 + p6*2^6 +p7*2^7 前辈们对此作出了总结，得出每个点周围8领域的256种情况，放在一个char data[256]的数组中，不可以删除用0来表示，能被删除的用1来表示。然后对图像进行处理得到二值图像<0和1&...
OpenCV——图像细化算法
wfengzi5的博客
07-29 5240
查表法中，由于输入的图像是一张二值图，将其归一化为像素值只有0和1的图像，然后对其进行卷积操作。具体卷积操作为将目标点的八领域和卷积进行点乘，接着将所有值相加即可得表的索引M，下一步用索引值M去找表中对应的值，对应的值为0或1，就把目标点的像素值修改为0或1，其中1为不可删除点，0位可删除点。在串行算法中，通过在每次迭代中用固定的次序检查像素来判断是否删除像素，在第n次迭代中像素p的删除取决于到执行过的所有操作，也就是必须在第(n-1)次迭代结果和第n次检测像素的基础之上进行像素删除操作；.........
opencv图片二值化python
04-19
OpenCV是一个开源的计算机视觉库，它提供了丰富的图像处理和计算机视觉算法。图片二值化是一种常用的图像处理技术，它将图像转换为只有两种颜色的形式，一般是黑色和白色。 在Python中使用OpenCV进行图片二值化可以通过以下步骤实现： 1. 导入OpenCV库： ```python import cv2 ``` 2. 读取图片： ```python image = cv2.imread('image.jpg', 0) ``` 这里的参数0表示以灰度图像的形式读取图片。 3. 进行二值化处理： ```python ret, binary_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY) ``` `cv2.threshold()`函数用于对图像进行阈值处理，其中的参数`127`表示阈值，`255`表示最大值，`cv2.THRESH_BINARY`表示使用二进制阈值化方法。 4. 显示二值化后的图片： ```python cv2.imshow('Binary Image', binary_image) cv2.waitKey(0) cv2.destroyAllWindows() ``` `cv2.imshow()`函数用于显示图片，`cv2.waitKey(0)`用于等待用户按下任意键，`cv2.destroyAllWindows()`用于关闭窗口。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值