opencv之图像轮廓（三）--凸包

于 2024-09-11 22:43:12 发布
阅读量712 收藏 9
点赞数 6
分类专栏： opencv 文章标签： opencv 人工智能 计算机视觉
本BLOG上原创文章未经本人许可，不得用于商业用途。转载请注明出处，否则保留追究法律责任的权利。
本文链接：https://blog.csdn.net/hola173841439/article/details/142151824
版权

文章目录

前言

逼近多边形是轮廓的高度近似，但是有时候，我们希望使用一个多边形的凸包来简化它。凸包跟逼近多边形很像，只不过它是物体最外层的“凸”多边形。凸包指的是完全包含原有轮廓，并且仅由轮廓上的点所构成的多边形。凸包的每一处都是凸的，即在凸包内连接任意两点的直线都在凸包的内部。在凸包内，任意连续三个点的内角小于180°。

例如，在图1中，最外层的多边形为机械手的凸包，在机械手边缘与凸包之间的部分被称为凸缺陷（Convexity Defect），凸缺陷能够用来处理手势识别等问题。
在这里插入图片描述

图1

获取凸包

OpenCV提供函数cv2.convexHull()用于获取轮廓的凸包。该函数的语法格式为：

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

式中的返回值hull为凸包角点。

式中的参数如下：

  • points：轮廓。
  • clockwise：布尔型值。该值为True时，凸包角点将按顺时针方向排列；该值为False时，则以逆时针方向排列凸包角点。
  • returnPoints：布尔型值。默认值是True，函数返回凸包角点的x/y轴坐标；当为False时，函数返回轮廓中凸包角点的索引。

【例1】观察函数cv2.convexHull()内参数returnPoints的使用情况。

import cv2

o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_TREE,
                                              cv2.CHAIN_APPROX_SIMPLE)
hull = cv2.convexHull(contours[0])  # 返回坐标值
print("returnPoints为默认值True时返回值hull的值：\n", hull)
hull2 = cv2.convexHull(contours[0], returnPoints=False)  # 返回索引值
print("returnPoints为False时返回值hull的值：\n", hull2)

【例2】使用函数cv2.convexHull()获取轮廓的凸包。

import cv2
# --------------读取并绘制原始图像------------------
o = cv2.imread('hand.bmp')
cv2.imshow("original", o)
# --------------提取轮廓------------------
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255, cv2.THRESH_BINARY)
image, contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
# --------------寻找凸包，得到凸包的角点------------------
hull = cv2.convexHull(contours[0])
# --------------绘制凸包------------------
cv2.polylines(o, [hull], True, (0, 255, 0), 2)
# --------------显示凸包------------------
cv2.imshow("result", o)
cv2.waitKey()
cv2.destroyAllWindows()

运行上述程序，会显示如图2所示的图像。
在这里插入图片描述

图2
  • 左图是图像o。
  • 右图是包含获取的凸包的图像。

凸缺陷

凸包与轮廓之间的部分，称为凸缺陷。在OpenCV中使用函数cv2.convexityDefects()获取凸缺陷。其语法格式如下：

convexityDefects = cv2.convexityDefects( contour, convexhull )

式中的返回值convexityDefects为凸缺陷点集。它是一个数组，每一行包含的值是[起点，终点，轮廓上距离凸包最远的点，最远点到凸包的近似距离]。

需要注意的是，返回结果中[起点，终点，轮廓上距离凸包最远的点，最远点到凸包的近似距离]的前三个值是轮廓点的索引，所以需要到轮廓点中去找它们。

式中的参数如下：

  • contour是轮廓。
  • convexhull是凸包。

需要注意的是，用cv2.convexityDefects()计算凸缺陷时，要使用凸包作为参数。在查找该凸包时，所使用函数cv2.convexHull()的参数returnPoints的值必须是False。为了让大家更直观地观察凸缺陷点集，我们尝试将凸缺陷点集在一幅图内显示出来。实现方式为，将起点和终点用一条线连接，在最远点画一个圆圈。下面我们通过一个例子来展示上述操作。

【例3】使用函数cv2.convexityDefects()计算凸缺陷。

import cv2
#----------------原图--------------------------
img = cv2.imread('hand.bmp')
cv2.imshow('original', img)
#----------------构造轮廓--------------------------
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255,0)
image, contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_TREE,
                                              cv2.CHAIN_APPROX_SIMPLE)
#----------------凸包--------------------------
cnt = contours[0]
hull = cv2.convexHull(cnt, returnPoints = False)
defects = cv2.convexityDefects(cnt, hull)
print("defects=\n", defects)
#----------------构造凸缺陷--------------------------
for i in range(defects.shape[0]):
    s, e, f, d = defects[i,0]
    start = tuple(cnt[s][0])
    end = tuple(cnt[e][0])
    far = tuple(cnt[f][0])
    cv2.line(img, start, end, [0,0,255],2)
    cv2.circle(img, far,5, [255,0,0], -1)
    #----------------显示结果，释放图像--------------------------
    cv2.imshow('result', img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

在这里插入图片描述

图3

图中用点标出了凸缺陷。

几何学测试

本节介绍几种与凸包有关的几何学测试。

测试轮廓是否是凸形的

在OpenCV中，可以用函数cv2.isContourConvex()来判断轮廓是否是凸形的，其语法格式为：

retval = cv2.isContourConvex( contour )

式中：

  • 返回值retval是布尔型值。该值为True时，表示轮廓为凸形的；否则，不是凸形的。
  • 参数contour为要判断的轮廓。

【例4】使用函数cv2.isContourConvex()来判断轮廓是否是凸形的。

根据题目的要求，编写代码如下：

import cv2
o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
#--------------凸包----------------------
image1=o.copy()
hull = cv2.convexHull(contours[0])
cv2.polylines(image1, [hull], True, (0, 255, 0), 2)
print("使用函数cv2.convexHull()构造的多边形是否是凸形的：",
      cv2.isContourConvex(hull))
cv2.imshow("result1", image1)
#------------逼近多边形--------------------
image2=o.copy()
epsilon = 0.01*cv2.arcLength(contours[0], True)
approx = cv2.approxPolyDP(contours[0], epsilon, True)
image2=cv2.drawContours(image2, [approx],0, (0,0,255),2)
print("使用函数cv2.approxPolyDP()构造的多边形是否是凸形的：",
      cv2.isContourConvex(approx))
cv2.imshow("result2", image2)
#------------释放窗口--------------------
cv2.waitKey()
cv2.destroyAllWindows()

在这里插入图片描述

图4
  • 左上1图是图像o。
  • 左上2图显示了在图像o上使用函数cv2.convexHull()构造的凸包。
  • 右下图2显示了在图像o上使用函数cv2.approxPolyDP()构造的逼近多边形。

从以上运行结果可以看出：

  • 使用函数cv2.convexHull()构造凸包后，对绘制的凸包使用函数cv2.isContourConvex()判断，返回值为True，说明该轮廓是凸形的。
  • 使用函数cv2.approxPolyDP()构造逼近多边形后，对绘制的逼近多边形使用函数cv2.isContourConvex()判断，返回值为False，说明该轮廓（多边形）不是凸形的。

点到轮廓的距离

在OpenCV中，函数cv2.pointPolygonTest()被用来计算点到多边形（轮廓）的最短距离（也就是垂线距离），这个计算过程又称点和多边形的关系测试。该函数的语法格式为：

retval = cv2.pointPolygonTest( contour, pt, measureDist )

式中的返回值为retval，与参数measureDist的值有关。

式中的参数如下：

  • contour为轮廓。
  • pt为待判定的点。
  • measureDist为布尔型值，表示距离的判定方式。
    • 当值为True时，表示计算点到轮廓的距离。如果点在轮廓的外部，返回值为负数；如果点在轮廓上，返回值为0；如果点在轮廓内部，返回值为正数。
    • 当值为False时，不计算距离，只返回“-1”、“0”和“1”中的一个值，表示点相对于轮廓的位置关系。如果点在轮廓的外部，返回值为“-1”；如果点在轮廓上，返回值为“0”；如果点在轮廓内部，返回值为“1”。

【例5】使用函数cv2.pointPolygonTest()计算点到轮廓的最短距离。使用函数cv2.pointPolygonTest()计算点到轮廓的最短距离，需要将参数measureDist的值设置为True。

import cv2

# ----------------原始图像-------------------------
o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)

# ----------------获取凸包------------------------
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# 使用新版 findContours 函数，只返回 contours 和 hierarchy
contours, hierarchy = cv2.findContours(binary, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)

# 获取第一个轮廓的凸包
hull = cv2.convexHull(contours[0])

# 将灰度图像转换为 BGR 格式以便显示彩色凸包线条
image = cv2.cvtColor(binary, cv2.COLOR_GRAY2BGR)
cv2.polylines(image, [hull], True, (0, 255, 0), 2)

# ----------------内部点A到轮廓的距离-------------------------
distA = cv2.pointPolygonTest(hull, (300, 150), True)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(image, 'A', (300, 150), font, 1, (0, 255, 0), 3)
print("distA=", distA)

# ----------------外部点B到轮廓的距离-------------------------
distB = cv2.pointPolygonTest(hull, (300, 250), True)
cv2.putText(image, 'B', (300, 250), font, 1, (0, 255, 0), 3)
print("distB=", distB)

# ------------正好处于轮廓上的点C到轮廓的距离-----------------
distC = cv2.pointPolygonTest(hull, (423, 112), True)
cv2.putText(image, 'C', (423, 112), font, 1, (0, 255, 0), 3)
print("distC=", distC)

# ----------------显示-------------------------
cv2.imshow("result1", image)
cv2.waitKey()
cv2.destroyAllWindows()

在这里插入图片描述

在这里插入图片描述

图5

从以上结果可以看出，

  • A点算出来的距离为20.314188617040656，是一个正数，说明A点在轮廓内部。

  • B点算出来的距离为-34.0，是一个负数，说明B点在轮廓外部。

  • C点算出来的距离为7.0，说明C点在轮廓上。

在实际使用中，如果想获取位于轮廓上的点，可以通过打印轮廓点集的方式获取。例如，本例中可以通过语句“print(hull)”获取轮廓上的点。在获取轮廓上的点以后，可以将其用作函数cv2.pointPolygonTest()的参数，以测试函数返回值是否为零。

【例6】使用函数cv2.pointPolygonTest()判断点与轮廓的关系。

使用函数cv2.pointPolygonTest()判断点与轮廓的关系时，需要将参数measureDist的值设置为False。

import cv2
#----------------原始图像-------------------------
o = cv2.imread('cs.bmp')
cv2.imshow("original", o)
#----------------获取凸包------------------------
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255, cv2.THRESH_BINARY)
image, contours, hierarchy = cv2.findContours(binary,
                                      cv2.RETR_LIST,
                                      cv2.CHAIN_APPROX_SIMPLE)
hull = cv2.convexHull(contours[0])
image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
cv2.polylines(image, [hull], True, (0, 255, 0), 2)
#----------------内部点A与轮廓的关系-------------------------
distA = cv2.pointPolygonTest(hull, (300, 150), False)
font=cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(image, 'A', (300,150), font, 1, (0,255,0),3)
print("distA=", distA)
#----------------外部点B与轮廓的关系-------------------------
distB = cv2.pointPolygonTest(hull, (300, 250), False)
font=cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(image, 'B', (300,250), font, 1, (0,255,0),3)
print("distB=", distB)
#----------------边缘线上的点C与轮廓的关系----------------------
distC = cv2.pointPolygonTest(hull, (423, 112), False)
font=cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(image, 'C', (423,112), font, 1, (0,255,0),3)
print("distC=", distC)
#print(hull)   #测试边缘到底在哪里，然后再使用确定位置的点绘制文字
#----------------显示-------------------------
cv2.imshow("result", image)
cv2.waitKey()
cv2.destroyAllWindows()

在这里插入图片描述

图6

从以上结果可以看出，

  • A点算出来的关系值为1，说明该点在轮廓的内部。
  • B点算出来的关系值为1，说明该点在轮廓的外部。
  • C点算出来的关系值为1，说明该点在轮廓的内部。

形状场景算法比较轮廓

不介绍

轮廓的特征值

轮廓自身的一些属性特征及轮廓所包围对象的特征对于描述图像具有重要意义。本节介绍几个轮廓自身的属性特征及轮廓所包围对象的特征。

宽高比

可以使用宽高比（AspectRation）来描述轮廓，例如矩形轮廓的宽高比为：宽高比=宽度（Width）/高度（Height）

【例7】计算矩形轮廓的宽高比。

import cv2

o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
x, y, w, h = cv2.boundingRect(contours[0])
cv2.rectangle(o, (x, y), (x + w, y + h), (255, 255, 255), 3)
aspectRatio = float(w) / h
print(aspectRatio)
cv2.imshow("result", o)
cv2.waitKey()
cv2.destroyAllWindows()


########################result###############################
D:\Code\py_demo\.venv\Scripts\python.exe D:\Code\py_demo\operator_cv\凸包.py 
2.1785714285714284

在这里插入图片描述

图7

可以看出，轮廓的宽高比约为2。

Extent

可以使用轮廓面积与矩形边界（矩形包围框、矩形轮廓）面积之比Extend来描述图像及其轮廓特征。计算方法为：

在这里插入图片描述

【例8】计算图像的轮廓面积与其矩形边界面积之比。

import cv2
o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
x, y, w, h = cv2.boundingRect(contours[0])
cv2.drawContours(o, contours[0], -1, (0,0,255),3)
cv2.rectangle(o, (x, y), (x+w, y+h), (255,0,0),3)
rectArea=w*h
cntArea=cv2.contourArea(contours[0])
extend=float(cntArea)/rectArea
print(extend)
cv2.imshow("result", o)
cv2.waitKey()
cv2.destroyAllWindows()

################################result#################################
D:\Code\py_demo\.venv\Scripts\python.exe D:\Code\py_demo\operator_cv\凸包.py 
0.680144906323185

在这里插入图片描述

图8

可以看出，本例中图像的轮廓面积与矩形边界面积的比值大约为0.7。

Solidity

可以使用轮廓面积与凸包面积之比Solidity来衡量图像、轮廓及凸包的特征。其计算方法为：

在这里插入图片描述

【例9】计算图像轮廓面积与凸包面积之比。

import cv2

o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(o, contours[0], -1, (0, 0, 255), 3)
cntArea = cv2.contourArea(contours[0])
hull = cv2.convexHull(contours[0])
hullArea = cv2.contourArea(hull)
cv2.polylines(o, [hull], True, (0, 255, 0), 2)
solidity = float(cntArea) / hullArea
print(solidity)
cv2.imshow("result", o)
cv2.waitKey()
cv2.destroyAllWindows()
###############################result############################
D:\Code\py_demo\.venv\Scripts\python.exe D:\Code\py_demo\operator_cv\凸包.py 
0.9110158068864109

在这里插入图片描述

图9

可以看出，本例中图像的轮廓面积与凸包面积的比值约为0.9。

等效直径（Equivalent Diameter）

可以用等效直径来衡量轮廓的特征值，该值是与轮廓面积相等的圆形的直径。其计算公式为：
在这里插入图片描述

【例10】计算与轮廓面积相等的圆形的直径，并绘制与该轮廓等面积的圆。

import cv2
import numpy as np

o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(o, contours[0], -1, (0, 0, 255), 3)
cntArea = cv2.contourArea(contours[0])
equiDiameter = np.sqrt(4 * cntArea / np.pi)
print(equiDiameter)
cv2.circle(o, (100, 100), int(equiDiameter / 2), (0, 0, 255), 3)  # 展示等直径大小的圆
cv2.imshow("result", o)
cv2.waitKey()
cv2.destroyAllWindows()

在这里插入图片描述

图10
  • ● 左图是图像o。
  • ● 右图显示了图像o的轮廓及与该轮廓等面积的圆（显示为灰色）。

同时，程序还会显示如下的运行结果：
在这里插入图片描述

可以看出，与本例中与轮廓面积相等的圆形的直径约为99。

方向

在OpenCV中，函数cv2.fitEllipse()可以用来构造最优拟合椭圆，还可以在返回值内分别返回椭圆的中心点、轴长、旋转角度等信息。使用这种形式，能够更直观地获取椭圆的方向等信息。

函数cv2.fitEllipse()返回各个属性值的语法格式为：

(x, y), (MA, ma), angle = cv2.fitEllipse(cnt)

式中几个返回值的意义如下：

  • (x, y)：椭圆的中心点。
  • (MA, ma)：椭圆水平方向轴和垂直方向轴的长度。
  • angle：椭圆的旋转角度。

【例11】观察函数cv2.fitEllipse()的不同返回值。

import cv2
o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
ellipse = cv2.fitEllipse(contours[0])
retval=cv2.fitEllipse(contours[0])
print("单个返回值形式：")
print("retval=\n", retval)
(x, y), (MA, ma), angle = cv2.fitEllipse(contours[0])
print("三个返回值形式：")
print("(x, y)=(", x, y, ")")
print("(MA, ma)=(", MA, ma, ")")
print("angle=", angle)
cv2.ellipse(o, ellipse, (0,0,255),2)
cv2.imshow("result", o)
cv2.waitKey()
cv2.destroyAllWindows()
###############################result###########################
D:\Code\py_demo\.venv\Scripts\python.exe D:\Code\py_demo\operator_cv\凸包.py 
单个返回值形式：
retval=
 ((388.0275573730469, 155.02651977539062), (97.1426010131836, 259.5243225097656), 82.80935668945312)
三个返回值形式：
(x, y)=( 388.0275573730469 155.02651977539062 )
(MA, ma)=( 97.1426010131836 259.5243225097656 )
angle= 82.80935668945312

在这里插入图片描述

图11

从以上运行结果可以看出，函数cv2.fitEllipse()以不同形式返回的值是相同的。

掩模和像素点

有时，我们希望获取某对象的掩模图像及其对应的点。12.1.3节介绍了将函数cv2.drawContours()的轮廓宽度参数thickness设置为“-1”，即可获取特定对象的实心轮廓，即特定对象的掩模。

另外，我们可能还希望获取轮廓像素点的具体位置信息。本节介绍如何获取轮廓（实心、空心）的像素点位置信息。

一般情况下，轮廓是图像内非零的像素点，可以通过两种方式获取轮廓像素点的位置信息。一种是使用Numpy函数，另外一种是使用OpenCV函数。

使用Numpy函数获取轮廓像素点

numpy.nonzero()函数能够找出数组内非零元素的位置，但是其返回值是将行、列分别显示的。

【例12】使用Numpy函数获取一个数组内的非零值元素的位置信息。

import numpy as np
#------------生成一个元素都是零值的数组a-------------------
a=np.zeros((5,5), dtype=np.uint8)
#-------随机将其中10个位置上的数值设置为1------------
#---times控制次数
#---i, j是随机生成的行、列位置
#---a[i, j]=1，将随机挑选出来的位置上的值设置为1
for times in range(10):
    i=np.random.randint(0,5)
    j=np.random.randint(0,5)
    a[i, j]=1
    #-------打印数组a，观察数组a内值的情况-----------
    print("a=\n", a)
    #------查找数组a内非零值的位置信息------------
    loc=np.transpose(np.nonzero(a))
    #-----输出数组a内非零值的位置信息------------
    print("a内非零值的位置：\n", loc)

在这里插入图片描述

图12

【例13】使用Numpy函数获取一个图像内的轮廓点位置。

import cv2
import numpy as np
#-----------------读取原始图像----------------------
o = cv2.imread('cc.bmp')
cv2.imshow("original", o)
#-----------------获取轮廓------------------------
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255, cv2.THRESH_BINARY)
image, contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
cnt=contours[0]
#-----------------绘制空心轮廓------------------------
mask1 = np.zeros(gray.shape, np.uint8)
cv2.drawContours(mask1, [cnt],0,255,2)
pixelpoints1 = np.transpose(np.nonzero(mask1))
print("pixelpoints1.shape=", pixelpoints1.shape)
print("pixelpoints1=\n", pixelpoints1)
cv2.imshow("mask1", mask1)
#-----------------绘制实心轮廓---------------------
mask2 = np.zeros(gray.shape, np.uint8)
cv2.drawContours(mask2, [cnt],0,255, -1)
pixelpoints2 = np.transpose(np.nonzero(mask2))
print("pixelpoints2.shape=", pixelpoints2.shape)
print("pixelpoints2=\n", pixelpoints2)
cv2.imshow("mask2", mask2)
#-----------------释放窗口------------------------
cv2.waitKey()
cv2.destroyAllWindows()

运行结果图像。其中：
在这里插入图片描述

图13
  • 左图是图像o。
  • 中间的是空心轮廓图像mask1。
  • 右图是实心轮廓图像mask2。

使用OpenCV函数获取轮廓点

OpenCV提供了函数cv2.findNonZero()用于查找非零元素的索引。该函数的语法格式为：

idx = cv2.findNonZero( src )

式中：

  • idx为返回值，表示非零元素的索引位置。需要注意的是，在返回的索引中，每个元素对应的是（列号，行号）的格式。
  • src为参数，表示要查找非零元素的图像

【例14】使用OpenCV函数cv2.findNonZero()获取一个数组内的非零值。

import cv2
import numpy as np

# ------------生成一个元素都是零值的数组a-------------------
a = np.zeros((5, 5), dtype=np.uint8)
# -------随机将其中10个位置上的值设置为1------------
# ---times控制次数
# ---i, j是随机生成的行、列位置
# ---a[i, j]=1，将随机挑选出来的位置上的值设置为1
for times in range(10):
    i = np.random.randint(0, 5)
    j = np.random.randint(0, 5)
    a[i, j] = 1
# -------打印数组a，观察数组a内值的情况-----------
print("a=\n", a)
# ------查找数组a内非零值的位置信息------------
loc = cv2.findNonZero(a)
# -----输出数组a内非零值的位置信息------------
print("a内非零值的位置：\n", loc)

运行上述程序，会显示如下的运行结果：

在这里插入图片描述

图14

【例15】使用OpenCV函数cv2.findNonZero()获取一个图像内的轮廓点的位置。

import cv2
import numpy as np

# -----------------读取原始图像----------------------
o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
cv2.imshow("original", o)
# -----------------获取轮廓------------------------
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
                                              cv2.RETR_LIST,
                                              cv2.CHAIN_APPROX_SIMPLE)
cnt = contours[0]
# -----------------绘制空心轮廓------------------------
mask1 = np.zeros(gray.shape, np.uint8)
cv2.drawContours(mask1, [cnt], 0, 255, 2)
pixelpoints1 = cv2.findNonZero(mask1)
print("pixelpoints1.shape=", pixelpoints1.shape)
print("pixelpoints1=\n", pixelpoints1)
cv2.imshow("mask1", mask1)
# -----------------绘制实心轮廓---------------------
mask2 = np.zeros(gray.shape, np.uint8)
cv2.drawContours(mask2, [cnt], 0, 255, -1)
pixelpoints2 = cv2.findNonZero(mask2)
print("pixelpoints2.shape=", pixelpoints2.shape)
print("pixelpoints2=\n", pixelpoints2)
cv2.imshow("mask2", mask2)
# -----------------释放窗口------------------------
cv2.waitKey()
cv2.destroyAllWindows()

最大值和最小值及它们的位置

OpenCV提供了函数cv2.minMaxLoc()，用于在指定的对象内查找像素最大值、最小值及其位置。该函数的语法格式是：

min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(imgray, mask = mask)

式中的返回值为：

  • min_val：最小值。
  • max_val：最大值。
  • min_loc：最小值的位置。
  • max_loc：最大值的位置。

式中的参数如下：

  • imgray：单通道图像。
  • mask：掩模。通过使用掩模图像，可以得到掩模指定区域内的最值信息。

平均颜色及平均灰度

OpenCV提供了函数cv2.mean()，用于计算一个对象的平均颜色或平均灰度。该函数的语法格式为：

mean_val = cv2.mean(im, mask = mask)

式中的返回值为mean_val，表示返回的平均值。

式中的参数如下：

  • im：原图像。
  • mask：掩模。
import cv2
import numpy as np

# --------读取并显示原始图像-----------------
o = cv2.imread('C:\\Users\\Administrator\\Desktop\\pitu.png')
cv2.imshow("original", o)

# --------获取轮廓-----------------
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)

# 检查是否检测到足够的轮廓
if len(contours) > 2:
    cnt = contours[2]  # 选择第3个轮廓
else:
    print(f"检测到的轮廓数不足: {len(contours)}")
    cnt = contours[-1]  # 选择最后一个轮廓，或根据需要选择其他索引

# --------使用掩模获取感兴趣区域的均值-----------------
mask = np.zeros(gray.shape, np.uint8)  # 构造mean所使用的掩模（必须是单通道的）
cv2.drawContours(mask, [cnt], 0, (255, 255, 255), -1)
meanVal = cv2.mean(o, mask=mask)  # mask是一个区域，所以必须是单通道的
print("meanVal=\n", meanVal)

# --------使用掩模获取感兴趣区域并显示-----------------
masko = np.zeros(o.shape, np.uint8)
cv2.drawContours(masko, [cnt], -1, (255, 255, 255), -1)
loc = cv2.bitwise_and(o, masko)
cv2.imshow("mask", loc)

# --------释放窗口-----------------
cv2.waitKey()
cv2.destroyAllWindows()

在这里插入图片描述

图15
  • 左图是图像o。
  • 右图是获取的感兴趣区域。

在这里插入图片描述

从上述结果可以看出，函数cv2.mean()能够计算各个通道的均值。上述4个值分别是RGB和A通道（alpha通道）的均值。本例中，RGB三个通道的值相同，所以计算出的均值也是一样的。

极点

有时，我们希望获取某个对象内的极值点，例如最左端、最右端、最上端、最下端的四个点。OpenCV提供了相应的函数来找出这些点，通常的语法格式是：

leftmost = tuple(cnt[cnt[:, :,0].argmin()][0])
rightmost = tuple(cnt[cnt[:, :,0].argmax()][0])
topmost = tuple(cnt[cnt[:, :,1].argmin()][0])
bottommost = tuple(cnt[cnt[:, :,1].argmax()][0])

【例16】计算一幅图像内的极值点。

import cv2
import numpy as np

o = cv2.imread('C:\\Users\\Administrator\\Desktop\\caonima.png')
# --------获取并绘制轮廓-----------------
gray = cv2.cvtColor(o, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy =cv2.findContours(binary, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
mask = np.zeros(gray.shape, np.uint8)
cnt = contours[0]
cv2.drawContours(mask, [cnt], 0, 255, -1)
# --------计算极值-----------------
leftmost = tuple(cnt[cnt[:, :, 0].argmin()][0])
rightmost = tuple(cnt[cnt[:, :, 0].argmax()][0])
topmost = tuple(cnt[cnt[:, :, 1].argmin()][0])
bottommost = tuple(cnt[cnt[:, :, 1].argmax()][0])
# --------打印极值-----------------
print("leftmost=", leftmost)
print("rightmost=", rightmost)
print("topmost=", topmost)
print("bottommost=", bottommost)
# --------绘制说明文字-----------------
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(o, 'A', leftmost, font, 1, (0, 0, 255), 2)
cv2.putText(o, 'B', rightmost, font, 1, (0, 0, 255), 2)
cv2.putText(o, 'C', topmost, font, 1, (0, 0, 255), 2)
cv2.putText(o, 'D', bottommost, font, 1, (0, 0, 255), 2)
# --------绘制图像-----------------
cv2.imshow("result", o)
# --------释放窗口-----------------
cv2.waitKey()
cv2.destroyAllWindows()

运行结果图像。
在这里插入图片描述

图16

同时，程序还会显示如下的运行结果：

在这里插入图片描述

hola173841439
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
036-OpenCV轮廓特征应用-凸包
weixin_48013634的博客
02-05 2638
所以要是有懂这儿是咋回事的大佬请指教一下弟弟，我就是个新手，请大佬指教！！！ 其实这早就应该发了，对于这我一直有点小问题，就没发，今天又查了一波资料，算是整明白了。 先说两个概念吧，第一个，啥是凸多边形。 上面竟是我说的，什么虎狼之词？！ 收回我上面说的话，还是有地方没弄明白，但就先这样吧，以后再解决它。 还是先说两个概念，啥是凸多边形，啥是凸包。 凸多边形，好像是初中学的…我是早忘了，凸多边形有三个定义，任意两个顶点间的线段位于多边形的内部或 多边形内任意两个点，其连线全部在多边形内部或边上，那就是凸多
OpenCV之图像轮廓
go___on的博客
03-05 7090
什么是图像轮廓？ 具有相同颜色（在彩色图片中）或强度（灰度图像要转变为二值化图像）的连续点的曲线 图像轮廓的作用： 1.可以用于图形分析 2.物体的识别与检测
16- OpenCV：轮廓的发现和轮廓绘制、凸包
bigger_belief的博客
01-30 1411
主要介绍凸包、轮廓发现，以及轮廓周围绘制矩形和圆形框的含义，以及如何实现。
11---OpenCV:图像进阶操作之①轮廓②凸包操作
zjjaibc的博客
08-31 534
OpenCV:图像进阶操作之①轮廓②凸包操作
Opencv(C++)笔记--检测绘制轮廓、检测并绘制凸包
牵一只蜗牛去散步
12-26 1146
常规定义：在一个多边形中，其边缘或内部任意两个点的连线都包含在多边形的边界或者内部，这个多边形称为凸包。严谨定义：包含点集合S中所有点的最小凸多边形称为凸包。③检测并提取二值化图像的轮廓；③ 检测轮廓，获取候选点集；①对原图像进行灰度化处理；②对原图像进行二值化处理；上图的绿色框表示其中一个检测并绘制的凸包。④ 调用API检测凸包；1-1--检测轮廓API。1-2--绘制轮廓API。2--检测并绘制凸包。2-1--凸包的概念。检测凸包的原理可参考。
OpenCV--凸包
m0_57454729的博客
06-29 2907
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、凸包是什么？二、使用步骤1.获取凸包2.凸包缺陷检测（图是有缺陷的）3.测试轮廓是否是凸型的总结 前言 随着人工智能的不断发展，OpenCV这门技术也越来越重要，很多人都开启了学习OpenCV，本文就介绍了OpenCV的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、凸包是什么？ 凸包(Convex Hull)是一个计算几何（图形学）中的概念，它的严格的数学定义为：在一个向量空间V中，对于给定集合X，所有
python-OpenCV-凸包
qq_59117868的博客
05-01 965
前言 python-OpenCV-凸包 #案例:Fu Xianjun. All Rights Reserved. 一、凸包是什么？ 凸包（Convex Hull）是一个计算几何（图形学）中的概念。 在一个实数向量空间V中，对于给定集合X，所有包含X的凸集的交集S被称为X的凸包。X的凸包可以用X内所有点(X1，...Xn)的凸组合来构造. 在二维欧几里得空间中，凸包可想象为一条刚好包著所有点的橡皮圈。 用不严谨的话来讲，给定二维平面上的点集，凸包就是将最外层的点连接起来构成的凸多边形，它能包含
openCV专栏(九)：图像轮廓：凸包
亿只萌新的博客
05-05 3467
openCV视觉图像python专栏，适合初学者的 手把手超详细傻瓜级别教学，图像轮廓t,凸包检测，几何学测试
OpenCV-Python中的图像处理-图像轮廓
SongYuLong
08-09 2090
轮廓可以简单认为成将连续的点（连着边界）连在一起的曲线，具有相同的颜色或者灰度。轮廓在形状分析和物体的检测和识别中很有用。为了更加准确，要使用二值化图像。在寻找轮廓之前，要进行阈值化处理或者 Canny 边界检测。查找轮廓的函数会修改原始图像。如果你在找到轮廓之后还想使用原始图像的话，你应该将原始图像存储到其他变量中。在 OpenCV 中，查找轮廓就像在黑色背景中超白色物体。你应该记住，要找的物体应该是白色而背景应该是黑色。
C#图像处理-OpenCVSharp教程(二十三) OpenCVSharp轮廓特征属性及应用(一)---凸包
Color Space的博客
06-15 1332
本文作者Color Space，文章未经作者允许禁止转载！ 本文将介绍OpenCVSharp轮廓特征属性及应用(一)---凸包！
OpenCV读书笔记之三--OpenCV中的图像处理之一
qq_19462847的博客
05-24 407
OpenCV中的图像处理 一、改变颜色空间 使用cv.cvtColor，cv.inRange等函数三种色彩空间的转换：BGR、GRAY、HSV 提取视频中的彩色对象 #获取颜色转换的所有标记 import cv2 as cv flags = [i for i in dir(cv) if i.startswith('COLOR_')] print(flags) 二、图像几何变换 三、图像阈值 四、图像平滑 五、形态转换 六、图像梯度 七、Canny边缘检测 八、图像金字塔 九、OpenCV中的轮廓 1、轮廓
Opencv图像处理---计算物体的凸包
LYKymy的博客
10-20 525
代码 #include "opencv2/highgui/highgui.hpp" #include "opencv2/imgproc/imgproc.hpp" #include <iostream> #include <stdio.h> #include <stdlib.h> using namespace cv; using namespa...
QT 联合opencv 易错点
最新发布
doubleintfloat的博客
09-10 431
QT 联合opencv 易错点
边缘检测运用
2301_77698138的博客
09-04 1879
边缘检测是图像处理和计算机视觉中的一个基本问题，旨在标识数字图像中亮度变化明显的点，即检测图像中的边缘或不连续区域。这些边缘通常反映了图像中不同区域之间的边界或过渡区域，包含了物体的轮廓和结构信息。
Opencv实现提取卡号（数字识别）
2401_84670644的博客
09-03 1570
接下来，你可能会想要使用这些数字模板与输入图像中的数字进行匹配，以确定输入图像中每个数字的具体值。这通常涉及到模板匹配技术，如使用。库来解析命令行输入，确保用户提供了输入图像和模板图像的路径。函数读取模板图像的路径，并显示原始图像。自定义的myutils库。
1-18 平滑处理——高斯滤波 opencv树莓派4B 入门系列笔记
Sisphusssss的博客
09-08 299
2、提前安装opencv库 以及 numpy库。1、树莓派4B 及 64位系统。
OpenCV结构分析与形状描述符（11）椭圆拟合函数fitEllipse()的使用
jndingxin的专栏
09-08 739
围绕一组2D点拟合一个椭圆。
OpenCV结构分析与形状描述符（17）判断轮廓是否为凸多边形的函数isContourConvex()的使用
jndingxin的专栏
09-10 548
cv::isContourConvex 函数是 OpenCV 提供的一个用于判断轮廓是否为凸多边形的函数。这个函数可以用来验证一个给定的轮廓是否是凸的，这对于后续处理（如使用 intersectConvexConvex 来寻找两个凸多边形的交集）是非常有用的。
opencv轮廓凸包
10-07
引用和引用[2]提供了关于OpenCV中轮廓凸包的相关信息。通过使用cv2.convexHull()函数可以计算给定轮廓的凸包，并返回凸包的角点。此外，通过使用cv2.convexityDefects()函数可以找到凸包中的缺陷点。 代码示例： ```python import cv2 # 读取图像并进行预处理 img = cv2.imread('1.jpg') imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) _, imgThreshold = cv2.threshold(imgGray, 180, 255, cv2.THRESH_BINARY_INV) # 查找轮廓 contours, _ = cv2.findContours(imgThreshold, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # 计算凸包 hull = cv2.convexHull(contours[0]) # 绘制凸包多边形 cv2.polylines(img, [hull], True, (0, 255, 0), 2) # 显示图像 cv2.imshow('Convex Hull', img) cv2.waitKey() cv2.destroyAllWindows() ``` 在上述代码中，我们首先读取图像并将其转换为灰度图像。然后，我们使用阈值化将图像转换为二值图像。接下来，我们使用cv2.findContours()函数查找图像中的轮廓。然后，我们使用cv2.convexHull()函数计算轮廓的凸包。最后，我们使用cv2.polylines()函数绘制凸包多边形，并显示图像。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hola173841439

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值