分享一个关于Opencv的小总结

import cv2   #opencv读取的格式是BGR

import numpy as np

一、#读入文件
img=cv2.imread('cat.jpg') #’’引号内是图片所在盘的地址+名字，如：D:/1.jpg

img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #转换成灰度图

二、#得到图片的信息  高，宽，通道数
img_gray.shape

三、#图片显示
cv2.imshow('image',img)

cv2.imshow("img_gray", img_gray) #显示窗口设置，"img_gray"窗口名字，img_gray需要显示的文件

四、关闭窗口
cv2.waitKey(0)     #参数为0：按键关闭窗口，参数为>0的为显示0ms

五、#创建Windows
窗口cv2.destroyAllWindows()

六、#图片保存
cv2.imwrite('mycat.png',img) #参数1：保存地址，参数2：需要保存的文件名

七、打开视频
vc = cv2.VideoCapture('test.mp4') #一个参数，如果是地址，则打开视频，如果参数为0，则是打开摄像头

八、  vc = cv2.VideoCapture('test.mp4')
if vc.isOpened(): # 检查是否打开正确

oepn, frame = vc.read() #返回两个参数，open打开的状态，frame打开后的文件

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 == 27:

break

vc.release()

cv2.destroyAllWindows()

九、#图片切片，相当于裁剪

cat=img[0:50,0:200]

十、边界填充
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) #填充函数

填充模式：1、cv2.BORDER_REPLICATE  ：复制法，复制最边缘的像素

2、cv2.BORDER_REFLECT ：反射法，abcd | dcba

3、cv2.BORDER_REFLECT_101 ：反射法 abcd | cba

4、cv2.BORDER_WRAP  ：外包装法 abcd |abcd

5、cv2.BORDER_CONSTANT, value=0 常量法，value = 0 (黑)  =1(白)  =2 (红)

十一、img_cat2= img_cat +10 #读取到的图片是一组像素数组，可以进行 加减法操作

img_cat2= img_cat +img_cat #同维数组可以进行相加

十二、res = cv2.resize(img, (0, 0), fx=4, fy=4) #改变照片的像素大小。 （0,0）固定值，Fx x轴放大倍数

img_dog = cv2.resize(img_dog, (500, 414)) #(value1 , value2)  想要改到的像素大小

十三、res = cv2.addWeighted(img_cat, 0.4, img_dog, 0.6, 0)  #图片融合， 0.4指cat的权重，0.6是dog的权重，0指偏移量

十四、图像阈值处理（全局）

ret, thresh1 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY)

img_gray：输入的图片，需要是灰度图

thresh1 ：输出的图片

Thresh = 127   阈值，既比较值，通常取127

Maxval = 255，

模式：  1、cv2.THRESH_BINARY， 大于Thresh ，取maxval。反之取 0

2、cv2.THRESH_BINARY_INV， 与1相反

3、cv2.THRESH_TRUNC 大于Thresh ，取maxval。反之不变

4、cv2.THRESH_TOZERO 大于Thresh ，不变。反之取0

5、cv2.THRESH_TOZERO_INV 与4相反
局部： dst = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 25, 10)

超大图像二值化： 利用FOR循环进行分块全局（局部）二值化

cw=256,； ch=256; h,w=image.shape[:2]; gary=cv.cvtColor(image,cv.COLOR_BGR2GRAY);

for row in range(0,h,ch): for col in range(0,w,cw): roi = gray[row:row+ch, col:col+cw]

dst = cv.ada... gray[row:row+ch, col:col+cw] = dst

十五、图像平滑处理

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

blur = cv2.blur(img, (3, 3)) img 源文件，（3,3）指3*3的单位矩阵，常用奇数来进行平滑处理

2、方框滤波，

box = cv2.boxFilter(img,-1,(3,3), normalize=True)   -1 指原通道不变， (3,3)同上，

normalize=True  是否进行归一化处理，True  效果好

3、高斯滤波

aussian = cv2.GaussianBlur(img, (5, 5), 1)

4、中值滤波

median = cv2.medianBlur(img, 5) 5 指 5*5矩阵

十六、矩阵拼接，（图像的拼接）

res = np.hstack((blur,aussian,median)) 括号内指的是所需要拼接的图片

hstack   横向拼接   vstack    纵向拼接

十七、腐蚀操作

kernel = np.ones((3,3),np.uint8) #称为 ‘核’，用3*3的矩阵去腐蚀，矩阵数可变

erosion = cv2.erode(img,kernel,iterations = 1) #iterations 迭代次数，既腐蚀的次数

十八、膨胀操作

dige_dilate = cv2.dilate(dige_erosion,kernel,iterations = 1)

十九、开运算与闭运算（可以去噪声）
先腐蚀后膨胀 称为开运算，通过调节矩阵的大小，可以提取图像中的横、竖线段，删除晓得干扰。

先膨胀后腐蚀 称为闭运算

opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
cv2.MORPH_OPEN  指开运算模式， cv2.MORPH_CLOSE  指闭运算

二十、梯度操作 （膨胀 - 腐蚀）
gradient = cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel)

二十一、礼帽：原始数据 - 开运算

tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)

黑帽：闭运算 - 原始数据

blackhat  = cv2.morphologyEx(img,cv2.MORPH_BLACKHAT, kernel)

二十二、计算图像梯度

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

dx = 1  dy=0  指计算x轴方向

dx = 0  dy=1  指计算y轴方向 不建议x = 1  dy=1  指计算x，y轴方向

Ksize 指Sobel 算子的大小 ，通常取3、5、7

sobelx = cv2.convertScaleAbs(sobelx) #求绝对值

分别求出x  ,y轴的梯度，并且得到绝对值，然后再两个梯度结合在一起

sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0) # 0.5指的是权重

二十三、其他算子
scharrx = cv2.Scharr(img,cv2.CV_64F,1,0) #scharr  算子，用法同 sobel

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

laplacian = cv2.convertScaleAbs(laplacian) #laplacian  拉普拉斯算子有别于前两种

二十四、Canny  边缘检测

1、使用高斯滤波器，平滑图像，除燥

2、计算像素点的梯度强度和方向

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

4、应用双阈值检测来确定真实的边缘 推荐高低阈值比 T2/T1 =3:1 or2:1

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

v1=cv2.Canny(img,80,150)

gaussian = cv.GaussianBlur(image, (3,3), 0)

gray = cv.cvtColor(gaussian, cv.COLOR_BGR2GRAY)

xgrad = cv.Sobel(gray, cv.CV_16SC1, 1, 0)

ygrad = cv.Sobel(gray, cv.CV_16SC1, 0, 1)

edge_output = cv.Canny(xgrad, ygrad, 80, 150)

cv.imshow('edge', edge_output)

gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)

output = cv.Canny(gray, 80, 150)

二十五、图像金字塔

1、高斯金字塔

up=cv2.pyrUp(img) 向上采样法，放大

down=cv2.pyrDown(img) 向下采样法，缩小

2、拉普拉斯金字塔

原始数据  减去  （原始数据先DOWN   再 UP）

二十六、图像轮廓

binary, contours, hierarchy = cv2.findContours(image, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

binary ：得到的二值图像， contours ：轮廓信息，  hierarchy ：层级

Image  :  灰度图

Mode：轮廓检索模式

1、RETR_EXTERNL    :只检测最边缘的轮廓

2、RETR_LIST ：检测所有，并保存在一条

3、RETR_CCOMP ：检测所有，并将他们组织两层，顶层是各部分的外部边界，第二层是空洞的边界

4、RETR_TREE ：检测所有的，并重构嵌套轮廓的整个层次。常用

Method ： 轮库逼近方法

cv2.CHAIN_APPROX_NONE   : 以Freemen链码方式输出轮廓，所有其他方法输出多边形

cv2.CHAIN_APPROX_SIMPLE ：压缩水平的，垂直的，斜的部分，函数只保留他们的终点部分

#传入绘制图像，轮廓，轮廓索引，颜色模式，线条厚度# 注意需要copy,要不原图会变。。。

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(image, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

draw_img = img.copy()

res = cv2.drawContours(draw_img, contours, -1, (0, 0, 255), 2)

draw_img  复制原图，    contours：得到的轮廓，  -1：所有的轮廓全部画出，

（0,0,255）用红色画出， 2 指线宽

二十七、轮廓信息

cnt = contours[0]

cv2.contourArea(cnt) #面积

cv2.arcLength(cnt,True) #周长，True表示闭合的

几何中心 mm = cv.moments(cnt)

cx = mm[‘m10’] / mm[‘m00’]

cy = mm[‘m01’] / mm[‘m00’]

cv.circle(image, (np.int(cx)), np.int(cy), 3, (0, 255, 255), -1)

二十八、边界矩形

cnt = contours[0]

x,y,w,h = cv2.boundingRect(cnt)

img = cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)

二十九、模板匹配

res = cv2.matchTemplate(img,template,1)

Img：原始图， template：模板图，既裁剪图，

Mode:

1. TM_SQDIFF 计算出的值越小越好
2. TM_CCORR 计算出的值越大越好
3. TM_CCOEFF 越大越好
4. TM_SQDIFF_NORMED 接近0好
5. TM_CCORR_NORMED 接近1好
6. TM_CCOEF_NORMED 接近1好

image = cv.imread('D:/3.jpg') #得到原数据

ima_template = image.copy()[200:300, 200:300] #得到模板数据

th, tw = ima_template.shape[:2] #得到模板的长、宽

res = cv.matchTemplate(image, ima_template, cv.TM_CCORR_NORMED) #进行模板匹配，返回数据RES

min_val, max_val, min_loc, max_loc = cv.minMaxLoc(res) #根据模式不同而选择不同的参数

t1 = max_loc #参数实例化

br = (t1[0] + tw, t1[1] + th) #得到矩形另一个对角

cv.rectangle(image, t1, br,(0, 0, 255), 2) #在原图像中画出模板

cv.imshow('1', image) #显示

三十、图像直方图

img = cv2.imread('D:/3.jpg', 0) 第一个参数是文件路径，第二个参数为0指灰度图，不使用第二个参数时指彩图

hist = cv2.calcHist([img],[0],None,[256],[0,256])

Img：原图像，格式为uint-8,或者float32。用[]括起来

channels 如果传入的是灰度图，用[0]. 彩图可以用[0][1][2]他们分别对应着BGR

Mask 掩模图像。直方图就把它为None。

histSize ：Bin数目， ranges：像素范围常数范围 常为[0,256]

color = ('blue', 'green', 'red')

for i, color in enumerate(color):

hist = cv.calcHist([image], [i], None, [256], [0, 256])

plt.plot(hist, color=color)

plt.xlim([0, 256])

plt.show()

直方图反向投影：（HSV与RGB色彩空间）

hsv = cv.cvtColor(image, cv.COLOR_BGR2HSV)

hist = cv.calcHist([hsv], [0,1], None, [180, 256], [0, 180, 0, 256])

三十一、创建Mask

mask = np.zeros(img.shape[:2], np.uint8)

mask[100:300, 100:400] = 255

masked_img = cv2.bitwise_and(img, img, mask=mask)  #与操作

三十二、将图片通过直方图的形式展现出来

equ = cv2.equalizeHist(img) #图片均衡化操作

plt.hist(equ .ravel(),256) #通过直方图展现

Plt.show()

三十三、自适应直方图均衡化（分别进行局部均衡化）

clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8)) #创建自适应均衡化方式

res_clahe = clahe.apply(img) #自适应均衡化

三十四、傅里叶变换

高频：变化剧烈的灰度分量，例如边界 低通滤波：只保留低频，会使图像模糊

低频：变化缓慢的灰度分量 高通滤波：只保留高频，会使图像细节增强

Opencv中主要就是cv2.dft() 和cv2.idft() ,输入图像需要先转化成np.float32格式

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

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

三十五、图像特征-harris角点检测

cv2.cornerHarris(img, blockSize, Ksize, k)

Img：数据类型为float32的图像   (先转换为灰度图，再转成32位)

blockSize：角点检测中指定区域的大小， 使用2  指2*2矩阵

Ksize：Sobel求导中使用的窗口大小  默认 3

K ：取值参数为[0.04 ,0.06] 默认值0.04

三十六、SIFT函数

sift = cv2.xfeatures2d.SIFT_create() 实例化SIFT

kp = sift.detect(image,None) image  灰度图

Img = cv2.drawWeypoints(image,kp,img)

Kp,des=sift.compute(image,kp) 计算特征

Print(np.array(kp).shape)

三十七、背景建模

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

2、混合高斯模型：在进行前景检测前，先对背景进行训练，对图像中每个背景采用一个混合高斯模型进行模拟，每个背景的混合高斯的个数可以自适应，然后再检测阶段，对新的像素进行GMM匹配，如果该像素能够匹配其中一个高斯，则认为是背景，否则认为是前景。由于整个过程GMM 模型再不断更新学习中，所以对动态背景有一定的鲁棒性。

三十八、光流估计

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

函数：cv2.calcOpticalFlowPyrLK()

参数：precImage 前一帧图像 nextImage 当前帧图像

prevPts 待跟踪的特征点向量 winSize 搜索窗口的大小

maxLevel 最大的金字塔层数

返回：nextPts 输出跟踪特征点向量 status 特征点是否找到，找到状态为1，未找到状态为0

三十九、创建一个照片

Img = np.zeros([400,400,3],np.uint8) 大小是400*400，3通道，8位

或者 img = np.ones([400, 400, 1], np.uint8)

Img[：，：，0] = np.ones([400,400])*127 改变创建图片的颜色

img.fill(100) 为每一个像素点赋值 100

四十、查看程序运行的时间

1、t1 = cv2.getTickCount() 2、t2 = cv2.getTickCount()

3、time = (t2 - t1) / cv2.getTickFrequency() 4、print('time:%s ms'%(time / 100))

四十一、像素取反

ima = cv2.bitwise_not(image)

四十二、色彩转换

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 灰度图

hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) HSV

yuv = cv2.cvtColor(image, cv2.COLOR_BGR2YUV) YUV

ycrb = cv2.cvtColor(image, cv2.COLOR_BGR2YCrCb) YCRB

四十三、色彩分离

hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) #在HSV格式下

Low_hsv = np.array([37,43,46])

Upper_hsv = np.array([77,255,2555]) #创建两个参数，在函数中进行筛选作用

Mask = cv2.inRange(hsv, Low_hsv, Upper_hsv)

四十四、算术运算

ima3 = cv.add(ima1,ima2) ima4 = cv.subtract(ima1,ima2)

ima5 = cv.divide(ima1, ima2) ima6 = cv.multiply(ima1, ima2)

逻辑运算：

cv.bitwise_and() cv.bitwise_or()

cv.bitwise_not() cv.bitwise_xor()

四十五、自定义模糊处理

kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32) #锐化算子

kernel = np.ones((5, 5), np.float32)/25 #自定义模糊算子

dst = cv.filter2D(image, -1, kernel=kernel)

四十六、EPF  (可用于美颜)

高斯双边保留 dst = cv.bilateralFilter(image, 0, 100, 15) 颜色边界选大一些的100， 空间边界选小的 15

均值迁移 dst = cv.pyrMeanShiftFiltering(image, 10, 50)

四十七、分水岭算法

输入图像---> 灰度变换（除燥）---> 二值化---> 距离变换---> 寻找种子---> 生成MASK--->

---> 分水岭变换---> 输出图像

距离变换  dist = cv.distanceTransform(mb, cv.DIST_L2, 3)

Mb：需要距离变换的图像，cv.DIST_L2 变换模式， 3：掩模，卷积核

dist_output = cv.normalize(dist, 0, 1.0, cv.NORM_MINMAX)

四十八、人脸检测

gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY) #传入灰度图

#人脸检测包

face_detector = cv.CascadeClassifier('G:/python/Anaconda3/Library/etc/haarcascades/haarcascade_frontalface_alt_tree.xml')

faces = face_detector.detectMultiScale(gray, 1.02, 3)

{ gray待检测图像， 1.02：图像放大倍数 3：当3次监测到属于人脸，则确定是人脸}

for x, y, w, h in faces: #通过FOR循环，画出人脸

cv.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)

{image：画在原图像中 （x , y）：起点， (x + w, y + h)：终点  (0, 0, 255)：颜色 2：线宽}

cv.imshow('face', image)

四十九、数字验证码识别

from PIL import Image

import pytesseract as tess

gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)

ret, thresh1 = cv.threshold(gray, 140, 255, cv.THRESH_BINARY_INV)

kernel = np.ones((1, 2), np.uint8)

open = cv.morphologyEx(thresh1, cv.MORPH_OPEN, kernel, iterations=1)

cv.bitwise_not(open, open) #取反

text_Image = Image.fromarray(open)              #变成text图像

text = tess.image_to_string(text_Image) #转换成数字

print('验证码为:{}'.format(text))

基于Haad + Adaboost 人脸识别

什么是特征：特征=像素经过运算得到的结果，可以是具体的值，向量，多维向量

1、Haar特征：

特征=白色-黑色

特征=整个区域*权重1+黑色-*权重2 权重1=1，权重2=-2

特征=（p1-p2-p3+p4）*w

2、SVM支持向量机

本质是寻求一个最优的超平面进行分类

3、KNN算法（K-近邻算法）：
工作原理：给定一个已知的标签类别的训练数据集，输入没有标签的新数据后，在训练集中找到与新数据最邻近的K个实例，如果这K个实例的多数属于某个类别，那么新数据就属于这个类别。

1、构建数据 构建一个字典类型的数据
2、计算已知数据类型中的数据点与当前数据之间的距离

movie_data_1_2 = movie_data.iloc[:6, 0:2] 选取字典中的0:6行，0:2列的数据

列求和 ：.sum(0) 行求和 ：.sum(1) 当有多个因素决定距离时，需要求得综合的距离

3、#确定前K个数据的类别出现的频率

re = dr.loc[:, 'label'].value_counts()

4、数据归一化，
有多个特征进行参考时，且每一个特征是同样重要，所以要进行归一化处理，使得多个特征的权重相同

方法：0-1标准化， Z-score标准化 Sigmoid压缩法
0-1标准化
data = pd.concat([data_minmax, data_test.iloc[:, 3]], axis=1)
concat():将两组元素合成一组，两组元素需要放进一个[]中，
结合方式由axis=决定。axis = 1,列结合，行数不变。axis=0,行结合，列数不变
test.index = range(test.shape[0])   #重置测试集的编号