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

Posted 2021-08-02 无乎648

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(): 
    oepn, 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")

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边缘检测

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

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

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

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

5. 通过抑制孤立的弱边缘最终完成边缘检测。
   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((以上是关于OpenCV最详细入门-python（代码全部可以直接运行）的主要内容，如果未能解决你的问题，请参考以下文章
 
 Python黑科技：50行代码运用Python＋OpenCV实现人脸追踪+详细教程+快速入门+图像识
 Python黑科技：50行代码运用Python＋OpenCV实现人脸追踪+详细教程+快速入门+图像识
 Python黑科技：50行代码运用Python＋OpenCV实现人脸追踪+详细教程+快速入门+图像识
 OpenCV 机器视觉入门精选 100 题（附 Python 代码）
 爆肝整理两天出的学习引导，最详细的Python入门基础教程
 难以置信！一篇文章就梳理清楚了 Python OpenCV 的知识体系