文章目錄

• • 致謝
• 3 圖像處理（上）
• • 3.1 幾何變換
  • • 3.1.1 圖像縮放
    • 3.1.2 圖像平移
    • 3.1.3 圖像旋轉
    • 3.1.4 仿射變換
  • 3.2 圖像閾值
  • 3.3 圖像平滑
  • • 3.3.1 圖像噪聲
    • • 3.3.1.1 椒鹽噪聲
      • 3.3.1.2 高斯噪聲
    • 3.3.2 均值濾波
    • 3.3.3 方框濾波
    • 3.3.4 高斯濾波
    • 3.3.5 中值濾波
    • 3.3.6 小結
  • 3.4 形態學操作
  • • 3.4.1 連通性
    • • 3.4.1.1 鄰接
      • 3.4.1.2 連通
    • 3.4.2 腐蝕和膨脹
    • • 3.4.2.1 腐蝕
      • 3.4.2.2 膨脹
    • 3.4.3 開閉運算
    • 3.4.4 黑帽和禮帽
    • 3.4.5 梯度
  • 3.5 圖像梯度處理
  • • 3.5.1 Sobel算子
    • 3.5.2 Scharr算子
    • 3.5.3 laplacian算子

致謝

OpenCV高斯濾波GaussianBlur_godadream的博客-CSDN博客_gaussianblur

opencv 圖像平移、縮放、旋轉、翻轉 圖像仿射變換_Ibelievesunshine的博客-CSDN博客_opencv 圖像仿射變換

opencv 圖像變換原理詳解 圖像平移 圖像旋轉 圖像縮放 - 我堅信陽光燦爛 - 博客園 (cnblogs.com)

3 圖像處理（上）

3.1 幾何變換

3.1.1 圖像縮放

cv2.resize(src,dsize,fx=0,fy=0,interpolation = cv2.INTER_LINEAR)

參數：

• src：輸入圖像
• dsize：按固定比例縮小
• fx、fy：自定義比例縮小
• interpolation：插值方法

插值含義

cv2.INTER_LINEAR	雙線性插值法
cv2.INTER_NEAREST	最近鄰插值
cv2.INTER_AREA	像素區域重采樣
cv2.INTER_CUBIC	雙三次插值

import cv2 as cv# 讀取圖片 img = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg") # 縮放 row, col = img.shape[0:2] resize_img = cv.resize(img, (2*col, 2*row), cv2.INTER_NEAREST) cv.imshow("image", resize_img) cv.waitKey(0)

3.1.2 圖像平移

cv.warpAffine(src,M,dsize)

• src：輸入的圖像
• M：2×3的移動矩陣
• 移動矩陣通常為2*3，對于處于(x,y)的像素點，要把他們移動到($x+t_x,y+t_y$)，則只需構建M = $\left[\begin{array}{ccc}1& 0& t_x\\ 0& 1& t_y\end{array}\right]$，并且該矩陣必須是np.fload32類型的矩陣
• dsize：輸出圖像的大小

import cv2 as cv import numpy as np import matplotlib.pyplot as plt import matplotlibmatplotlib.rcParams['font.family']='SimHei'# 讀取圖像 img = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg")# 設置平移矩陣 rows, cols = img.shape[:2] M = np.float32([[1, 0, 100], [0, 1, 50]]) dst = cv.warpAffine(img, M, (cols, rows))# 圖像顯示 fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 8), dpi=100) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("原圖") axes[1].imshow(dst[:, :, ::-1]) axes[1].set_title("平移后結果") plt.show()

out：

3.1.3 圖像旋轉

圖像旋轉是指圖像按照某個位置轉動一定角度的過程，旋轉中圖像仍然保持原始尺寸。

同樣地，圖像的選擇也需要提供一個矩陣，我們在此稱其為旋轉矩陣，在openCV中，通過cv2.getRotationMatrix2D可以返回一個矩陣。

cv.warpAffine(src,M,dsize)

• src：輸入的圖像
• M：旋轉矩陣
• dsize：輸出圖像的大小

cv.getRotationMatrix2D(center,anger,scale)

• center：旋轉中心
• angle：旋轉角度
• scale：縮放比例
• return：旋轉矩陣

import cv2 as cv import numpy as np import matplotlib.pyplot as plt import matplotlibmatplotlib.rcParams['font.family'] = 'SimHei'# 讀取圖像 img = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg")# 設置平移矩陣 rows, cols = img.shape[:2] M = cv.getRotationMatrix2D((100, 100), 30, 1) dst = cv.warpAffine(img, M, (cols, rows))# 圖像顯示 fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 8), dpi=100) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("原圖") axes[1].imshow(dst[:, :, ::-1]) axes[1].set_title("平移后結果") plt.show()

out：

3.1.4 仿射變換

圖像的仿射變換設計到圖像的形狀位置角度的變化，是深度學習預處理中常用到的一個功能。仿射變換的主要工作是對圖像進行縮放、旋轉、翻轉、平移的一系列組合操作。

仿射變換的內核是兩個點：

• 變換前是直線的，變換后依然是直線
• 直線比例保持不變

在OpenCV中，仿射變換的矩陣是一個2×3的矩陣。如下所示：
$$M=[A,B]=\left[\begin{array}{ccc}{a}_{00}& a_{01}& b_0\\ a_{10}& a_{11}& b_1\end{array}\right]$$
其中該矩陣的2×2子矩陣是線性變換矩陣，右邊2×1矩陣是平移項。

對于圖像中任一位置(x,y)，仿射變換執行的是如下的操作：

$T_{affine}=A\left[\begin{array}{c}x\\ y\end{array}\right]+B=M?\begin{array}{c}x\\ y\\ 1\end{array}?$

需要注意的是，對于圖像而言，寬度方向是x，高度方向是y，坐標的順序和圖像像素對應下標一致。所以原點的位置不是左下角而是右上角，y的方向也不是向上，而是向下。

在仿射變換中，原圖中所有的平行線在結果圖像中同樣平行。為了創建這個矩陣我們需要從原圖像中找到三個點以及它們在輸出圖像中的位置，然后通過OpenCV提供的cv2.getAffineTransform來創建仿射變換的2*3矩陣。

import cv2 as cv import numpy as np import matplotlib.pyplot as plt import matplotlibmatplotlib.rcParams['font.family'] = 'SimHei'# 讀取圖像 img = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg")# 設置平移矩陣 rows, cols = img.shape[:2] pts1 = np.float32([[50, 50], [200, 50], [50, 200]]) pts2 = np.float32([[100, 100], [200, 50], [100, 250]]) M = cv.getAffineTransform(pts1, pts2) dst = cv.warpAffine(img, M, (cols, rows))# 圖像顯示 fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 8), dpi=100) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("原圖") axes[1].imshow(dst[:, :, ::-1]) axes[1].set_title("平移后結果") plt.show()

out：

3.2 圖像閾值

ret,dst = cv2.threshold(src,thresh,maxval,type)

• src：輸入圖，只能輸入單通道圖像，通常來說為灰度圖
• dst：輸出圖
• thresh：閾值
• maxval：當像素值超過了閾值，所賦予的值
• type：二值化操作的類型
  • cv2.THRESH_BINARY：超過閾值部分取maxval，否則取0
  • cv2.THRESH_BINARY_INV：THRESH_BINARY的反轉
  • cv2.THRESH_TRUNC：大于閾值部分設為閾值，否則不變
  • cv2.THRESH_TOZERO：大于閾值部分不改變，否則設為0
  • cv2.THRESH_TOZERO_INV：cv2.THRESH_TOZERO的反轉

import cv2 import cv2 as cv import numpy as np import matplotlib.pyplot as pltimg = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg") ret, thresh1 = cv2.threshold(img, 127, 255, cv.THRESH_BINARY) ret, thresh2 = cv2.threshold(img, 127, 255, cv.THRESH_BINARY_INV) ret, thresh3 = cv2.threshold(img, 127, 255, cv.THRESH_TRUNC) ret, thresh4 = cv2.threshold(img, 127, 255, cv.THRESH_TOZERO) ret, thresh5 = cv2.threshold(img, 127, 255, cv.THRESH_TOZERO_INV)title = ['img', 'THRESH_BINARY', 'THRESH_BINARY_INV', 'THRESH_TRUNC','THRESH_TOZERO', 'THRESH_TOZERO_INV']fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(20, 8), dpi=80) axes[0][0].imshow(img[:, :, ::-1]) axes[0][0].set_title(title[0]) axes[0][1].imshow(thresh1[:, :, ::-1]) axes[0][1].set_title(title[1]) axes[0][2].imshow(thresh2[:, :, ::-1]) axes[0][2].set_title(title[2]) axes[1][0].imshow(thresh3[:, :, ::-1]) axes[1][0].set_title(title[3]) axes[1][1].imshow(thresh4[:, :, ::-1]) axes[1][1].set_title(title[4]) axes[1][2].imshow(thresh5[:, :, ::-1]) axes[1][2].set_title(title[5]) plt.show()

out：

3.3 圖像平滑

3.3.1 圖像噪聲

由于圖像采集、處理、傳輸等過程不可避免的會受到噪聲的污染，妨礙人們對圖像理解及分析處理，常見的噪聲有高斯噪聲、椒鹽噪聲等。

3.3.1.1 椒鹽噪聲

椒鹽噪聲也稱為脈沖噪聲，是圖像中經常見到的一種噪聲，它是一種隨機出現的白點或者黑點，其出現的原因可能是因為影像訊號受到突如其來的強烈干擾而產生。如下圖所示：

3.3.1.2 高斯噪聲

高斯噪聲滿足高斯分布。

3.3.2 均值濾波

均值濾波實際上就是深度學習里面的平均池化。

讓我們先給出一張帶有噪點的圖片，以便下面做處理。

我們來解釋一下池化的含義。

池化是卷積神經網絡CNN的術語。認識什么是池化之前，我們要先了解什么是卷積，卷積就是通過一個小型矩陣（卷積核）對原圖片矩陣做掃描來輸入另外一個矩陣，這個另外的矩陣我們叫做卷積層。

小型矩陣和原圖片矩陣的映射關系是通過互相關運算來實現的，即對應的元素相乘在相加。如下圖所示：

理解了原理就好說了。池化層也是通過某種關系來輸出新矩陣的，根據這種關系我們將池化層分為平均池化層和最大池化層，其本質是用一個n×n的卷積核去掃描，而這個卷積核是沒有數字的，且他也不和原圖片做互相關運算。如果是平均池化層，那么是輸出卷積核覆蓋區域的平均數；而如果是最大池化層，則輸出卷積核覆蓋區域的最大數。

舉個例子，用2×2的池化窗口去掃描，如果窗口內的值是

• max(0,1,3,4)=4,

• max(1,2,4,5)=5,

• max(3,4,6,7)=7,

• max(4,5,7,8)=8。

說完了池化，讓我們回到濾波器。實際上，均值濾波的本質實際上就是平均池化窗口。

讓我們試著對上面的圖片做一下均值濾波處理。

import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test03.jpg") blur_img = cv.blur(img, (3, 3)) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(blur_img[:, :, ::-1]) axes[1].set_title("blur_img") plt.show()

out：

3.3.3 方框濾波

cv2.boxFilter( src, ddepth, ksize, anchor, normalize, borderType)

• src指的是處理的圖像
• ddepth：處理結果圖像的圖像深度,一般使用1 表示與原始圖像使用相同的圖像深度
• normalize：是否進行歸一化

方框濾波使用歸一化時效果和均值濾波完全一樣，而不使用歸一化時，超過255的像素點默認會變成255,，如下所示。

import cv2 as cv import matplotlib.pyplot as pltimg = cv.imread(r"C:\Users\13966\Desktop\Test03.jpg") blur_img = cv.boxFilter(img, -1, (3, 3), normalize=False) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(blur_img[:, :, ::-1]) axes[1].set_title("blur_img") plt.show()

out：

3.3.4 高斯濾波

cv2.GaussianBlur(src, ksize, sigmaX, sigmaY=0, borderType=BORDER_DEFAULT);

• src：輸入圖像

• ksize：高斯卷積核的大小

• sigmaX：表示水平方向的標準差

sigmaY：表示垂直方向的標準差，默認為0，表示于sigmaX相同

• borderType：邊緣填充類型，默認無填充

高斯濾波器（卷積核）里的數值滿足高斯分布。

高斯濾波是一種線性平滑濾波，適用于消除高斯噪聲，廣泛應用于圖像處理的減噪過程。通俗的講，高斯濾波就是對整幅圖像進行加權平均的過程，每一個像素點的值，都由其本身和領域內的其他像素值經過加權平均后得到。

import cv2 as cv import matplotlib.pyplot as pltimg = cv.imread(r"C:\Users\13966\Desktop\Test03.jpg") blur_img = cv.GaussianBlur(img, (3, 3), 1) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(blur_img[:, :, ::-1]) axes[1].set_title("blur_img") plt.show()

out：

3.3.5 中值濾波

中值濾波是效果最好的濾波器，它是這么做的。用一個n×n（n一般為奇數）的卷積核去掃描一副圖像，在卷積核每一次覆蓋到的位置中，將里面所有的數字從小到大排列后取中位數，用中位數替換卷積核所在位置的中間值。如下圖所示：

import cv2 as cv import matplotlib.pyplot as pltimg = cv.imread(r"C:\Users\13966\Desktop\Test03.jpg") blur_img = cv.medianBlur(img, 5) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(blur_img[:, :, ::-1]) axes[1].set_title("blur_img") plt.show()

out：

3.3.6 小結

圖像處理中，常用的濾波算法有均值濾波、中值濾波以及高斯濾波等。

兩種噪聲：

噪聲說明

椒鹽噪聲	圖像中隨機出現的白點或者黑點
高斯噪聲	噪聲的概率分布是正態分布

三種濾波器的對比：

濾波器種類基本原理特點

均值濾波	使用模板內所有像素的平均值代替模板中心像素灰度值	算法簡單計算速度快，易收到噪聲的干擾，不能完全消除噪聲，只能相對減弱噪聲
中值濾波	計算模板內所有像素中的中值，并用所計算出來的中值體改模板中心像素的灰度值	對噪聲不是那么敏感，能夠較好的消除椒鹽噪聲，但是容易導致圖像的不連續性
高斯濾波	對圖像鄰域內像素進行平滑時，鄰域內不同位置的像素被賦予不同的權值	對圖像進行平滑的同時，同時能夠更多的保留圖像的總體灰度分布特征，對于高斯噪聲處理效果很好

我不是很建議你在初次學習的時候深究這些濾波器背后的數學原理，因為對于數學基礎不好的人來說一旦陷進去對自己的打擊很大。

3.4 形態學操作

形態學轉換是基于圖像形狀的一些簡單操作，它通常在二進制圖像上執行。腐蝕和膨脹是兩個基本的形態學運算符，他也有一些變體形式，如開運算、閉運算、禮帽黑帽等。

3.4.1 連通性

3.4.1.1 鄰接

在圖像中，最小的單位是像素，每個像素周圍有8個鄰接像素。常見的鄰接關系有3種：4鄰接、8鄰接和D鄰接。

其中我們用$N_4(p)$表示像素p的4鄰接，同理$N_D(p)$,$N_8(p)$。

3.4.1.2 連通

連通性是描述區域和邊界的重要概念，兩個像素連通的兩個必要條件是：

• 兩個像素的位置是否相鄰
• 兩個像素的灰度值是否滿足特定的相似性準則

連通也分三種，即4連通、8連通和m連通。

• 4連通：對于具有值V的像素p和q，如果q在集合$N_4(p)$中，則稱這兩個像素是4連通。
• 8連通：對于具有值V的像素p和q，如果q在集合$N_8(p)$中，則稱這兩個像素是8連通。

• m連通：m連通就是同時滿足4連通和D連通即為m連通。

3.4.2 腐蝕和膨脹

腐蝕和膨脹是最基本的形態學操作，其都是針對白色部分而言。換而言之就是對高亮區域的擴大與縮小。

3.4.2.1 腐蝕

腐蝕的具體操作是用一個結構元素掃描圖像中的每一個元素，用結構元素中的每一個元素與其覆蓋的像素做“與”操作，如果都為1，則該像素為1，否則為0。如下圖所示，結構A被結構B（我們暫且看做是卷積核）腐蝕后：

腐蝕的作用就是消除物體邊界點，使目標縮小，其可以消除小于結構元素的噪聲點。通俗來說就是讓白色部分變小。

cv.erode(src,kernel,iterations，borderType,bordervalue)

• src：要處理的圖像
• kernel：核結構
• iterations：腐蝕次數，默認為1
• borderType：填充類型
• bordervalue：填充值

import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test03.jpg") kernel = np.ones((5, 5)) new_img = cv.erode(img, kernel) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

out：

3.4.2.2 膨脹

膨脹的具體操作是用一個結構元素掃描圖像中的每一個元素，用結構元素中的每一個元素與其覆蓋的像素做“與”操作，如果都為0，則該像素為0，否則為1。其原理和腐蝕很像的，我就不畫圖了，太累了。通俗來講，膨脹實際上就是擴大白色部分。

cv.dilate(src,kernel,iterations，borderType,bordervalue)

• src：要處理的圖像
• kernel：核結構
• iterations：腐蝕次數，默認為1
• borderType：填充類型
• bordervalue：填充值

import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test03.jpg") kernel = np.ones((5, 5)) new_img = cv.dilate(img, kernel) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

out：

3.4.3 開閉運算

開運算和閉運算和按照一定的次序去進行腐蝕和膨脹，但將原圖開運算后是無法通過閉運算返回原圖的。

開運算是先腐蝕后膨脹，其作用是分離物體，消除小區域。說成人話就是，如果你的圖像是全是黑的，但是其中有一些白色的噪聲點，那么開運算可以使你的圖片先去除白色噪聲，然后又恢復原來的圖片，這實際上是一個去除毛刺的操作；閉運算是先膨脹后腐蝕，其作用是消除/閉合物體里面的孔洞，可以填充閉合區域。說成人話就是，先膨脹讓白色噪聲變大，后腐蝕白色噪聲就無法消除了，所以所得圖片應該是和原圖差不多的白色噪聲或比原圖還大的白色噪聲。說了我們也聽不太懂，我們試著來處理一下。

cv.morphologyEx(src,op,kernel)

• src：要處理的圖像
• op：處理的方式，進行開運算則cv.MORPH_OPEN，若進行閉運算，則設為cv.MORPH_CLOSE
• Kernel：核結構

import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg") kernel = np.ones((3, 3)) new_img = cv.morphologyEx(img, cv.MORPH_OPEN, kernel) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

有沒有感覺，這車子有點快跑出來的感覺。

import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg") kernel = np.ones((3, 3)) new_img = cv.morphologyEx(img, cv.MORPH_CLOSE, kernel) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

3.4.4 黑帽和禮帽

禮帽運算實際上是原圖像和開運算結果之差。

試想，開運算實際上就是消除白色毛刺，而原圖像又帶有刺，你用帶有刺的減去沒帶刺的，得到的結果（禮帽）不就是只有刺的圖了嗎。

開運算雖然優化了圖片，但是放大了裂縫或者局部低亮度的區域，因此，從原圖中減去開運算后的圖，得到的效果圖突出了比原圖輪廓周圍的區域更明亮的區域，且這一操作和選擇的核的大小有關。

而黑帽運算實際上是閉運算和原圖像之差。簡單來說，閉運算使得噪聲變大或不變，減去原圖像，得到的就是噪聲的輪廓。

黑帽運算后的效果圖突出了比原圖輪廓周圍的區域更暗的區域，且這一操作和選擇的核的大小有關。

黑帽運算用來分離比鄰近點暗一些的斑塊。

同樣的，黑帽運算和禮帽運算使用的是與開閉運算一樣的API。

cv.morphologyEx(src,op,kernel)

• op部分選擇MORPH_TOPHAT則為禮帽，選擇MORPH_BLACKHAT則為黑帽

import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test01.jpg") kernel = np.ones((3, 3)) #new_img = cv.morphologyEx(img, cv.MORPH_TOPHAT, kernel) new_img = cv.morphologyEx(img, cv.MORPH_BLACKHAT, kernel) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

out：

3.4.5 梯度

做一個梯度運算實際上就是先膨脹，再拿原圖膨脹的結果減去原圖腐蝕的結果。膨脹擴大白色區域，腐蝕縮小白色區域，兩個一做差，那么得到的肯定是白色區域的輪廓。如下圖所示：

import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test04.jpg") kernel = np.ones((3, 3)) new_img = cv.morphologyEx(img, cv.MORPH_GRADIENT, kernel) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

3.5 圖像梯度處理

3.5.1 Sobel算子

如上圖，我們如果在圖中畫一根紅線，紅線的左右有梯度嗎？明顯地，這里我們講的梯度可以用一個更簡單的詞來代替，即色差。可以看出，這條紅線左右是不存在梯度的。

那我們不禁想問，哪里有梯度呢？當然是這個白圈的邊緣了。

在形態學操作中，我們似乎都是用一個核去掃描圖像，在這里我們同樣這么做。我們可以用以下的卷積核去檢測區域的左右邊緣。
$$G_x=?\begin{array}{ccc}?1& 0& +1\\ ?2& 0& +2\\ ?1& 0& +1\end{array}??A$$
我們可以用以下的卷積核去檢測區域的上下邊緣。
$$G_y=?\begin{array}{ccc}?1& ?2& ?1\\ 0& 0& 0\\ +1& +2& +1\end{array}??A$$
我們把以上兩個卷積核叫做Sobel算子矩陣，其用于增強邊緣的差異。當檢測目標區域邊緣時，我們可以用對應的核與目標區域做互相關運算。拿$G_x$來說，其計算的結果我們可以看成是0列左右的差異值，即看成是梯度。

說完原理，讓我們看一下在OpenCV中如何使用Sobel算子。

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

• ddeph：圖像深度
• dx和dy分別表示水平和豎直方向
• ksize是Sobel算子的大小

import cv2 import cv2 as cv import matplotlib.pyplot as pltimg = cv.imread(r"C:\Users\13966\Desktop\Test04.jpg") new_img = cv.Sobel(img, cv2.CV_64F, 1, 0, ksize=3) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

out：

從指定參數和輸出結果來看，由于在sobel中我們指定參數dy = 0，dx = 1，說明使用上述Sobel算子矩陣$G_x$。此矩陣右邊為正左邊為負。在圖像中，看往左半邊圓圈為白(255)方框為黑(0)，則結果Sobel運算后得出結果為正數，所以得出的圖像左半圈留白明顯。其他情況也可按照上述推導過程推出結果，這里不過多贅述。

在Sobel運算中，白到黑是正數，黑到白是負數，而負數會被截斷成0，所以通常我們要取絕對值。

import cv2 import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test04.jpg") # kernel = np.ones((3, 3)) new_img = cv.Sobel(img, cv2.CV_64F, 1, 0, ksize=3) new_img = cv2.convertScaleAbs(new_img) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

out：

當你想要同時檢測左右邊緣和上下邊緣時，同時對參數dx和dy設為1未嘗不可，但是由于dx設為1時上下會黑，dy設為1時左右會黑，當同時開啟時，可以會導致上下左右都會黑，而不會出現完美檢測輪廓的效果。如下圖所示：

import cv2 import cv2 as cv import matplotlib.pyplot as pltimg = cv.imread(r"C:\Users\13966\Desktop\Test04.jpg") new_img = cv.Sobel(img, cv2.CV_64F, 1, 1, ksize=3) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

out：

為此，我們可以分別求解$G_x$和$G_y$，然后將兩者用圖像混合操作按比例混合即可。如下所示：

import cv2 import cv2 as cv import matplotlib.pyplot as plt import numpy as npimg = cv.imread(r"C:\Users\13966\Desktop\Test04.jpg") new_img_x = cv.Sobel(img, cv2.CV_64F, 1, 0, ksize=3) new_img_y = cv.Sobel(img, cv2.CV_64F, 0, 1, ksize=3) new_img = cv.addWeighted(new_img_x, 0.5, new_img_y, 0.5, 0) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("image") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("new_img") plt.show()

out：

上面的圖片似乎不是很能看出效果，我們用另外一張圖片來看看效果：

import cv2 import cv2 as cv import matplotlib.pyplot as plt import matplotlibmatplotlib.rcParams['font.family']='SimHei'img = cv.imread(r"C:\Users\13966\Desktop\Test02.jpg") new_img = cv.Sobel(img, cv2.CV_64F, 1, 1, ksize=3) new_img_x = cv.Sobel(img, cv2.CV_64F, 1, 0, ksize=3) new_img_y = cv.Sobel(img, cv2.CV_64F, 0, 1, ksize=3) new_img1 = cv.addWeighted(new_img_x, 0.5, new_img_y, 0.5, 0) fig, axes = plt.subplots(nrows=1, ncols=3) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("原圖") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("指定參數效果") axes[2].imshow(new_img1[:, :, ::-1]) axes[2].set_title("混合效果") plt.show()

out：

3.5.2 Scharr算子

Scharr算子與Sobel算子類似，只不過它對于邊緣的檢測效果會放大。
$$G_x=?\begin{array}{ccc}?3& 0& 3\\ ?10& 0& 10\\ ?3& 0& 3\end{array}??A$$

$$G_y=?\begin{array}{ccc}?3& ?10& ?3\\ 0& 0& 0\\ ?3& ?10& ?3\end{array}??A$$

我們來看看它對于圖片的處理效果：

import cv2 import cv2 as cv import matplotlib.pyplot as plt import matplotlibmatplotlib.rcParams['font.family'] = 'SimHei'img = cv.imread(r"C:\Users\13966\Desktop\Test02.jpg") new_img_x = cv.Scharr(img, cv2.CV_64F, 1, 0) new_img_y = cv.Scharr(img, cv2.CV_64F, 0, 1) new_img = cv.addWeighted(new_img_x, 0.5, new_img_y, 0.5, 0) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("原圖") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("Scharr算子效果") plt.show()

out：

3.5.3 laplacian算子

laplacian算子和上述兩個算子不同，其由二階導組成，對于一些邊緣十分敏感，這雖然能夠提高精度，但是卻易受噪點影響。
$$G=?\begin{array}{ccc}0& 1& 3\\ 1& ?4& 1\\ 0& 1& 0\end{array}?$$
對于拉普拉斯算子，其由于是二階導，所以不必在添加dx和dy參數。如下所示：

import cv2 import cv2 as cv import matplotlib.pyplot as plt import matplotlibmatplotlib.rcParams['font.family'] = 'SimHei'img = cv.imread(r"C:\Users\13966\Desktop\Test02.jpg") new_img = cv.Laplacian(img, cv2.CV_64F) fig, axes = plt.subplots(nrows=1, ncols=2) axes[0].imshow(img[:, :, ::-1]) axes[0].set_title("原圖") axes[1].imshow(new_img[:, :, ::-1]) axes[1].set_title("拉普拉斯算子效果") plt.show()

out：

總結

以上是生活随笔為你收集整理的OpenCV修养（三）——图像处理（上）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。