openCV_Note

图像基本操作

数据读取-图像

cv2.imread_color:彩色图像

cv2.imread_grayscale:灰度图像

import cv2     # openCV读取格式为BGR
import matplotlib.pyplot as pl
import numpy as np

img=cv2.imread('./img/dog.jpg')

 # 图像的显示，也可以创建多的窗口
 cv2.imshow('image',img)
 # 等待的时间，毫秒级。0表示任意键即可终止，1000表示1000ms后关闭终止
 cv2.waitKey(0)
 # cv2.waitKey(1000)
 cv2.destroyAllWindows()

import cv2 #openCV读取格式为BGR

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

img=cv2.imread('asset/img/dog.jpg', cv2.IMREAD_GRAYSCALE)     #灰度图

# cv_show('image',img)

# 图像保存
# cv2.imwrite('mydog.png',img)




print(type(img))
#<class 'numpy.ndarray'>

print(img.size)
#5992704

print(img.dtype)
#uint8

数据读取-视频

cv2.videoCapture可以捕获摄像头，用数字来控制不同的设备，例如0，1

如果时视频文件，直接指定好路径即可

import cv2
from pandas.core import frame

# 检查是否打开正确
vc=cv2.VideoCapture('./asset/video/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(500) & 0xFF ==27:      #前者表示视频的展示速度；'0xFF==27'表示退出键
            break
vc.release()
cv2.destroyAllWindows()

截取部分数据（ROI）

（ROI：感兴趣的区域）

# ROI
img=cv2.imread('asset/img/dog.jpg')
dog=img[500:800,800:1500]      #截取部分
cv_show('dog',dog)

边界填充

1、BORDER_REPLICATE：复制法，也就是复制最边缘的像素

2、BORDER_REFLECT：反射法，对感兴趣图像中的像素在两边进行复制，例：fedcba|abcdefgh|hgfedcb

3、BORDER_REFLECT_101:反射法，也就是以最边缘像素为轴，对称，

gfedcb|abcdefgh|gfedcba

4、BORDER_WRAP：外包装法，cdefgh|abcdefgh|abcdefg

5、BORDER_CONSTANT：常量法，以数值填充

import cv2

img=cv2.imread("asset/img/dog.jpg")

top_side,bottom_side,left_side,right_side=(50,50,50,50)

replicate=cv2.copyMakeBorder(img,top_side,bottom_side,left_side,right_side,borderType=cv2.BORDER_REPLICATE)
reflect=cv2.copyMakeBorder(img,top_side,bottom_side,left_side,right_side,cv2.BORDER_REFLECT)
reflect101=cv2.copyMakeBorder(img,top_side,bottom_side,left_side,right_side,cv2.BORDER_REFLECT_101)
wrap=cv2.copyMakeBorder(img,top_side,bottom_side,left_side,right_side,cv2.BORDER_WRAP)
constant=cv2.copyMakeBorder(img,top_side,bottom_side,left_side,right_side,cv2.BORDER_CONSTANT,value=0)

import matplotlib.pyplot as plt
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()

数值计算

import cv2

img_cat = cv2.imread('asset/img/cat.jpg')
img_dog = cv2.imread('asset/img/dog.jpg')


print(img_cat[:5,:,0])
img_cat2=img_cat+100    # 在每个像素点上都加10
print(img_cat2[:5,:,0])

# cv2.imshow("result",img_cat2)
# cv2.waitKey(0)
# cv2.destroyAllWindows()

result=(img_cat+img_cat2)[:5,:,0]       # 如果两值相加大于255(0-255)，结果=相加值%256
print(result)

result2=cv2.add(img_cat,img_cat2)[:5,:,0]       #如果两者大于255，结果是255
print(result2)

注意：

1、一般情况下，如果两者相加值大于255，则结果返回：相加值%256

2、使用add()下，如果大于255，则结果取255

图像融合（FUsion）

import cv2
import matplotlib.pyplot as plt

img_cat=cv2.imread("asset/img/cat.jpg")
img_dog=cv2.imread("asset/img/dog.jpg")

# img_cat+img_dog
# print(img_cat.shape)

img_dog=cv2.resize(img_dog,(1280,853)) #resize改变原有的，给一个w,h
# print(img_dog.shape)

res0=cv2.addWeighted(img_cat,0.4,img_dog,0.6,0)     #R=alpha X1,bata X2 +b
plt.imshow(res0)


res=cv2.resize(img_cat,(0,0),fx=3,fy=1)
# res1=cv2.resize(img_cat,(0,0),fx=1,fy=3)
# plt.imshow(res)
# plt.imshow(res1)

plt.show()

注意：

1、

图像处理

图像阈值

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的反转

图像平滑处理

1、均值滤波:简单的平均卷积操作

2、方框滤波：基本和均值一样，可以选择归一化

import cv2

#原始图片（有杂质）
import numpy as np
img=cv2.imread('asset/img/lenaNoise.png')

#均值滤波
blur=cv2.blur(img,(3,3))

#方框滤波
box=cv2.boxFilter(img,-1,(3,3),normalize=True)
#-1表示一致，normalize=True和均值效果一样\normalize=False 容易越界

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

3、高斯滤波: 高斯模糊的卷积核里的数值满足高斯分布，相当于更重视中间的

# 高斯滤波
gaussianblur=cv2.GaussianBlur(img,(5,5),1)

4、中值滤波：#相当于用中值代替

# 中值滤波
median=cv2.medianBlur(img,5)

腐蚀操作

erode()

import cv2
import numpy as np

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

kernel=np.ones((5,6),np.uint8)	#kernel表示核

erosion=cv2.erode(img,kernel,iterations=1) #iterations表示迭代次数



pie=cv2.imread('asset/img/pie.png')

kernel2=np.ones((30,30),np.uint8)
erosion1=cv2.erode(pie,kernel2,iterations=1)#第一次腐蚀
erosion2=cv2.erode(pie,kernel2,iterations=2)#第二次腐蚀
erosion3=cv2.erode(pie,kernel2,iterations=3)#第三次腐蚀
res=np.hstack((erosion1,erosion2,erosion3))

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

膨胀操作

dilate()

import cv2
import numpy as np

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

#膨胀
dilation=cv2.dilate(img,kernel,iterations=1)



pie=cv2.imread('asset/img/pie.png')
kernel2=np.ones((30,30),np.uint8)
dilation1=cv2.dilate(pie,kernel2,iterations=1)#第一次膨胀
dilation2=cv2.dilate(pie,kernel2,iterations=2)#第二次膨胀
dilation3=cv2.dilate(pie,kernel2,iterations=3)#第三次膨胀
res=np.hstack((dilation1,dilation2,dilation3))

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

开运算与闭运算(形态学)

需要morphologyEX(形态学）导入

开运算(MORPH_OPEN)：先腐蚀，再膨胀

闭运算(MORPH_CLOSE)：先膨胀，再腐蚀

import cv2
import numpy as np

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

# 开运算：先腐蚀，再膨胀
kernel=np.ones((3,3),np.uint8)
opening=cv2.morphologyEx(img,cv2.MORPH_OPEN,kernel)

# 开运算：先膨胀，再腐蚀
kernel=np.ones((3,3),np.uint8)
closing=cv2.morphologyEx(img,cv2.MORPH_CLOSE,kernel)

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

梯度运算

需要morphologyEX(形态学）导入

梯度(MORPH_GRADIENT)=膨胀-腐蚀

import cv2
import numpy as np

pie = cv2.imread('asset/img/pie.png')

kernel = np.ones((7,7),np.uint8)
#梯度=膨胀-腐蚀
gradient = cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel)

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

礼帽和黑帽

礼帽(MORPH_TOPHAT)=原始输入-开运算结果

黑帽(MORPH_BLACKHAT)=闭运算-原始输入

import cv2
import numpy as np

img = cv2.imread('asset/img/dige.png')
kernel = np.ones((7,7),np.uint8)

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

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

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

图像梯度-Soble算子

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

·ddepth：图像的深度

·dx和dy分别表示水平和竖直方向

·ksize是Soble算子的大小

#水平的梯度
sobleX=cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
#白到黑是正数，黑到白就是负数了，所有的负数会被截断成0，所以要取绝对值
sobleX=cv2.convertScaleAbs(sobleX)#取绝对值


#垂直的梯度
sobleY=cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobleY=cv2.convertScaleAbs(sobleY)

#分别计算x和y，再求和
sobleXY=cv2.addWeighted(sobleX,0.5,sobleY,0.5,0)

scharr算子

#scharr算子
scharr_x=cv2.Scharr(img,cv2.CV_64F,1,0)
scharr_y=cv2.Scharr(img,cv2.CV_64F,0,1)
scharr_x=cv2.convertScaleAbs(scharr_x)
scharr_y=cv2.convertScaleAbs(scharr_y)
scharr_xy=cv2.addWeighted(scharr_x,0.5,scharr_y,0.5,0)

scharr算子相比于soble算子，描述的更详细，能够捕捉到跟丰富的梯度信息

lapkacian算子

#laplacian算子
laplacian=cv2.Laplacian(img,cv2.CV_64F)
laplacian=cv2.convertScaleAbs(laplacian)

不建议单独使用该算子

Canny边缘检测

步骤：

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

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

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

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

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

1、高斯滤波

2、梯度和方向

3、非极大值抑制

方法一：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-roPecZdU-1650809092131)(C:\Users\yujunyu\AppData\Roaming\Typora\typora-user-images\image-20220402171136467.png)]

线性插值法：设g1的梯度幅值M(g1),g2的梯度幅值M(g2),则dtmp1就可以得到M(dtmp1)=w*M(g2)+(1-w) * M(g1)

其中w=distance(dtmp1,g2)/distance(g1,g2)

distance(g1,g2)表示两点之间的距离

方法二：

为了简化计算，由于一个像素周围有八个像素，把一个像素的梯度方向离散为八个方向，这样就只需要计算见后即可，不用再插值了

4、双阈值检测

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5QLPmX5P-1650809092132)(C:\Users\yujunyu\AppData\Roaming\Typora\typora-user-images\image-20220402171655535.png)]

img_lena=cv2.imread("../asset/img/lena.jpg",cv2.IMREAD_GRAYSCALE)
v1=cv2.Canny(img_lena,80,150)
v2=cv2.Canny(img_lena,50,100)
res=np.hstack((v1,v2))

img_car=cv2.imread("../asset/img/car.png",cv2.IMREAD_GRAYSCALE)
v3=cv2.Canny(img_car,120,250)	#阈值越大，检测的边界越模糊
v4=cv2.Canny(img_car,50,100)	#阈值越小，检测的边界越仔细
res1=np.hstack((v3,v4))

图像金字塔

高斯金字塔

1、向下采样方法（缩小）

1）将Gi与高斯内核卷积

2）将所有偶数行和列去除

PyrDown

2、向上采样方法（放大）

1）将图像再每个方向扩大为原来的两倍，新增的行和列以00填充

2）使用先前同样的内核（乘以四）与放大后的图像卷积，获得近似值

PyrUP

#上采样（放大）
up=cv2.pyrUp(img)

#下采样（缩小）
down=cv2.pyrDown(img)

如果先进行上采样，再进行下采样，结果图像和原始图像会有区别，进行完Up、Down的图像会有损失，会有模糊

拉普拉斯金字塔

Li=Gi-PyrUP(PyrDown(Gi))

简单来说，就是先Down,然后Up，再原始数据-down_up

图像轮廓

轮廓检测函数：cv2.findContours(img,mode,method)

mode：轮廓检索模式

·RETR_EXTERNAL：只检索最外面的轮廓

·RETR_LIST：检索所有的轮廓，并将其保存到一条链表当中

·RETR_CCOMP：检索所有的轮廓，并将它们组织为两层：顶部是各部分的外部边界，第二层是空洞的边界

·(常用)RETR_TREE：检索所有的轮廓，并重构嵌套轮廓的整个层次

method：轮廓逼近方法

·cv2.CHAIN_APPROX_NONE：以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶的序列）

·cv2.CHAIN_APPROX_SIMPLE：压缩水平的、垂直的和斜的部分，也就是，函数只保留它们的终点部分

做法：

1、为了更高的准确率，使用二值图像

img=cv2.imread('../asset/img/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)

2、绘制轮廓

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

轮廓特征

面积：countArea(img)

周长：arcLength(img,True) #True表示闭合的

轮廓近似

生成逼近曲线:approxPolyDP()

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]#拿到其中一个轮廓

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



#近似
epsilon=0.01*cv2.arcLength(cnt,True)    #0.15这个值，越小与原来一比没什么变化
approx=cv2.approxPolyDP(cnt,epsilon,True)

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

在图像轮廓中其他的操作：

边界矩形

外接圆

模板匹配

模板匹配和卷积原理很像，模板在原图像上从原点开始滑动，计算模板与（图像被模板覆盖的地方）的差别程度，这个差别程度的计算方法在opencv里有6种，然后将每次计算的结果放入一个矩阵里，作为结果输出。假如原图形是AxB大小，而模板是axb大小，则输出结果的矩阵是(A-a+1)x(B-b+1)

TM_SQDIFF：计算平方不同，计算出来的值越小，越相关

TM_CCORR：计算相关性，计算出来的值越大，越相关

TM_CCOEFF：计算相关系数，计算出来的值越大，越相关

TM_SQDIFF_NORMED：计算归一化平方不同，计算出来的值越接近0，越相关

TM_CCORR_NORMED：计算归一化相关性，计算出来的值越接近1，越相关

TM_CCOEFF_NORMED：计算归一化相关系数，计算出来的值越接近1，越相关

1、读取两张图像；一张是原始图像，一张是模板图像

2、模板匹配；cv2.matchTemplate(img,template,method)

3、定位；cv2.minMaxLoc(img)

直方图

calcHist()函数来计算图像直方图

cv2.calcHist(images,channels,mask,histSize,ranges)

- images: 原图像图像格式为 uint8 或 float32。当传入函数时应 用中括号 [] 括来例如[img]

- channels: 同样用中括号括来它会告函数我们统幅图 像的直方图。如果入图像是灰度图它的值就是 [0]如果是彩色图像 的传入的参数可以是 [0][1][2] 它们分别对应着 BGR。

- mask: 掩模图像。统整幅图像的直方图就把它为 None。但是如 果你想统图像某一分的直方图的你就制作一个掩模图像并 使用它。

- histSize:BIN 的数目。也应用中括号括来。通常为256

- ranges: 像素值范围常为 [0-256]

img=cv2.imread('../asset/img/lena.jpg',0)   #0表示灰度图
#直方图
hist=cv2.calcHist([img],[0],None,[256],[0,256])
#展示
plt.hist(img.ravel(),256)
plt.show()

mask操作

1、创建mask

#1-创建一个mask
mask=np.zeros(img2.shape[:2],np.uint8)      #使用np.zeros()来定义；参数二：图像大小，
# print(mask.shape)
mask[100:700,100:1100]=255      #保存为白色
# cv_show('mask',mask)

2、与操作

new_img=cv2.bitwise_and(img2,img2,mask=mask)    

直方图均衡化

equalizeHist(img)均衡化函数

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

#均衡化
equ=cv2.equalizeHist(img)
# plt.hist(equ.ravel(),256)
# plt.show()

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

自适应直方图均衡化

简单来说就是将图像分小块进行均衡化

cv2.createCLAHE(clipLimit，tileGridSize) #参数一：对比度限制，默认值是40，参数二：分块的大小，默认是8*8

img1=cv2.imread('../asset/img/clahe.jpg',0)
#自适应均衡化
clahe=cv2.createCLAHE(clipLimit=2.0,tileGridSize=(8,8))
#将自适应应用到图像上
res_clahe=clahe.apply(img1)

傅里叶变换

在频域中一切都是静止的

傅里叶变换的作用：

高频：变化剧烈的灰度分量，例如边界

低频：变换缓慢的灰度分量，例如一片大海

滤波：

低通滤波器：只保留低频，会使得图像模糊
高通滤波器：只保留高频，会使得图像细节增强

- opencv中主要就是cv2.dft()和cv2.idft()，输入图像需要先转换成np.float32 格式。dft就是执行傅里叶变换，idft就是逆变换

- 得到的结果中频率为0的部分会在左上角，通常要转换到中心位置，可以通过shift变换来实现。

- cv2.dft()返回的结果是双通道的（实部，虚部），通常还需要转换成图像格式才能展示（0,255）。

\1. cv2.dft(img, cv2.DFT_COMPLEX_OUTPUT) 进行傅里叶变化

参数说明: img表示输入的图片， cv2.DFT_COMPLEX_OUTPUT表示进行傅里叶变化的方法

\2. np.fft.fftshift(img) 将图像中的低频部分移动到图像的中心

参数说明：img表示输入的图片

\3. cv2.magnitude(x, y) 将sqrt(x^2 + y^2) 计算矩阵维度的平方根

参数说明：需要进行x和y平方的数

4.np.fft.ifftshift(img) # 进图像的低频和高频部分移动到图像原来的位置

参数说明：img表示输入的图片

5.cv2.idft(img) # 进行傅里叶的逆变化

参数说明：img表示经过傅里叶变化后的图片

第一步：载入图片

第二步：使用np.float32进行格式转换

第三步：使用cv2.dft进行傅里叶变化

第四步：使用np.fft.shiftfft将低频转移到中间位置

第五步：使用cv2.magnitude将实部和虚部投影到空间域

第六步：进行作图操作

import numpy as np
import cv2
from fontTools.merge import cmap
from matplotlib import pyplot as plt

#读入图像，转换为灰度图
img = cv2.imread('../asset/img/lena.jpg',0)

#转换为np.float32格式
img_float32 = np.float32(img)

#使用cv2.dft进行傅里叶变换
dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)

#使用np.fft.shiftfft()将转换后的图像的低频转移到中心位置
dft_shift = np.fft.fftshift(dft)

# 得到灰度图能表示的形式；
# 使用cv2.magnitude将实部和虚部转换为实部，乘以20是为了使得结果更大
magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))

plt.subplot(121)
plt.imshow(img,cmap='gray')
plt.subplot(122)
plt.imshow(magnitude_spectrum,cmap='gray')
plt.show()

# 使用掩模只保留低通

# 第一步读入图片
img = cv2.imread('lena.jpg', 0)
# 第二步：进行数据类型转换
img_float = np.float32(img)
# 第三步：使用cv2.dft进行傅里叶变化
dft = cv2.dft(img_float, flags=cv2.DFT_COMPLEX_OUTPUT)
# 第四步：使用np.fft.fftshift将低频转移到图像中心
dft_center = np.fft.fftshift(dft)
# 第五步：定义掩模：生成的掩模中间为1周围为0
crow, ccol = int(img.shape[0] / 2), int(img.shape[1] / 2) # 求得图像的中心点位置
mask = np.zeros((img.shape[0], img.shape[1], 2), np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1

# 第六步：将掩模与傅里叶变化后图像相乘，保留中间部分
mask_img = dft_center * mask

# 第七步：使用np.fft.ifftshift(将低频移动到原来的位置
img_idf = np.fft.ifftshift(mask_img)

# 第八步：使用cv2.idft进行傅里叶的反变化
img_idf = cv2.idft(img_idf)

# 第九步：使用cv2.magnitude转化为空间域内
img_idf = cv2.magnitude(img_idf[:, :, 0], img_idf[:, :, 1])

# 第十步：进行绘图操作
plt.subplot(121)
plt.imshow(img, cmap='gray')
plt.subplot(122)
plt.imshow(img_idf, cmap='gray')
plt.show()

实战：银行卡号识别

基本思路：

1、读取模板

​ 2、灰度处理

​ 3、二值处理

​ 4、检测轮廓

​ 5、算外接矩形

6、读取检测图像

​ 7、灰度转换

​ 8、二值

​ 9、礼帽操作

​ 10、闭操作

​ 11、轮廓检测，对每检测到的一组切分成小区域，（5412–>5 4 1 2)

12、模板匹配

一、模板处理：

1）模板预处理

1、读取模板

2、转灰度图

3、二值图

2）模板轮廓检测

4、计算轮廓

5、遍历轮廓

二、输入图像处理：

1）预处理

2）去除不需要的内容

3）轮廓检测

实战：文档OCR

图像特征

harris

基本原理：

代码实现：

cv2.cornerHarris(img,blockSize,ksize,K)

img:数据类型为float32的输入图像

blockSize:角点检测中指定的区域的大小

ksize:Sobel求导中使用的窗口大小

k：取值参数为【0.04，0.06】

SIFT

SIFT(Scale Invariant Feature Transfrom)

图像尺度空间

尺度空间的获取通常使用高斯模糊来实现

不同α的高斯函数决定了对图像的平滑程度，越大的α值对应的图像越模糊

多分辨率金字塔

高斯差分金字塔（DOG）

代码实现：

img=cv2.imread('../asset/img/test_1.jpg')
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

# 得到特征点
sift=cv2.SIFT_create()
kp=sift.detect(gray,None)

img=cv2.drawKeypoints(gray,kp,img)

show.cv_show("img",img)

# 计算特征
kp,des=sift.compute(gray,kp)
print(np.array(kp).shape)

print(des.shape)

特征匹配

img1=cv2.imread('../asset/img/box.png',0)
img2=cv2.imread('../asset/img/box_in_scene.png',0)


sift=cv2.SIFT_create()

kp1,des1=sift.detectAndCompute(img1,None)
kp2,des2=sift.detectAndCompute(img2,None)

# crossCheck表示两个特征点要互相匹，例如A中的第i个特征点与B中的第j个特征点最近的，并且B中的第j个特征点到A中的第i个特征点也是
# NORM_L2: 归一化数组的(欧几里德距离)，如果其他特征计算方法需要考虑不同的匹配计算方式
bf=cv2.BFMatcher(crossCheck=True)

# 1对1的匹配
matches=bf.match(des1,des2)
matches=sorted(matches,key=lambda x:x.distance)
img3=cv2.drawMatches(img1,kp1,img2,kp2,matches[:5],None,flags=None)


# k对最佳匹配
bf=cv2.BFMatcher()
matches=bf.knnMatch(des1,des2,k=2)

#过滤操作，
good=[]
for m,n in matches:
    if m.distance<0.75*n.distance:
        good.append([m])

img4=cv2.drawMatchesKnn(img1,kp1,img2,kp2,good,None,flags=2)

show.cv_show('res',img4)

RANSAC算法

随机抽样一致算法（random sample consens）

实战：全景图像拼接

实战：停车场车位识别

实战：答题卡识别

背景建模

帧差法（了解）

由于场景中的目标在运动，目标的影像在不同图像帧中的位置不同。该类算法对时间上连续的两帧图像进行差分运算，不同帧对应的像素点相减，判断灰度差的绝对值，当绝对值超过一定阈值时，即可判断为运动目标，从而实现目标的检测功能。

帧差法非常简单，但是会引入噪音和空洞问题

混合高斯模型

可以实现行人跟踪

光流估计

光流是空间运动物体在观测成像平面上的像素运动的“瞬时速度”，根据各个像素点的速度矢量特征，可以对图像进行动态分析，例如目标跟踪

实习光流满足的三个前提：

亮度恒定：同一点随着时间的变化，其亮度不会发生改变

小运动：随着时间的变化不会引起位置的剧烈变化

空间一致：一个场景上邻近的点投影到图像上也是邻近点，且邻近点速度一致。例一辆车的左车灯和右车灯

Lucas-Kanade算法

约束方程：

cv2.calcOpticalFlowPyrLK()

参数：

• prevImage 前一帧图像

• nextImage 当前帧图像

• prevPts 待跟踪的特征点向量

• winSize 搜索窗口的大小

• maxLevel 最大的金字塔层数

返回：

• nextPts 输出跟踪特征点向量

• status 特征点是否找到，找到的状态为1，未找到的状态为0

实现代码

import numpy as np
import cv2

cap = cv2.VideoCapture('test.avi')

# 角点检测所需参数
feature_params = dict( maxCorners = 100,
                       qualityLevel = 0.3,
                       minDistance = 7)

# lucas kanade参数
lk_params = dict( winSize  = (15,15),
                  maxLevel = 2)

# 随机颜色条
color = np.random.randint(0,255,(100,3))

# 拿到第一帧图像
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
# 返回所有检测特征点，需要输入图像，角点最大数量（效率），品质因子（特征值越大的越好，来筛选）
# 距离相当于这区间有比这个角点强的，就不要这个弱的了
p0 = cv2.goodFeaturesToTrack(old_gray, mask = None, **feature_params)

# 创建一个mask
mask = np.zeros_like(old_frame)

while(True):
    ret,frame = cap.read()
    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # 需要传入前一帧和当前图像以及前一帧检测到的角点
    p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)

    # st=1表示
    good_new = p1[st==1]
    good_old = p0[st==1]

    # 绘制轨迹
    for i,(new,old) in enumerate(zip(good_new,good_old)):
        a,b = new.ravel()
        c,d = old.ravel()
        mask = cv2.line(mask, (a,b),(c,d), color[i].tolist(), 2)
        frame = cv2.circle(frame,(a,b),5,color[i].tolist(),-1)
    img = cv2.add(frame,mask)

    cv2.imshow('frame',img)
    k = cv2.waitKey(150) & 0xff
    if k == 27:
        break

    # 更新
    old_gray = frame_gray.copy()
    p0 = good_new.reshape(-1,1,2)

cv2.destroyAllWindows()
cap.release()

cv2.dnn.readNetCaffe()