OpenCV最详细入门（一）-python（代码全部可以直接运行）

OpenCV详细入门（基础篇）一、OpenCV介绍OpenCV（open source computer vision library）是一个基于BSD许可（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows、Android和Mac OS操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像

无乎648

101437人浏览 · 2021-07-05 20:54:03

无乎648 · 2021-07-05 20:54:03 发布

OpenCV详细入门（基础篇）

一、OpenCV介绍

OpenCV（open source computer vision library）是一个基于BSD许可（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows、Android和Mac OS操作系统上。
它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。
OpenCV用C++语言编写，它的主要接口也是C++语言，但是依然保留了大量的C语言接口。
在计算机视觉项目的开发中，OpenCV作为较大众的开源库，拥有了丰富的常用图像处理函数库，采用C/C++语言编写，可以运行在Linux/Windows/Mac等操作系统上，能够快速的实现一些图像处理和识别的任务。
此外，OpenCV还提供了Java、python、cuda等的使用接口、机器学习的基础算法调用，从而使得图像处理和图像分析变得更加易于上手，让开发人员更多的精力花在算法的设计上。

二、编译环境

直接pip安装
pip install opencv-python
注意：
1.安装的是opencv_python，但在导入的时候是import cv2。
2.OpenCV依赖一些库，比如Numpy和matplotlib，先安装上。

三、图像基本操作

在这里插入图片描述
（1）读入图片

import cv2 #opencv读取的格式是BGR
import matplotlib.pyplot as plt
import numpy as np 
%matplotlib inline 
img=cv2.imread('cat.jpg')
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述

img.shape

(414, 500, 3)

总所周知，图片就是一个矩阵，每一个像素点都是矩阵中的一个数值而已，对于彩色图片，是采用BGR三通道显示的，也就是一个彩色图片是由三个矩阵组成的，所以上述输出的(414, 500, 3)中，表示是414×500的彩色图片。

img=cv2.imread("Resources/test.png",cv2.IMREAD_GRAYSCALE)
img.shape

(559, 768)
cv2.IMREAD_COLOR：彩色图像
cv2.IMREAD_GRAYSCALE：灰度图像
img为灰度图像，不是彩色图像，所以img.shape是一个二维矩阵。

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

在这里定义了一个图像显示的函数，其中imshow()为显示函数，waitKey(0)为无限时间的显示函数，如果改为参数1就是显示1ms以此类推，destroyAllWindows()按下任意键便可关闭窗口。

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

保存图片代码

vc = cv2.VideoCapture('test.mp4')
# 检查是否打开正确
if vc.isOpened(): 
    open, frame = vc.read()
else:
    open = False

读取视频

while open:
    ret, frame = vc.read()
    if frame is None:
        break
    if ret == True:
        gray = cv2.cvtColor(frame,  cv2.COLOR_BGR2GRAY)
        cv2.imshow('result', gray)
        if cv2.waitKey(100) & 0xFF == ord('q'):
            break
vc.release()
cv2.destroyAllWindows()

上述代码为展示视频，并且当视频播放完或键盘按下q就退出。

img=cv2.imread('cat.jpg')
cat=img[0:50,0:200] 
cv_show('cat',cat)

在这里插入图片描述
对图片进行截取，因为图片就是一个二维数组，可以按照二维数组那样截取。

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

对图片进行颜色通道提取

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

对图片进行颜色通道合并，与split正好相反

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('REFLECT_101')
plt.subplot(235), plt.imshow(wrap, 'gray'), plt.title('WRAP')
plt.subplot(236), plt.imshow(constant, 'gray'), plt.title('CONSTANT')

plt.show()

对图片进行边界填充，主要是改变图片最外围的边框，共有五种方法：
BORDER_REPLICATE：复制法，也就是复制最边缘像素。
BORDER_REFLECT：反射法，对感兴趣的图像中的像素在两边进行复制例如：fedcba|abcdefgh|hgfedcb
BORDER_REFLECT_101：反射法，也就是以最边缘像素为轴，对称，gfedcb|abcdefgh|gfedcba
BORDER_WRAP：外包装法cdefgh|abcdefgh|abcdefg
BORDER_CONSTANT：常量法，常数值填充。
在这里插入图片描述
图像融合：

img_cat=cv2.imread('cat.jpg')
img_dog=cv2.imread('dog.jpg')
img_dog = cv2.resize(img_dog, (500, 414))#将两个图片改为同样大小
res = cv2.addWeighted(img_cat, 0.4, img_dog, 0.6, 0)#猫占0.4权重，狗占0.6权重
plt.imshow(res)

在这里插入图片描述

res = cv2.resize(img, (0, 0), fx=1, fy=3)

更改图片长宽比
在这里插入图片描述

四、图像处理

BGR转HSV
在 HSV 颜色空间下，比 BGR 更容易跟踪某种颜色的物体，常用于分割指定颜色的物体。
HSV 表达彩色图像的方式由三个部分组成：
-Hue（色调、色相）
-Saturation（饱和度、色彩纯净度）
-Value（明度）
用下面这个圆柱体来表示 HSV 颜色空间，圆柱体的横截面可以看做是一个极坐标系，H 用极坐标的极角表示，S 用极坐标的极轴长度表示，V 用圆柱中轴的高度表示。
在这里插入图片描述
在Hue一定的情况下，饱和度减小，就是往光谱色中添加白色，光谱色所占的比例也在减小，饱和度减为0，表示光谱色所占的比例为零，导致整个颜色呈现白色。
明度减小，就是往光谱色中添加黑色，光谱色所占的比例也在减小，明度减为0，表示光谱色所占的比例为零，导致整个颜色呈现黑色。

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()

在这里插入图片描述
图像平滑

img = cv2.imread('lenaNoise.png')
blur = cv2.blur(img, (3, 3))# 均值滤波
box1 = cv2.boxFilter(img,-1,(3,3), normalize=True)  # 方框滤波
box2 = cv2.boxFilter(img,-1,(3,3), normalize=False) # 方框滤波
aussian = cv2.GaussianBlur(img, (5, 5), 1)  # 高斯滤波
median = cv2.medianBlur(img, 5)  # 中值滤波
res = np.hstack((blur,aussian,median))

在这里插入图片描述
其中可以看出中值滤波的效果最佳。
形态学-腐蚀操作

pie = cv2.imread('pie.png')
kernel = np.ones((30,30),np.uint8) 
erosion_1 = cv2.erode(pie,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.waitKey(0)
cv2.destroyAllWindows()

在这里插入图片描述
从左到右分别是腐蚀一次到三次的效果图。
形态学-膨胀操作

pie = cv2.imread('pie.png')

kernel = np.ones((30,30),np.uint8) 
dilate_1 = cv2.dilate(pie,kernel,iterations = 1)
dilate_2 = cv2.dilate(pie,kernel,iterations = 2)
dilate_3 = cv2.dilate(pie,kernel,iterations = 3)
res = np.hstack((dilate_1,dilate_2,dilate_3))
cv2.imshow('res', res)
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()

在这里插入图片描述

gradient = cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel)

cv2.imshow('gradient', gradient)
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算子的大小

img = cv2.imread('pie.png',cv2.IMREAD_GRAYSCALE)
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)

cv_show(sobelx,'sobelx')

在这里插入图片描述

sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobelx = cv2.convertScaleAbs(sobelx)
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely = cv2.convertScaleAbs(sobely)  
sob=np.hstack((sobelx,sobely))
cv_show(sob,"sob")

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210705172703742.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dVSFU2NDg=,size_16,color_FFFFFF,t_70

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

在这里插入图片描述
可以看出，sobelx与sobely分开算效果更加完美。
图像梯度-Scharr算子

图像梯度-laplacian算子

不同算子的差异

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')

在这里插入图片描述
从左到右分别是Sobel、Scharr、Laplacian不同算子的效果图。
可以看出Scharr要比Sobel显示的边缘更加多，而Laplacian就显示的更加少了。

Canny边缘检测

使用高斯滤波器，以平滑图像，滤除噪声。
计算图像中每个像素点的梯度强度和方向。
应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散响应。
应用双阈值（Double-Threshold）检测来确定真实的和潜在的边缘。
通过抑制孤立的弱边缘最终完成边缘检测。
1:高斯滤波器

2:梯度和方向

3：非极大值抑制

4：双阈值检测

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')

在这里插入图片描述
可以通过改变最大值和最小值来进行调整参数。

图像金字塔

高斯金字塔
拉普拉斯金字塔
在这里插入图片描述
高斯金字塔：向下采样方法（缩小）

高斯金字塔：向上采样方法（放大）

img=cv2.imread("AM.png")
print (img.shape)
up=cv2.pyrUp(img)
print (up.shape)
down=cv2.pyrDown(img)
print (down.shape)

(442, 340, 3)
(884, 680, 3)
(221, 170, 3)
pyrUp()放大图像，空白的像素点补0.
pyrDown()缩小图像，将奇数行和列去掉。
放大缩小后会比原图像模糊，因为有像素值丢失。
拉普拉斯金字塔
在这里插入图片描述

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)
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)#-1表示显示所有轮廓，123表示第123个轮廓
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')

在这里插入图片描述
图中白色的是原图像，红色的是轮廓近似。
边界矩形

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

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
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')