读取显示图像

cv2.imshow('image',img) 
# 等待时间，毫秒级，0表示任意键终止
cv2.waitKey(10000) 
cv2.destroyAllWindows()
# 可以将其写成一个函数
def cv_show(name, img):
	cv2.imshow(name,img) 
	cv2.waitKey(0) 
	cv2.destroyAllWindows()

保存图片

#保存
cv2.imwrite('mycat.png',img)

查看图片信息

img.size
img.dtype
img.shape

读取视频

vc = cv2.VideoCapture('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(10) & 0xFF == 27:  # 10ms读取一帧，按“ESC”键退出。
			break
vc.release()
cv2.destroyAllWindows()

截取部分图像数据

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))
# 只保留R
cur_img = img.copy()
cur_img[:, :, 0] = 0
cur_img[:, :, 1] = 0
cv_show('R',cur_img)
# 只保留G
cur_img = img.copy()
cur_img[:,:,0] = 0
cur_img[:,:,2] = 0
cv_show('G',cur_img)
# 只保留B
cur_img = img.copy()
cur_img[:,:,1] = 0
cur_img[:,:,2] = 0
cv_show('B',cur_img)

边界填充

代码原理：

• BORDER_REPLICATE：复制法，也就是复制最边缘像素。
• BORDER_REFLECT：反射法，对感兴趣的图像中的像素在两边进行复制例如：fedcba|abcdefgh|hgfedcb
• BORDER_REFLECT_101：反射法，也就是以最边缘像素为轴，对称，gfedcb|abcdefgh|gfedcba
• BORDER_WRAP：外包装法cdefgh|abcdefgh|abcdefg
• BORDER_CONSTANT：常量法，常数值填充，需要在函数中填入常数参数。

# 填充的范围
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()

数值计算

# 导入图片
img_cat=cv2.imread('cat.jpg')
img_dog=cv2.imread('dog.jpg')
# 将图片所有像素值加10
img_cat2= img_cat +10 
#两图片相加，超过255则溢出，相当于% 256
(img_cat + img_cat2)[:5,:,0] 
# 两图片相加，超过255则赋值为255
cv2.add(img_cat,img_cat2)[:5,:,0]

图像融合

# 首先应保证两张图片shape相同
print(img_cat.shape)
# 图像缩放
img_dog = cv2.resize(img_dog, (500, 414))  # [宽, 高]
print(img_dog.shape)
# 按权重组合两张图片，0.4和0.6是权重，0为偏置项，一般不加。
res = cv2.addWeighted(img_cat, 0.4, img_dog, 0.6, 0)
plt.imshow(res)
# 除了上面的图像缩放操作，也可以按照比例进行缩放。
res = cv2.resize(img, (0, 0), fx=1, fy=3)  # 宽是原来的一倍，高是原来的三倍
plt.imshow(res)

图像阈值

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

# 先将图片转化为灰度图
img = cv2.imread('cat.jpg')
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
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 = ['Gray 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')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# 均值滤波
# 用3*3的核对图片进行卷积操作，核上的参数都是1/9，达到均值的效果
blur = cv2.blur(img, (3, 3))
# 方框滤波（归一化）=均值滤波
box1 = cv2.boxFilter(img, -1, (3, 3), normalize=True)
# 方框滤波（不归一化）
box2 = cv2.boxFilter(img, -1, (3, 3), normalize=False)
# 高斯滤波
# 用5*5的核进行卷积操作，但核上离中心像素近的参数大。
guassian = cv2.GaussianBlur(img, (5, 5), 1)
# 中值滤波
# 将某像素点周围5*5的像素点提取出来，排序，取中值写入此像素点。
mean = cv2.medianBlur(img, 5)

# 展示效果
titles = ['Original figure', 'blur', 'box_norm', 'box_no_norm', 'guassian', 'mean']
images = [img, blur, box1, box2, guassian, mean]
for i in range(6):
    plt.subplot(2, 3, i+1), plt.imshow(images[i])
    plt.title(titles[i])
    plt.xticks([]), plt.yticks([])
plt.show()

形态学-腐蚀操作

# 读取图片
img = cv2.imread('dige.png')
# 展示原始图片
cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
# 将图上的“刺”腐蚀掉
kernel = np.ones((3, 3), np.uint8)
erosion = cv2.erode(img, kernel, iteration=1)
# 展示经腐蚀后的图片
cv2.imshow('erosion', erosion)
cv2.waitKey(0)
cv2.destroyAllWindows()

原理
用3*3的核遍历整个图像，如果遇到像素值为255的像素点和像素值为0的像素点同时被核包含进去，则将255的像素点赋值为0。如：

pie = cv2.imread('pie.png')
cv2.imshow('pie', pie)
cv2.waitKey(0)
cv2.destroyAllWindows()

kernel = np.ones((30,30),np.uint8) 
erosion_1 = cv2.erode(pie,kernel,iterations = 1)  # iteration指进行腐蚀操作的次数
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()

形态学-膨胀操作

其原理与腐蚀操作正好相反。

img = cv2.imread('dige.png')
cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

kernel = np.ones((3,3),np.uint8) 
dige_erosion = cv2.erode(img,kernel,iterations = 1)

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

kernel = np.ones((3,3),np.uint8) 
dige_dilate = cv2.dilate(dige_erosion,kernel,iterations = 1)

cv2.imshow('dilate', dige_dilate)
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()

梯度运算

gradient = cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel)

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

原理：即用膨胀后的图片减去腐蚀后的图片，从而提取出边缘。

# 梯度=膨胀-腐蚀
pie = cv2.imread('pie.png')
kernel = np.ones((7,7),np.uint8) 
dilate = cv2.dilate(pie,kernel,iterations = 1)
erosion = cv2.erode(pie,kernel,iterations = 1)

res = cv2.subtract(dilate, erosion)

cv2.imshow('res', res)
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算子

原理：
前一个Sobel矩阵与原始图像A进行卷积操作后得到的是右边的像素值减去左边的像素值；后一个Sobel矩阵与原始图像A进行卷积操作后得到的是下边的像素值减去上边的像素值。
dst = cv2.Sobel(src, ddepth, dx, dy, ksize)

• ddepth:图像的深度
• dx和dy分别表示水平和竖直方向
• ksize是Sobel算子的大小

# x方向取边缘
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
# 白到黑是正数，黑到白就是负数了，所有的负数会被截断成0，所以要取绝对值
sobelx = cv2.convertScaleAbs(sobelx)
cv_show(sobelx,'sobelx')
# y方向取边缘
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely = cv2.convertScaleAbs(sobely) 
cv_show(sobely,'sobely')

但是用sobelxy=cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)时效果并不好。
所以一般先分别计算x方向和y方向的边缘再求和。

sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)  # 0表示偏置项，一般不加
cv_show(sobelxy,'sobelxy')

Scharr算子

原理：
其实就是将Sobel算子的数增大了，这样对边缘的检测更敏感。

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')

Canny边缘检测

原理：

• 1. 使用高斯滤波器，以平滑图像，滤除噪声。
• 2. 计算图像中每个像素点的梯度强度和方向。
• 3. 应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散响应。
• 4. 应用双阈值（Double-Threshold）检测来确定真实的和潜在的边缘。
• 5. 通过抑制孤立的弱边缘最终完成边缘检测。

高斯滤波器

梯度和方向

非极大值抑制

双阈值检测

img=cv2.imread("car.png",cv2.IMREAD_GRAYSCALE)

v1=cv2.Canny(img,120,250)
v2=cv2.Canny(img,50,100)

res = np.hstack((v1,v2))
cv_show(res,'res')

图像金字塔

原理

高斯金字塔：向下采样（缩小）

高斯金字塔：向上采样（放大）

img=cv2.imread("AM.png")
cv_show(img,'img')
print (img.shape)
# 上采样
up=cv2.pyrUp(img)
cv_show(up,'up')
print (up.shape)
# 下采样
down=cv2.pyrDown(img)
cv_show(down,'down')
print (down.shape)
# 先上采样后下采样得到的图片相比于原图片会有损失
up=cv2.pyrUp(img)
up_down=cv2.pyrDown(up)
cv_show(np.hstack((img,up_down)),'up_down')

拉普拉斯金字塔

down=cv2.pyrDown(img)
down_up=cv2.pyrUp(down)
l_1=img-down_up
cv_show(l_1,'l_1')

提取图像轮廓

cv2.findContours(img,mode,method)
mode:轮廓检索模式

• RETR_EXTERNAL ：只检索最外面的轮廓；
• RETR_LIST：检索所有的轮廓，并将其保存到一条链表当中；
• RETR_CCOMP：检索所有的轮廓，并将他们组织为两层：顶层是各部分的外部边界，第二层是空洞的边界;
• RETR_TREE（最常用）：检索所有的轮廓，并重构嵌套轮廓的整个层次;

method:轮廓逼近方法

• CHAIN_APPROX_NONE：以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）。
• CHAIN_APPROX_SIMPLE（最常用）:压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分。

# 为了更高的准确率，使用二值图像。
img = cv2.imread('contours.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
cv_show(thresh, 'thresh')
# 提取轮廓
contours, hierarchy = cv2.findContours(thresh, cv2.RETE_TREE, cv2.CHAIN_APPROX_SIMPLE)
# 查看提取的轮廓数量
np.array(contours).shape
# 绘制轮廓
# 注意需要copy,要不原图会变。。。
draw_img = img.copy()
res = cv2.drawContours(draw_img, contours, -1, (0, 0, 255), 2)  # -1表示绘制所有轮廓
cv_show(res,'res')
draw_img = img.copy()
res = cv2.drawContours(draw_img, contours, 0, (0, 0, 255), 2)  # 0表示绘制第一条轮廓
cv_show(res,'res')

此外，轮廓特征也可以被获取

# 首先，取出需要获取特征的那条轮廓
cnt = contours[0]
# 面积
cv2.contourArea(cnt)
# 周长
cv2.arcLength(cnt, True)

轮廓也可以被近似画出：

# 提取轮廓并绘制轮廓
img = cv2.imread('contours2.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)
cnt = contours[0]

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

# 近似轮廓
epsilon = 0.1*cv2.arcLength(cnt, True)  # 设置阈值，阈值越小，轮廓越近似
approx = cv2.approxPolyDP(cnt, epsilon, True)

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

# 边界矩形
img = cv2.imread('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)
cnt = contours[0]

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

area = cv2.contourArea(cnt)
x, y, w, h = cv2.boundingRect(cnt)
rect_area = w * h
extent = float(area) / rect_area
print ('轮廓面积与边界矩形比',extent)

# 外接圆
(x, y), radius = cv2.minEnclosingCircle(cnt)
center = (int(x), int(y))
radius = int(radius)
img = cv2.circle(img, center, radius, (0, 255, 0), 2)
cv_show(img, 'img')

模板匹配

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

img = cv2.imread('lena.jpg', 0)
template = cv2.imread('face.jpg', 0)
h, w = template.shape[:2] 

方法

• TM_SQDIFF：计算平方不同，计算出来的值越小，越相关
• TM_CCORR：计算相关性，计算出来的值越大，越相关
• TM_CCOEFF：计算相关系数，计算出来的值越大，越相关
• TM_SQDIFF_NORMED：计算归一化平方不同，计算出来的值越接近0，越相关
• TM_CCORR_NORMED：计算归一化相关性，计算出来的值越接近1，越相关
• TM_CCOEFF_NORMED：计算归一化相关系数，计算出来的值越接近1，越相关
  具体公式可参考：Opencv官网

methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
           'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']
# 先使用计算平方的方法匹配模板
res = cv2.matchTemplate(img, template, cv2.TM_SQDIFF)
# 得到计算值的最大值、最小值以及它们的左上角的位置
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
# 运用所有方法
for meth in methods:
    img2 = img.copy()

    # 匹配方法的真值
    method = eval(meth)
    res = cv2.matchTemplate(img, template, method)
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

    # 如果是平方差匹配TM_SQDIFF或归一化平方差匹配TM_SQDIFF_NORMED，取最小值；否则取最大值。
    if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
        top_left = min_loc
    else:
        top_left = max_loc
    bottom_right = (top_left[0] + w, top_left[1] + h)

    # 画矩形
    cv2.rectangle(img2, top_left, bottom_right, 255, 2)

    plt.subplot(121), plt.imshow(res, cmap='gray')
    plt.xticks([]), plt.yticks([])  # 隐藏坐标轴
    plt.subplot(122), plt.imshow(img2, cmap='gray')
    plt.xticks([]), plt.yticks([])
    plt.suptitle(meth)
    plt.show()

如果需要匹配多个对象，则：

img_rgb = cv2.imread('mario.jpg')
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
template = cv2.imread('mario_coin.jpg', 0)
h, w = template.shape[:2]

res = cv2.matchTemplate(img_gray, template, cv2.TM_CCOEFF_NORMED)
threshold = 0.8
# 取匹配程度大于%80的坐标，而不是找匹配度最大的坐标。
loc = np.where(res >= threshold)
for pt in zip(*loc[::-1]):  # *号表示可选参数
    bottom_right = (pt[0] + w, pt[1] + h)
    cv2.rectangle(img_rgb, pt, bottom_right, (0, 0, 255), 2)

cv2.imshow('img_rgb', img_rgb)
cv2.waitKey(0)