opencv 凸包convexHull、道格拉斯-普克算法Douglas-Peucker algorithm、approxPloyDP 函数

本文详细介绍了道格拉斯-普克算法（Douglas-Peucker algorithm）及其在曲线简化中的应用，同时讲解了OpenCV中approxPolyDP函数与凸包convexHull函数的使用方法，通过实例演示了如何使用这些算法和函数进行曲线近似与多边形拟合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

凸包convexHull、道格拉斯-普克算法Douglas-Peucker algorithm、approxPloyDP 函数

道格拉斯-普克算法（Douglas–Peucker algorithm），亦称为拉默-道格拉斯-普克算法（Ramer–Douglas–Peucker algorithm），这个算法最初由拉默（Urs Ramer）于1972年提出，1973年道格拉斯（David Douglas）和普克（Thomas Peucker）二人又独立于拉默提出了该算法。我们知道，一条曲线上包含着无数个点，但是计算机在存储曲线时只能存取有限个点，通常存储的点越多，那么对该曲线的描述也就越精确。当我们要对原本用N个点描述的曲线进行压缩表示时，即采用K（K<N）个点来描述曲线，为了尽可能保证原有曲线的形态不至有太大的改变，我们就需要一种算法，而道格拉斯-普克算法就是这样一种将曲线近似表示为一系列点，并减少点的数量的一种算法。它的优点是具有平移和旋转不变性，给定曲线与阈值后，抽样结果一定。

下面，我们通过一个例子来介绍一下该算法的执行步骤。假设当前我们有一条曲线，它由8各点来描述，如下图所示

初始曲线是一系列有序的点集，我们需要设定一个距离（阈值）参数 ε > 0。最开始时，在曲线首尾两点A，B之间连接一条直线AB。算法自动将首尾两个点记下（也就是存入结果点集）。得到曲线上离该直线段（AB）距离最大的点C，计算其与AB的距离d，如下图所示

如果用直线段AB来作为原曲线的近似表示，那么点C显然是位于曲线上，离AB最远的点。现在比较距离 d 与预先给定的阈值 ε 的大小，如果小于 ε，则表明任何当前没有被记下的点都可以被丢弃了，因为用已经得到的直线段作为曲线的近似，不会比 ε 更早，即该段曲线处理完毕。

如果距离 d 大于阈值，则用C将曲线分为两段AC和BC，并将点C记下。

然后分别对已经得到两段曲线递归地进行上述处理。

当所有曲线都处理完毕时，依次连接各个分割点形成的折线，即可以作为曲线的近似。就本例而言，接下来的处理步骤如下图所示：

↓

最终我们得到的（用更少的点表示的）近似曲线如下

参考：https://blog.youkuaiyun.com/baimafujinji/article/details/6475432

python 实现：

#-*- coding:utf-8 -*-
"""
道格拉斯算法的实现
程序需要安装shapely模块
"""
import math
from shapely import wkt,geometry
import matplotlib.pyplot as plt
 
class Point:
	"""点类"""
	x=0.0
	y=0.0
	index=0 #点在线上的索引
 
	def __init__(self,x,y,index):
		self.x=x
		self.y=y
		self.index=index
 
class Douglas:
	"""道格拉斯算法类"""
	points=[]
	D=1 #容差
 
	def readPoint(self):
		"""生成点要素"""
		g=wkt.loads("LINESTRING(1 4,2 3,4 2,6 6,7 7,8 6,9 5,10 10)")
		coords=g.coords
		for i in range(len(coords)):
			self.points.append(Point(coords[i][0],coords[i][1],i))
 
	def compress(self,p1,p2):
		"""具体的抽稀算法"""
		swichvalue=False
		#一般式直线方程系数 A*x+B*y+C=0,利用点斜式,分母可以省略约区
		#A=(p1.y-p2.y)/math.sqrt(math.pow(p1.y-p2.y,2)+math.pow(p1.x-p2.x,2))
		A=(p1.y-p2.y)
		#B=(p2.x-p1.x)/math.sqrt(math.pow(p1.y-p2.y,2)+math.pow(p1.x-p2.x,2))
		B=(p2.x-p1.x)
		#C=(p1.x*p2.y-p2.x*p1.y)/math.sqrt(math.pow(p1.y-p2.y,2)+math.pow(p1.x-p2.x,2))
		C=(p1.x*p2.y-p2.x*p1.y)
		
		m=self.points.index(p1)
		n=self.points.index(p2)
		distance=[]
		middle=None
 
		if(n==m+1):
			return
		#计算中间点到直线的距离
		for i in range(m+1,n):
			d=abs(A*self.points[i].x+B*self.points[i].y+C)/math.sqrt(math.pow(A,2)+math.pow(B,2))
			distance.append(d)
 
		dmax=max(distance)
 
		if dmax>self.D:
			swichvalue=True
		else:
			swichvalue=False
 
		if(not swichvalue):
			for i in range(m+1,n):
				del self.points[i]
		else:
			for i in range(m+1,n):
				if(abs(A*self.points[i].x+B*self.points[i].y+C)/math.sqrt(math.pow(A,2)+math.pow(B,2))==dmax):
					middle=self.points[i]
			self.compress(p1,middle)
			self.compress(middle,p2)
 
	def printPoint(self):
		"""打印数据点"""
		for p in self.points:
			print "%d,%f,%f"%(p.index,p.x,p.y)
 
def main():
	"""测试"""
	#p=Point(20,20,1)
	#print '%d,%d,%d'%(p.x,p.x,p.index)
	
	d=Douglas()
	d.readPoint()
	#d.printPoint()
	#结果图形的绘制，抽稀之前绘制
	fig=plt.figure()
	a1=fig.add_subplot(121)
	dx=[]
	dy=[]
	for i in range(len(d.points)):
		dx.append(d.points[i].x)
		dy.append(d.points[i].y)
	a1.plot(dx,dy,color='g',linestyle='-',marker='+')
 
	
	d.compress(d.points[0],d.points[len(d.points)-1])
 
	#抽稀之后绘制
	dx1=[]
	dy1=[]
	a2=fig.add_subplot(122)
	for p in d.points:
		dx1.append(p.x)
		dy1.append(p.y)
	a2.plot(dx1,dy1,color='r',linestyle='-',marker='+')
 
	#print "========================\n"
	#d.printPoint()
 
	plt.show()
 
if __name__=='__main__':
 
	main()

opencv多边形拟合曲线approxPolyDP()函数

approxPolyDP()函数是opencv中对指定的点集进行多边形逼近的函数，其逼近的精度可通过参数设置。

对应的函数为：
void approxPolyDP(InputArray curve, OutputArray approxCurve, double epsilon, bool closed)；

例如：approxPolyDP(contourMat, approxCurve, 10, true);//找出轮廓的多边形拟合曲线

第一个参数 InputArray curve：输入的点集
第二个参数OutputArray approxCurve：输出的点集，当前点集是能最小包容指定点集的。画出来即是一个多边形。
第三个参数double epsilon：指定的精度，也即是原始曲线与近似曲线之间的最大距离。
第四个参数bool closed：若为true，则说明近似曲线是闭合的；反之，若为false，则断开。

该函数采用是道格拉斯-普克算法（Douglas-Peucker）来实现。该算法也以Douglas-Peucker算法和迭代终点拟合算法为名。是将曲线近似表示为一系列点，并减少点的数量的一种算法。该算法的原始类型分别由乌尔斯·拉默（Urs Ramer）于1972年以及大卫·道格拉斯（David Douglas）和托马斯·普克（Thomas Peucker）于1973年提出，并在之后的数十年中由其他学者予以完善。

经典的Douglas-Peucker算法描述如下：

（1）在曲线首尾两点A，B之间连接一条直线AB，该直线为曲线的弦；

（2）得到曲线上离该直线段距离最大的点C，计算其与AB的距离d；

（3）比较该距离与预先给定的阈值threshold的大小，如果小于threshold，则该直线段作为曲线的近似，该段曲线处理完毕。

（4）如果距离大于阈值，则用C将曲线分为两段AC和BC，并分别对两段取信进行1~3的处理。

（5）当所有曲线都处理完毕时，依次连接各个分割点形成的折线，即可以作为曲线的近似。

凸包convexHull

作用：找到2D点集的凸包

cv2.convexHull(points[, clockwise[, returnPoints]]]) -> hull

参数：

points - 2D点集 2D point set

clockwise - 布尔类型，默认false；若为true，输出的凸包则为顺时针方向；若为false，输出的凸包则为逆时针方向。注意：这里的坐标系是x轴方向指向右侧，y轴方向指向上方。

returnPoints - 布尔类型，默认true，在矩阵情况下，若为true，则返回凸包点集；若为false，则返回整数向量的索引

返回值：

hull - 输出的凸包，是整数向量的索引（an integer vector of indices）或点集向量（vector of points）

代码示例：

hull = cv2.convexHull(cnt)

运行效果：

代码综合

import cv2
import numpy as np

img = cv2.imread('Mjolnir.jpg')  
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)  
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)  
contours, hierarchy = cv2.findContours(binary,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE) 

for cnt in contours:

    # ----源轮廓-------
    cv2.drawContours(img, [cnt], -1, (0, 255, 0), 2)

    # 近似多边形
    # epsilon 为近似度参数，该值需要轮廓的周长信息
    # 多边形周长与源轮廓周长之比就是epsilon
    epsilon = 0.01 * cv2.arcLength(cnt,True)
    approx = cv2.approxPolyDP(cnt, epsilon, True)
    cv2.drawContours(img, [approx], -1, (255, 255, 0), 2)

    # 凸包
    hull = cv2.convexHull(cnt)
    cv2.drawContours(img, [hull], -1, (0, 0, 255), 2)

cv2.imshow("approx",img)
cv2.waitKey(0)
cv2.destroyAllWindows()

运行效果