Opencv环境的配置与基本使用

最新推荐文章于 2024-04-24 13:35:29 发布

ViperL1

最新推荐文章于 2024-04-24 13:35:29 发布

阅读量1.8k

点赞数

分类专栏：环境搭建&故障排除文章标签： python 开发语言

本文链接：https://blog.csdn.net/weixin_37878740/article/details/127232264

版权

环境搭建&故障排除专栏收录该内容

19 篇文章 0 订阅

订阅专栏

一、环境配置

推荐使用Anaconda进行配置。然后在控制台下使用以下脚本配置,建议使用3.4之前的

pip install opencv-python - 版本

配置完成后可在控制台下用脚本进行检查

import cv2    //引用opencv
cv2.__version__    //打印版本

配置完成后加载opencv扩展包，版本号需与之前安装的一致

pip install opencv-contrib-python - 版本

二、基本操作

1.图像的读取与处理

图像的属性shape可以获取(h,w,c)三个属性，如果读取灰度图像则仅有(h,w)，没有彩色通道c。属性size可以获取其大小，dtype可以查看数据类型

img = cv2.imread('路径')    #读取图像，默认为彩色
img = cv2.imread('路径',cv2.IMREAD_GRAYSCALE)    #读取灰度图像
                        cv2.IMREAD_COLOR    #彩色图像

cv_show(name,img)    #展示图片

cv2.imwrite('路径',img)    #保存img

2.视频的读取和处理

vc = cv2.VideoCapture('路径/设备名')    #可以读取设备，如0，1；文件则直接指定路径

#用以检查是否正确打开
if vc.isOpened();
    open,frame = vc.read()    #是否打开(bool),当前的一帧
else
    open = Fasle

逐帧处理视频（以waitkey作为延迟，控制处理速度）

while open:
    ret,frame = vc,read()
    if frame is None:
        break            #若已完成读取，跳出循环
    if ret == True
        gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GAY)  #处理图像（图像(帧)，处理方法）
        cv2.imshow('result',gray)    #展示
        if cv2.waitKey(10) & 0xFF == 27:    #延迟(帧之间的速度)&退出键
            break    #退出
vc.relase()
cv2.destoryAllWindows()

3.ROI区域

部分提取

cat = img[0:50,0:200]    #在区域中选取切片(H=50,W=200)

切分通道

b,g,r = cv2.split(img)

组合通道（顺序为bgr）

img = cv2.merge((b,g,r))

示例：仅保留R通道（将其他通道置0）

cur_img = img_copy()    #复制图像
cur_img[:,:,0] = 0    #b置0
cur_img[:,:,1] = 0    #g置0

4.边界填充

top_size,bottom_size,left_size,right_size=(50,50,50,50)    #填充值

replicate = cv2.copyMakeBorder(img,top_size,bottom_size,
                                   left_size,right_size,
                                   cv2.BORDER_REPLICATE)

参数为：图像，边界填充的尺寸，填充方式（有以下几种）

名称	效果
cv2.BORDER_REPLICATE	复制法：复制边缘像素
cv2.BORDER_REFLECT	反射法：对感兴趣的图像中像素在两边进行复制
cv2.BORDER_REFLECT_101	反射法：以最边缘像素为轴，对称复制
cv2.BORDER_WRAP	外包装法：将边缘循环复制
cv2.BORDER_CONSTANT,value=0	常量法：常数（纯色）填充

5.数值计算

img_cat2 = img_cat + 10    #在原始图像每个数据都加10
img_cat1 + img_cat2    #维度一致时相加（若越界则会余256）
cv2.add(img_cat1,img_cat2)    #相加（越界时取最大值）

#图像融合（因shape值不同无法直接相加）
img_dog = cv2.resize(img_dog,(500,414))    #重新指定shape值
img_dog = cv2.resize(img_dog,(0,0),fx=3,fy=1)    #重新指定shape值（倍数关系）

res = cv2.addWeighted(img_cat,0.4,img_dog,0.6,0)

融合公式： $R=\alpha x_1+\beta x_2 +b$ 权重1，权重2，亮度集（提亮）

6.图像阈值

ret,dst = cv2.threshold(src,thresh,maxval,type)    #图像，阈值，最大可能值，二值化操作
    #输出参数：阈值，输出图

一般输入图像为灰度图像，阈值为255，type有以下几种

名称	效果
cv2.THRESH_BINARY	超出部分取maxval，否则0
cv2.THRESH_BINARY_INV	反转的binary
cv2.THRESH_TRUNC	大于阈值部分设为阈值，否则不变
cv2.THRESH_TOZERO	大于部分不变，否则为0
cv2.THRESH_TOZERO_INV	反转的tozero

7.图像滤波

用于消噪（噪音点）

#均值滤波--简单的平均卷积操作
blur = cv2.blur(img,(3,3))    #使用一个3x3的卷积核

#方框滤波--基本同均值滤波，但可以选择归一化
box = cv2.boxFilter(img,-1,(3,3),normalize=True)
    #图像，颜色通道数（一致），卷积核，归一化

#高斯滤波--按照正态分布取值
aussian = cv2.GaussianBlur(img,(5,5),1)

#中值滤波--取计算队列中值
median = cv2.medianBlur(img,5)
    #对抗噪音点效果较好

tips:同时展示多个结果

res = np.hstack(img1,img2,img3)

8.腐蚀操作

用于消除毛刺

kernel = np.ones((5,5),np,uint8)    #构建卷积核

erosion_3=cv2.erode(pie,kernel,iterations=1)    #图像、卷积核、腐蚀次数（程度）

9.膨胀操作

img = cv2.dilate(img_org,kernel,iterations=1)    #与腐蚀互为逆操作

10.开运算与闭运算

#开运算--先腐蚀、再膨胀
opening = cv2.morphologyEx(img,cv2.MORPH_OPEN,kernel)

#闭运算--先膨胀，再腐蚀
closing = cv2.morphologEx(img,cv2.MORPH_CLOSE,kernel)

11.梯度运算

#梯度运算 = 膨胀结果 - 腐蚀结果
gradient = cv2.morphologyEx(pie,cv2.MORPH_GRADIENT,kernel)

①礼帽与黑帽

礼帽 = 原始输入 - 开计算结果

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

tophat = cv2.morphologyEx(img,cv2.MORPH_TOPHAT,kernel)    #礼帽
blackhat = cv2.morphologyEx(img,cv2.MORPH_BLACKHAT,kernel)    #黑帽

②Sobel算子

卷积核：

dst = cv2.Sobel(src,ddepth,dx,dy,ksize)    #ddpepth-深度,dx和dy为水平和垂直方向
                                           #ksize为算子大小

始终为（左边-右边），若方向不对会变成负数，需要截断后取ABS

sobelx = cv2.Sbole(img,cv2.CV_64F,1,0,ksize=3)    #左半边
sobelx = cv2.converScaleAbs(sobelx)    #截断取绝对值

sobely = cv2.Sbole(img,cv2.CV_64F,0,1,ksize=3)    #左半边
sobely = cv2.converScaleAbs(sobely)    #截断取绝对值

sbelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)    #叠加

③Scharr算子

sharrx = cv2.Scharr(img,cv2.CV_64F,1,0)

描边效果比Sobel算子更好

④Laplacian算子

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

描边算法效果弱于Sobel算子

12.Canny边界检测

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

②计算每个像素点的梯度和方向

③应用非极大值抑制，消除边缘检测带来的杂散响应

线性差值法：

设g2的梯度幅值为M(g1),g(2)的梯度幅值为M(g2)，则

M(dtmp1)=w*M(g2)+(1-w)*M(g1),其中w=distance(dtmp1,g2)/distance(g1,g2)

简化计算：将一个像素的梯度方向分散为八个方向，仅需计算前后即可，不用差值

④应用双阈值检测真实和潜在的边缘

梯度值在minVal和maxVal之间的值保留，其他的舍弃（用于检测潜在边界）

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

v1 = cv2.Canny(img,80,150)    #图像,minVal,maxVal

阈值大小决定了边缘细节保留的程度。值越小，保留的越多

13.图像金字塔

高斯金字塔

向下采样（缩小）：用高斯内核进行卷积+将所有偶数行列去除

向上采样（放大）：将原有的图像放大两倍，新增的位置以0填充+将内核放大4倍进行卷积

制作↓，但是放大会损失原有的信息

up = cv2.pyrUp(img)    #上采样    -- 效果：放大
down = cv2.pyrDown(img)    #下采样    --  效果：缩小

拉普拉斯金字塔

$L_i=G_i-PyrUp(PyrDown(G_i))$

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

效果：提取轮廓信息

14.图像轮廓

①轮廓检测

binary,contours,hierarchy = cv2.findContours(img,mode,method)

model：轮廓检索模式

RETR_EXTERNAL：只检索最外层轮廓

RETR_LIST：检索所有轮廓并保存在一个链表中

RETR_CCOMP:检索所有轮廓，将其分为两层（顶层为所有外部边界，第二层为空洞的边界）

RETR_TREE：检索所有轮廓，并重构嵌套轮廓的整个层次

method：轮廓逼近方法

CHAIN_APPROX_NONE:以Freeman码链的方式输出轮廓(输出所有点)

CHAIN_APPROX_SIMPLE:压缩到其顶点部分输出（仅输出顶点）

为保证精确度，需要进行以下操作：

gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)    #灰度图
ret,thresh = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)    #二值化（阈值检测）

②绘制轮廓

binary,contours,hierarchy = cv2.findContours(img,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
    #二值化结果，轮廓点信息，层级信息

draw_img = img.copy()    #复制，若不执行会直接修改原图
res = cv2.drawContours(draw_img,contours,-1,(0,0,255),2)    
        #绘制图像，轮廓，轮廓索引(-1为所有轮廓)，颜色模式(B,G,R)，线条厚度
cv_show(res,'res')    #展示

③轮廓与近似

#获取轮廓参数
cnt = contours[0]    #取出第一层轮廓
cv2.contourArea(cnt)    #获取面积
cv2.arcLength(cn,True)    #获取周长,TRUE表闭合的

#轮廓近似
epsilon = 0.1*cv2.arcLength(cnt,True)    0.1倍周长作为阈值
approx = cv2.approxPolyDP(cnt,epsilon,True)    #轮廓，阈值（一般为周长的百分比），
    #近似轮廓：阈值越小越精准

#外接矩形
x,y,w,h = cv2.boundingRect(cnt)    #外接矩形参数
img = cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)    #绘制矩形

#外接圆
(x,y),radius = cv2.minEnclosingCircle(cnt)    #外接圆参数
center = (int(x),int(y))
radius = int(radius)
img = cv2.circle(img,center,radius,(0,255,0),2)

15.模板匹配

将图像的部分匹配到原图中对应的位置（区域）

匹配方式如下：(尽可能使用归一化方法)

方法	作用
TM_SQDIFF	计算平方不同，值越小，越相关
TM_CCORR	计算相关性，值越大，越相关
TM_CCOEFF	计算相关系数，值越大，越相关
TM_SQDIFF_NORMED	计算归一化平凡不同，越接近0，越相关
TM_CCORR_NORMED	计算归一化相关性，越接近1，越相关
TM_CCOEFF_NORMED	计算归一化相关系数，越接近1，越相关

匹配方法如下：

h,w = template.shape[:2]    #获取目标图像的尺寸

res = cv2.matchTemplate(img,template,cv2.TM_SQDIFF)    #源图、检测目标，匹配方式

若源图尺寸为AxB,检测目标为axb则输出矩阵res为(A-a+1)x(B-b+1)--滑动窗口

min_val,max_val,min_loc,max_loc = cv2.minMaxLoc(res)
    #获取矩阵中最大最小值，及其位置

多模板匹配

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.rectagle(img_rgb,pt,bottom_right,(0,0,255),2)

16.直方图

用于统计图中的像素点（灰度图则统计灰度，彩色图可以分别统计RGB）

hist = cv2.calcHist(images,channels,mask,histSize,ranges)
        #images：原图格式为uint8或float32，传入时使用[img]
        #channels：通道编号，灰度图为[0]，彩图为[0][1][2]--对应BGR
        #mask：掩模图像，告知函数统计边界，如果全图统计则为NONE
        #histSize：BIN的数目，应用中括号
        #ranges：像素范围[0,256]

#使用示例
hist = cv2.calcHist([img],[0],NONE,[256],[0,256])

plt.hist(img.ravel(),256)
plt.show()

①掩码

掩码覆盖的地方，像素值均置位纯黑，等同于裁剪了一部分图像

#创建掩码
mask = np.zeros(img,shape[:2],np.uint8)    #原图，尺寸(和原图保持一致)
mask[100:300,100:400] =255    #将要保存的内容置位255

masked_img = cv2.bitwise_and(img,img,mask=mask)    #将原始图像和掩码求与
cv_show(masked_img,'masked_img')    #展示

②均匀化

原理：先分灰度值进行统计，计算其累积概率；然后根据函数进行映射；最后对其进行取整。其中函数为：累积概率 * 取值范围<255-0>

equ = cv2.equalizeHist(img)    #均衡化

均衡化会使图像提亮，但是会丢失一定细节。

clahe = cv2.createCLAHE(clipLimt=2.0,titleGridSize=(8,8))    #自适应均衡化
    #自适应均衡化会将图像切割为小块，每个小块独立进行均衡化

res_clahe = clahe.apply(img)    #将其应用在图像之中

17.傅立叶变换

将时域转换到复频域。有以下作用：

高频：变化剧烈的灰度分量（如边界）

低频：变化缓慢的恢复分量（如一片纯色）

滤波器的作用：

低通滤波：只保留低频，使图像模糊

高通滤波：只保留高频，使图像细节增强（仅保留边界）

使用之前需要将图像转换为np.float32，展示的时候同样需要将其逆变换为cv2.dift()或cv2.idft()

img_float32 = np.float32(img)    #格式转换
dft = cv2.dft(img_float32,flags = cv2.DFT_COMPLEX_OUTPUT)    #傅立叶变化

img_float32 = np.float32(img)    #格式转换
dft = cv2.dft(img_float32,flags=cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)    #傅立叶变换

cows,clos = img.shape    #获取尺寸
crow,ccol=int(rows/2),int(clos/2)    #获取中心位置

#低通滤波
mask = np.zeros((rows,cols,2),np.uint8)    #构建掩模--为0的保留
mask[crow-30:crow+30,ccol-30:ccol+30]=1    #中心区域置1

#IDFT
dshift = dft_shift*mask
f_ishift = np.fft.iffshift(fshift)    #逆变换（归还中心点）
img_back = cv2.idft(f_ishift)        
img_back = cv2.magnitude(img_back[:,:,0],img[:,:,1])    #实部和虚部处理为实数

img_float32 = np.float32(img)    #格式转换
dft = cv2.dft(img_float32,flags=cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)    #傅立叶变换

cows,clos = img.shape    #获取尺寸
crow,ccol=int(rows/2),int(clos/2)    #获取中心位置

#高通滤波
mask = np.ones((rows,cols,2),np.uint8)    #构建掩模--为1的保留
mask[crow-30:crow+30,ccol-30:ccol+30]=0    #消去低频部分

#IDFT
dshift = dft_shift*mask
f_ishift = np.fft.iffshift(fshift)    #逆变换（归还中心点）
img_back = cv2.idft(f_ishift)        
img_back = cv2.magnitude(img_back[:,:,0],img[:,:,1])    #实部和虚部处理为实数