OpenCV笔记02

模板匹配–单目标匹配

import cv2
target = cv2.imread("sources/target.jpg")
template = cv2.imread("sources/template.jpg")
height, width = template.shape[:2]
result = cv2.matchTemplate(target, template, cv2.TM_SQDIFF_NORMED)  # 执行模板匹配，采用的匹配方式cv2.TM_SQDIFF_NORMED
cv2.normalize(result, result, 0, 1, cv2.NORM_MINMAX, -1)  # 归一化处理
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)  # 寻找矩阵（一维数组当做向量，用Mat定义）中的最大值和最小值的匹配结果及其位置
strmin_val = str(min_val)  # 匹配值转换为字符串
# 对于cv2.TM_SQDIFF及cv2.TM_SQDIFF_NORMED方法min_val越趋近与0匹配度越好，匹配位置取min_loc
# 对于其他方法max_val越趋近于1匹配度越好，匹配位置取max_loc
cv2.rectangle(target, min_loc, (min_loc[0]+width, min_loc[1]+height), (0, 0, 225), 2)
# 绘制矩形边框，将匹配区域标注出来
# min_loc：矩形定点
# (min_loc[0]+width,min_loc[1]+height)：矩形的宽高
# (0,0,225)：矩形的边框颜色；2：矩形边框宽度
cv2.imshow("MatchResult----MatchingValue="+strmin_val, target)
cv2.waitKey()
cv2.destroyAllWindows()

cv2.matchTemplate

目标匹配函数

参数

image：待搜索图像
templ：模板图像
result：匹配结果
method：计算匹配程度的方法

匹配方法

关于匹配方法，使用不同的方法产生的结果的意义可能不太一样，有些返回的值越大表示匹配程度越好，而有些方法返回的值越小表示匹配程度越好。

关于参数 method：
CV_TM_SQDIFF 平方差匹配法：该方法采用平方差来进行匹配；最好的匹配值为0；匹配越差，匹配值越大。
CV_TM_CCORR 相关匹配法：该方法采用乘法操作；数值越大表明匹配程度越好。
CV_TM_CCOEFF 相关系数匹配法：1表示完美的匹配；-1表示最差的匹配。
CV_TM_SQDIFF_NORMED 归一化平方差匹配法

CV_TM_CCORR_NORMED 归一化相关匹配法

CV_TM_CCOEFF_NORMED 归一化相关系数匹配法

cv2.normalize

归一化函数（归一化就是要把需要处理的数据经过处理后（通过某种算法）限制在你需要的一定范围内）

参数

src-输入数组。

dst-与SRC大小相同的输出数组。

α-范数值在范围归一化的情况下归一化到较低的范围边界。

β-上限范围在范围归一化的情况下；它不用于范数归一化。

范式-规范化类型（见下面的细节）。

dType——当输出为负时，输出数组具有与SRC相同的类型；否则，它具有与SRC相同的信道数和深度＝CVH-MatthAsHead（DyType）。

面具-可选的操作面具。

四种归一化方式

NORM_MINMAX:数组的数值被平移或缩放到一个指定的范围，线性归一化。
NORM_INF: 归一化数组的（切比雪夫距离）L∞范数(绝对值的最大值)
NORM_L1 : 归一化数组的（曼哈顿距离）L1-范数(绝对值的和)
NORM_L2: 归一化数组的(欧几里德距离)L2-范数

cv2.minMaxLoc

假设有一个矩阵a,现在需要求这个矩阵的最小值，最大值，并得到最大值，最小值的索引。咋一看感觉很复杂，但使用这个cv2.minMaxLoc()函数就可全部解决。函数返回的四个值就是上述所要得到的。

模板匹配–多目标匹配

在上面那些代码基础上添加如下代码：

temp_loc = min_loc  # 初始化位置参数
other_loc = min_loc
numOfloc = 1
threshold = 0.01  # 对于cv2.TM_SQDIFF及cv2.TM_SQDIFF_NORMED方法设置匹配阈值为0.01
loc = numpy.where(result < threshold)  # 第一次筛选----规定匹配阈值，将满足阈值的从result中提取出来
for other_loc in zip(*loc[::-1]):  # 遍历提取出来的位置
    if (temp_loc[0] + 5 < other_loc[0]) or (temp_loc[1] + 5 > other_loc[1]):  # 第二次筛选----将位置偏移小于5个像素的结果舍去
        numOfloc += 1
        temp_loc = other_loc
        cv2.rectangle(target, other_loc, (other_loc[0]+width, other_loc[1]+height), (0, 0, 225), 2)
str_numOfloc = str(numOfloc)
cv2.imshow("MatchResult----MatchingValue="+strmin_val+"----NumberOfPosition="+str_numOfloc, target)

numpy.where

有两种用法：

1. np.where(condition, x, y)
   满足条件(condition)，输出x，不满足输出y。

2. np.where(condition)
   只有条件 (condition)，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。

python3的zip

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = [7, 8, 9, 10]
>>> zip(a, b)
<zip object at 0x0000021E31A2CD48>
>>> list(zip(a, b))
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a, c))
[(1, 7), (2, 8), (3, 9)]
>>> d, e = zip(*zip(a, b))
>>> d
(1, 2, 3)
>>> e
(4, 5, 6)
>>> list(d)
[1, 2, 3]
>>> list(e)
[4, 5, 6]

[::-1]

取从后向前（相反）的元素，（切片翻转）

BFMatching描述特征点

（结果不准确）

import cv2
from matplotlib import pyplot as plt
template = cv2.imread("sources/template2.jpg", 0)
target = cv2.imread("sources/target.jpg", 0)  # 格式为灰度图
orb = cv2.ORB_create()  # 建立orb特征检测器
kp1, des1 = orb.detectAndCompute(template, None)  # 计算template中的特征点和描述符
kp2, des2 = orb.detectAndCompute(target, None)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)  # 建立匹配关系
matches = bf.match(des1, des2)  # 匹配描述符
matches = sorted(matches, key=lambda x: x.distance)  # 根据距离来排序
result = cv2.drawMatches(template, kp1, target, kp2, matches[:40], None, flags=2)  # 画出匹配关系
plt.imshow(result), plt.show()  # matplotlib描绘出来

基于FLANN的匹配器描述特征点

# -*- coding: utf-8-*-
import cv2
from matplotlib import pyplot as plt
queryImage = cv2.imread("sources/template2.jpg", 0)
trainingImage = cv2.imread("sources/target.jpg", 0)
sift = cv2.xfeatures2d.SIFT_create()  # 创建sift检测器
kp1, des1 = sift.detectAndCompute(queryImage, None)
kp2, des2 = sift.detectAndCompute(trainingImage, None)
FLANN_INDEX_KDTREE = 0  # 设置Flann参数
indexParams = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
searchParams = dict(checks=50)
flann = cv2.FlannBasedMatcher(indexParams, searchParams)
matches = flann.knnMatch(des1, des2, k=2)
matchesMask = [[0, 0] for i in range(len(matches))]  # 设置初始匹配值
for i, (m, n) in enumerate(matches):
    if m.distance < 0.5 * n.distance:  # 舍弃小于0.5的匹配结果
        matchesMask[i] = [1, 0]
drawParams = dict(matchColor=(0, 0, 255), singlePointColor=(255, 0, 0), matchesMask=matchesMask, flags=0)
# 给特征点和匹配的线定义颜色
resultImage = cv2.drawMatchesKnn(queryImage, kp1, trainingImage, kp2, matches, None, **drawParams)
plt.imshow(resultImage,), plt.show()

1.FLANN代表近似最近邻居的快速库。它代表一组经过优化的算法，用于大数据集中的快速最近邻搜索以及高维特征。
2.对于大型数据集，它的工作速度比BFMatcher快。
3.需要传递两个字典来指定要使用的算法及其相关参数等
对于SIFT或SURF等算法，可以用以下方法：
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
对于ORB，可以使用以下参数：
index_params= dict(algorithm = FLANN_INDEX_LSH,
table_number = 6, # 12 这个参数是searchParam,指定了索引中的树应该递归遍历的次数。值越高精度越高
key_size = 12, # 20
multi_probe_level = 1) #2

dict

用于创建一个新的字典，返回一个新的字典
语法：dict(key/value)
参数说明：key/value – 用于创建字典的键/值对，可以表示键/值对的方法有很多。

>>> dict()  # 1、传一个空字典
{}
>>> dict({'name': 'li', 'age': 24})  # 2、传一个字典
{'name': 'li', 'age': 24}
>>> dict(user='admin', password=123456)  # 3、传关键字
{'user': 'admin', 'password': 123456}
>>> dict([('student', 1), ('teacher', 2)])  # 4、传一个包含一个或多个元组的列表
{'student': 1, 'teacher': 2}
>>> dict(zip(['a', 'A'], [3, 4]))  # 5、传一个zip()函数
{'a': 3, 'A': 4}

knnMatch

返回的DMatch类型的数据结构(一组返回的两个DMatch类型)
这两个DMatch数据类型是两个与原图像特征点最接近的两个特征点（match返回的是最匹配的）。只有这俩个特征点的欧式距离小于一定值的时候才会认为匹配成功。例如：原图像特征点与两个绿色苹果相匹配，那么就会认为这个特征点是绿苹果，但若与原图像最接近的匹配分别是一个绿苹果和一个红苹果，那么就会认为匹配是失败的，即没有相匹配的特征点。

enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

基于FLANN的匹配器定位图片

在上面那些代码基础上添加如下代码：

MIN_MATCH_COUNT = 10  # 设置最低特征点匹配数量为10
good = []  
for m, n in matches:  # 舍弃大于0.7的匹配
    if m.distance < 0.7 * n.distance:
        good.append(m)
if len(good) > MIN_MATCH_COUNT:  # 获取关键点的坐标
    src_pts = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2)
    dst_pts = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2)
    M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)  #
    matchesMask = mask.ravel().tolist()
    h, w = template.shape
    # 使用得到的变换矩阵对原图像的四个角进行变换，获得在目标图像上对应的坐标
    pts = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]).reshape(-1, 1, 2)
    dst = cv2.perspectiveTransform(pts, M)
    cv2.polylines(target, [np.int32(dst)], True, 0, 2, cv2.LINE_AA)
else:
    print("Not enough matches are found - %d/%d" % (len(good), MIN_MATCH_COUNT))
    matchesMask = None
draw_params = dict(matchColor=(0, 255, 0),
                   singlePointColor=None,
                   matchesMask=matchesMask,
                   flags=2)
result = cv2.drawMatches(template, kp1, target, kp2, good, None, **draw_params)
plt.imshow(result, 'gray')
plt.show()

reshape

用于改变数组的形状,-1代表的意思：不知道分多少行，但必须分成xxx

cv2.findHomography

如果我们传了两个图像里的点集合，它会找到那个目标的透视转换。
(找到两个平面之间的转换矩阵)

ravel

降维

>>> x = np.array([[1, 2, 3], [4, 5, 6]])
>>> np.ravel(x)
array([1, 2, 3, 4, 5, 6])

tolist

将数组或者矩阵转换成列表

>>> a1 = [[1,2,3],[4,5,6]] # a1是列表
>>> a2 = array(a1) # 列表——>数组
>>> a2
array([[1, 2, 3],
       [4, 5, 6]])
>>> a4 = a2.tolist()  # 数组——>列表
>>> a4
[[1, 2, 3], [4, 5, 6]]

cv2.perspectiveTransform

投射变换

cv2.polylines

画多边形