[Opencv实验]棋盘格特征检测显示

一、实验目的：

        掌握图像中特征检测和显示。

掌握OpenCV中轮廓查找的方法

二、实验内容：

1、相机拍摄棋盘格为目标的视频，用Harris、FAST和SIFT检测角点特征并进行显示；

2、仍以棋盘格为目标，利用Hough变换检测其直线并显示；

3. 【挑战-选做】利用OpenCV实现查找棋盘格。

三、实验要求：

1、相机拍摄棋盘格为目标的图像，用三种检测角点特征并进行显示；

2、仍以棋盘格为目标，利用Hough变换检测其直线并显示；

3.利用OpenCV实现查找棋盘格。

要包含有软件的流程设计图及说明；结果的截屏图像及实验结果详细说明

四、实验原理：

本实验使用了opencv中videocapture方法，Harris、FAST和SIFT检测角点特征方法，hough变换检测直线方法以及以角点检测为基础的棋盘格检测方式。完成不同方式检测角点以及棋盘格查找。

实验所用设备配置为：

处理器  AMD Ryzen 7 4800U with Radeon Graphics            1.80 GHz

机带 RAM    16.0 GB (15.4 GB 可用)

系统类型      64 位操作系统, 基于 x64 的处理器

五、实验过程：

六、实验结果：

Harris角点检测结果

fast角点检测结果

SIFT角点检测结果

Huogh变换检测直线结果

棋盘格检测结果

Fast： 

import cv2
import numpy as np

def Fast_detect_fault(img_01):
    fast = cv2.FastFeatureDetector_create()    # 初始化(参数可不写,也可以写入数字)
    keypoint = fast.detect(img_01,None)
    img_01 = cv2.drawKeypoints(img_01,keypoint,img_01,color=(255,0,0))
    cv2.imshow('fault.png',img_01)

    # Print all default params
    print ("Threshold: ", fast.getThreshold())
    print ("nonmaxSuppression: ", fast.getNonmaxSuppression())
    print ("neighborhood: ", fast.getType())
    print ("Total Keypoints with nonmaxSuppression: ", len(keypoint))


def Fast_detect_Setparam(img_02,thre):
    # fast = cv2.FastFeatureDetector_create()
    # fast.setNonmaxSuppression(100) 使用fast.setNonmaxSuppression来设置默认参数


    fast_02 = cv2.FastFeatureDetector_create(threshold=thre, nonmaxSuppression=True,
                                          type=cv2.FAST_FEATURE_DETECTOR_TYPE_5_8)  # 获取FAST角点探测器

    kp = fast_02.detect(img_02, None)                                 # 描述符
    img_0 = cv2.drawKeypoints(img_02, kp, img_02, color=(255, 0, 0))    # 画到img上面
    #cv2.imshow('sp_'+str(thre),img_02)

    # Print all set params
    print("Threshold: ", fast_02.getThreshold())                   # 输出阈值
    print("nonmaxSuppression: ", fast_02.getNonmaxSuppression())   # 是否使用非极大值抑制
    print("neighborhood: ", fast_02.getType())
    print("Total Keypoints with nonmaxSuppression: ", len(kp))  # 特征点个数
    #cv2.waitKey(0)
    return img_02


if __name__ == '__main__':
    video = cv2.VideoCapture("ForCalibration.avi")

    if video.isOpened():
        # video.read() 一帧一帧地读取
        # open 得到的是一个布尔值，就是 True 或者 False
        # frame 得到当前这一帧的图像
        open, frame = video.read()
    else:
        open = False

    while open:
        ret, frame = video.read()
        # 如果读到的帧数不为空，那么就继续读取，如果为空，就退出
        if frame is None:
            break
        if ret == True:
            
            h, w, _ = frame.shape
            img = frame[:, w // 2:w, :]
            img = Fast_detect_Setparam(img,5)
            cv2.imshow('dst', frame)
            # 这里使用 waitKey 可以控制视频的播放速度，数值越小，播放速度越快
            # 这里等于 27 也即是说按下 ESC 键即可退出该窗口
            if cv2.waitKey(1) & 0xFF == 27:
                break
    video.release()
    cv2.destroyAllWindows()

Sift： 

import cv2
import numpy as np


# 展示图像，封装成函数

video = cv2.VideoCapture("ForCalibration.avi")
# 第一步：读取图像，咋换成灰度图
cv2.namedWindow("123")
while(1):
    i,frame = video.read()
    h, w, _ = frame.shape
    img = frame[:, w // 2:w, :]
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # 使用cv2.xfeatures2d.SIFT_create() 实例化sift函数
    sift = cv2.xfeatures2d.SIFT_create()

    # 得到所有的关键点
    keypoints = sift.detect(gray, None)  # 计算关键点

    keypoints, descriptor = sift.compute(gray, keypoints)  # 根据关键点计算周围区域的特征向量描述
   

    # 或者一次性计算出关键点和特征向量，如下：
    keypoints, descriptor = sift.detectAndCompute(gray, None)

    # 打印特征点的信息，其中最关键的 kpoint.pt 就是包含了位置信息
    
   

    # 将关键点标记的图片上
    img2 = cv2.drawKeypoints(image=img, outImage=img, keypoints=keypoints,
                            flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,
                            color=(255, 0, 0))
    cv2.imshow("123", frame)
    cv2.waitKey(10)  # 等待时间，单位是毫秒，0代表任意键终止
    
    

 Harris：

import cv2
from PIL import Image
import numpy as np

video = cv2.VideoCapture("ForCalibration.avi")

if video.isOpened():

    open, frame = video.read()
else:
    open = False

while open:
    ret, frame = video.read()
    # 如果读到的帧数不为空，那么就继续读取，如果为空，就退出
    if frame is None:
        break
    if ret == True:
        
        h,w,_  = frame.shape
        img = frame[:,w//2:w,:]
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        gray = np.float32(gray)

        # 输入图像必须是float32，最后一个参数在0.04到0.05
        dst = cv2.cornerHarris(gray, 2, 3, 0.04)
        dst = cv2.dilate(dst, None)

        # Threshold for an optimal value, it may vary depending on the image.
        img[dst > 0.01 * dst.max()] = [0, 0, 255]
        cv2.imshow('dst', frame)
        # 这里使用 waitKey 可以控制视频的播放速度，数值越小，播放速度越快
        # 这里等于 27 也即是说按下 ESC 键即可退出该窗口
        if cv2.waitKey(1) & 0xFF == 27:
            break
video.release()
cv2.destroyAllWindows()

Hough直线检测： 

import cv2
from PIL import Image
import numpy as np

def Line(img):
    # 通过边缘检测，得到二值化图像
    img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

    edges = cv2.Canny(img_gray, 50, 150, apertureSize=3)
    # cv2.imshow('1',edges)
    # cv2.waitKey(0)
    # 霍夫直线检
    minLineLength = 10
    maxLineGap = 2
    lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 30, minLineLength, maxLineGap)
    #画出图像上检测到的所有直线
    try:
        for line in lines:
            for x1, y1, x2, y2 in line:
                cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
    except TypeError as e:
        pass
    return img

if __name__ == "__main__":
    video = cv2.VideoCapture("ForCalibration.avi")

    if video.isOpened():
        # video.read() 一帧一帧地读取
        # open 得到的是一个布尔值，就是 True 或者 False
        # frame 得到当前这一帧的图像
        open, frame = video.read()
    else:
        open = False

    while open:
        ret, frame = video.read()
        # 如果读到的帧数不为空，那么就继续读取，如果为空，就退出
        if frame is None:
            break
        if ret == True:
            # 转换为灰度图
            h, w, _ = frame.shape
            img = frame[:, w // 2:w, :]
            img = Line(img)
            cv2.imshow('dst', frame)
            #cv2.waitKey(0)
            # 这里使用 waitKey 可以控制视频的播放速度，数值越小，播放速度越快
            # 这里等于 27 也即是说按下 ESC 键即可退出该窗口
            if cv2.waitKey(20) & 0xFF == 27:
                break
    video.release()
    cv2.destroyAllWindows()

棋盘格：

# -*- coding: utf-8 -*-
import cv2

# 查找棋盘格 角点
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.1)

# 棋盘格参数
corners_vertical = 6  # 纵向角点个数;
corners_horizontal = 8  # 横向角点个数;
pattern_size = (corners_vertical, corners_horizontal)


def find_corners_sb(img):
    """
    查找棋盘格角点函数 SB升级款
    :param img: 处理原图
    """
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 查找棋盘格角点;
    ret, corners = cv2.findChessboardCornersSB(gray, pattern_size, cv2.CALIB_CB_EXHAUSTIVE + cv2.CALIB_CB_ACCURACY)
    if ret:
        # 精细查找角点
        corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
        # 显示角点
        cv2.drawChessboardCorners(img, pattern_size, corners2, ret)


def find_corners(img):
    """
    查找棋盘格角点函数
    :param img: 处理原图
    """
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # 查找棋盘格角点;
    ret, corners = cv2.findChessboardCorners(gray, pattern_size, cv2.CALIB_CB_ADAPTIVE_THRESH +
                                             cv2.CALIB_CB_FAST_CHECK +
                                             cv2.CALIB_CB_FILTER_QUADS)
    if ret:
        # 精细查找角点
        corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
        # 显示角点
        cv2.drawChessboardCorners(img, pattern_size, corners2, ret)


def main():
    video = cv2.VideoCapture("ForCalibration.avi")

    if video.isOpened():
        # video.read() 一帧一帧地读取
        # open 得到的是一个布尔值，就是 True 或者 False
        # frame 得到当前这一帧的图像
        open, frame = video.read()
    else:
        open = False

    while open:
        ret, frame = video.read()
        # 如果读到的帧数不为空，那么就继续读取，如果为空，就退出
        if frame is None:
            break
        if ret == True:
            
            h, w, _ = frame.shape
            img = frame[:, w // 2:w, :]
            if img is not None:
                # 执行查找角点算法
                find_corners_sb(img)
                # find_corners(img_src)
            cv2.imshow('dst', frame)
            # cv2.waitKey(0)
            # 这里使用 waitKey 可以控制视频的播放速度，数值越小，播放速度越快
            # 这里等于 27 也即是说按下 ESC 键即可退出该窗口
            if cv2.waitKey(1) & 0xFF == 27:
                break
    video.release()
    cv2.destroyAllWindows()
    # file_path = ('cheese1.png')
    # img_src = cv2.imread(file_path)
    #
    # if img_src is not None:
    #     # 执行查找角点算法
    #     find_corners_sb(img_src)
    #     # find_corners(img_src)
    #
    #     # 显示图片
    #     cv2.imshow("img", img_src)
    #     cv2.waitKey(0)
    #
    # cv2.destroyAllWindows()


if __name__ == '__main__':
    main()