原文鏈接：http://coolshell.cn/articles/10590.html#jtss-tsina

識別二維碼的項目數不勝數，每次都是開箱即用，方便得很。

這次想用 OpenCV 從零識別二維碼，主要是溫習一下圖像處理方面的基礎概念，熟悉 OpenCV 的常見操作，以及了解二維碼識別和編碼的基本原理。

作者本人在圖像處理方面還是一名新手，采用的方法大多原始粗暴，如果有更好的解決方案歡迎指教。

QRCode

二維碼有很多種，這里我選擇的是比較常見的 QRCode 作為探索對象。QRCode 全名是 Quick Response Code，是一種可以快速識別的二維碼。

尺寸

QRCode 有不同的 Version ，不同的 Version 對應著不同的尺寸。將最小單位的黑白塊稱為 module ，則 QRCode 尺寸的公式如下：

Version V = ((V-1)*4 + 21) ^ 2 modules

常見的 QRCode 一共有40種尺寸：

• Version 1 : 21 * 21 modules
• Version 2 : 25 * 25 modules
• …
• Version 40: 177 * 177 modules

分類

QRCode 分為 Model 1、Model 2、Micro QR 三類：

• Model 1 ：是 Model 2 和 Micro QR 的原型，有 Version 1 到 Version 14 共14種尺寸。
• Model 2 ：是 Model 1 的改良版本，添加了對齊標記，有 Version 1 到 Version 40 共40種尺寸。
• Micro QR ：只有一個定位標記，最小尺寸是 11*11 modules 。

組成

QRCode 主要由以下

QRCode 主要由以下部分組成：

• 1 - Position Detection Pattern：位于三個角落，可以快速檢測二維碼位置。
• 2 - Separators：一個單位寬的分割線，提高二維碼位置檢測的效率。
• 3 - Timing Pattern：黑白相間，用于修正坐標系。
• 4 - Alignment Patterns：提高二維碼在失真情況下的識別率。
• 5 - Format Information：格式信息，包含了錯誤修正級別和掩碼圖案。
• 6 - Data：真正的數據部分。
• 7 - Error Correction：用于錯誤修正，和 Data 部分格式相同。

具體的生成原理和識別細節可以閱讀文末的參考文獻，比如耗子叔的這篇《 二維碼的生成細節和原理 》。

由于二維碼的解碼步驟比較復雜，而本次學習重點是數字圖像處理相關的內容，所以本文主要是解決二維碼的識別定位問題，數據解碼的工作交給第三方庫（比如 ZBAR ）完成。

OpenCV

在開始識別二維碼之前，還需要補補課，了解一些圖像處理相關的基本概念。

contours

輪廓（contour）可以簡單理解為一段連續的像素點。比如一個長方形的邊，比如一條線，比如一個點，都屬于輪廓。而輪廓之間有一定的層級關系，以下圖為例：

主要說明以下概念：

• external & internal：對于最大的包圍盒而言，2 是外部輪廓（external），2a 是內部輪廓（internal）。
• parent & child：2 是 2a 的父輪廓（parent），2a 是 2 的子輪廓（child），3 是 2a 的子輪廓，同理，3a 是 3 的子輪廓，4 和 5 都是 3a 的子輪廓。
• external | outermost：0、1、2 都屬于最外圍輪廓（outermost）。
• hierarchy level：0、1、2 是同一層級（same hierarchy），都屬于 hierarchy-0 ，它們的第一層子輪廓屬于 hierarchy-1 。
• first child：4 是 3a 的第一個子輪廓（first child）。實際上 5 也可以，這個看個人喜好了。

在 OpenCV 中，通過一個數組表達輪廓的層級關系：

[Next, Previous, First_Child, Parent]

• Next：同一層級的下一個輪廓。在上圖中， 0 的 Next 就是 1 ，1 的 Next 就是 2 ，2 的 Next 是 -1 ，表示沒有下一個同級輪廓。
• Previous：同一層級的上一個輪廓。比如 5 的 Previous 是 4， 1 的 Previous 就是 0 ，0 的 Previous 是 -1 。
• First_Child：第一個子輪廓，比如 2 的 First_Child 就是 2a ，像 3a 這種有兩個 Child ，只取第一個，比如選擇 4 作為 First_Child 。
• Parent：父輪廓，比如 4 和 5 的 Parent 都是 3a ，3a 的 Parent 是 3 。

關于輪廓層級的問題，參考閱讀：《 Tutorial: Contours Hierarchy 》

findContours

了解了 contour 相關的基礎概念之后，接下來就是在 OpenCV 里的具體代碼了。

findContours 是尋找輪廓的函數，函數定義如下：

cv2.findContours(image, mode, method) → image, contours, hierarchy

其中：

• image：資源圖片，8 bit 單通道，一般需要將普通的 BGR 圖片通過 cvtColor 函數轉換。
• mode：邊緣檢測的模式，包括：
  • CV_RETR_EXTERNAL：只檢索最大的外部輪廓（extreme outer），沒有層級關系，只取根節點的輪廓。
  • CV_RETR_LIST：檢索所有輪廓，但是沒有 Parent 和 Child 的層級關系，所有輪廓都是同級的。
  • CV_RETR_CCOMP：檢索所有輪廓，并且按照二級結構組織：外輪廓和內輪廓。以前面的大圖為例，0、1、2、3、4、5 都屬于第0層，2a 和 3a 都屬于第1層。
  • CV_RETR_TREE：檢索所有輪廓，并且按照嵌套關系組織層級。以前面的大圖為例，0、1、2 屬于第0層，2a 屬于第1層，3 屬于第2層，3a 屬于第3層，4、5 屬于第4層。
• method：邊緣近似的方法，包括：
  • CV_CHAIN_APPROX_NONE：嚴格存儲所有邊緣點，即：序列中任意兩個點的距離均為1。
  • CV_CHAIN_APPROX_SIMPLE：壓縮邊緣，通過頂點繪制輪廓。

drawContours

drawContours 是繪制邊緣的函數，可以傳入 findContours 函數返回的輪廓結果，在目標圖像上繪制輪廓。函數定義如下：

Python: cv2.drawContours(image, contours, contourIdx, color) → image

其中：

• image：目標圖像，直接修改目標的像素點，實現繪制。
• contours：需要繪制的邊緣數組。
• contourIdx：需要繪制的邊緣索引，如果全部繪制則為 -1。
• color：繪制的顏色，為 BGR 格式的 Scalar 。
• thickness：可選，繪制的密度，即描繪輪廓時所用的畫筆粗細。
• lineType: 可選，連線類型，分為以下幾種：
  • LINE_4：4-connected line，只有相鄰的點可以連接成線，一個點有四個相鄰的坑位。
  • LINE_8：8-connected line，相鄰的點或者斜對角相鄰的點可以連接成線，一個點有四個相鄰的坑位和四個斜對角相鄰的坑位，所以一共有8個坑位。
  • LINE_AA：antialiased line，抗鋸齒連線。
• hierarchy：可選，如果需要繪制某些層級的輪廓時作為層級關系傳入。
• maxLevel：可選，需要繪制的層級中的最大級別。如果為1，則只繪制最外層輪廓，如果為2，繪制最外層和第二層輪廓，以此類推。

moments

矩（moment）起源于物理學的力矩，最早由阿基米德提出，后來發展到統計學，再后來到數學進行歸納。本質上來講，物理學和統計學的矩都是數學上矩的特例。

物理學中的矩表示作用力促使物體繞著支點旋轉的趨向，通俗理解就像是擰螺絲時用的扭轉的力，由矢量和作用力組成。

數學中的矩用來描述數據分布特征的一類數字特征，例如：算術平均數、方差、標準差、平均差，這些值都是矩。在實數域上的實函數 f(x) 相對于值 c 的 n 階矩為：

常用的矩有兩類：

• 原點矩（raw moment）：相對原點的矩，即當 c 為 0 的時候。1階原點矩為期望，也成為中心。
• 中心矩（central moment）：相對于中心點的矩，即當 c 為 E(x) 的時候。1階中心矩為0，2階中心矩為方差。

到了圖像處理領域，對于灰度圖（單通道，每個像素點由一個數值來表示）而言，把坐標看成二維變量 (X, Y)，那么圖像可以用二維灰度密度函數 I(x, y) 來表示。

簡單來講，圖像的矩就是圖像的像素相對于某個點的分布情況統計，是圖像的一種特征描述。

raw moment

圖像的原點矩（raw moment）是相對于原點的矩，公式為：

對于圖像的原點矩而言：

• M ₀₀ 相當于權重系數為 1 。將所有 I(x, y) 相加，對于二值圖像而言，相當于將每個點記為 1 然后求和，也就是圖像的面積；對于灰度圖像而言，則是圖像的灰度值的和。
• M ₁₀ 相當于權重為 x 。對二值圖像而言，相當于將所有的 x 坐標相加。
• M ₀₁ 相當于權重為 y 。對二值圖像而言，相當于將所有的 y 坐標相加。
• 圖像的幾何中心（centroid）等于 (M ₁₀ / M ₀₀ , M ₀₁ / M ₀₀ )。

central moment

圖像的中心矩（central moment）是相對于幾何中心的矩，公式為：

可以看到，中心矩表現的是圖像相對于幾何中心的分布情況。一個通用的描述中心矩和原點矩關系的公式是：

中心矩在圖像處理中的一個應用便是尋找不變矩（invariant moments），這是一個高度濃縮的圖像特征。

所謂的不變性有三種，分別對應圖像處理中的三種仿射變換：

• 平移不變性（translation invariants）：中心矩本身就具有平移不變性，因為它是相對于自身的中心的分布統計，相當于是采用了相對坐標系，而平移改變的是整體坐標。
• 縮放不變性（scale invariants）：為了實現縮放不變性，可以構造一個規格化的中心矩，即將中心矩除以 (1+(i+j)/2) 階的0階中心矩，具體公式見 《 Wiki: scale invariants 》。
• 旋轉不變性（rotation invariants）：通過2階和3階的規格化中心矩可以構建7個不變矩組，構成的特征量具有旋轉不變性。具體可以看 《 Wiki: rotation invariants 》。

Hu moment 和 Zernike moment 之類的內容就不繼續展開了，感興趣的可以翻閱相關文章。

OpenCV + QRCode

接下來就是將 QRCode 和 OpenCV 結合起來的具體使用了。

初步構想的識別步驟如下：

• 加載圖像，并且進行一些預處理，比如通過高斯模糊去噪。
• 通過 Canny 邊緣檢測算法，找出圖像中的邊緣
• 尋找邊緣中的輪廓，將嵌套層數大于 4 的邊緣找出，得到 Position Detection Pattern 。
• 如果上一步得到的結果不為 3 ，則通過 Timing Pattern 去除錯誤答案。
• 計算定位標記的最小矩形包圍盒，獲得三個最外圍頂點，算出第四個頂點，從而確定二維碼的區域。
• 計算定位標記的幾何中心，連線組成三角形，從而修正坐標，得到仿射變換前的 QRCode 。

在接下來的內容里，將會嘗試用 OpenCV 識別下圖中的二維碼：

加載圖像

首先加載圖像，并通過 matplotlib 顯示圖像查看效果：

%matplotlib inline
import cv2
from matplotlib import pyplot as plt
import numpy as np def show(img, code=cv2.COLOR_BGR2RGB): cv_rgb = cv2.cvtColor(img, code) fig, ax = plt.subplots(figsize=(16, 10)) ax.imshow(cv_rgb) fig.show() img = cv2.imread('1.jpg') show(img) 

OpenCV 中默認是 BGR 通道，通過 cvtColor 函數將原圖轉換成灰度圖：

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

邊緣檢測

有了灰度圖之后，接下來用 Canny 邊緣檢測算法檢測邊緣。

Canny 邊緣檢測算法主要是以下幾個步驟：

• 用高斯濾波器平滑圖像去除噪聲干擾（低通濾波器消除高頻噪聲）。
• 生成每個點的亮度梯度圖（intensity gradients），以及亮度梯度的方向。
• 通過非極大值抑制（non-maximum suppression）縮小邊緣寬度。非極大值抑制的意思是，只保留梯度方向上的極大值，刪除其他非極大值，從而實現銳化的效果。
• 通過雙閾值法（double threshold）尋找潛在邊緣。大于高閾值為強邊緣（strong edge），保留；小于低閾值則刪除；不大不小的為弱邊緣（weak edge），待定。
• 通過遲滯現象（Hysteresis）處理待定邊緣。弱邊緣有可能是邊緣，也可能是噪音，判斷標準是：如果一個弱邊緣點附近的八個相鄰點中，存在一個強邊緣，則此弱邊緣為強邊緣，否則排除。

在 OpenCV 中可以直接使用 Canny 函數，不過在那之前要先用 GaussianBlur 函數進行高斯模糊：

img_gb = cv2.GaussianBlur(img_gray, (5, 5), 0)

接下來使用 Canny 函數檢測邊緣，選擇 100 和 200 作為高低閾值：

edges = cv2.Canny(img_gray, 100 , 200)

執行結果如下：

可以看到圖像中的很多噪音都被處理掉了，只剩下了邊緣部分。

尋找定位標記

有了邊緣之后，接下來就是通過輪廓定位圖像中的二維碼。二維碼的 Position Detection Pattern 在尋找輪廓之后，應該是有6層（因為一條邊緣會被識別出兩個輪廓，外輪廓和內輪廓）：

所以，如果簡單處理的話，只要遍歷圖像的層級關系，然后嵌套層數大于等于5的取出來就可以了：

img_fc, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)hierarchy = hierarchy[0]
found = []
for i in range(len(contours)):k = ic = 0while hierarchy[k][2] != -1: k = hierarchy[k][2] c = c + 1 if c >= 5: found.append(i) for i in found: img_dc = img.copy() cv2.drawContours(img_dc, contours, i, (0, 255, 0), 3) show(img_dc) 

繪制結果如下：

定位篩選

接下來就是把所有找到的定位標記進行篩選。如果剛好找到三個那就可以直接跳過這一步了。然而，因為這張圖比較特殊，找出了四個定位標記，所以需要排除一個錯誤答案。

講真，如果只靠三個 Position Detection Pattern 組成的直角三角形，是沒辦法從這四個當中排除錯誤答案的。因為，一方面會有形變的影響，比如斜躺著的二維碼，本身三個頂點連線就不是直角三角形；另一方面，極端情況下，多余的那個標記如果位置比較湊巧的話，完全和正確結果一模一樣，比如下面這種情況：

所以我們需要 Timing Pattern 的幫助，也就是定位標記之間的黑白相間的那兩條黑白相間的線。解決思路大致如下：

• 將4個定位標記兩兩配對
• 將他們的4個頂點兩兩連線，選出最短的那兩根
• 如果兩根線都不符合 Timing Pattern 的特征，則出局

尋找定位標記的頂點

找的的定位標記是一個輪廓結果，由許多像素點組成。如果想找到定位標記的頂點，則需要找到定位標記的矩形包圍盒。先通過 minAreaRect 函數將檢查到的輪廓轉換成最小矩形包圍盒，并且繪制出來：

draw_img = img.copy()
for i in found:rect = cv2.minAreaRect(contours[i])box = cv2.boxPoints(rect)box = np.int0(box)cv2.drawContours(draw_img,[box], 0, (0,0,255), 2) show(draw_img) 

繪制如下：

這個矩形包圍盒的四個坐標點就是頂點，將它存儲在 boxes 中：

boxes = []
for i in found:rect = cv2.minAreaRect(contours[i])box = cv2.boxPoints(rect)box = np.int0(box)box = map(tuple, box)boxes.append(box)

定位標記的頂點連線

接下來先遍歷所有頂點連線，然后從中選擇最短的兩根，并將它們繪制出來：

def cv_distance(P, Q):return int(math.sqrt(pow((P[0] - Q[0]), 2) + pow((P[1] - Q[1]),2))) def check(a, b): # 存儲 ab 數組里最短的兩點的組合 s1_ab = () s2_ab = () # 存儲 ab 數組里最短的兩點的距離，用于比較 s1 = np.iinfo('i').max s2 = s1 for ai in a: for bi in b: d = cv_distance(ai, bi) if d < s2: if d < s1: s1_ab, s2_ab = (ai, bi), s1_ab s1, s2 = d, s1 else: s2_ab = (ai, bi) s2 = d a1, a2 = s1_ab[0], s2_ab[0] b1, b2 = s1_ab[1], s2_ab[1] # 將最短的兩個線畫出來 cv2.line(draw_img, a1, b1, (0,0,255), 3) cv2.line(draw_img, a2, b2, (0,0,255), 3) for i in range(len(boxes)): for j in range(i+1, len(boxes)): check(boxes[i], boxes[j]) show(draw_img) 

繪制結果如下：

獲取連線上的像素值

有了端點連線，接下來需要獲取連線上的像素值，以便后面判斷是否是 Timing Pattern 。

在這之前，為了更方便的判斷黑白相間的情況，先對圖像進行二值化：

th, bi_img = cv2.threshold(img_gray, 100, 255, cv2.THRESH_BINARY)

接下來是獲取連線像素值。由于 OpenCV3 的 Python 庫中沒有 LineIterator ，只好自己寫一個。在《 OpenCV 3.0 Python LineIterator 》這個問答里找到了可用的直線遍歷函數，可以直接使用。

以一條 Timing Pattern 為例：

打印其像素點看下結果：

[ 255.  255.  255.  255.  255. 255. 255. 255. 255. 255. 255. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 255. 255. 255. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 0. 0. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255.] 

修正端點位置

照理說， Timing Pattern 的連線，像素值應該是黑白均勻相間才對，為什么是上面的這種一連一大片的結果呢？

仔細看下截圖可以發現，由于取的是定位標記的外部包圍盒的頂點，所以因為誤差會超出定位標記的范圍，導致沒能正確定位到 Timing Pattern ，而是相鄰的 Data 部分的像素點。

為了修正這部分誤差，我們可以對端點坐標進行調整。因為 Position Detection Pattern 的大小是固定的，是一個 1-1-3-1-1 的黑白黑白黑相間的正方形，識別 Timing Pattern 的最佳端點應該是最靠里的黑色區域的中心位置，也就是圖中的綠色虛線部分：

所以我們需要對端點坐標進行調整。調整方式是，將一個端點的 x 和 y 值向另一個端點的 x 和 y 值靠近 1/14 個單位距離，代碼如下：

a1 = (a1[0] + (a2[0]-a1[0])*1/14, a1[1] + (a2[1]-a1[1])*1/14) b1 = (b1[0] + (b2[0]-b1[0])*1/14, b1[1] + (b2[1]-b1[1])*1/14) a2 = (a2[0] + (a1[0]-a2[0])*1/14, a2[1] + (a1[1]-a2[1])*1/14) b2 = (b2[0] + (b1[0]-b2[0])*1/14, b2[1] + (b1[1]-b2[1])*1/14) 

調整之后的像素值就是正確的 Timing Pattern 了：

[ 255.  255.  255.  255.  255. 255. 255. 255. 255. 255. 255. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255. 255.] 

驗證是否是 Timing Pattern

像素序列拿到了，接下來就是判斷它是否是 Timing Pattern 了。 Timing Pattern 的特征是黑白均勻相間，所以每段同色區域的計數結果應該相同，而且旋轉拉伸平移都不會影響這個特征。

于是，驗證方案是：

• 先除去數組中開頭和結尾處連續的白色像素點。
• 對數組中的元素進行計數，相鄰的元素如果值相同則合并到計數結果中。比如 [0,1,1,1,0,0] 的計數結果就是 [1,3,2] 。
• 計數數組的長度如果小于 5 ，則不是 Timing Pattern 。
• 計算計數數組的方差，看看分布是否離散，如果方差大于閾值，則不是 Timing Pattern 。

代碼如下：

def isTimingPattern(line):# 除去開頭結尾的白色像素點 while line[0] != 0: line = line[1:] while line[-1] != 0: line = line[:-1] # 計數連續的黑白像素點 c = [] count = 1 l = line[0] for p in line[1:]: if p == l: count = count + 1 else: c.append(count) count = 1 l = p c.append(count) # 如果黑白間隔太少，直接排除 if len(c) < 5: return False # 計算方差，根據離散程度判斷是否是 Timing Pattern threshold = 5 return np.var(c) < threshold 

對前面的那條連線檢測一下，計數數組為：

[11, 12, 11, 12, 11, 12, 11, 13, 11] 

方差為 0.47 。其他非 Timing Pattern 的連線方差均大于 10 。

找出錯誤的定位標記

接下來就是利用前面的結果除去錯誤的定位標記了，只要兩個定位標記的端點連線中能找到 Timing Pattern ，則這兩個定位標記有效，把它們存進 set 里：

valid = set()
for i in range(len(boxes)):for j in range(i+1, len(boxes)): if check(boxes[i], boxes[j]): valid.add(i) valid.add(j) print valid 

結果是：

set([1, 2, 3])

好了，它們中出了一個叛徒，0、1、2、3 四個定位標記，0是無效的，1、2、3 才是需要識別的 QRCode 的定位標記。

找出二維碼

有了定位標記之后，找出二維碼就輕而易舉了。只要找出三個定位標記輪廓的最小矩形包圍盒，那就是二維碼的位置了：

contour_all = np.array([])
while len(valid) > 0:c = found[valid.pop()]for sublist in c:for p in sublist: contour_all.append(p) rect = cv2.minAreaRect(contour_ALL) box = cv2.boxPoints(rect) box = np.array(box) draw_img = img.copy() cv2.polylines(draw_img, np.int32([box]), True, (0, 0, 255), 10) show(draw_img) 

繪制結果如下：

小結

后面仿射變換后坐標修正的問題實在是寫不動了，這篇就先到這里吧。

回頭看看，是不是感覺繞了個大圈子？

『費了半天勁，只是為了告訴我第0個定位標記是無效的，我看圖也看出來了啊！』

是的，不過代碼里能看到的只是像素值和它們的坐標，為了排除這個錯誤答案確實花了不少功夫。

不過這也是我喜歡做數字圖像處理的原因之一：可用函數數不勝數，專業概念層出不窮，同樣的一個問題，不同的人去解決，就有著不同的答案，交流的過程便是學習的過程。

啊對了，如果有更好的解決方案，歡迎在評論里指出！

?

轉載于:https://www.cnblogs.com/jsxyhelu/p/6397118.html

總結

以上是生活随笔為你收集整理的转载：使用 OpenCV 识别 QRCode的全部內容，希望文章能夠幫你解決所遇到的問題。

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