opencv python簡易文檔之圖像處理算法的示例分析

這篇文章主要介紹opencv python簡易文檔之圖像處理算法的示例分析，文中介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們一定要看完！

將圖片轉為灰度圖

import cv2 #opencv讀取的格式是BGR
img=cv2.imread('cat.jpg')
# 將圖片轉為灰度圖像操作
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
img_gray.shape

HSV

H - 色調（主波長）。

S - 飽和度（純度/顏色的陰影）。

V值（強度）

import cv2
hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
cv2.imshow("hsv", hsv)
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_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的反轉

ret, thresh2 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY)
ret, thresh3 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY_INV)
ret, thresh4 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TRUNC)
ret, thresh5 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO)
ret, thresh6 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO_INV)

titles = ['Original Image', 'BINARY', 'BINARY_INV', 'TRUNC', 'TOZERO', 'TOZERO_INV']
images = [img, thresh2, thresh3, thresh4, thresh5, thresh6]

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

圖像平滑

使用均值濾波實現圖像平滑

# 均值濾波
# 簡單的平均卷積操作
# 使用3*3的卷積和
blur = cv2.blur(img, (3, 3))

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

使用方框濾波實現圖像平滑：

# 方框濾波
# 基本和均值一樣，可以選擇歸一化
box = cv2.boxFilter(img,-1,(3,3), normalize=True)  

cv2.imshow('box', box)
cv2.waitKey(0)
cv2.destroyAllWindows()
# 方框濾波
# 基本和均值一樣，可以選擇歸一化,容易越界，越界后值為255
box = cv2.boxFilter(img,-1,(3,3), normalize=False)  

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

使用高斯濾波實現圖像平滑：

# 高斯濾波
# 高斯模糊的卷積核里的數值是滿足高斯分布，相當于更重視距離
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()

使用np將所有處理圖片拼接顯示:

# 展示所有的
res = np.hstack((blur,aussian,median))
#print (res)
cv2.imshow('median vs average', res)
cv2.waitKey(0)
cv2.destroyAllWindows()

形態學-腐蝕操作

腐蝕操作可以用于去除圖像中的毛刺

# iterations為腐蝕操作的迭代次數
kernel = np.ones((3,3),np.uint8) 
erosion = cv2.erode(img,kernel,iterations = 1)

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

形態學-膨脹操作

膨脹操作通常與腐蝕操作配合使用

# 先對圖像進行腐蝕操作去除干擾信息
# kernel 為卷積核大小
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()

開運算與閉運算

開運算：先腐蝕，再膨脹

閉運算：先膨脹，再腐蝕

# 開：先腐蝕，再膨脹
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()

梯度運算

提取圖片邊緣信息

# 梯度=膨脹-腐蝕
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算子

Scharr算子

laplacian算子

對于梯度更敏感

檢測圖像像素梯度變換GX為水平梯度檢測，GY為垂直梯度檢測。GX與GY相當于前面提到的卷積和。

dst = cv2.Sobel(src, ddepth, dx, dy, ksize)
# ddepth:圖像的深度
# dx和dy分別表示水平和豎直方向
# ksize是Sobel算子的大小
# 在opencv中像素小于0的點直接被認為是0

# 計算GX
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
# 將負數部分轉為正數
sobelx = cv2.convertScaleAbs(sobelx)
cv_show(sobelx,'sobelx')
# 計算GY
sobelx = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
# 將負數部分轉為正數
sobelx = cv2.convertScaleAbs(sobelx)
cv_show(sobelx,'sobelx')
# 計算GX與GY的加和
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.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邊緣檢測

使用高斯濾波器，以平滑圖像，濾除噪聲。

計算圖像中每個像素點的梯度強度和方向。

應用非極大值（Non-Maximum Suppression）抑制，以消除邊緣檢測帶來的雜散響應。

應用雙閾值（Double-Threshold）檢測來確定真實的和潛在的邊緣。

通過抑制孤立的弱邊緣最終完成邊緣檢測。

1:高斯濾波器

卷積核為符合高斯分布的數據，主要將圖像平滑。

2:梯度和方向

3：非極大值抑制

4：雙閾值檢測

img=cv2.imread("lena.jpg",cv2.IMREAD_GRAYSCALE)

v1=cv2.Canny(img,80,150)
v2=cv2.Canny(img,50,100)

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

圖像金字塔

高斯金字塔

拉普拉斯金字塔

主要用于特征提取

高斯金字塔：向下采樣方法（縮小）

高斯金字塔：向上采樣方法（放大）

# 向上變換
up=cv2.pyrUp(img)
# 向下變換
down=cv2.pyrDown(img)

拉普拉斯金字塔

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')
# 提取輪廓
binary, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
# 繪制輪廓
#傳入繪制圖像，輪廓，輪廓索引，顏色模式，線條厚度
# 注意需要copy,要不原圖會變。。。
draw_img = img.copy()
res = cv2.drawContours(draw_img, contours, -1, (0, 0, 255), 2)
cv_show(res,'res')

輪廓特征

# 選取輪廓     0表示第一個輪廓
cnt = contours[0]
#面積
cv2.contourArea(cnt)
#周長，True表示閉合的
cv2.arcLength(cnt,True)

輪廓近似

epsilon = 0.15*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)
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')
# 外接圓
(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')

直方圖

用于統計圖片像素值分布,x軸表示像素值（0-255），y軸表示該像素值對應個數。

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

images: 原圖像圖像格式為 uint8 或 ?oat32。當傳入函數時應 用中括號 [] 括來例如[img]

channels: 同樣用中括號括來它會告函數我們統幅圖 像的直方圖。如果入圖像是灰度圖它的值就是 [0]如果是彩色圖像 的傳入的參數可以是 [0][1][2] 它們分別對應著 BGR。

mask: 掩模圖像。統整幅圖像的直方圖就把它為 None。但是如 果你想統圖像某一分的直方圖的你就制作一個掩模圖像并 使用它。

histSize:BIN 的數目。也應用中括號括來

ranges: 像素值范圍常為 [0256]

# 統計灰度圖的直方圖
img = cv2.imread('cat.jpg',0) #0表示灰度圖
hist = cv2.calcHist([img],[0],None,[256],[0,256])
hist.shape
# 統計三通道直方圖
img = cv2.imread('cat.jpg') 
color = ('b','g','r')
for i,col in enumerate(color): 
    histr = cv2.calcHist([img],[i],None,[256],[0,256]) 
    plt.plot(histr,color = col) 
    plt.xlim([0,256])

mask操作：

# 創建mask
mask = np.zeros(img.shape[:2], np.uint8)
print (mask.shape)
mask[100:300, 100:400] = 255
cv_show(mask,'mask')
# 將mask與圖像融合
masked_img = cv2.bitwise_and(img, img, mask=mask)#與操作
cv_show(masked_img,'masked_img')
# 使用mask進行直方圖統計與非mask進行直方圖統計
hist_full = cv2.calcHist([img], [0], None, [256], [0, 256])
hist_mask = cv2.calcHist([img], [0], mask, [256], [0, 256])

直方圖均衡化：

是圖像像素分布更加均勻。

# 直方圖均衡化
equ = cv2.equalizeHist(img) 
plt.hist(equ.ravel(),256)
plt.show()

自適應均衡化：

通過將圖片劃分為局部圖片，然后進行直方圖均衡化處理。

clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))

傅里葉變換

時域-》頻域

傅里葉變換的作用

高頻：變化劇烈的灰度分量，例如邊界

低頻：變化緩慢的灰度分量，例如一片大海

濾波

低通濾波器：只保留低頻，會使得圖像模糊，相當于對于邊界的處理。

高通濾波器：只保留高頻，會使得圖像細節增強，相當于對于非邊界的處理。

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

結果（高通對非邊界值不友好）

模板匹配

模板匹配和卷積原理很像，模板在原圖像上從原點開始滑動，計算模板與（圖像被模板覆蓋的地方）的差別程度，這個差別程度的計算方法在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，越相關

methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
           'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']
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()

以上是“opencv python簡易文檔之圖像處理算法的示例分析”這篇文章的所有內容，感謝各位的閱讀！希望分享的內容對大家有幫助，更多相關知識，歡迎關注億速云行業資訊頻道！