python-opencv 垫片缺陷检测

阅读量：

复制代码

    import cv2
    import numpy as np
    # 8 后座表面有色斑
    im = cv2.imread("img/8.bmp")
    im_o = cv2.resize(im, (800, 600))
    
    im_gauss = cv2.cvtColor(im_o, cv2.COLOR_RGB2GRAY)
    im_gauss = cv2.GaussianBlur(im_gauss, (7, 7), 0)
    ret, im = cv2.threshold(im_gauss, 30, 255, 0)
    cv2.imshow("o", im)
    # Setup SimpleBlobDetector parameters.
    params = cv2.SimpleBlobDetector_Params()
    
    # Change thresholds
    params.minThreshold = 10
    params.maxThreshold = 200
    
    # Filter by Area.
    params.filterByArea = True
    # 过滤掉小于像素16的区域
    params.minArea = 16
    
    # Filter by Circularity
    params.filterByCircularity = True
    # 设置类圆性
    params.minCircularity = 0.3
    
    # Filter by Convexity
    params.filterByConvexity = True
    # 设置最小凸性
    params.minConvexity = 0.67  #0.57
    
    # Filter by Inertia
    params.filterByInertia = True
    # 测量了一个形状有多长：对于一个圆，这个值是1，对于一个椭圆，它在0到1之间，对于一条直线，它是0
    params.minInertiaRatio = 0.01
    
    # Create a detector with the parameters
    ver = (cv2.__version__).split('.')
    if int(ver[0]) < 3:
    detector = cv2.SimpleBlobDetector(params)
    else:
    detector = cv2.SimpleBlobDetector_create(params)
    
    # Detect blobs.
    keypoints = detector.detect(im)
    
    # Draw detected blobs as red circles.
    # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures
    # the size of the circle corresponds to the size of blob
    
    im_with_keypoints = cv2.drawKeypoints(im_o, keypoints, np.array([]), (0, 0, 255),
                                      cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
    
    # Show blobs
    cv2.imshow("Keypoints", im_with_keypoints)
    cv2.waitKey(0)

在这里插入图片描述

复制代码

    import numpy as np
    import cv2
    import matplotlib.pyplot as plt
    # 2 铝垫圈表面压伤
    image = cv2.imread("img/2.bmp", 0)
    image1 = cv2.imread("img/2.bmp")
    image2 = cv2.resize(image, (800, 600))
    cv2.imshow('image1', image2)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (625, 500), 210, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (625, 505), 252, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    # cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    # cv2.waitKey(0)
    
    # 高斯滤波
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(masked, (3, 3), 0)
    
    # Canny算子
    canny = cv2.Canny(im_gauss, 120, 240)
    canny1 = cv2.resize(canny, (800, 600))
    cv2.imshow('Canny', canny1)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=240, param2=10, minRadius=2, maxRadius=50)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
    cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
    # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10)  # 画圆心
    
    image2 = cv2.resize(image1, (800, 600))
    cv2.imshow("HoughCircle", image2)
    cv2.waitKey(0)
    # cv2.destroyAllWindows()
    # plt.subplot(121), plt.imshow(canny, 'gray')
    # plt.title('img'), plt.xticks([]), plt.yticks([])
    # plt.subplot(122), plt.imshow(im_gauss, 'gray')
    # plt.title('img'), plt.xticks([]), plt.yticks([])
    # plt.show()
    
    
    # cv2.imshow('image',image)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()

在这里插入图片描述

复制代码

    import numpy as np
    import cv2
    import matplotlib.pyplot as plt
    # 1 铝垫圈外径顶角有缺料现象
    image = cv2.imread("img/1.bmp", 0)
    image1 = cv2.imread("img/1.bmp")
    image2 = cv2.resize(image, (800, 600))
    cv2.imshow('image1', image2)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (633, 543), 249, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (633, 543), 259, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    # cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    
    # 高斯滤波
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(masked, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 60, 255, 0)
    cv2.imshow('threshold', im)
    
    # 开运算：先腐蚀，后膨胀
    kernel = np.ones((3, 3), np.uint8)
    opening = cv2.morphologyEx(im, cv2.MORPH_OPEN, kernel)
    opening = cv2.morphologyEx(opening, cv2.MORPH_OPEN, kernel)
    # cv2.imshow('open', opening)
    
    # Canny算子
    canny = cv2.Canny(opening, 100, 200)
    canny1 = cv2.resize(canny, (800, 600))
    cv2.imshow('Canny', canny1)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=200, param2=5, minRadius=6, maxRadius=11)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
    cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
    # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10)  # 画圆心
    
    image2 = cv2.resize(image1, (800, 600))
    cv2.imshow("HoughCircle", image2)
    cv2.waitKey(0)

在这里插入图片描述

复制代码

    import cv2
    import numpy as np
    # 4 M12螺纹导向处有碰伤
    image = cv2.imread("img/4.bmp")
    image1 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('image1', image1)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (628, 493), 211, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (628, 493), 256, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    # cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    
    
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(im_o, (7, 7), 0)
    ret, im = cv2.threshold(im_gauss, 180, 255, 0)
    # cv2.imshow("o", im)
    
    canny = cv2.Canny(im, 64, 128)
    cv2.imshow('Canny', canny)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=128, param2=3, minRadius=1, maxRadius=0)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
    cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
    # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10)  # 画圆心
    
    cv2.imshow("HoughCircle", image1)
    cv2.waitKey(0)

在这里插入图片描述

复制代码

    import cv2
    import numpy as np
    # 7 后座底部有碰伤
    image = cv2.imread("img/7.bmp")
    image1 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('image1', image1)
    
    # 定义一个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (655, 447), 122, 255, -1)
    
    mask = circle1
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow("masked", masked)
    
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(im_o, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 80, 255, 0)
    # cv2.imshow("o", im)
    
    canny = cv2.Canny(im, 100, 200)
    cv2.imshow('Canny', canny)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 20, param1=200, param2=6, minRadius=3, maxRadius=10)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
    cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
    # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10)  # 画圆心
    
    cv2.imshow("HoughCircle", image1)
    cv2.waitKey(0)

在这里插入图片描述

复制代码

    import cv2
    import numpy as np
    # 3 铝垫圈表面有贯穿伤
    image = cv2.imread("img/3.bmp")
    image1 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('image1', image1)
    # cv2.waitKey(0)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (605, 529), 246, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (605, 529), 204, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(im_o, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 180, 255, 0)
    # cv2.imshow("o", im)
    # cv2.waitKey(0)
    
    canny = cv2.Canny(im, 64, 128)
    cv2.imshow('Canny', canny)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=128, param2=5, minRadius=1, maxRadius=0)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
    cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
    # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10)  # 画圆心
    
    cv2.imshow("HoughCircle", image1)
    cv2.waitKey(0)

在这里插入图片描述

复制代码

    import cv2
    import numpy as np
    # 5 六面角端面有碰伤
    image = cv2.imread("img/5.bmp")
    image2 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    image = cv2.circle(image, (644, 503), 293, 0, -1)
    image1 = cv2.resize(image, (800, 600))
    # cv2.imshow('image2', image2)
    cv2.imshow('image1', image1)
    # cv2.waitKey(0)
    
    im_gauss = cv2.GaussianBlur(image1, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 40, 255, 0)
    cv2.imshow("o", im)
    # canny = cv2.Canny(im, 125, 250)
    canny = cv2.Canny(im, 50, 100)
    cv2.imshow('Canny', canny)
    # cv2.waitKey(0)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    # circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 20, param1=250, param2=5, minRadius=4, maxRadius=8)
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 20, param1=100, param2=7, minRadius=6, maxRadius=1)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
    cv2.circle(image2, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
    # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10)  # 画圆心
    
    cv2.imshow("HoughCircle", image2)
    cv2.waitKey(0)

在这里插入图片描述

全部评论 (0)

还没有任何评论哟~

python-opencv 垫片缺陷检测

importcv2 importnumpyasnp 8后座表面有色斑 im=cv2.imreadimg/8.bmp imo=cv2.resizeim,800,600 imgauss=cv2.cvtCo...

python图像缺陷检测_python opencv 图片缺陷检测!

一、利用直方图的方式进行批量的图片缺陷检测方法简单二、步骤完整代码见最后 2.1灰度转换将原图和要检测对比的图分开灰度化灰度化的作用是因为后面的直方图比较需要以像素256为基准进行相关性比较 im...

python opencv 缺陷检测_Opencv+Python实现缺陷检测

实验七、缺陷检测一、题目描述对下面的图片进行缺陷检测操作，请详细地记录每一步操作的步骤。第一站图片是标准样品，后面几张图中有几个样品有瑕疵，需要你通过计算在图片上显示出哪张是合格，哪张不合格...

python图像缺陷检测_python OpenCV 实现缺陷检测

机器视觉第七次实验一、实验目的通过OpenCV第七次进行实验，对图片进行缺陷检测。二、实验内容对图片进行缺陷测量。三、实验过程我使用的是python语言+openCV对图片进行缺陷检测的功...

opencv缺陷检测

用传统算法，根据实际工程项目，手把手教你做一个最典型的产品缺陷检测项目案例，虽然这个案例与实际生产还存在一定的差距，但是这个检测流程已经很接近实际生产了。

opencv缺陷检测

随着自动化生产设备的普及，工业机器人在各行各业的应用也越来越广泛，越来越多的生产线由自动化设备取代人工操作，实现自动化生产。在机器人分拣过程中，机器人不仅可以将不同规格和质量的产品准确地放入指定的托盘...

Opencv Python瓶口缺陷检测

OpencvPython瓶口缺陷检测这是最近在课程作业中做的小项目，放在这里和大家分享一下。主要任务判断瓶口是否完好，寻找瓶口缺陷部分，并将其框出（以下图为例进行演示）（包含程序部分代码）解决...

python-OpenCV检测成像缺陷

任务利用路由器将海康工业相机成像传递给工控机的过程中，部分图像出现成行的绿线，用pythonOpenCV进行处理，追求在最短的时间内检测出有瑕疵的图片进行排除。

halcon python缺陷检测_halcon缺陷检测

devclosewindow devupdateoff readimageImage3,'C:/Users/Administrator/Desktop/药品检测.png' getimagesizeIm...

opencv表面缺陷检测_视觉检测：表面缺陷检测

当今社会，随着计算机技术，人工智能等科学技术的出现和发展，以及研究的深入，出现了基于机器视觉技术的表面缺陷检测技术。这种技术的出现，大大提高了生产作业的效率，避免了因作业条件，主观判断等影响检测结果的...

是否确定退出登录?

python-opencv 垫片缺陷检测

全部评论 (0)

相关文章推荐

python-opencv 垫片缺陷检测

python图像缺陷检测_python opencv 图片缺陷检测!

python opencv 缺陷检测_Opencv+Python实现缺陷检测

python图像缺陷检测_python OpenCV 实现缺陷检测

opencv缺陷检测

opencv缺陷检测

Opencv Python瓶口缺陷检测

python-OpenCV检测成像缺陷

halcon python缺陷检测_halcon缺陷检测

opencv表面缺陷检测_视觉检测：表面缺陷检测