通过模板匹配先定位检测的对象再检测圆形零件和孔针

先通过外面检测的大圆，以圆心定位中心孔和针的检测区域，再通过斑点检测

斑点检测时其必须为黑色，如果其检测对象是白色可通过

black_image = 255 - src_image

将检测的对象区域变为黑色

如果检测对象是黑色，则不用转化

import os
import cv2
import numpy as np
import math
import xml.etree.ElementTree as ET
import imutils
# 检测针脚位置
def needelCenter_detect(img):
    params = cv2.SimpleBlobDetector_Params()
    # Setup SimpleBlobDetector parameters.
    # print('params')
    # print(params)
    # print(type(params))

    # Filter by Area.
    params.filterByArea = True
    params.minArea = 100
    params.maxArea = 10e3
    params.minDistBetweenBlobs = 50
    # params.filterByColor = True
    params.filterByConvexity = False
    # tweak these as you see fit
    # Filter by Circularity
    params.filterByCircularity = False
    params.minCircularity = 0.2
    # params.blobColor = 0
    # # # Filter by Convexity
    # params.filterByConvexity = True
    # params.minConvexity = 0.87
    # Filter by Inertia
    # params.filterByInertia = True
    # params.filterByInertia = False
    # params.minInertiaRatio = 0.01

    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # Detect blobs.
    minThreshValue = 110
    _, gray = cv2.threshold(gray, minThreshValue, 255, cv2.THRESH_BINARY)
    # erosion_size = 3
    # # element = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2 * erosion_size + 1, 2 * erosion_size + 1),
    # #                                     (erosion_size, erosion_size))
    # element = cv2.getStructuringElement(cv2.MORPH_ERODE, (2 * erosion_size + 1, 2 * erosion_size + 1),
    #                                     (erosion_size, erosion_size))
    # gray = cv2.erode(gray, element, 2)
    # cv2.imshow("gray",gray)
    # cv2.waitKey()



    detector = cv2.SimpleBlobDetector_create(params)
    gray = 255 - gray
    keypoints = detector.detect(gray)
    # print(len(keypoints))
    # print(keypoints[0].pt[0])
    # 如果这儿没检测到可能会出错
    if len(keypoints) == 0:
        print("没有检测到针角坐标，可能需要调整针角斑点检测参数")
        return keypoints

    else:
        # print(len(keypoints))
        # im_with_keypoints = cv2.drawKeypoints(gray, keypoints, np.array([]), (255, 0, 0),
        #                                       cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

        # if keypoints is not None:

        # color_img = cv2.cvtColor(im_with_keypoints, cv2.COLOR_BGR2RGB)
        # 画出圆的圆心
        # cv2.circle(color_img, (int(keypoints[0].pt[0]), int(keypoints[0].pt[1])), 5, (0, 255, 0), -1)
        # cv2.imshow("color_img",color_img)
        # cv2.waitKey()

        return keypoints



# 检测连接器圆形位置
def circle_detect(image):
    # 灰度化
    circle_img = image.copy()
    gray = cv2.cvtColor(circle_img, cv2.COLOR_BGR2GRAY)
    # minThreshValue = 150
    # _, gray = cv2.threshold(gray, minThreshValue, 255, cv2.THRESH_BINARY)
    # cv2.imshow("gray", gray)
    # cv2.waitKey()
    # print(image.shape)
    # 进行中值滤波
    img = cv2.medianBlur(gray, 3)


    # 针角圆心坐标
    out_x = 0
    out_y = 0

    # 霍夫变换圆检测
    circles = cv2.HoughCircles(img, cv2.HOUGH_GRADIENT, 1, 10e10, param1=100, param2=30, minRadius=100, maxRadius=500)
    # 如果没检测到会报错
    # 这种判断方式过于简单
    if circles is None:
        print("没有检测到连接器外圆")

    else:
        for circle in circles[0]:
            # 圆的基本信息
            # print(circle[2])
            # 坐标行列－圆心坐标
            out_x = int(circle[0])
            out_y = int(circle[1])
            # 半径
            r = int(circle[2])
            # 在原图用指定颜色标记出圆的边界
            cv2.circle(circle_img, (out_x, out_y), r, (0, 0, 255), 2)
            # # 画出圆的圆心
            cv2.circle(circle_img, (out_x, out_y), 3, (0, 0, 255), -1)

        # cv2.namedWindow("circle_img", 2)
        # cv2.imshow("circle_img", circle_img)
        # cv2.waitKey()
        # 记录外圆坐标
        out_xpoint = out_x
        out_ypoint = out_y

        # 只框出单个针角的位置区域
        step_center = 30
        step_rect = 60
        out_x -= step_center
        out_y -= step_center

        needleRect = image[out_y: out_y + step_rect, out_x: out_x + step_rect]
        # cv2.namedWindow("needleRect", 2)
        # cv2.imshow("needleRect", needleRect)
        # cv2.waitKey()

        # 根据检测到的圆形连接器中心找针角位置
        centerPoint = needelCenter_detect(needleRect)

        if len(centerPoint) == 0:
            print("调整位置")
            return False
        else:
            # 将针角的坐标原还至原图
            in_x = int(centerPoint[0].pt[0])
            in_y = int(centerPoint[0].pt[1])
            in_x +=   out_x
            in_y +=   out_y

            # 画出针角的圆心
            cv2.circle(circle_img, (in_x, in_y), 3, (0, 255, 0), -1)

            # 计算两者的距离
            # 假设通过标定其一个像素代表0.0056mm
            DPI = 0.019696448792778324
            dis = math.sqrt(math.pow(out_xpoint - in_x,2) + math.pow(out_ypoint - in_y,2))*DPI
            print("两者相互之间的距离为（mm）:", dis)

            # 将计算结果保存在xml文件
            configFile_xml = "wellConfig.xml"
            tree = ET.parse(configFile_xml)
            root = tree.getroot()
            secondRoot = root.find("distance")
            print(secondRoot.text)

            secondRoot.text = str(dis)
            tree.write("wellConfig.xml")


            cv2.namedWindow("image", 2)
            cv2.imshow("image",circle_img)
            cv2.waitKey()
            return True




# 1 路径写入xml文件
# 2 检测结果也写入xml
if __name__ == "__main__":

    # 从xml文件中读取要检测的图片位置
    configFile_xml = "wellConfig.xml"
    tree = ET.parse(configFile_xml)
    root = tree.getroot()
    secondRoot = root.find("needleFilePath")
    secondRootmatch = root.find("needleMatchFilePath")

    # print(secondRoot.text)

    # # 测试 如果是小图
    image = cv2.imread(secondRoot.text)
    template = cv2.imread(secondRootmatch.text)
    #
    # roi = image[1370:1680, 2200:2490]
    # cv2.imwrite("temp01.jpg", roi)
    #
    # cv2.imshow("roi",roi)
    #
    # # cv2.imshow("template",template)
    # cv2.waitKey()


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

    roi = image[max_loc[1]:max_loc[1] + theight, max_loc[0]:max_loc[0] + twidth]
    # cv2.imshow("roi",roi)
    # cv2.waitKey()
    if circle_detect(roi):
        print("检测成功")
    else:
        print("检测失败")



    # # 测试1 从原图中换到连接器位置
    # image = cv2.imread("SingleImages/src/single.jpg")
    # # cv2.imshow("show",image)
    # # cv2.waitKey()
    # # 如何准确找到圆形连接器 ---》用yolo训练后能准备找到
    # roi = image[1800:2300, 1800:2300 ]
    # # cv2.imshow("show",roi)
    # # cv2.waitKey()
    # circle_detect(roi)



    # # 测试2 如果是小图  需要将检测程序中的cv2.waitKey(1)修改为cv2.waitKey()不然看到图片
    # image = cv2.imread("SingleImages/single04.jpg")
    # # cv2.imshow("show",image)
    # # cv2.waitKey()
    # roi = image
    # circle_detect(roi)


    #
    # # 测试3 检测文件夹下所有图片
    # path = r"D:\BUFFER\Pycharm\ZhenJiaoDect\Images\Type02"
    # for filename in os.listdir(path):  # listdir的参数是文件夹的路径
    #     filenames = path + '\\' + filename
    #     # print(filenames)
    #     img_orig = cv2.imread(filenames, 1)
    #     print(filenames)
    #     template = cv2.imread("images/Type02/temp00.jpg")
    #     if img_orig is None:
    #         print("Warning: No Pictures")
    #     else:
    #         # 测试 如果是小图
    #         image = img_orig
    #
    #
    #         # roi = image[930:1310, 1658:2040]
    #         # cv2.imwrite("temp00.jpg", roi)
    #         #
    #         # cv2.imshow("roi",roi)
    #         #
    #         # # cv2.imshow("template",template)
    #         # cv2.waitKey()
    #
    #         theight, twidth = template.shape[:2]
    #         # 执行模板匹配，采用的匹配方式cv2.TM_SQDIFF_NORMED
    #         result = cv2.matchTemplate(image, template, cv2.TM_CCOEFF_NORMED)
    #         # 归一化处理
    #         cv2.normalize(result, result, 0, 1, cv2.NORM_MINMAX, -1)
    #         # 寻找矩阵（一维数组当做向量，用Mat定义）中的最大值和最小值的匹配结果及其位置
    #         min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
    #         # 匹配值转换为字符串
    #         # 对于cv2.TM_SQDIFF及cv2.TM_SQDIFF_NORMED方法min_val越趋近与0匹配度越好，匹配位置取min_loc
    #         # 对于其他方法max_val越趋近于1匹配度越好，匹配位置取max_loc
    #         strmin_val = str(max_val)
    #         # 绘制矩形边框，将匹配区域标注出来
    #         # min_loc：矩形定点
    #         # (min_loc[0]+twidth,min_loc[1]+theight)：矩形的宽高
    #         # (0,0,225)：矩形的边框颜色；2：矩形边框宽度
    #         # cv2.rectangle(image, max_loc, (max_loc[0] + twidth, max_loc[1] + theight), (0, 0, 225), 2)
    #         # 显示结果,并将匹配值显示在标题栏上
    #         # cv2.namedWindow("MatchResult----MatchingValue=" +  strmin_val, 2)
    #         # cv2.imshow("MatchResult----MatchingValue=" + strmin_val, image)
    #         # cv2.waitKey()
    #
    #         roi = image[max_loc[1]:max_loc[1] + theight, max_loc[0]:max_loc[0] + twidth]
    #         # cv2.imshow("roi",roi)
    #         # cv2.waitKey()
    #         circle_detect(roi)


    # # # 测试4 打开相机测试
    # # 需要将检测程序中的cv2.waitKey()修改为cv2.waitKey(1)
    # # 否则看到不视频实时检测结果
    # capture = cv2.VideoCapture(0)
    #
    # while (True):
    #     # 获取一帧
    #     ret, frame = capture.read()
    #     circle_detect(frame)
    #
    #     # cv2.imshow('frame', frame)
    #
    #     if cv2.waitKey(1) == ord('q'):
    #         break

wellConfig.xml

		images/OneType02/Image_04.jpg
		images/NeedleTemplate.jpg
	    0
	    images/OneType03/Image_01.jpg
	    images/HoleTemplate.jpg
	    False
	    0.15383418280030892
		
			https://www.baidu.com/