opencv快速入门

最新推荐文章于 2024-10-31 20:27:32 发布

大模型研究僧

最新推荐文章于 2024-10-31 20:27:32 发布

阅读量286

点赞数 1

分类专栏：机器学习文章标签： opencv 计算机视觉 python

本文链接：https://blog.csdn.net/weixin_44006686/article/details/129525092

版权

机器学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了OpenCV库的基础操作，包括图像读取、HSV颜色模型、阈值处理、各种滤波技术如均值滤波、高斯滤波、中值滤波，以及边缘检测方法如Canny边缘检测。此外，还涉及图像平滑、形态学操作和傅里叶变换等概念。

摘要由CSDN通过智能技术生成

本文不阐述python以及数组相关基础知识,需要读者有一定的基础再来看效果更好
能够帮助你快速了解opencv中的一下基础操作和概念,有助于机器学习领域和机器视觉领域的学习

图像结构

图像是由数组组成的,一个RGB图像就是一个三维数组,每一个像素在计算机的严重就是一个[60,80,120],这三个数字分别对应着rgb的值,取值范围实在0-255之间.
在这里插入图片描述
在计算机眼中基本上是这样的一个结构

环境配置

需要opencv,安装过程不再阐述

import cv2 #opencv读取的格式是BGR
import numpy as np
import matplotlib.pyplot as plt#Matplotlib是RGB

图像操作

读取图像

img=cv2.imread('../cat.jpg')   # 读取图像
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
img_gray.shape
cv2.imshow("img", img)    #打印图像内容
cv2.waitKey(0)    
cv2.destroyAllWindows()

在这里插入图片描述
是这样的一张图像

HSV概念

H - 色调（主波长）。
S - 饱和度（纯度/颜色的阴影）。
V值（强度）

hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)

cv2.imshow("hsv", hsv)
cv2.waitKey(0)    
cv2.destroyAllWindows()

效果如下:
在这里插入图片描述

图像阈值

ret, dst = cv2.threshold(src, thresh, maxval, type)

src：输入图，只能输入单通道图像，通常来说为灰度图
dst：输出图
thresh：阈值
maxval：当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的值
type：二值化操作的类型，包含以下5种类型： cv2.THRESH_BINARY； cv2.THRESH_BINARY_INV； cv2.THRESH_TRUNC； cv2.THRESH_TOZERO；cv2.THRESH_TOZERO_INV
cv2.THRESH_BINARY 超过阈值部分取maxval（最大值），否则取0
cv2.THRESH_BINARY_INV THRESH_BINARY的反转
cv2.THRESH_TRUNC 大于阈值部分设为阈值，否则不变
cv2.THRESH_TOZERO 大于阈值部分不改变，否则设为0
cv2.THRESH_TOZERO_INV THRESH_TOZERO的反转

ret, thresh1 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY_INV)
ret, thresh3 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TRUNC)
ret, thresh4 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO)
ret, thresh5 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO_INV)

titles = ['Original Image', 'BINARY', 'BINARY_INV', 'TRUNC', 'TOZERO', 'TOZERO_INV']
images = [img, thresh1, thresh2, thresh3, thresh4, thresh5]

for i in range(6):
    plt.subplot(2, 3, i + 1), plt.imshow(images[i], 'gray')
    plt.title(titles[i])
    plt.xticks([]), plt.yticks([])
plt.show()

在这里插入图片描述
方法一样,只是变动了一个属性,产生的结果就十分的不同
阈值分为minval和maxval 根据使用的方法不同来进行不同的处理

图像平滑处理

在这里插入图片描述
就是黄色的框框,是一个3*3的(可以自己调整大小),然后一格一格的平移去处理

img = cv2.imread('lenaNoise.png')
cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

读图进来效果如下:
在这里插入图片描述
可以看到图像上有很多白点点,就是椒盐噪音

均值滤波

# 均值滤波
# 简单的平均卷积操作
blur = cv2.blur(img, (3, 3))

cv2.imshow('blur', blur)
cv2.waitKey(0)
cv2.destroyAllWindows()

效果如下:
在这里插入图片描述

方框滤波

基本上和均值滤波一样,不过可以选择归一化操作
归一化定义:归一化就是使用领域内相乘的和除以面积
不选择归一化可能会越界,在方框滤波的方法中,越界后的值会取值255

# 方框滤波
# 基本和均值一样，可以选择归一化,容易越界
box = cv2.boxFilter(img,-1,(3,3), normalize=False)  

cv2.imshow('box', box)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述
可以看到效果大差不差的
这个图是未采用归一化的图像

高斯滤波

# 高斯滤波
# 高斯模糊的卷积核里的数值是满足高斯分布，相当于更重视中间的
aussian = cv2.GaussianBlur(img, (5, 5), 1)  

cv2.imshow('aussian', aussian)
cv2.waitKey(0)
cv2.destroyAllWindows()

就是在卷积核中加入了权重的概念,下面为举例:
[0.6,0.7,0,6,
0.8,1,0.8,
0.6,0.8,0.6]

在这里插入图片描述

中值滤波

取像素框内的中值,中值滤波对椒盐噪声效果很好

# 中值滤波
# 相当于用中值代替
median = cv2.medianBlur(img, 5)  # 中值滤波

cv2.imshow('median', median)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述

所有效果图展示

# 展示所有的
res = np.hstack((blur,aussian,median))
#print (res)
cv2.imshow('median vs average', res)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述

腐蚀操作

图例展示

img = cv2.imread('../dige.png')

cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述
腐蚀操作执行后:

kernel = np.ones((3,3),np.uint8) 
erosion = cv2.erode(img,kernel,iterations = 1)

cv2.imshow('erosion', erosion)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述
这个操作的核心在于处理毛刺,通常要用于处理二级值后的图像
二级值是通过阈值来筛选,大于阈值的赋值多少小于阈值的赋值多少

膨胀操作

与腐蚀操作相反

开运算与闭运算

开运算:先腐蚀,再膨胀

# 开：先腐蚀，再膨胀
img = cv2.imread('../dige.png')

kernel = np.ones((5,5),np.uint8) 
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

cv2.imshow('opening', opening)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述

闭运算:先膨胀,在腐蚀

# 闭：先膨胀，再腐蚀
img = cv2.imread('dige.png')

kernel = np.ones((5,5),np.uint8) 
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

cv2.imshow('closing', closing)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述

梯度运算

原始梯度 = 膨胀 - 腐蚀
就是相当于两个矩阵相减

# 梯度=膨胀-腐蚀
pie = cv2.imread('pie.png')
kernel = np.ones((7,7),np.uint8) 
dilate = cv2.dilate(pie,kernel,iterations = 5)
erosion = cv2.erode(pie,kernel,iterations = 5)

res = np.hstack((dilate,erosion))

cv2.imshow('res', res)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述
右侧为腐蚀左侧为膨胀
下图为梯度

礼帽与黑帽

礼帽 = 原始输入-开运算结果
黑帽 = 闭运算-原始输入

#礼帽
img = cv2.imread('dige.png')
tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)
cv2.imshow('tophat', tophat)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述

#黑帽
img = cv2.imread('dige.png')
blackhat  = cv2.morphologyEx(img,cv2.MORPH_BLACKHAT, kernel)
cv2.imshow('blackhat ', blackhat )
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述

Sobel算子

dst = cv2.Sobel(src, ddepth, dx, dy, ksize)

ddepth:图像的深度
dx和dy分别表示水平和竖直方向
ksize是Sobel算子的大小

先看图像
在这里插入图片描述
经过sobel算子计算后

sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)

cv_show(sobelx,'sobelx')

在这里插入图片描述
要分别计算xy

sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobelx = cv2.convertScaleAbs(sobelx)
cv_show(sobelx,'sobelx')

sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely = cv2.convertScaleAbs(sobely)  
cv_show(sobely,'sobely')

# 分别计算xy,再求和
sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
cv_show(sobelxy,'sobelxy')

在这里插入图片描述

scharr算子

与上方代码相差较小

lablacian算子

在这里插入图片描述
不同算子之间的差异

#不同算子的差异
img = cv2.imread('lena.jpg',cv2.IMREAD_GRAYSCALE)
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobelx = cv2.convertScaleAbs(sobelx)   
sobely = cv2.convertScaleAbs(sobely)  
sobelxy =  cv2.addWeighted(sobelx,0.5,sobely,0.5,0)  

scharrx = cv2.Scharr(img,cv2.CV_64F,1,0)
scharry = cv2.Scharr(img,cv2.CV_64F,0,1)
scharrx = cv2.convertScaleAbs(scharrx)   
scharry = cv2.convertScaleAbs(scharry)  
scharrxy =  cv2.addWeighted(scharrx,0.5,scharry,0.5,0) 

laplacian = cv2.Laplacian(img,cv2.CV_64F)
laplacian = cv2.convertScaleAbs(laplacian)   

res = np.hstack((sobelxy,scharrxy,laplacian))
cv_show(res,'res')

在这里插入图片描述
从左到右依次是上方代码的顺序

Canny边缘检测

基本上有五个步骤

   使用高斯滤波器，以平滑图像，滤除噪声。

   计算图像中每个像素点的梯度强度和方向。

   应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散响应。

   应用双阈值（Double-Threshold）检测来确定真实的和潜在的边缘。

   通过抑制孤立的弱边缘最终完成边缘检测。

在这里插入图片描述

img=cv2.imread("lena.jpg",cv2.IMREAD_GRAYSCALE)

v1=cv2.Canny(img,80,150)
v2=cv2.Canny(img,50,100)

res = np.hstack((v1,v2))
cv_show(res,'res')

在这里插入图片描述
可以看到右侧图像保留的细节更多
结论:minval越大标准越高,差距越小,内容越丰富
另一个例子更好的反映

图像金字塔

在这里插入图片描述
分为高斯金字塔

可以将图像放大缩小,但是显示的细节会不一样

img=cv2.imread("AM.png")
cv_show(img,'img')
print (img.shape)


up=cv2.pyrUp(img)
cv_show(up,'up')
print (up.shape)

down=cv2.pyrDown(img)
cv_show(down,'down')
print (down.shape)

减法

up=cv2.pyrUp(img)
up_down=cv2.pyrDown(up)
cv_show(img-up_down,'img-up_down')

减法展示样图
在这里插入图片描述

拉普拉斯金字塔

在这里插入图片描述

down=cv2.pyrDown(img)
down_up=cv2.pyrUp(down)
l_1=img-down_up
cv_show(l_1,'l_1')

图像轮廓

cv2.findContours(img,mode,method)
mode:轮廓检索模式

RETR_EXTERNAL ：只检索最外面的轮廓；
RETR_LIST：检索所有的轮廓，并将其保存到一条链表当中；
RETR_CCOMP：检索所有的轮廓，并将他们组织为两层：顶层是各部分的外部边界，第二层是空洞的边界;
RETR_TREE：检索所有的轮廓，并重构嵌套轮廓的整个层次;

method:轮廓逼近方法

CHAIN_APPROX_NONE：以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）。
CHAIN_APPROX_SIMPLE:压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分。

通常需要使用二值图像

img = cv2.imread('contours.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
cv_show(thresh,'thresh')

contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

#传入绘制图像，轮廓，轮廓索引，颜色模式，线条厚度
# 注意需要copy,要不原图会变。。。
draw_img = img.copy()
res = cv2.drawContours(draw_img, contours, -1, (0, 0, 255), 2)
cv_show(res,'res')

效果如下:
普通图像:
在这里插入图片描述
识别轮廓:

分为内轮廓和外轮廓

轮廓特征

面积:

cnt = contours[0]

#面积
cv2.contourArea(cnt)

#周长，True表示闭合的
cv2.arcLength(cnt,True)

轮廓近似

在这里插入图片描述

epsilon = 0.15*cv2.arcLength(cnt,True) 
approx = cv2.approxPolyDP(cnt,epsilon,True)

draw_img = img.copy()
res = cv2.drawContours(draw_img, [approx], -1, (0, 0, 255), 2)
cv_show(res,'res')

epsilon = 0.15*cv2.arcLength(cnt,True) 
approx = cv2.approxPolyDP(cnt,epsilon,True)

draw_img = img.copy()
res = cv2.drawContours(draw_img, [approx], -1, (0, 0, 255), 2)
cv_show(res,'res')

在这里插入图片描述

边界矩形

img = cv2.imread('contours.png')

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
cnt = contours[0]

x,y,w,h = cv2.boundingRect(cnt)
img = cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
cv_show(img,'img')

在这里插入图片描述

外接圆

(x,y),radius = cv2.minEnclosingCircle(cnt) 
center = (int(x),int(y)) 
radius = int(radius) 
img = cv2.circle(img,center,radius,(0,255,0),2)
cv_show(img,'img')

傅里叶变换

不同于生活中的时间来计,而是使用频率来计数

高频：变化剧烈的灰度分量，例如边界
低频：变化缓慢的灰度分量，例如一片大海

滤波

低通滤波器：只保留低频，会使得图像模糊,相当于内容
高通滤波器：只保留高频，会使得图像细节增强,相当于边界
opencv中主要就是cv2.dft()和cv2.idft()，输入图像需要先转换成np.float32 格式。
得到的结果中频率为0的部分会在左上角，通常要转换到中心位置，可以通过shift变换来实现。
cv2.dft()返回的结果是双通道的（实部，虚部），通常还需要转换成图像格式才能展示（0,255）。

import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('lena.jpg',0)

img_float32 = np.float32(img)

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
# 得到灰度图能表示的形式
magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

在这里插入图片描述
左侧为灰度图像右侧为他的傅里叶变换之后的图像

import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('lena.jpg',0)

img_float32 = np.float32(img)

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

rows, cols = img.shape
crow, ccol = int(rows/2) , int(cols/2)     # 中心位置

# 低通滤波
mask = np.zeros((rows, cols, 2), np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1

# IDFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1])

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Result'), plt.xticks([]), plt.yticks([])

plt.show()

高通和低通滤波的对比如下:
在这里插入图片描述
可以看到左侧图像更加锐利,因为它保留了边界,模糊了内容
右侧图像则很模糊,因为它保留了内容模糊了边界

最后在看一下输出高通滤波的效果:


img = cv2.imread('lena.jpg',0)

img_float32 = np.float32(img)

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

rows, cols = img.shape
crow, ccol = int(rows/2) , int(cols/2)     # 中心位置

# 高通滤波
mask = np.ones((rows, cols, 2), np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 0

# IDFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1])

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Result'), plt.xticks([]), plt.yticks([])

plt.show()