#环境设置
D:\python;
D:\python\Lib\site-packages;
D:\python\Scripts;
#模块下载
pip install opencv-python
pip install numpy #需要安装numpy模块
#测试是否下载成功
import cv2
print(cv2.__Version__)
#2.4.9
基本流程：图像读取，窗口创建，图像显示，图像保存，资源释放
图像读取
path = 'image\gezi.jpg' #图像路径
#图像读取
img = cv2.imread(path,flags=1) # flags=0读取图像为单通道的灰度图，1为BRG格式的三通道图像
print(type(img)) # <class 'numpy.ndarray'>
print(img.shape) # (1005, 1200, 3) h*w*c
path:注意路径格式用\或/，同时路径中不要有中文
如果路径是错误的，opencv是不会提示的，但是读取的图像是None
采取异常处理
if img is None: #img==None是错误的
print('read img error')
cv2.imread(path,flags=1)中flags参数
创建窗口
cv2.namedWindow(winname: Any, flags: int = …)
cv2.namedWindow('image',cv2.WINDOW_GUI_NORMAL)
flags参数
图像显示
#图像显示
cv2.imshow('image',img)
如果之前没用cv2.namedWindow创建image窗口，那么会自动调用cv2.namedWindow创建窗口。
图像保存
#图像保存
cv2.imwrite('save.png',img)
相同路径会替换原有的。
资源释放
#资源释放
cv2.destroyAllWindows()
cv2.destroyWindow() #销毁指定窗口，参数填窗口名称
窗口等待
用于窗口停留展示，不然窗口会一闪而过结束程序。
key = cv2.waitKey(delay=100)
if key == ord('s'):
print('save image')
结束条件：delay时间结束，或键盘触发(key接受键盘按键ASCII码)。delay = 0为无限等待。
完整代码
import cv2
import numpy as np
print(cv2.__version__)
path = 'image\gezi.jpg' #图像路径
#图像读取
img = cv2.imread(path,flags=1) # flags=0读取图像为单通道的灰度图，1为BRG格式的三通道图像
print(type(img)) # <class 'numpy.ndarray'>
print(img.shape) # (1005, 1200, 3) h*w*c
#窗口创建
cv2.namedWindow('image',flags=0) #flags可以调节窗口的大小
#图像显示
cv2.imshow('image',img)
#图像保存
cv2.imwrite('save.png',img)
key = cv2.waitKey(delay=0)
#资源释放
cv2.destroyAllWindows()
其他补充
cv2读取的图像是numpy格式的，所以numpy的操作是适用的。
VideoCapture类提供了从摄像机或视频文件捕获视频的C++接口。
基本流程：创建视频接口，捕获视频帧，视频播放，视频保存，资源释放
创建视频接口
方式a:
filename = 'gamevideo.mp4'
cap = cv2.VideoCapture()
cap.open(filename)
方式b:
filename = 'gamevideo.mp4'
cap = cv2.VideoCapture(filename)
以上这两种打开的视频可以是本地，也可以是网络视频filename = "http://www.laganiere.name/bike.avi"
方式c:从摄像头获取视频
dev = 0
cap = cv2.VideoCapture(dev)
捕获视频帧
读取视频要加异常判断
方式a:
if cap.isOpened():
print('打开失败')
方式b:在读取时进行判断
ret,frame = cap.read()
if ret == False:
print('ret is false')
ret,frame = cap.read()，frame就是每一帧的画面。
视频播放
while True:
ret,frame = cap.read()
if ret == False:
print('ret is false')
break
cv2.imshow('frame',frame)
cv2.waitKey(1000//24)
注意在视频显示的时候需要延时，1s24帧。
视频保存
保存每一帧构成视频。
fourcc = cv2.VideoWriter_fourcc(*'mp4v') #自定义视频编解码器
out = cv2.VideoWriter('ouput.mp4',fourcc,20.0,(w,h)) #创建保存视频类
out.write(frame)#写入帧
cv2.VideoWriter()
资源释放
cap.release() #关闭视频文件
完整代码
import cv2
import numpy as np
print(cv2.__version__)
#
filename = 'gamevideo.mp4'
cap = cv2.VideoCapture(filename)
# dev = 0
# cap = cv2.VideoCapture(dev)
if not cap.isOpened():
print('打开失败')
ret,frame = cap.read()
if ret == False:
print('ret is false')
fourcc = cv2.VideoWriter_fourcc(*'mp4v') #自定义视频编解码器
h,w = frame.shape[:-1]
out = cv2.VideoWriter('ouput.mp4',fourcc,20.0,(w,h))
while True:
ret,frame = cap.read()
if ret == False:
print('ret is false')
break
cv2.imshow('frame',frame)
out.write(frame[...,::-1])
cv2.waitKey(1000//24)
#资源释放
cap.release() #关闭视频文件
cv2.destroyAllWindows()
其他功能
在opencv中用元组表示颜色。如BGR(0,255,255,alpha)表示黄色,alpha是透明度一般用不到就不给。
#创建黑底
bg = np.zeros((500,500，3),dtype=np.uint8)
cv2.imshow('bg',bg)
cv2.waitKey()
这里需要三通道，不然后面绘图函数的颜色是出不来的，只有黑和白。
bg = np.zeros((500,500,3),dtype=np.uint8)
l = cv2.line(bg,(100,100),(200,200),color=(0,255,0),thickness=2)
cv2.imshow('bg',bg)
cv2.waitKey()
cv2.line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) → img
bg = np.zeros((500,500,3),dtype=np.uint8)
cir = cv2.circle(bg,(250,250),100,(0,255,0),thickness=-1)
cv2.imshow('bg',bg)
cv2.waitKey()
cv2.circle(img, center, radius, color[, thickness[, lineType[, shift]]])
thickness=-1
thickness>0
bg = np.zeros((500,500,3),dtype=np.uint8)
rec = cv2.rectangle(bg,(100,100),(200,200),(0,255,0))
cv2.imshow('bg',bg)
cv2.waitKey()
(100,100),(200,200)分别是左上角和右下角的坐标。
bg = np.zeros((500,500,3),dtype=np.uint8)
cv2.putText(bg,'Opencv',(100,100),cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),1)
cv2.imshow('bg',bg)
cv2.waitKey()
cv2.putText(bg,‘Opencv’,(100,100),cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),1)
cv2.setMouseCallback(windowName, onMouse [, param]) -> None
def onmouse(event,x,y,flags,*param):
print(x,y,param)
#创建背景
bg = np.full((500,500),fill_value=255,dtype=np.uint8)
cv2.imshow('bg',bg)
#创建鼠标事件
cv2.setMouseCallback('bg',onmouse,0)
回调函数onmouse(event,x,y,flags,*param)的输入参数最好是这样的。
Event:
#define CV_EVENT_MOUSEMOVE 0 //滑动
#define CV_EVENT_LBUTTONDOWN 1 //左键点击
#define CV_EVENT_RBUTTONDOWN 2 //右键点击
#define CV_EVENT_MBUTTONDOWN 3 //中键点击
#define CV_EVENT_LBUTTONUP 4 //左键放开
#define CV_EVENT_RBUTTONUP 5 //右键放开
#define CV_EVENT_MBUTTONUP 6 //中键放开
#define CV_EVENT_LBUTTONDBLCLK 7 //左键双击
#define CV_EVENT_RBUTTONDBLCLK 8 //右键双击
#define CV_EVENT_MBUTTONDBLCLK 9 //中键双击
flags:
#define CV_EVENT_FLAG_LBUTTON 1 //左鍵拖曳
#define CV_EVENT_FLAG_RBUTTON 2 //右鍵拖曳
#define CV_EVENT_FLAG_MBUTTON 4 //中鍵拖曳
#define CV_EVENT_FLAG_CTRLKEY 8 //(8~15)按Ctrl不放事件
#define CV_EVENT_FLAG_SHIFTKEY 16 //(16~31)按Shift不放事件
#define CV_EVENT_FLAG_ALTKEY 32 //(32~39)按Alt不放事件
参考: Opencv函数setMouseCallback鼠标事件响应
createTrackbar(trackbarName, windowName, value, count, onChange) -> None
def onChange(x):
print(x)
cv2.createTrackbar('woshihuakuai','bg',10,255,onChange)
path = r'datas\testimage.png'
contrast = 100*0.1
b = 50
img = cv2.imread(path,0)
for i in range(0,img.shape[0]):
for j in range(0,img.shape[1]):
bright = img[i,j]*contrast+b
if bright>255:
bright = 255
img[i,j] = bright
溢出保护：确保像素值为整数，且当灰度值大于255时，强转为255
b,g,r = cv2.split(img)
dst = cv2.merge([b,g,r])
roi = img[200:500,200:500]
注意ROI参数顺序y1, y2, x1, x2
要求运算对象的size和type一样
add(src1, src2[, dst[, mask[, dtype]]]) -> dst
dst = cv2.add(img1,img2)
img1和img2shape必须相同，类型必须相同。
addWeighted(src1, alpha, src2, beta, gamma[, dst[, dtype]]) -> dst
dst = cv2.addWeighted(img1,0.7,img2,0.3,0)
带权重的相加
cv2.subtract()
cv2.absdiff()
bitwise_and(src1, src2[, dst[, mask]]) -> dst
bg = np.zeros((500,500,3),dtype=np.uint8)
rect = cv2.rectangle(bg.copy(),(100,100),(400,400),(255,255,255),thickness=-1)
cv2.imshow('rect',rect)
cir = cv2.circle(bg.copy(),(250,250),180,(255,255,255),thickness=-1)
cv2.imshow('cir',cir)
dst = cv2.bitwise_and(rect,cir)
cv2.imshow('dst',dst)
注意copy
src1
src2
dst
取像素点为（255，255，255）的交集
cv2.bitwise_or
cv2.bitwise_xor
resize(src, dsize[, dst[, fx[, fy[, interpolation]]]]) -> dst
interpolation
resize_img = cv2.resize(img,dsize=(img.shape[0]//2,img.shape[1]//2),interpolation=cv2.INTER_AREA)
平移就是将对象换一个位置。如果你要沿(x,y)方向移动，移动的距离是(tx,ty),可以构建移动矩阵m.
使用numpy构建m
m = np.array([[1,0,50],[0,1,50]],dtype=np.float32)
warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]) -> dst
dst = cv2.warpAffine(img,m,dsize=img.shape[:-1])
M = cv2.getRotationMatrix2D((w/2, h/2), 90, 1) #中心点，旋转90度，不缩放
print(M.shape) #(2, 3)
如果不在进行后续变化了m取前二行即可(0,0,1是为了结果能进行后续仿射而特意添加的)，所以打印出来m的shape是2*3。
旋转仿射
dst = cv2.warpAffine(img1, M, (w, h))
图A，存在透视效果
我们的目的是把图像转换成图B
仿射的关键是构建M，那么这里的变换怎么构建M呢。我们可以去寻找4个点。
通过一些方法标注，变换前的4个点和变换后的4个点
src_p = np.float32([(13,66),(574,66),(55,380),(554,380)]) # x,y
dst_p = np.float32([(13,66),(574,66),(10,380),(576,380)]) # x',y'
利用getPerspectiveTransform(src, dst[, solveMethod]) -> retval反解出M，再使用仿射变化warpPerspective。
m = cv2.getPerspectiveTransform(src_p,dst_p)
dst = cv2.warpPerspective(scard,m,(w,h))
图像滤波函数方法：
6. 线性滤波：方框滤波、均值滤波、高斯滤波
7. 非线性滤波：中值滤波、双边滤波
邻域算子：利用给定像素周围的像素值决定此像素的最终输出值的一种算子
一种常用的邻域算子，像素输出取决于输入像素的加权和，如下图示：
锚点是中间位置。
线性滤波器输出像素g(i, j)是输入像素f(i+k, j+I)的加权和，其中h(k, l)我们称之为核，是滤波器的加权系数。基本上这就是CNN中的卷积操作。
kernel
当normalize为true时，方框滤波也就成了均值滤波。也就是说均值滤波是方框滤波归一化后的特殊情况。
boxFilter(src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]]) -> dst
dst = cv2.boxFilter(img,-1,(5,5),normalize=True)
效果对比
亮度变得均匀->模糊
均值滤波即方框滤波归一化特例，就是用邻域内像素均值来代替该点像素值，均值滤波在去噪的同时也破坏了图像细节部分
blur(src, ksize[, dst[, anchor[, borderType]]]) -> dst
dst = cv2.blur(img,(3,3))
效果对比
高斯滤波器被称为最有用的滤波器,每个像素点都是由本身和邻域内的其他像素值经过加权平均后得到的, 加权系数越靠近中心越大, 越远离中心越小, 能够很好的滤除噪声。
GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst
dst = cv2.GaussianBlur(img,(3,3),0)
效果对比
中值滤波是一种非线性滤波, 是用像素点邻域灰度值的中值代替该点的灰度值, 可以去除脉冲噪声和椒盐噪声。
什么是中值：
median({1,2,3,3,7,5,1,8})=3 排序后的中间那个值。如果中间有两个数可以取均值，或者取左侧or右侧随便一个值。
medianBlur(src, ksize[, dst]) -> dst
dst = cv2.medianBlur(img,3)
效果对比
双边滤波是一种非线性滤波, 是结合图像空间邻近度和像素值相似度的一种折中处理, 尽量在去噪同时保存边缘。
bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]]) -> dst
dst = cv2.bilateralFilter(img,20,500,500)
效果对比
两种主要的图像阈值化函数方法：
threshold(src, thresh, maxval, type[, dst]) -> retval, dst
maxval
| 宏定义 | 像素值>thresh | 其他情况 |
|---|---|---|
| cv2.THRESH_BINARY =0 | maxval | 0 |
| cv2.THRESH_BINARY_INV =1 上面取反 | 0 | maxval |
| cv2.THRESH_TRUNC =2 | thresh | 当前灰度值 |
| cv2.THRESH_TOZERO =3 | 当前灰度值 | 0 |
| cv2.THRESH_TOZERO_INV =4 | 0 | 当前灰度值 |
辅助宏定义自动获取thresh
| 宏定义 | 功能 |
|---|---|
| cv2.THRESH_OTSU | 使用最小二乘法处理像素点，适合双峰图 |
| cv2.THRESH_TRIANGLE | 使用三角算法处理像素点，适合单峰图 |
| cv2.THRESH_MASK | / |
单峰图或者双峰图指的是灰度直方图。
这种适合
参考: CV2简单阈值函数：cv2.threshold()
cv2.THRESH_OTSU、cv2.THRESH_TRIANGLE是标志位，他们可以和其他参数，比如cv2.THRESH_BINARY一起使用。当使用cv2.THRESH_OTSU或cv2.THRESH_TRIANGLE时，阈值是动态的，会根据计算结果返回相应的数值。
_,bingary = cv2.threshold(gray,120,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
效果对比
对矩阵采用自适应阈值操作, 自适应阈值是根据像素的邻域块的像素值分布来确定该像素位置上的二值化阈值
adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst]) -> dst
参数基本同cv2.threshold()，注意返回值只有一个。
每个局部的阈值T(x,y)的计算
if adaptiveMethod== cv2.ADAPTIVE_THRESH_MEAN_C:
先求出块中的均值，再减掉C
if adaptiveMethod== cv2.ADAPTIVE_THRESH_GAUSSIAN_C:
先求出块中的加权和(gaussian), 再减掉C
adaptiveThreshold 将灰度图像变换到二值图像，采用下面公式：
thresholdType= cv2.THRESH_BINARY :
thresholdType= cv2.THRESH_BINARY _INV:
代码
binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
效果对比
cv2.adaptiveThreshold()具有一定轮廓提取能力。
从数学角度上来讲, 膨胀或腐蚀就是将图像(或区域)A与核B进行卷积。最大值池化和最小值池化
构建核是进行膨胀和腐蚀的前提。核可以是任意大小和形状, 它有一个独立定义的参考点(锚点), 多数情况下, 核是一个小的中间带参考点的实心正方形或者圆盘, 可以看做是一个模板或掩码。
可使用cv2.getStructuringElement获得指定形状和尺寸的核。
getStructuringElement(shape, ksize[, anchor]) -> retval
k1 = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
k1:
[[0 1 0]
[1 1 1]
[0 1 0]]
当然，可以使用numpy直接构建，但是要注意数据类型，自行实验。
膨胀是求局部最大值的操做, 核B与图形卷积, 即核B覆盖的区域的像素点的最大值, 并把这个最大值复制给参考点指定的像素, 这样就会使图像中的高亮区域逐渐增长。
cv2.dilate(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst
#膨胀
k1 = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3)) #构建卷积核
dst_dilate = cv2.dilate(img_2v,k1,iterations=1)#img_2v为一张二值图
效果对比
腐蚀和膨胀相反, 是取局部最小值, 高亮区域逐渐减小, 如下图所示:
erode(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst
参数与膨胀一样，不做介绍。
k2 = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
dst_erosion = cv2.erode(img_2v,k2,iterations=1)
效果对比
开运算、闭运算、顶帽、黒帽、形态学梯度。这些操作都是基于膨胀和腐蚀实现的。
通过调用cv2.morphologyEx(src, op, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst来实现。
先腐蚀后膨胀的过程, 开运算可以用来消除小物体（高亮度的）, 在纤细点处分离物体, 并在平滑较大物体边界的同时不明显的改变其面积。op选择cv2.MORPH_OPEN
k = cv2.getStructuringElement(cv2.MORPH_CROSS,(4,4))
dst_open=cv2.morphologyEx(img_2v,cv2.MORPH_OPEN,k)
kernel的size是需要更具噪点的大小进行调整的。个人认为直接使用cv2.morphologyEx接口腐蚀和膨胀的核的大小是一样的，选择不同的核使用cv2.erode和cv2.dilate可能效果会更好。
效果对比
闭运算是先膨胀后腐蚀的过程, 闭运算可以用来消除小型黑洞(黑色区域)。
op选择cv2.MORPH_CLOSE
k = cv2.getStructuringElement(cv2.MORPH_CROSS,(4,4))
dst_close=cv2.morphologyEx(img_2v,cv2.MORPH_CLOSE,k)
效果对比
形态学梯度是膨胀图与腐蚀图之差, 以将团块(blob)边缘凸显出来, 可以用其来保留边缘轮廓。
op选择cv2.MORPH_GRADIENT
k = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
dst_gd = cv2.morphologyEx(img_2v,cv2.MORPH_GRADIENT,k)
效果对比：
顶帽运算也被称为”礼帽”, 是开运算结果和原图像做差的结果, 可以用来分离比邻近点亮一些的斑块。
op是cv2.MORPH_TOPHAT
k = cv2.getStructuringElement(cv2.MORPH_CROSS,(4,4))
dst_th = cv2.morphologyEx(img_2v,cv2.MORPH_TOPHAT,k)
效果对比
黑帽运算是原图像和开运算做差的结果, 可以用来分离比邻近点暗一些的斑块。
k = cv2.getStructuringElement(cv2.MORPH_CROSS,(4,4))
dst_b = cv2.morphologyEx(img_2v,cv2.MORPH_BLACKHAT,k)
效果对比
边缘信息变化比较大，梯度大，那么梯度大的地方就是边缘。
边缘检测可以提取图像重要轮廓信息, 减少图像内容, 可以用于分割图像、做特征提取等
边缘检测的一般步骤：
常用的边缘检测算子：
Sobel算子是一个主要用于边缘检测的离散微分算子, 它结合了高斯平滑和微分求导, 用来计算图像灰度函数的近似梯度。
Sobel边缘检测函数—cv2.Sobel()
Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]]) -> dst
ddepth有如下：
位深越大，小数点后的位数越多，计算越准确，速度越慢。
img_sb = cv2.Sobel(binary,cv2.CV_16S,1,0,ksize=3).astype(np.uint8)
or
img_sb = cv2.Sobel(binary,cv2.CV_16S,1,0,ksize=3)
img_sb = cv2.convertScaleAbs(img_sb)
dx = 1,dy = 0
注意到此时更加关注的是纵向的线
注意这里是需要进行类型转换的。
G=0.5*Gx+0.5Gy
img_sb_x = cv2.Sobel(binary,cv2.CV_16S,1,0,ksize=3)
img_sb_y = cv2.Sobel(binary,cv2.CV_16S,0,1,ksize=3)
img_sb_x = cv2.convertScaleAbs(img_sb_x)
img_sb_y = cv2.convertScaleAbs(img_sb_y)
img_sb = cv2.addWeighted(img_sb_x,0.5,img_sb_y,0.5,0)
效果图
Canny相较于Sobel最大的区别在于采用双阈值。
Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]) -> edges
canny = cv2.Canny(img,180,90)
效果图
Laplacian算子是n维欧几里德中的一个二阶微分算子。
数学定义：
Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]]) -> dst
代码
lap = cv2.Laplacian(img,-1,ksize=3)
效果图
Laplacian边缘效果似乎更加的细腻。
拉普拉斯和Canny边缘检测后不需要类型转换。
霍夫变换(Hough Transform)是图像处理中的一种特征提取技术, 该过程在一个参数空间中通过计算累计结果的局部最大值得到一个符合该特定形状的集合作为霍夫变换的结果。
霍夫变换在OpenCV中主要分两种:
主要使用的函数：
霍夫线变换是一种寻找直线的方法, 一般在使用霍夫变换前首先将图像进行边缘检测处理, 一般霍夫变换的输入为边缘二值图。
OpenCV支持三种不同的霍夫线变换, 包括:
cv2.HoughLines()
直方图是对数据进行统计的一种方法, 可以直观表现图像某属性的数值(频率)分布情况, 包括灰度直方图、RGB直方图等
相关概念及函数:
cv2.calcHist()
代码
import cv2
import numpy as np
import matplotlib.pyplot as plt
filename = r'datas\chepai.jpg'
img = cv2.imread(filename,0)
hist = cv2.calcHist([img],[0],None,[256],[0,255])
#hist是一个shape为(256,1)的数组，表示0-255每个像素值对应的像素个数，下标即为相应的像素值
#plot一般需要输入x,y,若只输入一个参数，那么默认x为range(n)，n为y的长度
plt.plot(hist,color = 'b')
plt.hist(img.ravel(),256,[0,256])
plt.show()
cv2.waitKey()
效果对比
模板匹配是一项在一幅图像中寻找与另一幅模板图像最匹配(相似)部分的技术。模板匹配不是基于直方图的, 而是通过在输入图像上滑动图像块(模板)同时比对相似度, 来对模板和输入图像进行匹配的一种方法。
输入图像：
模板：
实际中，模板的size必须要和输入图像中的匹配图像大小一致。
应用
cv2.matchTemplate()
| method | 定义 |
|---|---|
| cv2.TM_SQDIFF | 平方差匹配法(最好匹配0，越小越好) |
| cv2.TM_SQDIFF_NORMED | 归一化平方差匹配法(最好匹配0) |
| cv2.TM_CCORR - | 相关匹配法(最坏匹配0) |
| cv2.TM_CCORR_NORMED | 归一化相关匹配法(最坏匹配0) |
| cv2.TM_CCOEFF | 系数匹配法(最好匹配1，越大越好) |
| cv2.TM_CCOEFF_NORMED | 化相关系数匹配法(最好匹配1) |
上述模式越往下越复杂，花费时间越多，准确率应该是越高，根据需要选择。
import sys
import cv2
import numpy as np
filename = r'data\01.bmp'
templfile = r'testdata\templ0.bmp'
src = cv2.imread(filename)
templ = cv2.imread(templfile)
res = cv2.matchTemplate(src,templ,cv2.TM_SQDIFF)
print(res)
# cv2.imshow('src',src)
# cv2.imshow('templ',templ)
# cv2.imshow('res',res)
cv2.waitKey()
output
模板每次移动一个像素，每次计算相似度，相似度将会保存在result矩阵中。相似度的结果并不是保存在中心点，而是保存在左上角。
假设这个模式越靠近0说明越相似，那么我们需要从res这个矩阵中，找到其中最小的元素的位置，从而可以对应到原图src中的位置。
代码：
minMaxLoc(src[, mask]) -> minVal, maxVal, minLoc, maxLoc
import sys
import cv2
import numpy as np
filename = r'data\01.bmp'
templfile = r'testdata\templ0.bmp'
src = cv2.imread(filename)
templ = cv2.imread(templfile)
res = cv2.matchTemplate(src,templ,cv2.TM_SQDIFF)
min_value,max_value,min_loc,max_loc = cv2.minMaxLoc(res)
print(min_value,max_value,min_loc,max_loc)
cv2.waitKey()
output：
print(min_value,max_value,min_loc,max_loc)
72.0 1287406848.0 (365, 483) (1319, 1891)
那么(365, 483)差不多就是原图中匹配到的位置。为什么说是差不多呢，因为res和src还位置不是一样对应的，差多少取决于你模板的大小。
轮廓可以简单认为成将连续的点（连着边界）连在一起的曲线，具有相同的颜色或者灰度，提取轮廓就是提取这些具有相同颜色或者灰度的曲线，或者说是连通域，轮廓在形状分析和物体的检测和识别中非常有用。
程序如何保存这些曲线呢？保存轮廓点的集合，大致就可以保存下轮廓曲线。
注意：
cv2.findContours()-----查找轮廓
| mode | 意义 |
|---|---|
| cv2.RETR_EXTERNAL=0 | 表示只检测最外层轮廓（一般选用） |
| cv2.RETR_LIST=1 | 提取所有轮廓并放置在list中, 轮廓不建立等级关系 |
| cv2.RETR_CCOMP=2 | 提取所有轮廓并组织为双层结构 |
| cv2.RETR_TREE =3 | 提取所有轮廓并重新建立网状轮廓结构 |
| method | 意义 |
|---|---|
| cv2.CHAIN_APPROX_SIMPLE | 存储所有轮廓点。 |
| cv2.CHAIN_APPROX_NONE | 压缩存储。对于线段，只储存线段的两个端点。对四边形只用4个点就可以确定。 |
cv2.drawContours()---------绘制轮廓
filename = r'data\01.bmp'
src = cv2.imread(filename)
gray = cv2.cvtColor(src,cv2.COLOR_BGR2GRAY)
if src is None:
print('check the filenam')
sys.exit()
#二值化
_,binary = cv2.threshold(gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
#轮廓查找
cnts ,hir = cv2.findContours(binary,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)
cv2.namedWindow('binary',cv2.WINDOW_NORMAL)
cv2.imshow('binary',binary)
#轮廓绘制
cv2.drawContours(src,cnts,-1,(0,0,255),2) # -1绘制所有轮廓，0绘制cnts中第一个轮廓...
cv2.namedWindow('src',cv2.WINDOW_NORMAL)
cv2.imshow('src',src)
cv2.waitKey()
效果展示
红色就是绘制的轮廓。
#打印轮廓数量
print(hir.shape)
(1, 541, 4)
说明上图一共提取了514个轮廓，噪点太多。
#打印每个轮廓包含的点的数量
for cnt in cnts:
print(cnt.shape)
(1, 1, 2)
(15, 1, 2)
(1, 1, 2)
(4, 1, 2)
(2, 1, 2)
(1, 1, 2)
(1, 1, 2)
(5, 1, 2)
(12, 1, 2)
(6, 1, 2)
(36, 1, 2)
...
通过点的数量，也可以筛选出你需要的轮廓。
注意：
在实际应用中, 经常会有将检测到的轮廓用多边形表示出来的需求, 提取包围轮廓的多边形也方便我们做进一步分析, 轮廓包围主要有一下几种:
boundingRect(array) -> retval
dst = src.copy()
#轮廓外接矩形
for cnt in cnts:
if cnt.shape[0]>500:
x,y,w,h = cv2.boundingRect(cnt)
cv2.rectangle(dst,(x,y),(x+w,y+h),(0,0,255),3)
通过点的数量，筛选目标。
设置合适的点的数量阈值，直到准确寻找到轮廓。
minAreaRect(points) -> retval
手上有center、size、 angle可以画出矩形了吗？可能可以，我们使用另外的方式，使用函数获取矩形的每一个点。
boxPoints(box[, points]) -> points
box = cv2.boxPoints(res)
box = np.int0(box)
for cnt in cnts:
if cnt.shape[0]>500:
res = cv2.minAreaRect(cnt)
box = cv2.boxPoints(res)
box = np.int0(box)
cv2.drawContours(dst,[box],-1,(0,0,255),3)
由于获取的box是点集，那么我们可以使用cv2.drawContours进行绘制最小外接矩形。
效果图
轮廓最小外接圆—cv2.minEnclosingCircle()
minEnclosingCircle(points) -> center, radius
轮廓椭圆拟合—cv2.fitEllipse()
fitEllipse(points) -> retval
cv2.approxPolyDP
contourArea(contour[, oriented]) -> retval
#通过轮廓面积筛选轮廓
for cnt in cnts:
box_area = cv2.contourArea(cnt)
if box_area>2000:
cv2.drawContours(dst,cnt,-1,(0,0,255),3)
arcLength(curve, closed) -> retval
HSV颜色空间与人眼所看色彩较接近, 故常用于颜色
检测与识别。其中H(色调)、S(饱和度)、V(亮度)
H—不同的颜色(红色/绿色/蓝色)—范围: 0~360
S—颜色深浅(浅红/深红)—范围: 0.0~1.0
V—颜色亮暗(暗红/亮红)—范围: 0.0~1.0
OpenCV默认的HSV范围分别是:
H: 0~180, S: 0~255, V: 0~255
在opencv中，H、S和V仍然被放大到0-255直接，因此各个颜色的HSV取值如下。
inRange(src, lowerBound, upperbBound[, dst]) -> dst
代码
import sys
import cv2
import numpy as np
filename = r'datas\chepai.jpg'
src = cv2.imread(filename)
if src is None:
print('check the filenam')
sys.exit()
# 颜色区间范围删选
#BGR2GRAY
hsv = cv2.cvtColor(src,cv2.COLOR_BGR2HSV)
l_v = np.array([100,43,46]) #HSV 低阈值
h_v = np.array([124,255,255]) #HSV 高阈值
mask = cv2.inRange(hsv,l_v,h_v)
cv2.namedWindow('mask',cv2.WINDOW_NORMAL)
cv2.imshow('mask',mask)
cv2.waitKey()
效果对比：
可以看到蓝色像素点被置为255.
通过调节阈值可以获得更好的效果，上图中阈值设置如下
l_v = np.array([100,43,46]) #HSV 低阈值
h_v = np.array([124,255,255]) #HSV 高阈值
我们看到原图中，车牌上方的蓝色是比较暗的，所以我们调高一下低阈值的V
l_v = np.array([100,43,170]) #HSV 低阈值
h_v = np.array([124,255,255]) #HSV 高阈值
效果
可以看到有了显著的改善。