机器视觉初学记录

目录

图像基本操作

截取图片部分内容

 颜色通道提取

边界填充

数值计算

图像融合

形态学—腐蚀操作

形态学—膨胀操作

开运算和闭运算

梯度运算

礼帽和黑帽

图像处理

图像梯度—sobel算子

图像梯度—scharr算子

 图像梯度—laplacian算子

图像平滑-滤波处理

图像阈值

 Canny边缘检测

图像轮廓

模板匹配

 图像金字塔

---

图像基本操作

截取图片部分内容

#截取出图片200*200像素范围的图片
img=cv2.imread('cat.jpg')
cat=img(0:200,0:200)
cv2.imshow('cat',cat)

 颜色通道提取

b,g,r=cv2.split(img)

r.shape
#表示array元组包含414个元组元素，每个元组元素包含500个元素

shape方法的理解
​​​​

 将b,g,r组合起来

 img1=cv2.merge((b,g,r))

img.shape

边界填充

#图片的上下左右进行填充的大小
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)

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

数值计算

 越界会自动-255；像素范围0-255

#相当于img的每个像素点+10
img_cat=img+10

图像融合

融合前必须要reres = cv2.addWeighted(img_cat, 0.4, img_dog, 0.6, 0)

两张照片的权重和为1

形态学—腐蚀操作

#指定一个30*30的核
kernel=np.ones((30,30),np.uint8)
erosion_1=cv2.erode(img,kernel,iterations=1)
erosion_2=cv2.erode(img,kernel,iterations=1)
erosion_3=cv2.erode(img,kernel,iterations=1)
#将三张图片组合成一张图片
res=np.hstack((erosion_1,erosion_2,erosion_3))

'''
   karnel：内核
   erode:侵蚀
   erosion：腐蚀
   iterations:迭代次数
'''

形态学—膨胀操作

kernel=np.ones((30,30),np.uint8)

dilate=cv2.dilate(img,kernel,iterations=1)

'''
   dilate:膨胀
'''

开运算和闭运算

#开运算：先腐蚀再膨胀

kernel=np.ones((3,3),np.uint8)
opening=cv2.morphologyEx(img,cv2.MORPH_OPEN,kernel)
'''
   morph: 形态，图像变换，改变
'''

#闭运算：先膨胀再腐蚀

kernel=np.ones((3,3),np.uint8)
closeing=cv2.morphologyEx(img,cv2.MORPH_CLOSE,kernel)

梯度运算

#梯度=膨胀-腐蚀

kernel=np.ones((3,3),np.uint8)
gradient=cv2.morphologyEx(img,cv2.MORPH_GRADIENT,kernel)
'''
   gradient:梯度
'''

礼帽和黑帽

#礼帽=原始输入-开运算结果

tophat=cv2.morphologyEx(img,cv2.MORPH_TOPHAT,kernel)
'''
   tophat:顶帽，礼帽
'''

#黑帽=闭运算-原始输入

blackhat=cv2.morphologyEx(img,cv2.MORPH_BLACKHAT,kernel)
'''
   blackhat:黑帽
'''

图像处理

图像梯度—sobel算子

eg：Gx水平梯度 ， Gy竖直梯度

 

dst = cv2.Sobel(src, ddepth, dx, dy, ksize）

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

1.
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
#cv2.CV_64F就是将计算结果负数保持为负数，原本计算结果负数直接至0
 白到黑是正数，黑到白就是负数了，所有的负数会被截断成0，所以要取绝对值

2.计算sobelx
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
#可以将负值取绝对值，得到完整得轮廓
sobelx = cv2.convertScaleAbs(sobelx)

3.计算sobely
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
#可以将负值取绝对值，得到完整得轮廓
sobely = cv2.convertScaleAbs(sobely)  

4.分别计算x和y，再求和
#将上面得到得sobelx，sobely按权重计算得到sobelxy
sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)

5.直接计算
不建议直接计算，有重影模糊
sobelxy=cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)
sobelxy = cv2.convertScaleAbs(sobelxy) 

图像梯度—scharr算子

 图像梯度—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')

sobel、scharr、laplacian三种算子效果比较

图像平滑-滤波处理

均值滤波

#均值滤波
#简单得平均卷积操作
#3*3的核的像素取平均值
blur=cv2.blur(img,(3,3))

方框滤波

#方框滤波
#基本和均值一样，可以选择归一化

box=cv2.boxFilter(img,-1,(3,3),normalize=True)#归一化
-1表示得到的结果跟原始输入的颜色通道是一致的


box=cv2.boxFilter(img,-1,(3,3),normalize=False)#不归一化
没有除9的操作，发生越界的时候，像素直接取255，显示白色

'''
   filter:过滤，滤波
   normalize：正常化，规范化
'''

高斯滤波

#高斯滤波
#高斯模糊的卷积核里的数值是满足高斯分布，更重视中间的
gaussian=cv2.GaussianBlur(img,(5,5),1)

中值滤波

#中值滤波
#相当于用中值代替
median=cv2.medianBlur（img,5)

eg:中值滤波清除噪音效果比较好

图像阈值

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

  cv2.THRESH_BINARY:超过阈值部分取maxval(最大值）,否则取0
  CV2.THRESH_BINARY_INV：CV2.THRESH_TOZER0_INV的反转
  CV2.THRESH_TRUNC：大于阈值部分设为阈值，否则不变
  CV2.THRESH_TOZERO：大于阈值部分不变，否则设0
  CV2.THRESH_TOZER0_INV：CV2.THRESH_TOZERO的反转

'''
   threshold:阈值，门槛
   TRUNC：将数字截尾取整

'''

thresh一般设为127

maxval一般取255

 Canny边缘检测

单独写的一点

Canny边缘检测算法_runaway black hole的博客-CSDN博客

图像轮廓

cv2.findContours(img,mode,method)
# mode:轮廓检测模式
       RETR_EXTERNAL:只检索最外面的轮廓
       RETR_LIST:检索所有的轮廓，并将其保存到一条链表中
       RETR_CCOMP:检索所有的轮廓，并将他们组织为两层：
                  顶层是各部分的外部边界，第二层是空洞的边界
       RETR_TREE:检索所有的轮廓，并重构嵌套轮廓的整个层次
'''
用最后一个比较好
'''

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


'''
   contours:轮廓，轮廓线
   external:外部的，外面的
   CCOMP:
   APPROX:大约
   method:方法，办法
   simple:简单的，简明的
'''

CHAIN_APPROX_NONE ：完整的                                           CHAIN_APPROX_NONE:端点                                          

#读取图片
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(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

#传入绘制图像，轮廓，轮廓索引（-1默认所有轮廓，0第一个外圈轮廓，1是第一个内圈轮廓），
  颜色模式，线条厚度
# 注意需要copy,要不原图会变。。。
draw_img = img.copy()
res = cv2.drawContours(draw_img, contours, -1, (0, 0, 255), 2)
cv_show(res,'res')

绘制轮廓的步骤：

               1、转化为灰度图

               2、进行二值化处理

               3、得到轮廓

               4、绘制轮廓

轮廓特征

#选择第几个轮廓
cnt = contours[0]
#面积
cv2.contourArea(cnt)
得到返回值：8500.5
#周长,True表示闭合的
cv2.arcLength(cnt,True)
得到返回值：437.9482651948929

轮廓近似

A                                                B                                                  C

img = cv2.imread('contours2.png')

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
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')

#算周长并*0.1，指定越小越详细
epsilon = 0.1*cv2.arcLength(cnt,True) 
#cnt：选择哪条轮廓，epsilon：0.1倍的周长
approx = cv2.approxPolyDP(cnt,epsilon,True)

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

 外界矩形、外接圆

外接矩形

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

模板匹配

步骤：1、将图片分区如分成3*3的9个区

           2、将每个区与模板匹配，每个区的像素点与模板对应的像素点进行比对，计算差异

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

- 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

lena.jpg

face.jpg
​​​​​​

# 模板匹配
img = cv2.imread('lena.jpg', 0)
template = cv2.imread('face.jpg', 0)
h, w = template.shape[:2] 
img.shape
#上行的结果值：(263, 263)
template.shape
#上行的结果值：(110, 85)
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)
# cv2.TM_SQDIFF可改为1
res.shape
#上行的结果值：(154, 179)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)#minMaxLoc获得定位
#获得模板匹配最小值、最大值、最小值位置、最大值位置
min_val
#上行的结果值：39168.0
max_val
#上行的结果值：74403584.0
min_loc
#上行的结果值：(107, 89)
max_loc
#上行的结果值：(159, 62)

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

 图像金字塔

高斯金字塔

拉普拉斯金字塔

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

高斯金字塔:向上采样法（扩大）

#up就是上采样
up=cv2.pyrUp(img)#pyrup()
#down就是下采样
up_down=cv2.pyrDown(up)

拉普拉斯金字塔

注：就是每一层=原始图像—原始图像的向下采样再向上采样 

直方图

 

cv2.calcHist(images,channels,mask,histSize,ranges)

• images: 原图像图像格式为 uint8 或 float32。当传入函数时应 用中括号 [] 括来例如[img]
• channels: 同样用中括号括来它会告函数我们统幅图 像的直方图。如果入图像是灰度图它的值就是 [0]如果是彩色图像 的传入的参数可以是 [0][1][2] 它们分别对应着 BGR。
• mask: 掩模图像。统整幅图像的直方图就把它为 None。但是如 果你想统图像某一分的直方图的你就制作一个掩模图像并 使用它。
• histSize:BIN 的数目。也应用中括号括来
• ranges: 像素值范围常为 [0256]

直方图剩下的不想搞了，累了，过段时间再写

傅里叶变换

我们生活在时间的世界中，早上7:00起来吃早饭，8:00去挤地铁，9:00开始上班。。。以时间为参照就是时域分析。

但是在频域中一切都是静止的！

傅里叶分析之掐死教程（完整版）更新于2014.06.06 - 知乎

傅里叶变换的作用

• 高频：变化剧烈的灰度分量，例如边界

• 低频：变化缓慢的灰度分量，例如一片大海

滤波

• 低通滤波器：只保留低频，会使得图像模糊

• 高通滤波器：只保留高频，会使得图像细节增强

• opencv中主要就是cv2.dft()和cv2.idft()，输入图像需要先转换成np.float32 格式。
• 得到的结果中频率为0的部分会在左上角，通常要转换到中心位置，可以通过shift变换来实现。
• cv2.dft()返回的结果是双通道的（实部，虚部），通常还需要转换成图像格式才能展示（0,255）。

import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('lena.jpg',0)

img_float32 = np.float32(img)

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
# 得到灰度图能表示的形式
magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

低通

import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('lena.jpg',0)

img_float32 = np.float32(img)

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

rows, cols = img.shape
crow, ccol = int(rows/2) , int(cols/2)     # 中心位置

# 低通滤波
mask = np.zeros((rows, cols, 2), np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1

# IDFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1])

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Result'), plt.xticks([]), plt.yticks([])

plt.show() 

高通 

img = cv2.imread('lena.jpg',0)

img_float32 = np.float32(img)

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

rows, cols = img.shape
crow, ccol = int(rows/2) , int(cols/2)     # 中心位置

# 高通滤波
mask = np.ones((rows, cols, 2), np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 0

# IDFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1])

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Result'), plt.xticks([]), plt.yticks([])

plt.show()