前文链接：

OpenCV学习笔记(九)——图像轮廓(上)

OpenCV学习笔记(九)——图像轮廓(中)

6. 利用形状场景算法比较轮廓

用矩比较形状是一种非常有效的方法，不过现在有了更有效的方法。从OpenCV 3开始，有了专有模块shape，该模块中的形状场景算法能够更高效地比较形状。

6.1 计算形状场景距离

OpenCV 提供了使用“距离”作为形状比较的度量标准。这是因为形状之间的差异值和距离有相似之处，比如二者都只能是零或者正数，又比如当两个形状一模一样时距离值和差值都等于零。

retval = cv2.createShapeContextDistanceExtractor( [, nAngularBins[, nRadialBins[, innerRadius[, outerRadius[, iterations[, comparer[, transformer]]]]]]] )

nAngularBins：为形状匹配中使用的形状上下文描述符建立的角容器的数量。
nRadialBins：为形状匹配中使用的形状上下文描述符建立的径向容器的数量。
innerRadius：形状上下文描述符的内半径。
outerRadius：形状上下文描述符的外半径。
iterations：迭代次数。
comparer：直方图代价提取算子。该函数使用了直方图代价提取仿函数，可以直接采用直方图代价提取仿函数的算子作为参数。
transformer：形状变换参数。
式中的返回值为retval，返回结果。

该结果可以通过函数cv2.ShapeDistanceExtractor.computeDistance()计算两个不同形状之间的距离。此函数的语法格式为：

retval=cv2.ShapeDistanceExtractor.computeDistance(contour1, contour2)

式中，coutour1 和coutour2 是不同的轮廓。

import cv2
#-----------原始图像o1 的边缘--------------------
o1 = cv2.imread('cs.bmp')
cv2.imshow("original1",o1)
gray1 = cv2.cvtColor(o1,cv2.COLOR_BGR2GRAY)
ret, binary1 = cv2.threshold(gray1,127,255,cv2.THRESH_BINARY)
image,contours1, hierarchy = cv2.findContours(binary1,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
cnt1 = contours1[0]
#-----------原始图像o2 的边缘--------------------
o2 = cv2.imread('cs3.bmp')
cv2.imshow("original2",o2)
gray2 = cv2.cvtColor(o2,cv2.COLOR_BGR2GRAY)
ret, binary2 = cv2.threshold(gray2,127,255,cv2.THRESH_BINARY)
image,contours2, hierarchy = cv2.findContours(binary2,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
cnt2 = contours2[0]
#-----------原始图像o3 的边缘--------------------
o3 = cv2.imread('hand.bmp')
cv2.imshow("original3",o3)
gray3 = cv2.cvtColor(o3,cv2.COLOR_BGR2GRAY)
ret, binary3 = cv2.threshold(gray3,127,255,cv2.THRESH_BINARY)
image,contours3, hierarchy = cv2.findContours(binary3,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
cnt3 = contours3[0]
#-----------构造距离提取算子--------------------
sd = cv2.createShapeContextDistanceExtractor()
#-----------计算距离--------------------
d1 = sd.computeDistance(cnt1,cnt1)
print("与自身的距离d1=", d1)
d2 = sd.computeDistance(cnt1,cnt2)
print("与旋转缩放后的自身图像的距离d2=", d2)
d3 = sd.computeDistance(cnt1,cnt3)
print("与不相似对象的距离d3=", d3)
#-----------显示距离--------------------
cv2.waitKey()
cv2.destroyAllWindows()

运行后程序会显示如下的运行结果：
与自身的距离d1= 0.0
与旋转缩放后的自身图像的距离d2= 0.7913379669189453
与不相似对象的距离d3= 2.75199031829834

从上述运行结果可以看出；

• 相同图像之间的形状场景距离为零。
• 相似图像之间的形状场景距离较小。
• 不同图像之间的形状场景距离较大。

6.2 计算Hausdorff距离

Hausdorff 距离的计算方法是：
（1）针对图像A 内的每一个点，寻找其距离图像B 的最短距离，将这个最短距离作为
Hausdorff 直接距离D1。
（2）针对图像B 内的每一个点，寻找其距离图像A 的最短距离，将这个最短距离作为
Hausdorff 直接距离D2。
（3）将上述D1、D2 中的较大者作为Hausdorff 距离。
retval = cv2.createHausdorffDistanceExtractor( [, distanceFlag [, rankProp]])

• distanceFlag 为距离标记，是可选参数。
• rankProp 为一个比例值，范围在0 到1 之间，也是可选参数。

import cv2
#-----------读取原始图像--------------------
o1 = cv2.imread('cs.bmp')
o2 = cv2.imread('cs3.bmp')
o3 = cv2.imread('hand.bmp')
cv2.imshow("original1",o1)
cv2.imshow("original2",o2)
cv2.imshow("original3",o3)
#-----------色彩转换--------------------
gray1 = cv2.cvtColor(o1,cv2.COLOR_BGR2GRAY)
gray2 = cv2.cvtColor(o2,cv2.COLOR_BGR2GRAY)
gray3 = cv2.cvtColor(o3,cv2.COLOR_BGR2GRAY)
#-----------阈值处理--------------------
ret, binary1 = cv2.threshold(gray1,127,255,cv2.THRESH_BINARY)
ret, binary2 = cv2.threshold(gray2,127,255,cv2.THRESH_BINARY)
ret, binary3 = cv2.threshold(gray3,127,255,cv2.THRESH_BINARY)
#-----------提取轮廓--------------------
image,contours1, hierarchy = cv2.findContours(binary1,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
image,contours2, hierarchy = cv2.findContours(binary2,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
image,contours3, hierarchy = cv2.findContours(binary3,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
cnt1 = contours1[0]
cnt2 = contours2[0]
cnt3 = contours3[0]
#-----------构造距离提取算子--------------------
hd = cv2.createHausdorffDistanceExtractor()
#-----------计算距离--------------------
d1 = hd.computeDistance(cnt1,cnt1)
print("与自身图像的Hausdorff 距离d1=", d1)
d2 = hd.computeDistance(cnt1,cnt2)
print("与旋转缩放后的自身图像的Hausdorff 距离d2=", d2)
d3 = hd.computeDistance(cnt1,cnt3)
print("与不相似对象的Hausdorff 距离d3=", d3)
#-----------显示距离--------------------
cv2.waitKey()
cv2.destroyAllWindows()

运行后程序会显示如下的运行结果：
与自身图像的Hausdorff 距离d1= 0.0
与旋转缩放后的自身图像的Hausdorff 距离d2= 18.357559204101562
与不相似对象的Hausdorff 距离d3= 57.27128601074219

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

• 相同图像之间的Hausdorff 距离为零。
• 相似图像之间的Hausdorff 距离较小。
• 不同图像之间的Hausdorff 距离较大。

7. 轮廓的特征值

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

7.1 宽高比

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

import cv2
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)
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()

运行后程序显示如下的运行结果：
2.1506849315068495

7.2 Extend

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

import cv2
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)
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()

运行后程序显示如下的运行结果：
0.6717127650292296

7.3 Solidity

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

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)
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()

运行后程序显示如下的运行结果：
0.6752344564084751

7.4 等效直径（Equivalent Diameter）

可以用等效直径来衡量轮廓的特征值，该值是与轮廓面积相等的圆形的直径。其计算公式
为：等效直径 = 根号(4*轮廓面积/Π)

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)
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()

运行后程序显示如下的运行结果：
99.00522529212108

7.5 方向

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

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

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

import cv2
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)
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()

运行后程序显示如下的运行结果：
单个返回值形式：
retval=
((276.2112731933594, 139.6067352294922), (63.01350021362305,
166.72308349609375), 82.60102844238281)
三个返回值形式：
(x,y)=( 276.2112731933594 139.6067352294922 )
(MA,ma)=( 63.01350021362305 166.72308349609375 )
angle= 82.60102844238281

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

7.6 掩模和像素点

有时，我们希望获取某对象的掩模图像及其对应的点。1.3 节介绍了将函数cv2.drawContours()的轮廓宽度参数thickness设置为“-1”，即可获取特定对象的实心轮廓，即特定对象的掩模。另外，我们可能还希望获取轮廓像素点的具体位置信息。本节介绍如何获取轮廓(实心、空心)的像素点位置信息。
OpenCV 提供了函数cv2.findNonZero()用于查找非零元素的索引。该函数的语法格式为：

idx = cv2.findNonZero( src )

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

#使用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)

运行上述程序，会显示如下的运行结果：
a=
[[0 0 0 0 0]
[0 0 0 0 1]
[0 0 1 1 1]
[1 1 0 0 1]
[1 1 0 0 0]]
a 内非零值的位置:
[[[4 1]]
[[2 2]]
[[3 2]]
[[4 2]]
[[0 3]]
[[1 3]]
[[4 3]]
[[0 4]]
[[1 4]]]

#使用OpenCV 函数cv2.findNonZero()获取一个图像内的轮廓点的位置。
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 = 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()

#运行后程序显示如下的运行结果：
pixelpoints1.shape= (1400, 1, 2)
pixelpoints1=
[[[292 106]]
[[293 106]]
[[294 106]]
...
[[222 180]]
[[223 180]]
[[224 180]]]
pixelpoints2.shape= (7892, 1, 2)
pixelpoints2=
[[[293 107]]
[[294 107]]
[[295 107]]
...
[[221 179]]
[[222 179]]
[[223 179]]]

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

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

• min_val：最小值。
• max_val：最大值。
• min_loc：最小值的位置。
• max_loc：最大值的位置。
• imgray：单通道图像。
• mask：掩模。通过使用掩模图像，可以得到掩模指定区域内的最值信息。

import cv2
import numpy as np
o = cv2.imread('ct.png')
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[2] #coutours[0]、coutours[1]是左侧字母R
#--------使用掩模获取感兴趣区域的最值-----------------
#需要注意函数minMaxLoc 处理的对象为灰度图像，本例中处理的对象为灰度图像gray
#如果希望获取彩色图像的最值，需要提取各个通道图像，为每个通道独立计算最值
mask = np.zeros(gray.shape,np.uint8)
mask=cv2.drawContours(mask,[cnt],-1,255,-1)
minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(gray,mask = mask)
print("minVal=",minVal)
print("maxVal=",maxVal)
print("minLoc=",minLoc)
print("maxLoc=",maxLoc)
#--------使用掩模获取感兴趣区域并显示-----------------
masko = np.zeros(o.shape,np.uint8)
masko=cv2.drawContours(masko,[cnt],-1,(255,255,255),-1)
loc=cv2.bitwise_and(o,masko)
cv2.imshow("mask",loc)
#显示灰度结果
#loc=cv2.bitwise_and(gray,mask)
#cv2.imshow("mask",loc)
#--------释放窗口-----------------
cv2.waitKey()
cv2.destroyAllWindows()

程序显示如下的运行结果：
minVal= 42.0
maxVal= 200.0
minLoc= (87, 90)
maxLoc= (90, 110)

7.8 平均颜色及平均灰度

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

• im：原图像。
• mask：掩模。

import cv2
import numpy as np
#--------读取并显示原始图像-----------------
o = cv2.imread('ct.png')
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[2] #coutours[0]、coutours[1]是左侧字母R
#--------使用掩模获取感兴趣区域的均值-----------------
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()

运行后程序显示如下的运行结果：
meanVal= (85.45594913714805, 85.45594913714805, 85.45594913714805, 0.0)

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

7.9 极点

有时，我们希望获取某个对象内的极值点，例如最左端、最右端、最上端、最下端的四个点。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])

import cv2
import numpy as np
o = cv2.imread('cs.bmp')
#--------获取并绘制轮廓-----------------
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)
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()

运行后程序显示如下的运行结果：
leftmost= (202, 135)
rightmost= (423, 120)
topmost= (369, 69)
bottommost= (216, 179)