OpenCV5-图像特征harris-sift-特征匹配-图像全景拼接-答题卡识别判卷

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 前言
• [1. 图像特征harris](#1. 图像特征harris)
• • [1.1 角点检测基本原理](#1.1 角点检测基本原理)
  • [1.2 原理](#1.2 原理)
  • [1.3 使用](#1.3 使用)
• [2. 图像特征-sift](#2. 图像特征-sift)
• • [2.1 原理](#2.1 原理)
  • [2.2 使用](#2.2 使用)
• [3 特征匹配](#3 特征匹配)
• • [3.1 Brute-Force蛮力匹配](#3.1 Brute-Force蛮力匹配)
  • [3.2 1对1的匹配](#3.2 1对1的匹配)
  • [3.3 k对最佳匹配](#3.3 k对最佳匹配)
• [4. 样例实战-图像全景拼接](#4. 样例实战-图像全景拼接)
• • [4.1 流程解读](#4.1 流程解读)
• [5. 答题卡识别判卷](#5. 答题卡识别判卷)
• 总结

---

前言

1. 图像特征harris

1.1 角点检测基本原理

边界：沿着一个方向变化明显，另一个竖直方向变化不明显

角点：水平竖直方向都变化明显

角点特征更加明显

1.2 原理

最后就是看水平和竖直的变化率了

1.3 使用

cv2.cornerHarris()
img： 数据类型为 float32 的入图像
blockSize： 角点检测中指定区域的大小
ksize： Sobel求导中使用的窗口大小，一般为3
k： 取值参数为 [0,04,0.06]，一般就用0.04

import cv2 
import numpy as np

img = cv2.imread('../chessboard.jpg')
print ('img.shape:',img.shape)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# gray = np.float32(gray)
dst = cv2.cornerHarris(gray, 2, 3, 0.04)
print ('dst.shape:',dst.shape)

因为dst算出来的也是每个点的变换率，所以是512大小的

img[dst>0.01*dst.max()]=[0,0,255]
cv2.imshow('dst',img) 
cv2.waitKey(0) 
cv2.destroyAllWindows()

0,0,255\]是红色 把dst\>0.01\*dst.max()的点变为红色---》可能为角点   ## 2. 图像特征-sift SIFT（Scale-Invariant Feature Transform，尺度不变特征变换）是一种经典的图像局部特征提取算法，核心优势是能在图像尺度缩放、旋转、光照变化甚至部分遮挡的情况下，稳定提取出具有唯一性的局部特征点，为图像匹配、目标识别、图像拼接等计算机视觉任务提供关键支持。 ### 2.1 原理 在一定的范围内，无论物体是大还是小，人眼都可以分辨出来，然而计算机要有相同的能力却很难，所以要让机器能够对物体在不同尺度下有一个统一的认知，就需要考虑图像在不同的尺度下都存在的特点。 尺度空间的获取通常使用高斯模糊来实现：使用高斯滤波就可以变得越来越模糊   不同σ的高斯函数决定了对图像的平滑程度，越大的σ值对应的图像越模糊。  对每一层都进行高斯滤波  每相邻进行高斯滤波的进行差分 差值比较大的说明特征比较明显  第三个参数是高斯滤波的参数  DoG空间极值检测 为了寻找尺度空间的极值点，每个像素点要和其图像域（同一尺度空间）和尺度域（相邻的尺度空间）的所有相邻点进行比较，当其大于（或者小于）所有相邻点时，该点就是极值点。如下图所示，中间的检测点要和其所在图像的3×3邻域8个像素点，以及其相邻的上下两层的3×3领域18个像素点，共26个像素点进行比较。 不仅要和周围3\*3进行比较，还要和上下层进行比较  这些候选关键点是DOG空间的局部极值点，而且这些极值点均为离散的点，精确定位极值点的一种方法是，对尺度空间DoG函数进行曲线拟合，计算其极值点，从而实现关键点的精确定位。 估计出来的极值点可能不是真正极值点，所以要根据这些估计点，算出真实点的极值点  消除边界响应  每个特征点可以得到三个信息(x,y,σ,θ)，即位置、尺度和方向。具有多个方向的关键点可以被复制成多份，然后将方向值分别赋给复制后的特征点，一个特征点就产生了多个坐标、尺度相等，但是方向不同的特征点。   ### 2.2 使用 ```java pip list ``` 可以查看自己安装的包 ```java pip uninstall xxx ``` 直接删除 ```java import cv2 import numpy as np img = cv2.imread('../test_1.jpg') gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ``` ```java sift = cv2.SIFT_create() kp = sift.detect(gray, None) ``` kp就是关键点 ```java img = cv2.drawKeypoints(gray, kp, img) cv2.imshow('drawKeypoints', img) cv2.waitKey(0) cv2.destroyAllWindows() ```  计算特征 ```java kp, des = sift.compute(gray, kp) ``` kp还是关键点 des是每个关键点的特征  128个特征  ## 3 特征匹配 ### 3.1 Brute-Force蛮力匹配 ```java import cv2 import numpy as np import matplotlib.pyplot as plt %matplotlib inline ```    ```java sift = cv2.SIFT_create() ``` ```java kp1, des1 = sift.detectAndCompute(img1, None) kp2, des2 = sift.detectAndCompute(img2, None) ``` ```java # crossCheck表示两个特征点要互相匹，例如A中的第i个特征点与B中的第j个特征点最近的，并且B中的第j个特征点到A中的第i个特征点也是 #NORM_L2: 归一化数组的(欧几里德距离)，如果其他特征计算方法需要考虑不同的匹配计算方式 bf = cv2.BFMatcher(crossCheck=True) ```  crossCheck=True的含义是这样的，i的最近是j，但是j的最近也就只能是i了，不能为z ### 3.2 1对1的匹配 ```java matches = bf.match(des1, des2) matches = sorted(matches, key=lambda x: x.distance) ``` 返回的matches 是匹配出来的结果 排序的目的是给出匹配后的结果，比如第一个就是最相近的，第二个是第二相近的 ```java img3 = cv2.drawMatches(img1, kp1, img2, kp2, matches[:10], None,flags=2) ``` ```java cv_show('img3',img3) ```  matches\[:10\], # 要绘制的匹配对（这里只显示前10对） None, # 输出图像（None表示自动创建） flags=2 # 绘制标志（2表示只绘制匹配线，不显示单个特征点） ### 3.3 k对最佳匹配 ```java bf = cv2.BFMatcher() matches = bf.knnMatch(des1, des2, k=2) ``` 这个就表示一个点对应两个相近的点了 ```java good = [] for m, n in matches: if m.distance < 0.75 * n.distance: good.append([m]) ```  这个就是过滤出距离比小于0.75的了 ```java img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,good,None,flags=2) cv_show('img3',img3) ```  发现有些点配对错了----》过滤掉 如果需要更快速完成操作，可以尝试使用cv2.FlannBasedMatcher    ## 4. 样例实战-图像全景拼接 不是简单的切割  H矩阵可以把图像进行弯曲的效果，就是变换矩阵  这两个拼接，，比如柱子也应该拼接为一个才行 就是先找很多特征点配对，然后就可以拼接了  ### 4.1 流程解读 Stitcher.py： ```java import numpy as np import cv2 class Stitcher: #拼接函数 def stitch(self, images, ratio=0.75, reprojThresh=4.0,showMatches=False): #获取输入图片 (imageB, imageA) = images #检测A、B图片的SIFT关键特征点，并计算特征描述子 (kpsA, featuresA) = self.detectAndDescribe(imageA) (kpsB, featuresB) = self.detectAndDescribe(imageB) # 匹配两张图片的所有特征点，返回匹配结果 M = self.matchKeypoints(kpsA, kpsB, featuresA, featuresB, ratio, reprojThresh) # 如果返回结果为空，没有匹配成功的特征点，退出算法 if M is None: return None # 否则，提取匹配结果 # H是3x3视角变换矩阵 (matches, H, status) = M # 将图片A进行视角变换，result是变换后图片 result = cv2.warpPerspective(imageA, H, (imageA.shape[1] + imageB.shape[1], imageA.shape[0])) self.cv_show('result', result) # 将图片B传入result图片最左端 result[0:imageB.shape[0], 0:imageB.shape[1]] = imageB self.cv_show('result', result) # 检测是否需要显示图片匹配 if showMatches: # 生成匹配图片 vis = self.drawMatches(imageA, imageB, kpsA, kpsB, matches, status) # 返回结果 return (result, vis) # 返回匹配结果 return result def cv_show(self,name,img): cv2.imshow(name, img) cv2.waitKey(0) cv2.destroyAllWindows() def detectAndDescribe(self, image): # 将彩色图片转换成灰度图 gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # 建立SIFT生成器 descriptor = cv2.xfeatures2d.SIFT_create() # 检测SIFT特征点，并计算描述子 (kps, features) = descriptor.detectAndCompute(image, None) # 将结果转换成NumPy数组 kps = np.float32([kp.pt for kp in kps]) # 返回特征点集，及对应的描述特征 return (kps, features) def matchKeypoints(self, kpsA, kpsB, featuresA, featuresB, ratio, reprojThresh): # 建立暴力匹配器 matcher = cv2.BFMatcher() # 使用KNN检测来自A、B图的SIFT特征匹配对，K=2 rawMatches = matcher.knnMatch(featuresA, featuresB, 2) matches = [] for m in rawMatches: # 当最近距离跟次近距离的比值小于ratio值时，保留此匹配对 if len(m) == 2 and m[0].distance < m[1].distance * ratio: # 存储两个点在featuresA, featuresB中的索引值 matches.append((m[0].trainIdx, m[0].queryIdx)) # 当筛选后的匹配对大于4时，计算视角变换矩阵 if len(matches) > 4: # 获取匹配对的点坐标 ptsA = np.float32([kpsA[i] for (_, i) in matches]) ptsB = np.float32([kpsB[i] for (i, _) in matches]) # 计算视角变换矩阵 (H, status) = cv2.findHomography(ptsA, ptsB, cv2.RANSAC, reprojThresh) # 返回结果 return (matches, H, status) # 如果匹配对小于4时，返回None return None def drawMatches(self, imageA, imageB, kpsA, kpsB, matches, status): # 初始化可视化图片，将A、B图左右连接到一起 (hA, wA) = imageA.shape[:2] (hB, wB) = imageB.shape[:2] vis = np.zeros((max(hA, hB), wA + wB, 3), dtype="uint8") vis[0:hA, 0:wA] = imageA vis[0:hB, wA:] = imageB # 联合遍历，画出匹配对 for ((trainIdx, queryIdx), s) in zip(matches, status): # 当点对匹配成功时，画到可视化图上 if s == 1: # 画出匹配对 ptA = (int(kpsA[queryIdx][0]), int(kpsA[queryIdx][1])) ptB = (int(kpsB[trainIdx][0]) + wA, int(kpsB[trainIdx][1])) cv2.line(vis, ptA, ptB, (0, 255, 0), 1) # 返回可视化结果 return vis ``` ImageStiching.py： ```java from Stitcher import Stitcher import cv2 # 读取拼接图片 imageA = cv2.imread("left_01.png") imageB = cv2.imread("right_01.png") # 把图片拼接成全景图 stitcher = Stitcher() (result, vis) = stitcher.stitch([imageA, imageB], showMatches=True) # 显示所有图片 cv2.imshow("Image A", imageA) cv2.imshow("Image B", imageB) cv2.imshow("Keypoint Matches", vis) cv2.imshow("Result", result) cv2.waitKey(0) cv2.destroyAllWindows() ``` ## 5. 答题卡识别判卷  这个就是答题卡 ```java #导入工具包 import numpy as np import argparse import imutils import cv2 # 正确答案，表示第一题选B,第二题选E ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1} def order_points(pts): # 一共4个坐标点 rect = np.zeros((4, 2), dtype = "float32") # 按顺序找到对应坐标0123分别是 左上，右上，右下，左下 # 计算左上，右下 s = pts.sum(axis = 1) rect[0] = pts[np.argmin(s)] rect[2] = pts[np.argmax(s)] # 计算右上和左下 diff = np.diff(pts, axis = 1) rect[1] = pts[np.argmin(diff)] rect[3] = pts[np.argmax(diff)] return rect def four_point_transform(image, pts): # 获取输入坐标点 rect = order_points(pts) (tl, tr, br, bl) = rect # 计算输入的w和h值 widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2)) widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2)) # 因为类似梯形，所以取最大值 maxWidth = max(int(widthA), int(widthB)) heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2)) heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2)) maxHeight = max(int(heightA), int(heightB)) # 变换后对应坐标位置 dst = np.array([ [0, 0], [maxWidth - 1, 0], [maxWidth - 1, maxHeight - 1], [0, maxHeight - 1]], dtype = "float32") # 计算变换矩阵 M = cv2.getPerspectiveTransform(rect, dst) warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight)) # 返回变换后结果 return warped def sort_contours(cnts, method="left-to-right"): # reverse：控制排序是升序还是降序（例如 "从左到右" 是升序，"从右到左" 是降序）。 reverse = False # i：控制用边界框的 x 坐标（i=0）还是 y 坐标（i=1）作为排序依据（水平排序用 x，垂直排序用 y）。 i = 0 if method == "right-to-left" or method == "bottom-to-top": reverse = True if method == "top-to-bottom" or method == "bottom-to-top": i = 1 # cv2.boundingRect(c)返回轮廓c的最小外接矩形，格式为(x, y, width, height)，其中(x, y)是矩形左上角坐标。 boundingBoxes = [cv2.boundingRect(c) for c in cnts] # zip(cnts, boundingBoxes)将轮廓与其对应的边界框配对 (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes), key=lambda b: b[1][i], reverse=reverse)) # 排序后的轮廓列表（cnts），对应的排序后边界框列表（boundingBoxes） return cnts, boundingBoxes def cv_show(name,img): cv2.imshow(name, img) cv2.waitKey(0) cv2.destroyAllWindows() # 预处理 image = cv2.imread("./images/test_01.png") contours_img = image.copy() gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # 高斯滤波---》去掉噪音点 blurred = cv2.GaussianBlur(gray, (5, 5), 0) cv_show('blurred',blurred) # 边缘检测 edged = cv2.Canny(blurred, 75, 200) cv_show('edged',edged) # 轮廓检测，会返回两个值，[1]表示只需要轮廓 cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0] cv2.drawContours(contours_img,cnts,-1,(0,0,255),3) cv_show('contours_img',contours_img) docCnt = None # 确保检测到了 if len(cnts) > 0: # 根据轮廓大小进行排序 cnts = sorted(cnts, key=cv2.contourArea, reverse=True) # 遍历每一个轮廓 for c in cnts: # 近似， # 计算轮廓的周长，True表示轮廓是闭合的 peri = cv2.arcLength(c, True) # 对轮廓进行多边形近似，参数0.02 * peri表示近似精度（周长的 2%） approx = cv2.approxPolyDP(c, 0.02 * peri, True) # 准备做透视变换 # 当近似后的多边形有 4 个顶点时，认为找到了四边形（通常是矩形文档），将其保存到docCnt并跳出循环。 if len(approx) == 4: docCnt = approx break # 执行透视变换，，因为手机照出来的不是真正的长方形，所以要投射变换 warped = four_point_transform(gray, docCnt.reshape(4, 2)) cv_show('warped',warped) # Otsu's 阈值处理，THRESH_OTSU自动计算阈值来划分，但是第二个参数要为0 thresh = cv2.threshold(warped, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1] cv_show('thresh',thresh) thresh_Contours = thresh.copy() # 找到每一个圆圈轮廓 cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0] cv2.drawContours(thresh_Contours,cnts,-1,(0,0,255),3) cv_show('thresh_Contours',thresh_Contours) questionCnts = [] # 遍历，只要圆形 for c in cnts: # 计算比例和大小，计算外接矩形boundingRect---》圆的外接矩形，h和w差不多一样大 (x, y, w, h) = cv2.boundingRect(c) ar = w / float(h) # 根据实际情况指定标准 if w >= 20 and h >= 20 and ar >= 0.9 and ar <= 1.1: questionCnts.append(c) # 按照从上到下进行排序 questionCnts = sort_contours(questionCnts, method="top-to-bottom")[0] correct = 0 # 每排有5个选项，生成步长为 5 的索引序列（0,5,10...），用于按排取轮廓 # q：当前是第几排（从 0 开始计数） # i：当前排的起始索引（如第 1 排从 i=0 开始，第 2 排从 i=5 开始） for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)): # 排序 # questionCnts[i:i + 5]：截取当前排的 5 个选项轮廓 # sort_contours(...)：调用之前的排序函数，默认按 "从左到右" 排序 # [0]：取排序后的轮廓列表（因为sort_contours返回两个值：轮廓列表和边界框列表） cnts = sort_contours(questionCnts[i:i + 5])[0] bubbled = None # 遍历每一个结果 # j：当前选项在这一排中的索引（0-4，对应 5 个选项） for (j, c) in enumerate(cnts): # 使用mask来判断结果 mask = np.zeros(thresh.shape, dtype="uint8") cv2.drawContours(mask, [c], -1, 255, -1) #-1表示填充 cv_show('mask',mask) # 通过计算非零点数量来算是否选择这个答案 # mask与thresh进行and操作，， # 只保留掩码区域内的阈值图像内容 mask = cv2.bitwise_and(thresh, thresh, mask=mask) # # 统计掩码区域内非零像素的数量（即被涂黑的像素数） total = cv2.countNonZero(mask) # 通过阈值判断。。。找出最大黑色像素点---》被涂的位置，j表示涂的哪个选项，j=1表示选的B if bubbled is None or total > bubbled[0]: bubbled = (total, j) # 对比正确答案 color = (0, 0, 255) k = ANSWER_KEY[q] # 判断正确,bubbled[1]就是j if k == bubbled[1]: color = (0, 255, 0) correct += 1 # 绘图 cv2.drawContours(warped, [cnts[k]], -1, color, 3) score = (correct / 5.0) * 100 print("[INFO] score: {:.2f}%".format(score)) cv2.putText(warped, "{:.2f}%".format(score), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2) cv2.imshow("Original", image) cv2.imshow("Exam", warped) cv2.waitKey(0) ``` ## 总结