OpenCV 基礎筆記
本文大部份內容來源於入門者的Python快速教程 - 番外篇之Python-OpenCVphp
本篇將介紹和深度學習數據處理階段最相關的基礎使用，並完成4個有趣實用的小例子：python
- 延時攝影小程序
- 視頻中截屏採樣的小程序
- 圖片數據增長（data augmentation）的小工具
- 物體檢測框標註小工具
1 OpenCV 簡介
OpenCV 是計算機視覺領域應用最普遍的開源工具包，基於 C/C++，支持 Linux/Windows/MacOS/Android/iOS，並提供了 Python，Matlab 和 Java 等語言的接口，由於其豐富的接口，優秀的性能和商業友好的使用許可，無論是學術界仍是業界中都很是受歡迎。OpenCV 最先源於 Intel 公司 1998 年的一個研究項目，當時在 Intel 從事計算機視覺的工程師蓋瑞·布拉德斯基(Gary Bradski)訪問一些大學和研究組時發現學生之間實現計算機視覺算法用的都是各自實驗室裏的內部代碼或者庫，這樣新來實驗室的學生就能基於前人寫的基本函數快速上手進行研究。因而 OpenCV 旨在提供一個用於計算機視覺的科研和商業應用的高性能通用庫。 第一個 alpha 版本的 OpenCV 於 2000 年的 CVPR 上發佈，在接下來的 5 年裏，又陸續發佈了 5 個 beta 版本，2006 年發佈了第一個正式版。2009 年隨着蓋瑞加入了 Willow Garage，OpenCV 從 Willow Garage 獲得了積極的支持，併發布了 1.1 版。2010 年 OpenCV 發佈了 2.0 版本，添加了很是完備的 C++ 接口，從 2.0 開始的版本很是用戶很是龐大，至今仍在維護和更新。2015 年 OpenCV 3 正式發佈，除了架構的調整，還加入了更多算法，更多性能的優化和更加簡潔的 API，另外也增強了對 GPU 的支持，如今已經在許多研究機構和商業公司中應用開來。算法
1.1 OpenCV 的結構
和 Python 同樣，當前的 OpenCV 也有兩個大版本，OpenCV2 和 OpenCV3。相比 OpenCV2，OpenCV3 提供了更強的功能和更多方便的特性。編程
根據功能和需求的不一樣，OpenCV 中的函數接口大致能夠分爲以下部分：canvas
core：核心模塊，主要包含了 OpenCV 中最基本的結構（矩陣，點線和形狀等），以及相關的基礎運算/操做。imgproc：圖像處理模塊，包含和圖像相關的基礎功能（濾波，梯度，改變大小等），以及一些衍生的高級功能（圖像分割，直方圖，形態分析和邊緣/直線提取等）。highgui：提供了用戶界面和文件讀取的基本函數，好比圖像顯示窗口的生成和控制，圖像/視頻文件的 IO 等。
若是不考慮視頻應用，以上三個就是最核心和經常使用的模塊了。針對視頻和一些特別的視覺應用，OpenCV 也提供了強勁的支持：小程序
video：用於視頻分析的經常使用功能，好比光流法（Optical Flow）和目標跟蹤等。calib3d：三維重建，立體視覺和相機標定等的相關功能。features2d：二維特徵相關的功能，主要是一些不受專利保護的，商業友好的特徵點檢測和匹配等功能，好比ORB特徵。object：目標檢測模塊，包含級聯分類和 Latent SVMml：機器學習算法模塊，包含一些視覺中最經常使用的傳統機器學習算法。flann：最近鄰算法庫，Fast Library for Approximate Nearest Neighbors，用於在多維空間進行聚類和檢索，常常和關鍵點匹配搭配使用。gpu：包含了一些gpu加速的接口，底層的加速是CUDA實現。photo：計算攝像學（Computational Photography）相關的接口，固然這只是個名字，其實只有圖像修復和降噪而已。stitching：圖像拼接模塊，有了它能夠本身生成全景照片。nonfree：受到專利保護的一些算法，其實就是 SIFT 和 SURF。contrib：一些實驗性質的算法，考慮在將來版本中加入的。legacy：字面是遺產，意思就是廢棄的一些接口，保留是考慮到向下兼容。ocl：利用OpenCL並行加速的一些接口。superres：超分辨率模塊，其實就是 BTV-L1（Biliteral Total Variation – L1 regularization）算法viz：基礎的 3D 渲染模塊，其實底層就是著名的3D工具包 VTK（Visualization Toolkit）。
從使用的角度來看，和 OpenCV2 相比，OpenCV3 的主要變化是更多的功能和更細化的模塊劃分。數組
1.2 安裝和使用 OpenCV
做爲最流行的視覺包，在 inux 安裝 penCV 很是方便的，大多數 Linux 發行版都支持包管理器的安裝，好比在 Ubuntu 16.04 LTS 中，只須要在終端中輸入：網絡
sudo apt install libopencv-dev python-opencv
在 Windows 下安裝也很簡單：數據結構
pip install -U opencv-python
2 Python-OpenCV 基礎
2.1 圖像的表示
單通道的灰度圖像在計算機中的表示，就是一個 \(8\) 位無符號整形的矩陣。在 OpenCV 的 C++ 代碼中，表示圖像有個專門的結構叫作 cv::Mat，不過在Python-OpenCV 中，由於已經有了 numpy 這種強大的基礎工具，因此這個矩陣就用 numpy 的 array 表示。若是是多通道狀況，最多見的就是紅綠藍（RGB）三通道，則第一個維度是高度，第二個維度是高度，第三個維度是通道。架構
上圖右上角的矩陣裏每一個元素都是一個 \(3\) 維數組，分別表明這個像素上的三個通道的值。最多見的 RGB 通道中，第一個元素就是紅色（Red）的值，第二個元素是綠色（Green）的值，第三個元素是藍色（Blue）。RGB 是最多見的狀況，然而在 OpenCV 中，默認的圖像的表示確實反過來的，也就是 BGR，獲得的圖像是 b。能夠看到，前兩行的顏色順序都交換了，最後一行是三個通道等值的灰度圖，因此沒有影響。至於 OpenCV 爲何不是人民羣衆喜聞樂見的RGB，這是歷史遺留問題，在 OpenCV 剛開始研發的年代，BGR 是相機設備廠商的主流表示方法，雖而後來 RGB 成了主流和默認，可是這個底層的順序卻保留下來了，事實上 Windows 下的最多見格式之一 bmp，底層字節的存儲順序仍是 BGR。OpenCV 的這個特殊之處仍是須要注意的，好比在 Python 中，圖像都是用 numpy 的 array 表示，可是一樣的 array 在 OpenCV 中的顯示效果和 matplotlib 中的顯示效果就會不同。下面的簡單代碼就能夠生成兩種表示方式下體會其中區別：
import numpy as np
import cv2
import matplotlib.pyplot as plt
# 圖6-1中的矩陣
img = np.array(
[
[[255, 0, 0], [0, 255, 0], [0, 0, 255]],
[[255, 255, 0], [255, 0, 255], [0, 255, 255]],
[[255, 255, 255], [128, 128, 128], [0, 0, 0]],
],
dtype=np.uint8)
# 用matplotlib存儲
plt.imsave('img_pyplot.jpg', img)
# 用OpenCV存儲
cv2.imwrite('img_cv2.jpg', img)
下面咱們來看看它們長什麼樣？
img_plt = plt.imread('img_pyplot.jpg')
img_cv = plt.imread('img_cv2.jpg')
plt.subplot(221)
plt.imshow(img_cv)
plt.title('cv2')
plt.axis('off')
plt.subplot(222)
plt.imshow(img_plt)
plt.title('pyplot')
plt.axis('off')
plt.show()
2.2 基本圖像處理
1. 存取圖像
讀圖像用 cv2.imread()，能夠按照不一樣模式讀取，通常最經常使用到的是讀取單通道灰度圖，或者直接默認讀取多通道。保存圖像用 cv2.imwrite()，注意存的時候是沒有單通道這一說的，根據保存文件名的後綴和當前的 array 維度，OpenCV 自動判斷存的通道，另外壓縮格式還能夠指定存儲質量，來看代碼例子：
import cv2
filename = 'D:/images/cartoon/j.jpeg'
# 讀取一張圖像
color_img = cv2.imread(filename)
print(color_img.shape)
# 直接讀取單通道
gray_img = cv2.imread(filename, cv2.IMREAD_GRAYSCALE)
print(gray_img.shape)
# 把單通道圖片保存後，再讀取，仍然是3通道，至關於把單通道值複製到3個通道保存
cv2.imwrite('test_grayscale.jpg', gray_img)
reload_grayscale = cv2.imread('test_grayscale.jpg')
print(reload_grayscale.shape)
# cv2.IMWRITE_JPEG_QUALITY指定jpg質量，範圍0到100，默認95，越高畫質越好，文件越大
cv2.imwrite('test_imwrite.jpg', color_img, (cv2.IMWRITE_JPEG_QUALITY, 80))
# cv2.IMWRITE_PNG_COMPRESSION指定png質量，範圍0到9，默認3，越高文件越小，畫質越差
cv2.imwrite('test_imwrite.png', color_img, (cv2.IMWRITE_PNG_COMPRESSION, 5))
(1078, 1918, 3) (1078, 1918) (1078, 1918, 3) True
因爲 pyplot 和 cv2 的存儲圖片的方式不一致，爲了使用 pyplt 來顯示 cv2.imread 獲取的數組，咱們須要有嚴格轉換函數：img = cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB)：
plt.rcParams['font.sans-serif'] = ['SimHei'] # 指定默認字體, 爲在 Matplotlib 中顯示中文，設置特殊字體
plt.rcParams['axes.unicode_minus'] = False # 解決保存圖像是負號 '-' 顯示爲方塊的問題
plt.subplot(221)
plt.imshow(color_img)
plt.title('轉換以前')
plt.axis('off')
plt.subplot(222)
plt.imshow(cv2.cvtColor(color_img, cv2.COLOR_BGR2RGB))
plt.title('轉換以後')
plt.axis('off')
plt.show()
2. 縮放，裁剪和補邊
縮放經過 cv2.resize() 實現，裁剪則是利用 array 自身的下標截取實現，此外 OpenCV 還能夠給圖像補邊，這樣能對一幅圖像的形狀和感興趣區域實現各類操做。下面的例子執行了一些基礎的操做：
import cv2
# 讀取一張照片
img = cv2.imread(filename)
# 縮放成200x200的方形圖像
img_200x200 = cv2.resize(img, (200, 200))
# 不直接指定縮放後大小，經過fx和fy指定縮放比例，0.5則長寬都爲原來一半
# 等效於img_200x300 = cv2.resize(img, (300, 200))，注意指定大小的格式是(寬度,高度)
# 插值方法默認是cv2.INTER_LINEAR，這裏指定爲最近鄰插值
img_200x300 = cv2.resize(img, (0, 0), fx=0.5, fy=0.5,
interpolation=cv2.INTER_NEAREST)
# 在上張圖片的基礎上，上下各貼50像素的黑邊，生成300x300的圖像
img_300x300 = cv2.copyMakeBorder(img, 50, 50, 0, 0,
cv2.BORDER_CONSTANT,
value=(0, 0, 0))
# 對照片中樹的部分進行剪裁
patch_tree = img[20:150, -180:-50]
cv2.imwrite('cropped_tree.jpg', patch_tree)
cv2.imwrite('resized_200x200.jpg', img_200x200)
cv2.imwrite('resized_200x300.jpg', img_200x300)
cv2.imwrite('bordered_300x300.jpg', img_300x300)
# show
plt.rcParams['font.sans-serif'] = ['SimHei'] # 指定默認字體, 爲在 Matplotlib 中顯示中文，設置特殊字體
plt.rcParams['axes.unicode_minus'] = False # 解決保存圖像是負號 '-' 顯示爲方塊的問題
plt.subplot(221)
img1 = plt.imread('cropped_tree.jpg')
plt.imshow(img1)
plt.title('cropped_tree.jpg')
plt.axis('off')
plt.subplot(222)
img2 = plt.imread('resized_200x200.jpg')
plt.imshow(img2)
plt.title('resized_200x200.jpg')
plt.axis('off')
plt.subplot(223)
img3 =plt.imread('resized_200x300.jpg')
plt.imshow(img3)
plt.title('resized_200x300.jpg')
plt.axis('off')
plt.subplot(224)
img4= plt.imread('bordered_300x300.jpg')
plt.imshow(img4)
plt.title('bordered_300x300.jpg')
plt.axis('off')
plt.show()
3. 色調，明暗，直方圖和 Gamma 曲線
除了區域，圖像自己的屬性操做也很是多，好比能夠經過 HSV 空間對色調和明暗進行調節。HSV空間是由美國的圖形學專家 A. R. Smith 提出的一種顏色空間，HSV 分別是色調（Hue），飽和度（Saturation）和明度（Value）。在 HSV 空間中進行調節就避免了直接在 RGB 空間中調節是還須要考慮三個通道的相關性。OpenCV中H的取值是 \([0, 180)\)，其餘兩個通道的取值都是 \([0, 256)\)，下面例子接着上面例子代碼，經過 HSV 空間對圖像進行調整：
# 經過cv2.cvtColor把圖像從BGR轉換到HSV
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
# H空間中，綠色比黃色的值高一點，因此給每一個像素+15，黃色的樹葉就會變綠
turn_green_hsv = img_hsv.copy()
turn_green_hsv[:, :, 0] = (turn_green_hsv[:, :, 0]+15) % 180
turn_green_img = cv2.cvtColor(turn_green_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('turn_green.jpg', turn_green_img)
# 減少飽和度會讓圖像損失鮮豔，變得更灰
colorless_hsv = img_hsv.copy()
colorless_hsv[:, :, 1] = 0.5 * colorless_hsv[:, :, 1]
colorless_img = cv2.cvtColor(colorless_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('colorless.jpg', colorless_img)
# 減少明度爲原來一半
darker_hsv = img_hsv.copy()
darker_hsv[:, :, 2] = 0.5 * darker_hsv[:, :, 2]
darker_img = cv2.cvtColor(darker_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('darker.jpg', darker_img)
for i, filename in enumerate(['turn_green.jpg', 'colorless.jpg', 'darker.jpg']):
plt.subplot(221 + i)
img1 = plt.imread(filename)
plt.imshow(img1)
plt.title(filename)
plt.axis('off')
plt.show()
不管是 HSV 仍是 RGB，咱們都較難一眼就對像素中值的分佈有細緻的瞭解，這時候就須要直方圖。若是直方圖中的成分過於靠近 \(0\) 或者 \(255\)，可能就出現了暗部細節不足或者亮部細節丟失的狀況。這個時候，一個經常使用方法是考慮用 Gamma 變換來提高暗部細節。Gamma 變換是矯正相機直接成像和人眼感覺圖像差異的一種經常使用手段，簡單來講就是經過非線性變換讓圖像從對曝光強度的線性響應變得更接近人眼感覺到的響應。具體的定義和實現，仍是接着上面代碼中讀取的圖片，執行計算直方圖和 Gamma 變換的代碼以下：
import numpy as np
# 分通道計算每一個通道的直方圖
hist_b = cv2.calcHist([img], [0], None, [256], [0, 256])
hist_g = cv2.calcHist([img], [1], None, [256], [0, 256])
hist_r = cv2.calcHist([img], [2], None, [256], [0, 256])
# 定義Gamma矯正的函數
def gamma_trans(img, gamma):
# 具體作法是先歸一化到1，而後gamma做爲指數值求出新的像素值再還原
gamma_table = [np.power(x / 255.0, gamma) * 255.0 for x in range(256)]
gamma_table = np.round(np.array(gamma_table)).astype(np.uint8)
# 實現這個映射用的是OpenCV的查表函數
return cv2.LUT(img, gamma_table)
# 執行Gamma矯正，小於1的值讓暗部細節大量提高，同時亮部細節少許提高
img_corrected = gamma_trans(img, 0.5)
cv2.imwrite('gamma_corrected.jpg', img_corrected)
# 分通道計算Gamma矯正後的直方圖
hist_b_corrected = cv2.calcHist([img_corrected], [0], None, [256], [0, 256])
hist_g_corrected = cv2.calcHist([img_corrected], [1], None, [256], [0, 256])
hist_r_corrected = cv2.calcHist([img_corrected], [2], None, [256], [0, 256])
# 將直方圖進行可視化
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
pix_hists = [[hist_b, hist_g, hist_r],
[hist_b_corrected, hist_g_corrected, hist_r_corrected]]
pix_vals = np.arange(256).reshape((-1, 1))
for sub_plt, pix_hist in zip([121, 122], pix_hists):
ax = fig.add_subplot(sub_plt, projection='3d')
for c, z, channel_hist in zip(['b', 'g', 'r'], [20, 10, 0], pix_hist):
cs = [c] * 256
ax.bar(
pix_vals,
channel_hist,
zs=z,
zdir='y',
color=cs,
alpha=0.618,
edgecolor='none',
lw=0)
ax.set_xlabel('Pixel Values')
ax.set_xlim([0, 256])
ax.set_ylabel('Channels')
ax.set_zlabel('Counts')
plt.show()
上圖左右兩邊分別是 Gamma 變換先後後的直方圖，下圖能夠看到，Gamma 變換後的暗部細節比起原圖清楚了不少，而且從直方圖來看，像素值也從集中在 \(0\) 附近變得散開了一些。
img7 = plt.imread('gamma_corrected.jpg')
plt.imshow(img7)
plt.show()
2.3 圖像的仿射變換
圖像的仿射變換涉及到圖像的形狀位置角度的變化，是深度學習預處理中常到的功能。仿射變換具體到圖像中的應用，主要是對圖像的縮放，旋轉，剪切，翻轉和平移的組合。在 OpenCV 中，仿射變換的矩陣是一個 \(2 \times 3\) 的矩陣，其中左邊的 \(2 \times 2\) 子矩陣是線性變換矩陣，右邊的 \(2 \times 1\) 的兩項是平移項：
\[ A = \begin{pmatrix} a_{00} & a_{01}\\ a_{10} & a_{11} \end{pmatrix} \]
\[ B = \begin{pmatrix} b_0\\ b_1 \end{pmatrix} \]
\[ M = \begin{pmatrix} A & B \end{pmatrix} \]
對於圖片上任一位置 \((x, y)\)，仿射變換執行的是以下操做：
\[ T_{\text{affine}} A B = \begin{pmatrix} x\\ y \end{pmatrix} + B = M \begin{pmatrix} x\\ y\\ 1 \end{pmatrix} \]
須要注意的是，對於圖像而言，寬度方向是 \(x\)，高度方向是 \(y\)，座標的順序和圖像像素對應下標一致。因此原點的位置不是左下角而是右上角，\(y\) 的方向也不是向上，而是向下。在 OpenCV 中實現仿射變換是經過仿射變換矩陣和 cv2.warpAffine() 這個函數，仍是經過代碼來理解一下：
import cv2
import numpy as np
filename = 'D:/images/cartoon/j.jpeg'
# 讀取一張照片
img = cv2.imread(filename)
# 沿着橫縱軸放大1.6倍，而後平移(-150,-240)，最後沿原圖大小截取，等效於裁剪並放大
M_crop_elephant = np.array([[1.6, 0, -150], [0, 1.6, -240]], dtype=np.float32)
img_elephant = cv2.warpAffine(img, M_crop_elephant, (1400, 2000))
cv2.imwrite('cartoon.jpg', img_elephant)
# x軸的剪切變換，角度15°
theta = 15 * np.pi / 180
M_shear = np.array([[1, np.tan(theta), 0], [0, 1, 0]], dtype=np.float32)
img_sheared = cv2.warpAffine(img, M_shear, (1400, 2000))
cv2.imwrite('cartoon_sheared.jpg', img_sheared)
# 順時針旋轉，角度15°
M_rotate = np.array(
[[np.cos(theta), -np.sin(theta), 0], [np.sin(theta),
np.cos(theta), 0]],
dtype=np.float32)
img_rotated = cv2.warpAffine(img, M_rotate, (1400, 2000))
cv2.imwrite('cartooni_rotated.jpg', img_rotated)
# 某種變換，具體旋轉+縮放+旋轉組合能夠經過SVD分解理解
M = np.array([[1, 1.5, -400], [0.5, 2, -100]], dtype=np.float32)
img_transformed = cv2.warpAffine(img, M, (1400, 2000))
cv2.imwrite('cartoon_transformed.jpg', img_transformed)
for i, filename in enumerate([
'cartoon.jpg', 'cartoon_sheared.jpg', 'cartooni_rotated.jpg',
'cartoon_transformed.jpg'
]):
plt.subplot(221 + i)
img1 = plt.imread(filename)
plt.imshow(img1)
plt.title(filename)
plt.axis('off')
plt.show()
2.4 基本繪圖
OpenCV 提供了各類繪圖的函數，能夠在畫面上繪製線段，圓，矩形和多邊形等，還能夠在圖像上指定位置打印文字，好比下面例子：
import numpy as np
import cv2
# 定義一塊寬600，高400的畫布，初始化爲白色
canvas = np.zeros((400, 600, 3), dtype=np.uint8) + 255
# 畫一條縱向的正中央的黑色分界線
cv2.line(canvas, (300, 0), (300, 399), (0, 0, 0), 2)
# 畫一條右半部份畫面以150爲界的橫向分界線
cv2.line(canvas, (300, 149), (599, 149), (0, 0, 0), 2)
# 左半部分的右下角畫個紅色的圓
cv2.circle(canvas, (200, 300), 75, (0, 0, 255), 5)
# 左半部分的左下角畫個藍色的矩形
cv2.rectangle(canvas, (20, 240), (100, 360), (255, 0, 0), thickness=3)
# 定義兩個三角形，並執行內部綠色填充
triangles = np.array([[(200, 240), (145, 333), (255, 333)],
[(60, 180), (20, 237), (100, 237)]])
cv2.fillPoly(canvas, triangles, (0, 255, 0))
# 畫一個黃色五角星
# 第一步經過旋轉角度的辦法求出五個頂點
phi = 4 * np.pi / 5
rotations = [[[np.cos(i * phi), -np.sin(i * phi)],
[i * np.sin(phi), np.cos(i * phi)]] for i in range(1, 5)]
pentagram = np.array(
[[[[0, -1]] + [np.dot(m, (0, -1)) for m in rotations]]], dtype=np.float)
# 定義縮放倍數和平移向量把五角星畫在左半部分畫面的上方
pentagram = np.round(pentagram * 80 + np.array([160, 120])).astype(np.int)
# 將5個頂點做爲多邊形頂點連線，獲得五角星
cv2.polylines(canvas, pentagram, True, (0, 255, 255), 9)
# 按像素爲間隔從左至右在畫面右半部份的上方畫出HSV空間的色調連續變化
for x in range(302, 600):
color_pixel = np.array(
[[[round(180 * float(x - 302) / 298), 255, 255]]], dtype=np.uint8)
line_color = [
int(c) for c in cv2.cvtColor(color_pixel, cv2.COLOR_HSV2BGR)[0][0]
]
cv2.line(canvas, (x, 0), (x, 147), line_color)
# 若是定義圓的線寬大於半斤，則等效於畫圓點，隨機在畫面右下角的框內生成座標
np.random.seed(42)
n_pts = 30
pts_x = np.random.randint(310, 590, n_pts)
pts_y = np.random.randint(160, 390, n_pts)
pts = list(zip(pts_x, pts_y))
# 畫出每一個點，顏色隨機
for pt in pts:
pt_color = [int(c) for c in np.random.randint(0, 255, 3)]
cv2.circle(canvas, pt, 3, pt_color, 5)
# 在左半部分最上方打印文字
cv2.putText(canvas, 'Python-OpenCV Drawing Example', (5, 15),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)
cv2.imshow('Example of basic drawing functions', canvas)
cv2.waitKey()
執行這段代碼獲得以下的圖像：
2.4 視頻功能
視頻中最經常使用的就是從視頻設備採集圖片或者視頻，或者讀取視頻文件並從中採樣。因此比較重要的也是兩個模塊，一個是 VideoCapture，用於獲取相機設備並捕獲圖像和視頻，或是從文件中捕獲。還有一個 VideoWriter，用於生成視頻。仍是來看例子理解這兩個功能的用法，首先是一個製做延時攝影視頻的小例子：
import cv2
import time
interval = 60 # 捕獲圖像的間隔，單位：秒
num_frames = 500 # 捕獲圖像的總幀數
out_fps = 24 # 輸出文件的幀率
# VideoCapture(0)表示打開默認的相機
cap = cv2.VideoCapture(0)
# 獲取捕獲的分辨率
size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
# 設置要保存視頻的編碼，分辨率和幀率
video = cv2.VideoWriter("time_lapse.avi",
cv2.VideoWriter_fourcc('M', 'P', '4', '2'), out_fps,
size)
# 對於一些低畫質的攝像頭，前面的幀可能不穩定，略過
for i in range(42):
cap.read()
# 開始捕獲，經過read()函數獲取捕獲的幀
try:
for i in range(num_frames):
_, frame = cap.read()
video.write(frame)
# 若是但願把每一幀也存成文件，好比製做GIF，則取消下面的註釋
# filename = '{:0>6d}.png'.format(i)
# cv2.imwrite(filename, frame)
print('Frame {} is captured.'.format(i))
time.sleep(interval)
except KeyboardInterrupt:
# 提早中止捕獲
print('Stopped! {}/{} frames captured!'.format(i, num_frames))
# 釋放資源並寫入視頻文件
video.release()
cap.release()
這個例子實現了延時攝影的功能，把程序打開並將攝像頭對準一些緩慢變化的畫面，好比桌上緩慢蒸發的水，或者正在生長的小草，就能製做出有趣的延時攝影做品。好比下面這個連接中的圖片就是用這段程序生成的：
程序的結構很是清晰簡單，註釋裏也寫清楚了每一步，因此流程就不解釋了。須要提一下的有兩點：一個是 VideoWriter 中的一個函數 cv2.VideoWriter_fourcc()。這個函數指定了視頻編碼的格式，好比例子中用的是 MP42，也就是 MPEG-4，更多編碼方式能夠在下面的地址查詢：Video Codecs by FOURCC。
還有一個是 KeyboardInterrupt，這是一個經常使用的異常，用來獲取用戶 Ctrl+C 的停止，捕獲這個異常後直接結束循環並釋放 VideoCapture 和 VideoWriter 的資源，使已經捕獲好的部分視頻能夠順利生成。
從視頻中截取幀也是處理視頻時常見的任務，下面代碼實現的是遍歷一個指定文件夾下的全部視頻並按照指定的間隔進行截屏並保存：
import cv2
import os
import sys
# 第一個輸入參數是包含視頻片斷的路徑
input_path = sys.argv[1]
# 第二個輸入參數是設定每隔多少幀截取一幀
frame_interval = int(sys.argv[2])
# 列出文件夾下全部的視頻文件
filenames = os.listdir(input_path)
# 獲取文件夾名稱
video_prefix = input_path.split(os.sep)[-1]
# 創建一個新的文件夾，名稱爲原文件夾名稱後加上_frames
frame_path = '{}_frames'.format(input_path)
if not os.path.exists(frame_path):
os.mkdir(frame_path)
# 初始化一個VideoCapture對象
cap = cv2.VideoCapture()
# 遍歷全部文件
for filename in filenames:
filepath = os.sep.join([input_path, filename])
# VideoCapture::open函數能夠從文件獲取視頻
cap.open(filepath)
# 獲取視頻幀數
n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
# 一樣爲了不視頻頭幾幀質量低下，黑屏或者無關等
for i in range(42):
cap.read()
for i in range(n_frames):
ret, frame = cap.read()
# 每隔frame_interval幀進行一次截屏操做
if i % frame_interval == 0:
imagename = '{}_{}_{:0>6d}.jpg'.format(video_prefix,
filename.split('.')[0], i)
imagepath = os.sep.join([frame_path, imagename])
print('exported {}!'.format(imagepath))
cv2.imwrite(imagepath, frame)
# 執行結束釋放資源
cap.release()
3 用 OpenCV 實現數據增長小工具
到目前咱們已經熟悉了 numpy 中的隨機模塊，多進程調用和 OpenCV 的基本操做，基於這些基礎，本節將從思路到代碼一步步實現一個最基本的數據增長小工具。
數據增長（data augmentation），做爲一種深度學習中的經常使用手段，增長對模型的泛化性和準確性都有幫助。數據增長的具體使用方式通常有兩種，一種是實時增長，好比在 Caffe 中加入數據擾動層，每次圖像都先通過擾動操做，再去訓練，這樣訓練通過幾代（epoch）以後，就等效於數據增長。還有一種是更加直接簡單一些的，就是在訓練以前就經過圖像處理手段對數據樣本進行擾動和增長，也就是本節要實現的。
這個例子中將包含三種基本類型的擾動：隨機裁剪，隨機旋轉和隨機顏色/明暗。
3.1 隨機裁剪
在絕大多數用於分類的圖片中，樣本進入網絡前都是要變爲統一大小，因此寬高比擾動至關於對物體的橫向和縱向進行了縮放，這樣除了物體的位置擾動，又多出了一項擾動。只要變化範圍控制合適，目標物體始終在畫面內，這種擾動是有助於提高泛化性能的。實現這種裁剪的思路以下圖所示：
3.2 隨機旋轉
前面講到過的旋轉比起來，作數據增長時，通常但願旋轉是沿着畫面的中心。這樣除了要知道旋轉角度，還得計算平移的量才能讓仿射變換的效果等效於旋轉軸在畫面中心，好在 OpenCV 中有現成的函數 cv2.getRotationMatrix2D() 可使用。這個函數的第一個參數是旋轉中心，第二個參數是逆時針旋轉角度，第三個參數是縮放倍數，對於只是旋轉的狀況下這個值是 1，返回值就是作仿射變換的矩陣。
直接用這個函數並接着使用 cv2.warpAffine() 會有一個潛在的問題，就是旋轉以後會出現黑邊。若是要旋轉後的畫面不包含黑邊，就得沿着原來畫面的輪廓作個內接矩形，該矩形的寬高比和原畫面相同，以下圖所示：
在圖中，能夠看到，限制內接矩形大小的主要是原畫面更靠近中心的那條邊，也就是圖中比較長的一條邊 AB。所以咱們只要沿着中心O和內接矩形的頂點方向的直線，求出和 AB 的交點 P，就獲得了內接矩形的大小。先來看長邊的方程，考慮以前畫面和橫軸相交的點，通過角度- \(\theta\) 旋轉後，到了圖中的 Q 點所在：
3.5 代碼：圖片數據增長小工具
按照前面 4 個部分的思路和方法，這節來實現這麼一個圖片數據增長小工具，首先對於一些基礎的操做，咱們定義在一個叫作 image_augmentation.py 的文件裏：
import numpy as np
import cv2
def crop_image(img, x0, y0, w, h):
'''
定義裁剪函數，四個參數分別是：
左上角橫座標 x0
左上角縱座標 y0
裁剪寬度 w
裁剪高度 h
'''
return img[y0:y0 + h, x0:x0 + w]
def random_crop(img, area_ratio, hw_vari):
'''
隨機裁剪
area_ratio爲裁剪畫面佔原畫面的比例
hw_vari是擾動佔原高寬比的比例範圍
'''
h, w = img.shape[:2]
hw_delta = np.random.uniform(-hw_vari, hw_vari)
hw_mult = 1 + hw_delta
# 下標進行裁剪，寬高必須是正整數
w_crop = int(round(w * np.sqrt(area_ratio * hw_mult)))
# 裁剪寬度不可超過原圖可裁剪寬度
if w_crop > w:
w_crop = w
h_crop = int(round(h * np.sqrt(area_ratio / hw_mult)))
if h_crop > h:
h_crop = h
# 隨機生成左上角的位置
x0 = np.random.randint(0, w - w_crop + 1)
y0 = np.random.randint(0, h - h_crop + 1)
return crop_image(img, x0, y0, w_crop, h_crop)
def rotate_image(img, angle, crop):
'''
定義旋轉函數：
angle是逆時針旋轉的角度
crop是個布爾值，代表是否要裁剪去除黑邊
'''
h, w = img.shape[:2]
# 旋轉角度的週期是360°
angle %= 360
# 用OpenCV內置函數計算仿射矩陣
M_rotate = cv2.getRotationMatrix2D((w / 2, h / 2), angle, 1)
# 獲得旋轉後的圖像
img_rotated = cv2.warpAffine(img, M_rotate, (w, h))
# 若是須要裁剪去除黑邊
if crop:
# 對於裁剪角度的等效週期是180°
angle_crop = angle % 180
# 而且關於90°對稱
if angle_crop > 90:
angle_crop = 180 - angle_crop
# 轉化角度爲弧度
theta = angle_crop * np.pi / 180.0
# 計算高寬比
hw_ratio = float(h) / float(w)
# 計算裁剪邊長係數的分子項
tan_theta = np.tan(theta)
numerator = np.cos(theta) + np.sin(theta) * tan_theta
# 計算分母項中和寬高比相關的項
r = hw_ratio if h > w else 1 / hw_ratio
# 計算分母項
denominator = r * tan_theta + 1
# 計算最終的邊長係數
crop_mult = numerator / denominator
# 獲得裁剪區域
w_crop = int(round(crop_mult * w))
h_crop = int(round(crop_mult * h))
x0 = int((w - w_crop) / 2)
y0 = int((h - h_crop) / 2)
img_rotated = crop_image(img_rotated, x0, y0, w_crop, h_crop)
return img_rotated
def random_rotate(img, angle_vari, p_crop):
'''
隨機旋轉
angle_vari是旋轉角度的範圍[-angle_vari, angle_vari)
p_crop是要進行去黑邊裁剪的比例
'''
angle = np.random.uniform(-angle_vari, angle_vari)
crop = False if np.random.random() > p_crop else True
return rotate_image(img, angle, crop)
def hsv_transform(img, hue_delta, sat_mult, val_mult):
'''
定義hsv變換函數：
hue_delta是色調變化比例
sat_delta是飽和度變化比例
val_delta是明度變化比例
'''
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.float)
img_hsv[:, :, 0] = (img_hsv[:, :, 0] + hue_delta) % 180
img_hsv[:, :, 1] *= sat_mult
img_hsv[:, :, 2] *= val_mult
img_hsv[img_hsv > 255] = 255
return cv2.cvtColor(np.round(img_hsv).astype(np.uint8), cv2.COLOR_HSV2BGR)
def random_hsv_transform(img, hue_vari, sat_vari, val_vari):
'''
隨機hsv變換
hue_vari是色調變化比例的範圍
sat_vari是飽和度變化比例的範圍
val_vari是明度變化比例的範圍
'''
hue_delta = np.random.randint(-hue_vari, hue_vari)
sat_mult = 1 + np.random.uniform(-sat_vari, sat_vari)
val_mult = 1 + np.random.uniform(-val_vari, val_vari)
return hsv_transform(img, hue_delta, sat_mult, val_mult)
def gamma_transform(img, gamma):
'''
定義gamma變換函數：
gamma就是Gamma
'''
gamma_table = [np.power(x / 255.0, gamma) * 255.0 for x in range(256)]
gamma_table = np.round(np.array(gamma_table)).astype(np.uint8)
return cv2.LUT(img, gamma_table)
def random_gamma_transform(img, gamma_vari):
'''
隨機gamma變換
gamma_vari是Gamma變化的範圍[1/gamma_vari, gamma_vari)
'''
log_gamma_vari = np.log(gamma_vari)
alpha = np.random.uniform(-log_gamma_vari, log_gamma_vari)
gamma = np.exp(alpha)
return gamma_transform(img, gamma)
調用這些函數須要經過一個主程序。這個主程序裏首先定義三個子模塊，定義一個函數 parse_arg() 經過 Python 的 argparse 模塊定義了各類輸入參數和默認值。須要注意的是這裏用 argparse 來輸入全部參數是由於參數總量並非特別多，若是增長了更多的擾動方法，更合適的參數輸入方式多是經過一個配置文件。而後定義一個生成待處理圖像列表的函數 generate_image_list()，根據輸入中要增長圖片的數量和並行進程的數目儘量均勻地爲每一個進程生成了須要處理的任務列表。執行隨機擾動的代碼定義在 augment_images()中，這個函數是每一個進程內進行實際處理的函數，執行順序是鏡像裁剪旋轉 HSVGamma。須要注意的是鏡像裁剪，由於只是個演示例子，這未必是一個合適的順序。最後定義一個 main 函數進行調用，代碼以下：
import os
import argparse
import random
import math
from multiprocessing import Process
from multiprocessing import cpu_count
import cv2
# 導入image_augmentation.py爲一個可調用模塊
import image_augmentation as ia
# 利用Python的argparse模塊讀取輸入輸出和各類擾動參數
def parse_args():
parser = argparse.ArgumentParser(
description='A Simple Image Data Augmentation Tool',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('input_dir', help='Directory containing images')
parser.add_argument('output_dir', help='Directory for augmented images')
parser.add_argument(
'num', help='Number of images to be augmented', type=int)
parser.add_argument(
'--num_procs',
help='Number of processes for paralleled augmentation',
type=int,
default=cpu_count())
parser.add_argument(
'--p_mirror', help='Ratio to mirror an image', type=float, default=0.5)
parser.add_argument(
'--p_crop',
help='Ratio to randomly crop an image',
type=float,
default=1.0)
parser.add_argument(
'--crop_size',
help='The ratio of cropped image size to original image size, in area',
type=float,
default=0.8)
parser.add_argument(
'--crop_hw_vari',
help='Variation of h/w ratio',
type=float,
default=0.1)
parser.add_argument(
'--p_rotate',
help='Ratio to randomly rotate an image',
type=float,
default=1.0)
parser.add_argument(
'--p_rotate_crop',
help='Ratio to crop out the empty part in a rotated image',
type=float,
default=1.0)
parser.add_argument(
'--rotate_angle_vari',
help='Variation range of rotate angle',
type=float,
default=10.0)
parser.add_argument(
'--p_hsv',
help='Ratio to randomly change gamma of an image',
type=float,
default=1.0)
parser.add_argument(
'--hue_vari', help='Variation of hue', type=int, default=10)
parser.add_argument(
'--sat_vari', help='Variation of saturation', type=float, default=0.1)
parser.add_argument(
'--val_vari', help='Variation of value', type=float, default=0.1)
parser.add_argument(
'--p_gamma',
help='Ratio to randomly change gamma of an image',
type=float,
default=1.0)
parser.add_argument(
'--gamma_vari', help='Variation of gamma', type=float, default=2.0)
args = parser.parse_args()
args.input_dir = args.input_dir.rstrip('/')
args.output_dir = args.output_dir.rstrip('/')
return args
def generate_image_list(args):
'''
根據進程數和要增長的目標圖片數，
生成每一個進程要處理的文件列表和每一個文件要增長的數目
'''
# 獲取全部文件名和文件總數
filenames = os.listdir(args.input_dir)
num_imgs = len(filenames)
# 計算平均處理的數目並向下取整
num_ave_aug = int(math.floor(args.num / num_imgs))
# 剩下的部分不足平均分配到每個文件，因此作成一個隨機幸運列表
# 對於幸運的文件就多增長一個，湊夠指定的數目
rem = args.num - num_ave_aug * num_imgs
lucky_seq = [True] * rem + [False] * (num_imgs - rem)
random.shuffle(lucky_seq)
# 根據平均分配和幸運表策略，
# 生成每一個文件的全路徑和對應要增長的數目並放到一個list裏
img_list = [(os.sep.join([args.input_dir, filename]), num_ave_aug + 1
if lucky else num_ave_aug)
for filename, lucky in zip(filenames, lucky_seq)]
# 文件可能大小不一，處理時間也不同，
# 因此隨機打亂，儘量保證處理時間均勻
random.shuffle(img_list)
# 生成每一個進程的文件列表，
# 儘量均勻地劃分每一個進程要處理的數目
length = float(num_imgs) / float(args.num_procs)
indices = [int(round(i * length)) for i in range(args.num_procs + 1)]
return [img_list[indices[i]:indices[i + 1]] for i in range(args.num_procs)]
# 每一個進程內調用圖像處理函數進行擾動的函數
def augment_images(filelist, args):
# 遍歷全部列表內的文件
for filepath, n in filelist:
img = cv2.imread(filepath)
filename = filepath.split(os.sep)[-1]
dot_pos = filename.rfind('.')
# 獲取文件名和後綴名
imgname = filename[:dot_pos]
ext = filename[dot_pos:]
print('Augmenting {} ...'.format(filename))
for i in range(n):
img_varied = img.copy()
# 擾動後文件名的前綴
varied_imgname = '{}_{:0>3d}_'.format(imgname, i)
# 按照比例隨機對圖像進行鏡像
if random.random() < args.p_mirror:
# 利用numpy.fliplr(img_varied)也能實現
img_varied = cv2.flip(img_varied, 1)
varied_imgname += 'm'
# 按照比例隨機對圖像進行裁剪
if random.random() < args.p_crop:
img_varied = ia.random_crop(img_varied, args.crop_size,
args.crop_hw_vari)
varied_imgname += 'c'
# 按照比例隨機對圖像進行旋轉
if random.random() < args.p_rotate:
img_varied = ia.random_rotate(
img_varied, args.rotate_angle_vari, args.p_rotate_crop)
varied_imgname += 'r'
# 按照比例隨機對圖像進行HSV擾動
if random.random() < args.p_hsv:
img_varied = ia.random_hsv_transform(
img_varied, args.hue_vari, args.sat_vari, args.val_vari)
varied_imgname += 'h'
# 按照比例隨機對圖像進行Gamma擾動
if random.random() < args.p_gamma:
img_varied = ia.random_gamma_transform(img_varied,
args.gamma_vari)
varied_imgname += 'g'
# 生成擾動後的文件名並保存在指定的路徑
output_filepath = os.sep.join(
[args.output_dir, '{}{}'.format(varied_imgname, ext)])
cv2.imwrite(output_filepath, img_varied)
# 主函數
def main():
# 獲取輸入輸出和變換選項
args = parse_args()
params_str = str(args)[10:-1]
# 若是輸出文件夾不存在，則創建文件夾
if not os.path.exists(args.output_dir):
os.mkdir(args.output_dir)
print('Starting image data augmentation for {}\n'
'with\n{}\n'.format(args.input_dir, params_str))
# 生成每一個進程要處理的列表
sublists = generate_image_list(args)
# 建立進程
processes = [
Process(target=augment_images, args=(
x,
args,
)) for x in sublists
]
# 並行多進程處理
for p in processes:
p.start()
for p in processes:
p.join()
print('\nDone!')
if __name__ == '__main__':
main()
把這段代碼保存爲 run_augmentation.py，而後在命令行輸入：
>>> python run_augmentation.py -h
或者
>>> python run_augmentation.py --help
就能看到腳本的使用方法，每一個參數的含義，還有默認值。接下里來執行一個圖片增長任務：
>>> python run_augmentation.py imagenet_samples more_samples 1000 --rotate_angle_vari 180 --p_rotate_crop 0.5
其中 imagenet_samples 爲一些從 imagenet 圖片 url 中隨機下載的一些圖片，--rotate_angle_vari 設爲 180 方便測試全方向的旋轉，--p_rotate_crop 設置爲 0.5，讓旋轉裁剪對一半圖片生效。擾動增長後的 \(1\,000\) 張圖片在 more_samples 文件夾下。
4 用 OpenCV 實現數據標註小工具
除了對圖像的處理，OpenCV 的圖形用戶界面（Graphical User Interface, GUI）和繪圖等相關功能也是頗有用的功能，不管是可視化，圖像調試仍是咱們這節要實現的標註任務，均可以有所幫助。這節先介紹OpenCV窗口的最基本使用和交互，而後基於這些基礎和以前的知識實現一個用於物體檢測任務標註的小工具。
4.1 OpenCV 窗口循環
OpenCV 顯示一幅圖片的函數是 cv2.imshow()，第一個參數是顯示圖片的窗口名稱，第二個參數是圖片的 array。不過若是直接執行這個函數的話，什麼都不會發生，由於這個函數得配合 cv2.waitKey() 一塊兒使用。cv2.waitKey() 指定當前的窗口顯示要持續的毫秒數，好比 cv2.waitKey(1000) 就是顯示一秒，而後窗口就關閉了。比較特殊的是 cv2.waitKey(0)，並非顯示 \(0\) 毫秒的意思，而是一直顯示，直到有鍵盤上的按鍵被按下，或者鼠標點擊了窗口的小叉子才關閉。cv2.waitKey() 的默認參數就是 0，因此對於圖像展現的場景，cv2.waitKey() 或者 cv2.waitKey(0) 是最經常使用的：
import cv2
img = cv2.imread('Aitutaki.png')
cv2.imshow('Honeymoon Island', img)
cv2.waitKey()
cv2.waitKey() 參數不爲零的時候則能夠和循環結合產生動態畫面，好比在 2.4 的延時小例子中，咱們把延時攝影保存下來的全部圖像放到一個叫作 frames 的文件夾下。下面代碼從 frames 的文件夾下讀取全部圖片並以 \(24\) 的幀率在窗口中顯示成動畫：
import os
from itertools import cycle
import cv2
# 列出frames文件夾下的全部圖片
filenames = os.listdir('frames')
# 經過itertools.cycle生成一個無限循環的迭代器，每次迭代都輸出下一張圖像對象
img_iter = cycle([cv2.imread(os.sep.join(['frames', x])) for x in filenames])
key = 0
while key & 0xFF != 27:
cv2.imshow('Animation', next(img_iter))
key = cv2.waitKey(42)
在這個例子中咱們採用了 Python 的 itertools 模塊中的 cycle 函數，這個函數能夠把一個可遍歷結構編程一個無限循環的迭代器。另外從這個例子中咱們還發現，cv2.waitKey() 返回的就是鍵盤上出發的按鍵。對於字母就是 ascii 碼，特殊按鍵好比上下左右等，則對應特殊的值，其實這就是鍵盤事件的最基本用法。
4.2 鼠標和鍵盤事件
由於 GUI 老是交互的，因此鼠標和鍵盤事件基本使用必不可少，上節已經提到了 cv2.waitKey() 就是獲取鍵盤消息的最基本方法。好比下面這段循環代碼就可以獲取鍵盤上按下的按鍵，並在終端輸出：
while key != 27:
cv2.imshow('Honeymoon Island', img)
key = cv2.waitKey()
# 若是獲取的鍵值小於256則做爲ascii碼輸出對應字符，不然直接輸出值
msg = '{} is pressed'.format(chr(key) if key < 256 else key)
print(msg)
經過這個程序咱們能獲取一些經常使用特殊按鍵的值，好比在筆者用的機器上，四個方向的按鍵和刪除鍵對應的值以下：
- 上（\(\uparrow\)）：65362
- 下（\(\downarrow\)）：65364
- 左（\(\leftarrow\)）：65361
- 右（\(\rightarrow\)）：65363
- 刪除（Delete）：65535
須要注意的是在不一樣的操做系統裏這些值多是不同的。鼠標事件比起鍵盤事件稍微複雜一點點，須要定義一個回調函數，而後把回調函數和一個指定名稱的窗口綁定，這樣只要鼠標位於畫面區域內的事件就都能捕捉到。把下面這段代碼插入到上段代碼的 while 以前，就能獲取當前鼠標的位置和動做並輸出：
# 定義鼠標事件回調函數
def on_mouse(event, x, y, flags, param):
# 鼠標左鍵按下，擡起，雙擊
if event == cv2.EVENT_LBUTTONDOWN:
print('Left button down at ({}, {})'.format(x, y))
elif event == cv2.EVENT_LBUTTONUP:
print('Left button up at ({}, {})'.format(x, y))
elif event == cv2.EVENT_LBUTTONDBLCLK:
print('Left button double clicked at ({}, {})'.format(x, y))
# 鼠標右鍵按下，擡起，雙擊
elif event == cv2.EVENT_RBUTTONDOWN:
print('Right button down at ({}, {})'.format(x, y))
elif event == cv2.EVENT_RBUTTONUP:
print('Right button up at ({}, {})'.format(x, y))
elif event == cv2.EVENT_RBUTTONDBLCLK:
print('Right button double clicked at ({}, {})'.format(x, y))
# 鼠標中/滾輪鍵（若是有的話）按下，擡起，雙擊
elif event == cv2.EVENT_MBUTTONDOWN:
print('Middle button down at ({}, {})'.format(x, y))
elif event == cv2.EVENT_MBUTTONUP:
print('Middle button up at ({}, {})'.format(x, y))
elif event == cv2.EVENT_MBUTTONDBLCLK:
print('Middle button double clicked at ({}, {})'.format(x, y))
# 鼠標移動
elif event == cv2.EVENT_MOUSEMOVE:
print('Moving at ({}, {})'.format(x, y))
# 爲指定的窗口綁定自定義的回調函數
cv2.namedWindow('Honeymoon Island')
cv2.setMouseCallback('Honeymoon Island', on_mouse)
4.3 代碼：物體檢測標註的小工具
基於上面兩小節的基本使用，就能和 OpenCV 的基本繪圖功能就能實現一個超級簡單的物體框標註小工具了。基本思路是對要標註的圖像創建一個窗口循環，而後每次循環的時候對圖像進行一次拷貝。鼠標在畫面上畫框的操做，以及已經畫好的框的相關信息在全局變量中保存，而且在每一個循環中根據這些信息，在拷貝的圖像上再畫一遍，而後顯示這份拷貝的圖像。
基於這種實現思路，使用上咱們採用一個儘可能簡化的設計：
- 輸入是一個文件夾，下面包含了全部要標註物體框的圖片。若是圖片中標註了物體，則生成一個相同名稱加額外後綴名的文件保存標註信息。
- 標註的方式是按下鼠標左鍵選擇物體框的左上角，鬆開鼠標左鍵選擇物體框的右下角，鼠標右鍵刪除上一個標註好的物體框。全部待標註物體的類別，和標註框顏色由用戶自定義，若是沒有定義則默認只標註一種物體，定義該物體名稱叫「Object」。
- 方向鍵的 \(\leftarrow\) 和 \(\rightarrow\) 用來遍歷圖片，\(\uparrow\) 和 \(\downarrow\) 用來選擇當前要標註的物體，
Delete鍵刪除一張圖片和對應的標註信息。
每張圖片的標註信息，以及自定義標註物體和顏色的信息，用一個元組表示，第一個元素是物體名字，第二個元素是表明 BGR 顏色的 tuple 或者是表明標註框座標的元組。對於這種並不複雜複雜的數據結構，咱們直接利用 Python 的 repr() 函數，把數據結構保存成機器可讀的字符串放到文件裏，讀取的時候用 eval() 函數就能直接得到數據。這樣的方便之處在於不須要單獨寫個格式解析器。若是須要能夠在此基礎上再編寫一個轉換工具就可以轉換成常見的 Pascal VOC 的標註格式或是其餘的自定義格式。
在這些思路和設計下，咱們定義標註信息文件的格式的例子以下：
('Hill', ((221, 163), (741, 291)))
('Horse', ((465, 430), (613, 570)))
元組中第一項是物體名稱，第二項是標註框左上角和右下角的座標。這裏之因此不把標註信息的數據直接用 pickle 保存，是由於數據自己不會很複雜，直接保存還有更好的可讀性。自定義標註物體和對應標註框顏色的格式也相似，不過更簡單些，由於括號能夠不寫，具體以下：
'Horse', (255, 255, 0)
'Hill', (0, 255, 255)
'DiaoSi', (0, 0, 255)
第一項是物體名稱，第二項是物體框的顏色。使用的時候把本身定義好的內容放到一個文本里，而後保存成和待標註文件夾同名，後綴名爲 labels 的文件。好比咱們在一個叫 samples 的文件夾下放上一些草原的照片，而後自定義一個 samples.labels 的文本文件。把上段代碼的內容放進去，就定義了小山頭的框爲黃色，駿馬的框爲青色，以及紅色的屌絲。基於以上，標註小工具的代碼以下：
import os
import cv2
# tkinter是Python內置的簡單GUI庫，實現一些好比打開文件夾，確認刪除等操做十分方便
from tkinter.filedialog import askdirectory
from tkinter.messagebox import askyesno
# 定義標註窗口的默認名稱
WINDOW_NAME = 'Simple Bounding Box Labeling Tool'
# 定義畫面刷新的大概幀率（是否能達到取決於電腦性能）
FPS = 24
# 定義支持的圖像格式
SUPPOTED_FORMATS = ['jpg', 'jpeg', 'png']
# 定義默認物體框的名字爲Object，顏色藍色，當沒有用戶自定義物體時用默認物體
DEFAULT_COLOR = {'Object': (255, 0, 0)}
# 定義灰色，用於信息顯示的背景和未定義物體框的顯示
COLOR_GRAY = (192, 192, 192)
# 在圖像下方多出BAR_HEIGHT這麼多像素的區域用於顯示文件名和當前標註物體等信息
BAR_HEIGHT = 16
# 上下左右，ESC及刪除鍵對應的cv.waitKey()的返回值
# 注意這個值根據操做系統不一樣有不一樣，能夠經過6.4.2中的代碼獲取
KEY_UP = 65362
KEY_DOWN = 65364
KEY_LEFT = 65361
KEY_RIGHT = 65363
KEY_ESC = 27
KEY_DELETE = 65535
# 空鍵用於默認循環
KEY_EMPTY = 0
get_bbox_name = '{}.bbox'.format
# 定義物體框標註工具類
class SimpleBBoxLabeling:
def __init__(self, data_dir, fps=FPS, window_name=None):
self._data_dir = data_dir
self.fps = fps
self.window_name = window_name if window_name else WINDOW_NAME
# pt0是正在畫的左上角座標，pt1是鼠標所在座標
self._pt0 = None
self._pt1 = None
# 代表當前是否正在畫框的狀態標記
self._drawing = False
# 當前標註物體的名稱
self._cur_label = None
# 當前圖像對應的全部已標註框
self._bboxes = []
# 若是有用戶自定義的標註信息則讀取，不然用默認的物體和顏色
label_path = '{}.labels'.format(self._data_dir)
self.label_colors = DEFAULT_COLOR if not os.path.exists(
label_path) else self.load_labels(label_path)
# 獲取已經標註的文件列表和還未標註的文件列表
imagefiles = [
x for x in os.listdir(self._data_dir)
if x[x.rfind('.') + 1:].lower() in SUPPOTED_FORMATS
]
labeled = [x for x in imagefiles if os.path.exists(get_bbox_name(x))]
to_be_labeled = [x for x in imagefiles if x not in labeled]
# 每次打開一個文件夾，都自動從還未標註的第一張開始
self._filelist = labeled + to_be_labeled
self._index = len(labeled)
if self._index > len(self._filelist) - 1:
self._index = len(self._filelist) - 1
# 鼠標回調函數
def _mouse_ops(self, event, x, y, flags, param):
# 按下左鍵時，座標爲左上角，同時代表開始畫框，改變drawing標記爲True
if event == cv2.EVENT_LBUTTONDOWN:
self._drawing = True
self._pt0 = (x, y)
# 左鍵擡起，代表當前框畫完了，座標記爲右下角，並保存，同時改變drawing標記爲False
elif event == cv2.EVENT_LBUTTONUP:
self._drawing = False
self._pt1 = (x, y)
self._bboxes.append((self._cur_label, (self._pt0, self._pt1)))
# 實時更新右下角座標方便畫框
elif event == cv2.EVENT_MOUSEMOVE:
self._pt1 = (x, y)
# 鼠標右鍵刪除最近畫好的框
elif event == cv2.EVENT_RBUTTONUP:
if self._bboxes:
self._bboxes.pop()
# 清除全部標註框和當前狀態
def _clean_bbox(self):
self._pt0 = None
self._pt1 = None
self._drawing = False
self._bboxes = []
# 畫標註框和當前信息的函數
def _draw_bbox(self, img):
# 在圖像下方多出BAR_HEIGHT這麼多像素的區域用於顯示文件名和當前標註物體等信息
h, w = img.shape[:2]
canvas = cv2.copyMakeBorder(
img, 0, BAR_HEIGHT, 0, 0, cv2.BORDER_CONSTANT, value=COLOR_GRAY)
# 正在標註的物體信息，若是鼠標左鍵已經按下，則顯示兩個點座標，不然顯示當前待標註物體的名稱
label_msg = '{}: {}, {}'.format(self._cur_label, self._pt0, self._pt1) \
if self._drawing \
else 'Current label: {}'.format(self._cur_label)
# 顯示當前文件名，文件個數信息
msg = '{}/{}: {} | {}'.format(self._index + 1, len(self._filelist),
self._filelist[self._index], label_msg)
cv2.putText(canvas, msg, (1, h + 12), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(0, 0, 0), 1)
# 畫出已經標好的框和對應名字
for label, (bpt0, bpt1) in self._bboxes:
label_color = self.label_colors[
label] if label in self.label_colors else COLOR_GRAY
cv2.rectangle(canvas, bpt0, bpt1, label_color, thickness=2)
cv2.putText(canvas, label, (bpt0[0] + 3, bpt0[1] + 15),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, label_color, 2)
# 畫正在標註的框和對應名字
if self._drawing:
label_color = self.label_colors[
self.
_cur_label] if self._cur_label in self.label_colors else COLOR_GRAY
if self._pt1[0] >= self._pt0[0] and self._pt1[1] >= self._pt0[1]:
cv2.rectangle(
canvas, self._pt0, self._pt1, label_color, thickness=2)
cv2.putText(canvas, self._cur_label,
(self._pt0[0] + 3, self._pt0[1] + 15),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, label_color, 2)
return canvas
# 利用repr()導出標註框數據到文件
@staticmethod
def export_bbox(filepath, bboxes):
if bboxes:
with open(filepath, 'w') as f:
for bbox in bboxes:
line = repr(bbox) + '\n'
f.write(line)
elif os.path.exists(filepath):
os.remove(filepath)
# 利用eval()讀取標註框字符串到數據
@staticmethod
def load_bbox(filepath):
bboxes = []
with open(filepath, 'r') as f:
line = f.readline().rstrip()
while line:
bboxes.append(eval(line))
line = f.readline().rstrip()
return bboxes
# 利用eval()讀取物體及對應顏色信息到數據
@staticmethod
def load_labels(filepath):
label_colors = {}
with open(filepath, 'r') as f:
line = f.readline().rstrip()
while line:
label, color = eval(line)
label_colors[label] = color
line = f.readline().rstrip()
return label_colors
# 讀取圖像文件和對應標註框信息（若是有的話）
@staticmethod
def load_sample(filepath):
img = cv2.imread(filepath)
bbox_filepath = get_bbox_name(filepath)
bboxes = []
if os.path.exists(bbox_filepath):
bboxes = SimpleBBoxLabeling.load_bbox(bbox_filepath)
return img, bboxes
# 導出當前標註框信息並清空
def _export_n_clean_bbox(self):
bbox_filepath = os.sep.join(
[self._data_dir,
get_bbox_name(self._filelist[self._index])])
self.export_bbox(bbox_filepath, self._bboxes)
self._clean_bbox()
# 刪除當前樣本和對應的標註框信息
def _delete_current_sample(self):
filename = self._filelist[self._index]
filepath = os.sep.join([self._data_dir, filename])
if os.path.exists(filepath):
os.remove(filepath)
filepath = get_bbox_name(filepath)
if os.path.exists(filepath):
os.remove(filepath)
self._filelist.pop(self._index)
print('{} is deleted!'.format(filename))
# 開始OpenCV窗口循環的方法，定義了程序的主邏輯
def start(self):
# 以前標註的文件名，用於程序判斷是否須要執行一次圖像讀取
last_filename = ''
# 標註物體在列表中的下標
label_index = 0
# 全部標註物體名稱的列表
labels = self.label_colors.keys()
# 待標註物體的種類數
n_labels = len(labels)
# 定義窗口和鼠標回調
cv2.namedWindow(self.window_name)
cv2.setMouseCallback(self.window_name, self._mouse_ops)
key = KEY_EMPTY
# 定義每次循環的持續時間
delay = int(1000 / FPS)
# 只要沒有按下Esc鍵，就持續循環
while key != KEY_ESC:
# 上下鍵用於選擇當前標註物體
if key == KEY_UP:
if label_index == 0:
pass
else:
label_index -= 1
elif key == KEY_DOWN:
if label_index == n_labels - 1:
pass
else:
label_index += 1
# 左右鍵切換當前標註的圖片
elif key == KEY_LEFT:
# 已經到了第一張圖片的話就不須要清空上一張
if self._index > 0:
self._export_n_clean_bbox()
self._index -= 1
if self._index < 0:
self._index = 0
elif key == KEY_RIGHT:
# 已經到了最後一張圖片的話就不須要清空上一張
if self._index < len(self._filelist) - 1:
self._export_n_clean_bbox()
self._index += 1
if self._index > len(self._filelist) - 1:
self._index = len(self._filelist) - 1
# 刪除當前圖片和對應標註信息
elif key == KEY_DELETE:
if askyesno('Delete Sample', 'Are you sure?'):
self._delete_current_sample()
key = KEY_EMPTY
continue
# 若是鍵盤操做執行了換圖片，則從新讀取，更新圖片
filename = self._filelist[self._index]
if filename != last_filename:
filepath = os.sep.join([self._data_dir, filename])
img, self._bboxes = self.load_sample(filepath)
# 更新當前標註物體名稱
self._cur_label = labels[label_index]
# 把標註和相關信息畫在圖片上並顯示指定的時間
canvas = self._draw_bbox(img)
cv2.imshow(self.window_name, canvas)
key = cv2.waitKey(delay)
# 當前文件名就是下次循環的老文件名
last_filename = filename
print('Finished!')
cv2.destroyAllWindows()
# 若是退出程序，須要對當前進行保存
self.export_bbox(
os.sep.join([self._data_dir,
get_bbox_name(filename)]), self._bboxes)
print('Labels updated!')
if __name__ == '__main__':
dir_with_images = askdirectory(title='Where are the images?')
labeling_task = SimpleBBoxLabeling(dir_with_images)
labeling_task.start()
須要注意的是幾個比較通用且獨立的方法前加上了一句 @staticmethod，代表是個靜態方法。執行這個程序，並選擇 samples 文件夾。
- 1. Opencv筆記（十）——卷積基礎
- 2. openCV基礎知識學習筆記-計算機視覺基礎
- 3. OpenCV學習筆記 OpenCV視頻操做基礎
- 4. OPENCV基礎
- 5. Python基礎筆記
- 6. React 基礎筆記
- 7. scrapy基礎筆記
- 8. Nginx基礎筆記
- 9. js基礎筆記
- 10. JavaSE基礎筆記
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Opencv筆記（十）——卷積基礎
- 2. openCV基礎知識學習筆記-計算機視覺基礎
- 3. OpenCV學習筆記 OpenCV視頻操做基礎
- 4. OPENCV基礎
- 5. Python基礎筆記
- 6. React 基礎筆記
- 7. scrapy基礎筆記
- 8. Nginx基礎筆記
- 9. js基礎筆記
- 10. JavaSE基礎筆記