唐宇迪opencv 学习笔记 自用

视频读取与处理

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

print(img.shape)

(414,500,3)#height weight channel

img.show（……，cv2.IMGEAD_GRAYSCALE）#读取灰度图

if vc.is0pened（）:
    oepn.frame = vc.read()
else :
    open =False

while open:
    ret, frame = vc.readO
    if frame is None:
        break
    if ret == True:
        gray = ev2.cvtColor(frame, cv2.COLOR_BGR2GRAY)cv2.imshow("result', gray)
    if cv2.waitKey(10)&OxFF == 27:#10为每帧停留时间
        break
vc.release()
cv2.destroyAllwindows ()

ROI区域

截取部分图像数据

img=cv2.imread('cat.jpg')
cat=img[0:200,0:200]
cv_show('cat' ,cat)

颜色通道提取和组合

b,g,r=cv2.split(img)#bgr顺序不可以乱
img2=cv2.merge(b,g,r)

只保留某个颜色通道

cur_img =img.copy()
cur_img[:,:,0]=0
cur_img[:.:,1]=0
cv_show('R' , cur_img)

边界填充

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=o)

数值计算

cv2. add(img_cat, img_ cat2)[:5, :,0]|

152+142=294＞255 越界

294-256=38

cv2.resize(img,(0,0),fx=,fy)

res = cv2. addWeighted(img_cat, 0.4, img_ dog, 0.6,0)

腐蚀操作

可以是色彩追踪更加精准，少了很多的颜色干扰

kernel = np.ones((30,30), np.uint8)#卷积大小
erosion_1 = cv2.erode (pie, kernel, iterations = 1)#iterations为迭代次数
erosion_2 = cv2.erode (pie, kernel, iterations = 2)
erosion_3 = cv2.erode (pie, kernel, iterations = 3) I
res = np.hstack((erosion_1,erosion_2,erosion_3))
cv2.imshow('res',res)
cv2.waitKey(0）
cv2.destroyAllWindows()

具体操作：定义卷积大小，逐像素扫描，遇到边缘就腐蚀。（边缘判定：卷积块中不同像素个数达到阈值）

腐蚀1到3次的效果

腐蚀前后区别

字变细了 再

膨胀操作

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

开运算和闭运算（膨胀和腐蚀一起用）

梯度运算

#梯度=膨胀-腐蚀
pie = cv2.imread( pie. png' )
kernel = np.ones((7, 7), np.uint8)
dilate = cv2.dilate (pie, kernel, iterations = 5)
erosion = cv2.erode (pie, kernel, iterations = 5)
res = np.hstack((dilate, erosion) )
cv2.imshow('res',res)
cv2.waitKey(0)
cv2.destroyAllWindows()

gradient = cv2.morphologyEx(pie, cv2. MORPH_GRADIENT, kernel)
cv2.imshow('gradient',gradient)
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算子

若矩阵乘法计算出负数结果，函数只能输入0-255之间的数，会默认为0

如-30默认为0

直接求梯度的结果

原因

sobelxy = cv2.addWeighted(sobelx, 0.5,sobely,0.5,0)#两个0.5均为为权重
cv_show(sobelxy,'sobelxy' )

不建议直接计算

sobelxy=cv2.Sobel(img, cv2.CV_64F, 1, 1,ksize=3)
sobelxy = cv2.convertScaleAbs(sobelxy)
cv_show(sobelxy,'sobelxy' )

gx、gy融合效果不佳

分别计算

img = cv2.imread('lena.jpgcv2.IMREAD_GRAYSCALE)
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)
sobelx = cv2.convertScaleAbs(sobelx)
sobely = cv2.Sobel (img, cv2.CV_64F, 0, 1, ksize=3)
sobely = cv2.convertScaleAbs(sobely)
sobelxy = cv2.addWeighted(sobelx, 0.5, sobely, 0.5, 0)
cV_show(sobelxy, 'sobelxy' )

不同算子的差异

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.addWei ghted(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')

scharr更加敏感可以展现更多的细节

laplacian不建议单独使用，和其他操作一起用

---

平滑处理

#均值滤波
#简单的平均卷积操作
blur = cv2.blur(img, (3,3))
cv2.imshow(' blur',b1ur)
cv2.waitKey (0)
cv2.destroyAllWindows ()

多一个normalize操作

#方框滤波
#基本和均值一样， 可以选择妇一化
box = cv2.boxFilter(img, -1, (3, 3), normalize=True)#normalize归一化求均值
cv2.imshow('box',box)
cv2.waitKey(0)
cv2.destroyAllWindows()

normalize若设置为false易造成越界（0-255）：方框中值直接相加，不求均值（大于255被默认为255，变成白色）

#高斯滤波
#高斯模糊的卷积核里的数值是满足高斯分布，相当于更重视中间的
aussian = cv2.GaussianBlur(img, (5, 5), 1)
cv2.imshow('aussian',aussian)
cv2.waitKey(0)
cv2.destroyAllWindows ()

#中值滤波
#相当于用中值代替
median = cv2.medianBlur(img, 5) # 中值滤波
cv2. imshow('median',median)
cv2. waitKey(0)
cv2. destroyAllWindows()

---

图像阈值

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 T

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

ret, threshl = cv2.threshold(img_gray,127, 255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img_gray,127, 255, cv2.THRESH BINARY_INV)
ret, thregh3 = 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 = ['0riginal Image' ,'BINARY','BINARY_ INV','TRUNC','TOZE','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(O]),plt. yticks([])
plt.show()

BINARY二值处理：亮的变白（＞127） 暗的变黑（<127）

BINARY_INV：二值处理的反转

TRUNC：设置截断值（大于127的全部视为127）

TOZERO：小于127的转换成0

TOZERO_inv：TOZERO反转

---

Canny边缘检测

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

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

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

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

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

sobel算子

法一：

法二：

高低阈值相差越大，边缘检测获取信息越多，但也可能引入噪点

---

图像轮廓

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

绘制轮廓

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

---

模板匹配

① 模板匹配和卷积原理很像，模板在原图像上从原点开始滑动，计算模板与（图像被模板覆盖的地方）的差别程度(例如值127与值190的区别)，这个差别程度的计算方法在opencv里有6种，然后将每次计算的结果放入一个矩阵里，作为结果输出。

② 假如原图形是AxB大小，而模板是axb大小，则输出结果的矩阵是(A-a+1)x(B-b+1)。

③ 模板匹配计算方式6种方式 ( 用归一化后的方式更好一些 )：

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

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

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

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

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

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

④ 公式：https://docs.opencv.org/3.3.1/df/dfb/group__imgproc__object.html#ga3a7850640f1fe1f58fe91a2d7583695d

for meth in methods:
    img2 = img. copy()
    #匹配方法的真值
    method = eval(meth)
    print(method)
    res = cv2.matchTemplate(img,template,method)
    min_val, max_val, min_loc，max_loc = cv2.minMaxLoc(res)
    #如果是平方差匹配TM SQDIFF或归一化平方差匹配TM SQDIFF NORME
    if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_ NORMED]:
        top_left = min_1oc 
    else:
        top_1eft = max_1oc
    bottom_right =(top_1eft[0] + w, top_1eft[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('01_Picture/14_Mario.jpg')
img_gray = cv2.cvtColor(img_rgb,cv2.COLOR_BGR2GRAY)
template = cv2.imread('01_Picture/15_Mario_coin.jpg',0)
print('template.shape：',template.shape)
h, w = template.shape[:2]

# res 是 result 的简称
res = cv2.matchTemplate(img_gray, template, cv2.TM_CCOEFF_NORMED) # res 是返回每一个小块窗口得到的结果值
threshold = 0.8

# 取匹配程度大于 80% 的坐标
loc = np.where(res >= threshold) # np.where 使得返回 res 矩阵中值大于 0.8 的索引，即坐标

# zip函数为打包为元组的列表，例 a = [1,2,3] b = [4,5,6] zip(a,b) 为 [(1, 4), (2, 5), (3, 6)]    
for pt in zip(*loc[::-1]): # 当用 *b 作为传入参数时, b 可以为列表、元组、集合，zip使得元组中两个 numpy.array 进行配对   
    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)

模板为金币

---

图像金字塔

img=cv2.imread('AM.png' )
cv_show(img,'img')
print(img.shape)#(442，340, 3) 

up=cv2.pyrUp(img)
cv_show(up,'up')
print(up.shape)#(884，680，3)

down=cv2.pyrDown(img)
cv_show(down,'down' )
print(down.shape)#(221，170，3)

原图和上采样后再下采样恢复到原图大小的处理后图片相比

上采样往矩阵中填充了0，下采样又损失了一些信息

down=cv2.pyrDown(img)
down_up=cv2.pyrUp(down)
1_1=img-down_up
cv_show(1_ 1,'1 _1')

处理后图片