python-opencv 垫片缺陷检测
2024-04-13 22:10:27
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 blobim_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)
python-opencv 垫片缺陷检测相关推荐
- python opencv 图片缺陷检测!
一.利用直方图的方式进行批量的图片缺陷检测(方法简单) 转存失败重新上传取消 二.步骤(完整代码见最后) 2.1灰度转换(将原图和要检测对比的图分开灰度化) 灰度化的作用是因为后面的直方图比较需要以像 ...
- python + opencv试纸缺陷检测——思路
用于检测试纸生产线对合格与不合格产品进行分拣,实时检测. 先要对整个区域进行分割,只对研究对象进行处理,是否用ROI? 1)选择数据:将数据分成三组:训练数据.验证数据.测试数据 2)模型数据:使用训 ...
- python图像缺陷检测_python OpenCV 实现缺陷检测
机器视觉第七次实验 一.实验目的 通过OpenCV第七次进行实验,对图片进行缺陷检测. 二.实验内容 对图片进行缺陷测量. 三.实验过程 我使用的是python语言+openCV对图片进行缺陷检测的功 ...
- 基于Python+OpenCV车道线检测(直道和弯道)
基于Python+OpenCV车道线检测(直道和弯道) 基于Python+OpenCV车道线检测(直道和弯道)
- python+opencv车道线检测（简易实现）
python+opencv车道线检测(简易实现) 技术栈:python+opencv 实现思路: canny边缘检测获取图中的边缘信息: 霍夫变换寻找图中直线: 绘制梯形感兴趣区域获得车前范围: 得到 ...
- python opencv车道线检测
python3 opencv车道线检测 简介 特征提取 车道检测 鸟瞰图 找到车道起点 滑动窗口向上扫描 多项式拟合 鸟瞰图还原到原图 评估 总结 参考 简介 记录一下车道检测的过程.本文使用传统方法 ...
- opencv 轮廓 缺陷检测
1.凸性缺陷 物体与凸壳任何偏差都可以认为是凸性缺陷. cv.convexityDefects() import cv2 as cv import numpy as np img = cv.imrea ...
- python+opencv摄像头人脸检测+代码注释
比较简单直接上代码: #导入模块 import cv2 #摄像头 cap=cv2.VideoCapture('1.mp4')falg = 1 num = 1while(cap.isOpened()): ...
- python+OpenCV 特征点检测
1.Harris角点检测 Harris角点检测算法是一个极为简单的角点检测算法,该算法在1988年就被发明了,算法的主要思想是如果像素周围显示存在多于一个方向的边,我们认为该点为兴趣点.基本原理是根据 ...
- python + OpenCV 实现人脸检测(全网之最通俗易懂)
文章目录 先看一下效果 采集人脸信息 人脸识别 以上源码 本文人脸识别检测具体是通过程序采集图像并进行训练,并且基于这些训练的图像对人脸进行动态识别. 人脸识别前所需要的人脸库可以通过两种方式获得: ...
最新文章
- JavaScript 中的内存泄露模式
- 虚拟机登陆别的服务器吗,云服务器只能用虚拟机登录吗
- oracle数据库配置助手来初始化参数,使用服务器参数文件（SPFILE）管理初始化参数...
- STM32的AFIO时钟什么时候开启？
- 文字层一点就变红_《蚂蚁前端研发最佳实践》文字稿
- python3有什么用_Python 3.9的到来到底是意味着什么
- 收好这份来自大厂技术大咖的“远程办公指南”
- 数据结构与算法之-----图（代码实现）
- 谷粒商城：15.商城业务 — 商品上架
- JavaScript实现(轮播图，随机数，抽名字游戏，广告循环文字)
- JDK动态代理和CGLIB动态代理介绍
- 解决Cannot find module ‘./index.module.scss‘ or its corresponding type declarations.ts(2307）
- 一个网站查遍所有英文文章 “会议地点及出版商”（亲测搜了80篇全部有效）
- 滴滴翻译技术探索与实践
- 计算机派位录取,北京幼升小多校划片电脑派位是什么意思
- 云计算工程师必备技能
- AndroidStudio 跑马灯效果不自动滚动的原因
- 战火与秩序迁城显示服务器忙,战火与秩序怎么玩(战火与秩序怎么迁城到联盟攻略解读)...
- 基于Python的蒙特卡罗方法估计Pi值的实现
- 专访马云：下一个星辰大海是百货商店