opencv基础一（python）

飞锡2024

已于 2022-08-11 10:35:57 修改

阅读量604

点赞数

CC 4.0 BY-SA版权

于 2020-08-01 13:05:51 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_38235865/article/details/107726610

计算机视觉专栏收录该内容

25 篇文章

订阅专栏

本文深入探讨了图像处理和计算机视觉领域的核心操作，包括图像读取、展示、颜色通道处理、图像融合、边缘检测、模板匹配等技术，并介绍了直方图、傅里叶变换、图形梯度处理等高级主题，旨在帮助读者掌握图像处理和计算机视觉的基本技能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考：
https://www.bilibili.com/video/BV1PV411774y?p=19&spm_id_from=pageDriver&vd_source=36b7c8676358c983e1f9ccb9cfe786b4

一.图像基本操作

引包：

import cv2 #openvc读取图像格式BGR
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

读取图片
cv2.imread(filename, flags)
参数：
filepath：读入imge的完整路径
flags：标志位，{cv2.IMREAD_COLOR，cv2.IMREAD_GRAYSCALE，cv2.IMREAD_UNCHANGED}
cv2.IMREAD_COLOR：默认参数，读入一副彩色图片，忽略alpha通道，可用1作为实参替代
cv2.IMREAD_GRAYSCALE：读入灰度图片，可用0作为实参替代
cv2.IMREAD_UNCHANGED：顾名思义，读入完整图片，包括alpha通道，可用-1作为实参替代
PS：alpha通道，又称A通道，是一个8位的灰度通道，该通道用256级灰度来记录图像中的透明度复信息，定义透明、不透明和半透明区域，其中黑表示全透明，白表示不透明，灰表示半透明

# 图片不存在 img为None
img = cv2.imread('s.jpg')
#cv2.IMREAD_GRAYSCALE 读取图片为灰度图
img = cv2.imread('s.jpg',cv2.IMREAD_GRAYSCALE)

展示图片

#图像的显示，也可以创建多个窗口
cv2.imshow('image',img)
#等待时间，毫秒级，0标识任意键终止
cv2.waitKey(0)
cv2.destroyAllWindows()

定义读取图片函数

def cv_show(name,img):
    cv2.imshow('image',img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

保存图片

cv2.imwrite('myTeamH.png',img)

截图

# 截取部分图像数据
img = cv2.imread('xx.jpg')
h = img[0:50,0:50]
cv_show('x',h)

颜色通道提取和merge

#颜色通道提取
b,g,r = cv2.split(img)
#还原
img = cv2.merge((b,g,r))

复制和只保留一个通道

#只保留R
cur_img = img.copy()
cur_img[:,:,0]=0
cur_img[:,:,1]=0
cv_show('G',cur_img)

按比例缩放图片

img_border = cv2.imread('files/border_.jpg')
img_border = cv2.resize(img_border,(0,0),fx=2,fy=4)
plt.imshow(img_border)

数值计算
numpy加法超过255取255的余数
CV2加法超过255 就是255
图像融合

img_hm = cv2.imread('hm.jpg')
img_oth=cv2.imread('oth.jpg')
img_oth = cv2.resize(img_oth,(415,471))
res = cv2.addWeighted(img_hm,0.5,img_oth,0.5,0)
plt.imshow(res)

多图同时展示

#展示所有
res=np.hstack((img,img2,img3))#hstack水平 vstack竖直
print(res)
cv2.imshow('res',res)
cv2.waitKey(0)
cv2.destroyAllWindows()

视频操作

读取视频，转换为黑白视频

vc = cv2.VideoCapture('test.mp4')
#检查是否正确打开
if vc.isOpened():
    open,frame = vc.read()
else:
    open = False
#一帧一帧读取
while open:
    # get a frame
    ret, frame = vc.read()
    if frame is None:
        break
    if ret == True:
        gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
        # show a frame
        cv2.imshow("result", gray)
        #esc终止
        if cv2.waitKey(10) & 0xFF == 27:
            break
vc.release()
cv2.destroyAllWindows()

二、阈值与平滑处理

边界填充
cv2.copyMakeBorder()

borderType：定义要添加边框的类型，它可以是以下的一种：
cv2.BORDER_CONSTANT：添加的边界框像素值为常数（需要额外再给定一个参数）
cv2.BORDER_REFLECT：添加的边框像素将是边界元素的镜面反射，类似于gfedcba|abcdefgh|hgfedcba
cv2.BORDER_REFLECT_101 or cv2.BORDER_DEFAULT：和上面类似，但是有一些细微的不同，类似于gfedcb|abcdefgh|gfedcba
cv2.BORDER_REPLICATE：使用最边界的像素值代替，类似于aaaaaa|abcdefgh|hhhhhhh
cv2.BORDER_WRAP： cdefgh|abcdefgh|abcdefg

#填充大小
top_size,bottom_size,left_size,right_size=(50,50,50,50)
#填充
replicate = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv2.BORDER_REPLICATE)
reflect = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,cv2.BORDER_REFLECT)
reflect101 = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,cv2.BORDER_REFLECT_101)
wrap = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,cv2.BORDER_WRAP)
constant = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,cv2.BORDER_CONSTANT,value=0)
#展示
plt.subplot(231),plt.imshow(img,'gray'),plt.title('original')
plt.subplot(232),plt.imshow(replicate,'gray'),plt.title('replicate')
plt.subplot(233),plt.imshow(reflect,'gray'),plt.title('reflect')
plt.subplot(234),plt.imshow(reflect101,'gray'),plt.title('reflect101')
plt.subplot(235),plt.imshow(wrap,'gray'),plt.title('wrap')
plt.subplot(236),plt.imshow(constant,'gray'),plt.title('constant')

平滑：滤波

方框滤波，与均值滤波的不同在于，方框滤波不会计算像素均值。在均值滤波中，滤波结果的像素值是任意一个点的邻域平均值，等于各邻域像素值之和除以邻域面积。而在方框滤波中，可以自由选择是否对均值滤波的结果进行归一化，即可以自由选择滤波结果是邻域像素值之和的平均值，还是邻域像素值之和
均值滤波,简单的平均卷积, blur= cv2.blur(img,(3,3))
高斯滤波,高斯模糊的卷积核里的数值满足高斯分布，距离越近越重要, aussian = cv2.GaussianBlur(img,- (5,5),1)
中值滤波,用filter格子中值代替, median = cv2.medianBlur(img,5)

dst=cv2.boxFilter（src,ddepth,ksize,anchor,normalize,borderType）

式中：

src 是需要处理的图像，即原始图像。
ddepth是处理结果图像的图像深度，一般使用-1表示与原始图像使用相同的图像深度。
ksize 是滤波核的大小。滤波核大小是指在滤波处理过程中所选择的邻域图像的高度和宽度。
anchor 是锚点，其默认值是（-1,-1），表示当前计算均值的点位于核的中心点位置。该值使用默认值即可，在特殊情况下可以指定不同的点作为锚点。
normalize 表示在滤波时是否进行归一化（这里指将计算结果规范化为当前像素值范围内的值）处理，该参数是一个逻辑值，可能为真（值为1）或假（值为0）：

当参数normalize=1时，表示要进行归一化处理，要用邻域像素值的和除以面积。此时方框滤波与均值滤波效果相同。

当参数normalize=0时，表示不需要进行归一化处理，直接使用邻域像素值的和。当 normalize=0时，因为不进行归一化处理，因此滤波得到的值很可能超过当前像素值范围的最大值，从而被截断为最大值。这样，就会得到一幅纯白色的图像。

borderType是边界样式，该值决定了以何种方式处理边界。

三、图像形态学处理：腐蚀、膨胀、开、闭

1.腐蚀操作

腐蚀操作原理：存在一个kernel，比如(3, 3)，在图像中不断的平移，在这个9方框中，哪一种颜色所占的比重大，9个方格中将都是这种颜色

1.1读取图片
1.2腐蚀操作
1.3展示

kernel = np.ones((5,5),np.uint8)
erosion = cv2.erode(img,kernel,iterations=1)
#多次腐蚀
#erosion_2 = cv2.erode(pie,kernel,iterations=2)
#erosion_3 = cv2.erode(pie,kernel,iterations=3)
 
#res = np.hstack((erosion_1,erosion_2,erosion_3))
#cv2.imshow('res',res)
cv2.imshow('erosion',erosion)
cv2.waitKey(0)
cv2.destroyAllWindows()

2.膨胀操作
cv2.dilate(img, kernel, iteration)
膨胀操作原理：存在一个kernel，在图像上进行从左到右，从上到下的平移，如果方框中存在白色，那么这个方框内所有的颜色都是白色

2.1读取图片
2.2膨胀操作
2.3展示

#先腐蚀
kernel = np.ones((5,5),np.uint8)
dige_erosion= cv2.erode(img,kernel,iterations=1)

kernel = np.ones((3,3),np.uint8)
dige_dilate = cv2.dilate(dige_erosion,kernel,iterations=1)

cv2.imshow('dilate',dige_dilate)
cv2.waitKey(0)
cv2.destroyAllWindows()
 
#res = np.hstack((erosion_1,erosion_2,erosion_3))
cv2.imshow('dige_erosion',dige_erosion)
cv2.waitKey(0)
cv2.destroyAllWindows()

3.开运算与闭运算
cv2.morphologyEx(src, op, kernel)

#开：先腐蚀 再膨胀，可以消除小黑点
img=cv2.imread('zhang.jpg')
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('zhang.jpg')
kernel = np.ones((5,5),np.uint8)
closing = cv2.morphologyEx(img,cv2.MORPH_CLOSE,kernel)

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

4.梯度

#梯度 = 膨胀-腐蚀
pie = cv2.imread('pie.jpg')
kernel = np.ones((5,5),np.uint8)
gradient = cv2.morphologyEx(pie,cv2.MORPH_GRADIENT,kernel)
cv2.imshow('gradient',gradient)
cv2.waitKey(0)
cv2.destroyAllWindows()

5.礼帽与黑帽
礼帽 = 原始输入-开运算结果
得到的是噪声图像

img = cv2.imread('zhang.jpg')
tophat = cv2.morphologyEx(img,cv2.MORPH_TOPHAT,kernel)

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

黑帽=闭运算-原始输入
得到图像内部的小孔，或者背景色中的小黑点

#黑帽
img = cv2.imread('zhang.jpg')
blackhat = cv2.morphologyEx(img,cv2.MORPH_BLACKHAT,kernel)

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

四、图形梯度处理

Solbel算子

过滤器，带有方向,用来计算图像灰度函数的近似梯度。
dst = cv2.Sobel(src,depth,dx,dy,ksize)
depth:图像深度
dx ,dy 水平和竖直方向
ksize是Sobel算子大小
在这里插入图片描述

img= cv2.imread('circle.jpg',cv2.IMREAD_GRAYSCALE)

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

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

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

sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
# 融合不太好
#sobelxy = cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)
#sobelxy = cv2.convertScaleAbs(xy)
cv_show2(sobelxy,'sobelxy')

Scharr算子、 Laplacian算子

Scharr数值更大，结果差异更大

在这里插入图片描述

Laplacian，二阶导，对变化更敏感，对噪音点更敏感
在这里插入图片描述

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_show2(res,'res')

在这里插入图片描述

五、边缘检测

Canny
在这里插入图片描述

在这里插入图片描述

edges = cv.Canny( image, threshold1, threshold2[, apertureSize[, L2gradient]])

threshold1 表示处理过程中的第一个阈值。
threshold2 表示处理过程中的第二个阈值。
apertureSize 表示 Sobel 算子的孔径大小。
L2gradient 为计算图像梯度幅度（gradient magnitude）的标识。其默认值为 False。如果为 True，则使用更精确的 L2 范数进行计算（即两个方向的导数的平方和再开方），否则使用 L1 范数（直接将两个方向导数的绝对值相加）

threshold1越小细节越多

img = cv2.imread('hm.jpg',cv2.IMREAD_GRAYSCALE)
v1 = cv2.Canny(img,80,150)
v2 = cv2.Canny(img,50,100) # 边界信息更大
res = np.hstack((v1,v2))
cv_show2(res,'res')

六、图像金字塔和轮廓检测

向下采样（缩小）：向下采样（放大）

应用：图像特征提取…
在这里插入图片描述

高斯金字塔

上采样

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

下采样

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

拉普拉斯金字塔

在这里插入图片描述

轮廓信息

down=cv2.pyrDown(img)
down_up=cv2.pyrUp(down)
l_l=iimg-down_up
cv_show2(l_1,'1_1')

图像轮廓
为了更高的准确率，使用二值图像
在这里插入图片描述

#读数据 转换灰度图 二值处理
img=cv2.imread('circle.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# 大于127的取一个值，小于127取另一个值
ret, thresh = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
cv_show(thresh,'thresh')

binary,contours,HIERARCHY = cv2.findContours(thresh, cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)

#绘制轮廓

draw_img=img.copy()#需要复制，否则原图会变 
res=cv2.drawContours(draw_img,contours,-1,(0,0,225),2)#-1是全部轮廓 1是第一个图像外圈,...最后一个参数是线条长度
cv_show(res,'res')

轮廓特征

cnt = contours[0] #第0个轮廓
# 面积
cv2.contourArea(cnt)
# 周长,True表示闭合的
cv2.arcLength(cnt,True)

在这里插入图片描述

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

epsilon = 0.1 * 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_show2(res,'res')

# 外接圆
#边界圆
(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')

在这里插入图片描述

外接矩形
在这里插入图片描述

七、模板匹配

模板在原始图像上从远点开始华东，计算模板与图像被模板覆盖的地方的差别程度

cv2.matchTemplate
该函数具有三个参数：
输入图像：包含我们要检测的对象的图像
模板图像：对象的图像
模板匹配方法：
在这里插入图片描述
建议使用归一化的值

img = cv2.imread('hm.jpg',0)
template = cv2.imread('h.jpg',0)
h,w = template.shape[:2]
res = cv2.matchTemplate(img,template,cv2.TM_SQDIFF)#1
#坐标
min_val,max_val,min_loc,max_loc = cv2.minMaxLoc(res)

# 画匹配的位置
img_rgb = img.copy()
top_left = min_loc
bottom_right = (top_left[0]+w,top_left[1]+h)
cv2.rectangle(img_rgb, top_left, bottom_right, (0,0,255), 1)
cv2.imshow('img_rgb',img_rgb)
cv2.waitKey(0)

methods = ['cv2.TM_SQDIFF','cv2.TM_CCORR_NORMED','cv2.TM_CCORR',
           'cv2.TM_CCORR_NORMED','cv2.TM_SQDIFF','cv2.TM_SQDIFF_NORMED']

不同匹配方法的结果
在这里插入图片描述

在这里插入图片描述
cv2.TM_CCORR_NORMED

在这里插入图片描述

匹配多个对象

img_rgb = cv2.imread('cs.jpg')
img_gray = cv2.cvtColor(img_rgb,cv2.COLOR_BGR2GRAY)
template = cv2.imread('c.jpg',0)

h,w = template.shape[:2]

res = cv2.matchTemplate(img_gray,template,cv2.TM_CCOEFF_NORMED)
threshold = 0.8#取匹配度大于80%
loc = np.where(res>=threshold)
for pt in zip(*loc[::-1]):
    bottom_right = (pt[0]+w,pt[1]+h)
    cv2.rectangle(img_rgb, pt, bottom_right, (0,0,255), 1)
    
cv2.imshow('img_rgb',img_rgb)
cv2.waitKey(0)

八、直方图

统计
cv2.calcHist(images,channels,mask,histSize,ranges)
在这里插入图片描述

img = cv2.imread('h.jpg',0)
hist = cv2.calcHist([img],[0],None,[256],[0,256])
plt.hist(img.ravel(),256)
plt.show()

在这里插入图片描述

均衡化

#原始图像
img = cv2.imread('cat.jpg',0)
cv_show(img,'img')

#建掩码
#创建mask 一部分黑一部分白
mask = np.zeros(img.shape[:2],np.uint8)
mask[100:300,100:300]=255
cv_show2(mask,'mask')

#掩码后图像
masked_img = cv2.bitwise_and(img, img, mask = mask) #与操作
cv_show(masked_img,'masked_img')

hist_full = cv2.calcHist([img],[0],None,[256],[0,256])
hist_mask = cv2.calcHist([img],[0],mask,[256],[0,256])

plt.subplot(221),plt.imshow(img,'gray')
plt.subplot(222),plt.imshow(mask,'gray')
plt.subplot(223),plt.imshow(masked_img,'gray')
plt.subplot(224),plt.plot(hist_full),plt.plot(hist_mask)
plt.xlim([0,256])
plt.show()

在这里插入图片描述

直方图均衡化

在这里插入图片描述
cv2.equalizeHist

img = cv2.imread('hm.jpg',0)
plt.hist(img.ravel(),256)
plt.show()

equ = cv2.equalizeHist(img)
plt.hist(equ.ravel(),256)
plt.show()

res = np.hstack((img,equ))
cv_show(res,'res')

在这里插入图片描述

res = np.hstack((img,equ))
cv_show(res,'res')

细节会丢失
在这里插入图片描述

分模块，均衡化会更好

自适应均衡化（分块部分明亮）

cv2.createCLAHE()

clahe = cv2.createCLAHE(clipLimit = 2.0,tileGridSize=(8,8))

res_clahe = clahe.apply(img)
res = np.hstack((img,equ,res_clahe))
cv_show(res,'res')

在这里插入图片描述

九、傅里叶变换

在这里插入图片描述
下图转自https://www.zhihu.com/people/Erdnussoelbearbeiter

在这里插入图片描述

高频滤波器

#低频 图像模糊 高频 细节增强 滤波
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'),plt.xticks([]),plt.yticks([])

plt.subplot(122),plt.imshow(magnitude_spectrum,cmap = 'gray')
plt.title('magnitude_spectrum'),plt.xticks([]),plt.yticks([])
plt.show()

在这里插入图片描述

低频滤波器

#低频 图像模糊 高频 细节增强 滤波
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'),plt.xticks([]),plt.yticks([])
plt.subplot(122),plt.imshow(img_back,cmap = 'gray')
plt.title('result'),plt.xticks([]),plt.yticks([])
plt.show()