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:
- TM_SQDIFF 计算出的值越小越好
- TM_CCORR 计算出的值越大越好
- TM_CCOEFF 越大越好
- TM_SQDIFF_NORMED 接近0好
- TM_CCORR_NORMED 接近1好
- 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]) #重置测试集的编号