(一)OpenCV-Python學習—基礎知識

　　opencv是一個強大的圖像處理和計算機視覺庫，實現了很多實用算法，值得學習和深究下。

1.opencv包安裝

·　　這里直接安裝opencv-python包（非官方）： pip install opencv-python

　　 官方文檔：https://opencv-python-tutroals.readthedocs.io/en/latest/

2. opencv簡單圖像處理

　　2.1 圖像像素存儲形式

　　　　首先得了解下圖像在計算機中存儲形式：(為了方便畫圖，每列像素值都寫一樣了)

　　　　對於只有黑白顏色的灰度圖，為單通道，一個像素塊對應矩陣中一個數字，數值為0到255, 其中0表示最暗（黑色） ，255表示最亮（白色）

　　　　

 

　　　　對於采用RGB模式的彩色圖片，為三通道圖，Red、Green、Blue三原色，按不同比例相加，一個像素塊對應矩陣中的一個向量, 如[24,180, 50]，分別表示三種顏色的比列, 即對應深度上的數字，如下圖所示：

　　　　

　　　　需要注意的是，由於歷史遺留問題，opencv采用BGR模式，而不是RGB

　　2.2 圖像讀取和寫入

　　　　cv2.imread()

imread(img_path,flag) 讀取圖片，返回圖片對象
    img_path: 圖片的路徑，即使路徑錯誤也不會報錯，但打印返回的圖片對象為None
    flag：cv2.IMREAD_COLOR，讀取彩色圖片，圖片透明性會被忽略，為默認參數，也可以傳入1
          cv2.IMREAD_GRAYSCALE,按灰度模式讀取圖像，也可以傳入0
          cv2.IMREAD_UNCHANGED,讀取圖像，包括其alpha通道，也可以傳入-1

　　　　cv2.imshow()

imshow(window_name,img)：顯示圖片，窗口自適應圖片大小
    window_name: 指定窗口的名字
    img：顯示的圖片對象
    可以指定多個窗口名稱，顯示多個圖片
    
waitKey(millseconds)  鍵盤綁定事件，阻塞監聽鍵盤按鍵，返回一個數字（不同按鍵對應的數字不同）
    millseconds: 傳入時間毫秒數，在該時間內等待鍵盤事件；傳入0時，會一直等待鍵盤事件
    
destroyAllWindows(window_name) 
    window_name: 需要關閉的窗口名字，不傳入時關閉所有窗口

　　　　cv2.imwrite()

imwrite(img_path_name,img)
    img_path_name:保存的文件名
    img：文件對象

　　使用示例：

#coding:utf-8

import cv2
img = cv2.imread(r"C:\Users\Administrator\Desktop\roi.jpg")
# print(img.shape)
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret,img_threshold = cv2.threshold(img_gray,127,255,cv2.THRESH_BINARY)
cv2.imshow("img",img)
cv2.imshow("thre",img_threshold)

key = cv2.waitKey(0)
if key==27: #按esc鍵時，關閉所有窗口
    print(key)
    cv2.destroyAllWindows()
cv2.imwrite(r"C:\Users\Administrator\Desktop\thre.jpg",img_threshold)

　　2.3 圖像像素獲取和編輯

　　　　像素值獲取：

img = cv2.imread(r"C:\Users\Administrator\Desktop\roi.jpg")

#獲取和設置
pixel = img[100,100]  #[57 63 68],獲取(100,100)處的像素值
img[100,100]=[57,63,99] #設置像素值
b = img[100,100,0]    #57, 獲取(100,100)處，blue通道像素值
g = img[100,100,1]    #63
r = img[100,100,2]      #68
r = img[100,100,2]=99    #設置red通道值

#獲取和設置
piexl = img.item(100,100,2)
img.itemset((100,100,2),99)

　　　　圖片性質

import cv2
img = cv2.imread(r"C:\Users\Administrator\Desktop\roi.jpg")

#rows,cols,channels
img.shape   #返回(280, 450, 3), 寬280(rows)，長450(cols)，3通道(channels)
#size
img.size    #返回378000，所有像素數量，=280*450*3
#type
img.dtype   #dtype('uint8')

　　　ROI截取（Range of Interest）

#ROI,Range of instrest
roi = img[100:200,300:400]  #截取100行到200行，列為300到400列的整塊區域
img[50:150,200:300] = roi   #將截取的roi移動到該區域 （50到100行，200到300列）
b = img[:,:,0]  #截取整個藍色通道

b,g,r = cv2.split(img) #截取三個通道，比較耗時
img = cv2.merge((b,g,r))

　　2.4 添加邊界(padding)　　

cv2.copyMakeBorder()
    參數：
        img:圖像對象
        top,bottom,left,right: 上下左右邊界寬度，單位為像素值
        borderType:
            cv2.BORDER_CONSTANT, 帶顏色的邊界，需要傳入另外一個顏色值
            cv2.BORDER_REFLECT, 邊緣元素的鏡像反射做為邊界
            cv2.BORDER_REFLECT_101/cv2.BORDER_DEFAULT
            cv2.BORDER_REPLICATE, 邊緣元素的復制做為邊界
            CV2.BORDER_WRAP
        value: borderType為cv2.BORDER_CONSTANT時，傳入的邊界顏色值，如[0,255,0]

　　　　使用示例：

#coding:utf-8


import cv2 as cv
import matplotlib.pyplot as plt

img2 = cv.imread(r"C:\Users\Administrator\Desktop\dog.jpg")
img = cv.cvtColor(img2,cv.COLOR_BGR2RGB)  #matplotlib的圖像為RGB格式
constant = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_CONSTANT,value=[0,255,0]) #綠色
reflect = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_REFLECT)
reflect01 = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_REFLECT_101)
replicate = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_REPLICATE)
wrap = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_WRAP)
titles = ["constant","reflect","reflect01","replicate","wrap"]
images = [constant,reflect,reflect01,replicate,wrap]

for i in range(5):
    plt.subplot(2,3,i+1),plt.imshow(images[i]),plt.title(titles[i])
    plt.xticks([]),plt.yticks([])
plt.show()





 

　　　　

　　2.5 像素算術運算

　　　　　　cv2.add()  相加的兩個圖片，應該有相同的大小和通道

cv2.add()
    參數：
        img1:圖片對象1
        img2:圖片對象2
        mask:None （掩膜，一般用灰度圖做掩膜，img1和img2相加后，和掩膜與運算，從而達到掩蓋部分區域的目的）
        dtype:-1

注意：圖像相加時應該用cv2.add(img1,img2)代替img1+img2    
        >>> x = np.uint8([250])
        >>> y = np.uint8([10])
        >>> print cv2.add(x,y) # 250+10 = 260 => 255  #相加，opencv超過255的截取為255
        [[255]]
        >>> print x+y          # 250+10 = 260 % 256 = 4  #相加，np超過255的會取模運算 （uint8只能表示0-255，所以取模）
        [4]

　　　　　　使用示例：圖一無掩膜，圖二有掩膜

#coding:utf-8


import cv2 as cv
import numpy as np
img1 = cv.imread("C:\Users\Administrator\Desktop\cat.jpg",0)
roi_img  = np.zeros(img1.shape[0:2],dtype=np.uint8)
# print(img1.shape[0:2])
roi_img[100:280,400:550]=255

img_add = cv.add(img1,img1)
img_add_mask = cv.add(img1,img1,mask=roi_img)
# cv.imshow("img1",img1)
# cv.imshow("roi_img",roi_img)
cv.imshow("img_add",img_add)
cv.imshow("img_add_mask",img_add_mask)

cv.waitKey(0)
cv.destroyAllWindows()

　　　　　　

　　

　　　　　　

　　　　　　cv.addWeight(): 兩張圖片相加，分別給予不同權重，實現圖片融合和透明背景等效果

cv2.addWeighted() 兩張圖片相加，分別給予不同權重，實現圖片融合和透明背景等效果
    參數：
        img1:圖片對象1
        alpha:img1的權重
        img2:圖片對象2
        beta:img1的權重
        gamma：常量值，圖像相加后再加上常量值
        dtype：返回圖像的數據類型，默認為-1，和img1一樣
    (img1*alpha+img2*beta+gamma)

　　　　使用示例：

#coding:utf-8

import cv2 as cv

img1 = cv.imread(r"C:\Users\Administrator\Desktop\dog.jpg")
img = img1[0:426,43:683]
img2 = cv.imread(r"C:\Users\Administrator\Desktop\cat.jpg")

blend = cv.addWeighted(img,0.5,img2,0.9,0)  #兩張圖的大小和通道也應該相同

cv.imshow("blend",blend)
cv.waitKey()
cv.destroyAllWindows()

　　　　

　　2.6 圖像位運算

　　　　　btwise_and(), bitwise_or(), bitwise_not(), bitwise_xor()

cv2.btwise_and(): 與運算
    參數：
        img1:圖片對象1
        img2:圖片對象2
        mask:掩膜
    cv2.bitwise_or()：或運算
    參數：
        img1:圖片對象1
        img2:圖片對象2
        mask:掩膜
    cv2.bitwise_not(): 非運算
        img1:圖片對象1
        mask:掩膜
    cv2.bitwise_xor():異或運算，相同為1，不同為0（1^1=0,1^0=1）
        img1:圖片對象1
        img2:圖片對象2
        mask:掩膜

　　使用示例：將logo圖片移動到足球圖片中，需要截取logo圖片的前景和足球圖片ROI的背景，然后疊加，效果如下：

#coding:utf-8


import cv2 as cv
import matplotlib.pyplot as plt

img1 = cv.imread(r"C:\Users\Administrator\Desktop\logo.png")
rows,cols = img1.shape[0:2]
img2 = cv.imread(r"C:\Users\Administrator\Desktop\Messi.jpg")
roi = img2[0:rows,0:cols]
img1_gray = cv.cvtColor(img1,cv.COLOR_BGR2GRAY)

ret,img1_thres = cv.threshold(img1_gray,200,255,cv.THRESH_BINARY_INV)
img1_fg =cv.add(img1,img1,mask=img1_thres)    #拿到logo圖案的前景

img1_thres_inv = cv.bitwise_not(img1_thres)
roi_bg = cv.add(roi,roi,mask=img1_thres_inv)  #拿到roi圖案的背景

img_add = cv.add(img1_fg,roi_bg)     #背景和前景相加    
img2[0:rows,0:cols] = img_add

cv.imshow("gray",img1_gray)
cv.imshow("thres",img1_thres)
cv.imshow("fg",img1_fg)
cv.imshow("tinv",img1_thres_inv)
cv.imshow("roi_bg",roi_bg)
cv.imshow("img_add",img_add)
cv.imshow("img2",img2)
cv.waitKey(0)
cv.destroyAllWindows()

　　2.7 圖像顏色空間轉換

　　　　cv2.cvtColor()

cv2.cvtColor()
    參數：
        img: 圖像對象
        code：
            cv2.COLOR_RGB2GRAY: RGB轉換到灰度模式
            cv2.COLOR_RGB2HSV： RGB轉換到HSV模式（hue,saturation,Value）
cv2.inRange()
    參數：
        img: 圖像對象/array
        lowerb: 低邊界array，  如lower_blue = np.array([110,50,50])
        upperb：高邊界array， 如 upper_blue = np.array([130,255,255])
    mask = cv2.inRange(hsv, lower_green, upper_green)

　　2.8 性能評價　

　　　cv2.getTickCount()： 獲得時鍾次數

　　　cv2.getTickFrequency()：獲得時鍾頻率 （每秒振動次數）

img1 = cv2.imread('messi5.jpg')

e1 = cv2.getTickCount()
for i in xrange(5,49,2):
    img1 = cv2.medianBlur(img1,i)
e2 = cv2.getTickCount()
t = (e2 - e1)/cv2.getTickFrequency()
print t

 　　2.9 綁定trackbar到圖像

　　　　cv2.createTrackbar()

　　　　cv2.getTrackbarPos()

    cv2.createTrackbar() 為窗口添加trackbar
    參數：
        trackbarname: trackbar的名字
        winname: 窗口的名字
        value: trackbar創建時的值
        count：trackbar能設置的最大值，最小值總為0
        onChange：trackbar值發生變化時的回調函數，trackbar的值作為參數傳給onchange
        
    cv2.getTrackbarPos() 獲取某個窗口中trackbar的值
    參數：
        trackbarname: trackbar的名字
        winname: 窗口的名字

　　　　使用示例：通過改變trackbar的值，來尋找最優的mask范圍，從而識別出圖片中藍色的瓶蓋

#coding:utf-8

import cv2 as cv
import numpy as np

def nothing(args):
    pass

img = cv.imread(r"C:\Users\Administrator\Desktop\frame.png")
img_hsv = cv.cvtColor(img,cv.COLOR_BGR2HSV)
cv.namedWindow('tracks')
cv.createTrackbar("LH","tracks",0,255,nothing)
cv.createTrackbar("LS","tracks",0,255,nothing)
cv.createTrackbar("LV","tracks",0,255,nothing)

cv.createTrackbar("UH","tracks",255,255,nothing)
cv.createTrackbar("US","tracks",255,255,nothing)
cv.createTrackbar("UV","tracks",255,255,nothing)

# switch = "0:OFF \n1:ON"
# cv.createTrackbar(switch,"tracks",0,1,nothing)


while(1):
        
    l_h = cv.getTrackbarPos("LH","tracks")
    l_s = cv.getTrackbarPos("LS","tracks")
    l_v = cv.getTrackbarPos("LV","tracks")
    u_h = cv.getTrackbarPos("UH","tracks")
    u_s = cv.getTrackbarPos("US","tracks")
    u_v = cv.getTrackbarPos("UV","tracks")
    
    lower_b = np.array([l_h,l_s,l_v])
    upper_b = np.array([u_h,u_s,u_v])
    
    mask = cv.inRange(img_hsv,lower_b,upper_b)
    res = cv.add(img,img,mask=mask)
    
    cv.imshow("img",img)
    cv.imshow("mask",mask)
    cv.imshow("res",res)
    k = cv.waitKey(1)
    if k==27:
        break
    
    
    # print(r,g,b)
    # if s==0:
        # img[:]=0
    # else:
        # img[:]=




cv.destroyAllWindows()

　　　　　　

 

　　　

3. 圖像閾值化

　　cv2.threshold()

　　cv2.adaptiveThreshold()

cv2.threshold(): 
參數：
    img:圖像對象，必須是灰度圖
    thresh:閾值
    maxval：最大值
    type:
        cv2.THRESH_BINARY:     小於閾值的像素置為0，大於閾值的置為maxval
        cv2.THRESH_BINARY_INV： 小於閾值的像素置為maxval，大於閾值的置為0
        cv2.THRESH_TRUNC：      小於閾值的像素不變，大於閾值的置為thresh
        cv2.THRESH_TOZERO       小於閾值的像素置0，大於閾值的不變
        cv2.THRESH_TOZERO_INV   小於閾值的不變，大於閾值的像素置0
返回兩個值
    ret:閾值
    img：閾值化處理后的圖像
    
cv2.adaptiveThreshold() 自適應閾值處理，圖像不同部位采用不同的閾值進行處理
參數：
    img: 圖像對象，8-bit單通道圖
    maxValue:最大值
    adaptiveMethod: 自適應方法
        cv2.ADAPTIVE_THRESH_MEAN_C     ：閾值為周圍像素的平均值
        cv2.ADAPTIVE_THRESH_GAUSSIAN_C : 閾值為周圍像素的高斯均值（按權重）
    threshType:
        cv2.THRESH_BINARY:     小於閾值的像素置為0，大於閾值的置為maxValuel
        cv2.THRESH_BINARY_INV:  小於閾值的像素置為maxValue，大於閾值的置為0
    blocksize: 計算閾值時，自適應的窗口大小,必須為奇數 （如3：表示附近3個像素范圍內的像素點，進行計算閾值）
    C： 常數值，通過自適應方法計算的值，減去該常數值
(mean value of the blocksize*blocksize neighborhood of (x, y) minus C)

　　使用示例：

#coding:utf-8

import cv2 as cv
import matplotlib.pyplot as plt

img = cv.imread(r"C:\Users\Administrator\Desktop\maze.png",0)

ret,thre1 = cv.threshold(img,127,255,cv.THRESH_BINARY)
adaptive_thre1 = cv.adaptiveThreshold(img,255,cv.ADAPTIVE_THRESH_MEAN_C,cv.THRESH_BINARY,7,2)
adaptive_thre2 = cv.adaptiveThreshold(img,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C,cv.THRESH_BINARY,7,2)

titles = ["img","thre1","adaptive_thre1","adaptive_thre2"]
imgs = [img,thre1,adaptive_thre1,adaptive_thre2 ]

for i in range(4):
    plt.subplot(2,2,i+1), plt.imshow(imgs[i],"gray")
    plt.title(titles[i])
    plt.xticks([]),plt.yticks([])
plt.show()

　　　　

　　奧斯二值化（Otsu's Binarization）

　　　　對於一些雙峰圖像，奧斯二值化能找到兩峰之間的像素值作為閾值，並將其返回。適用於雙峰圖像的閾值化，或者通過去噪而產生的雙峰圖像。

　　　　官網使用示例：

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

img = cv2.imread('noisy2.png',0)

# global thresholding
ret1,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)

# Otsu's thresholding
ret2,th2 = cv2.threshold(img,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# Otsu's thresholding after Gaussian filtering
blur = cv2.GaussianBlur(img,(5,5),0)
ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# plot all the images and their histograms
images = [img, 0, th1,
          img, 0, th2,
          blur, 0, th3]
titles = ['Original Noisy Image','Histogram','Global Thresholding (v=127)',
          'Original Noisy Image','Histogram',"Otsu's Thresholding",
          'Gaussian filtered Image','Histogram',"Otsu's Thresholding"]

for i in xrange(3):
    plt.subplot(3,3,i*3+1),plt.imshow(images[i*3],'gray')
    plt.title(titles[i*3]), plt.xticks([]), plt.yticks([])
    plt.subplot(3,3,i*3+2),plt.hist(images[i*3].ravel(),256)
    plt.title(titles[i*3+1]), plt.xticks([]), plt.yticks([])
    plt.subplot(3,3,i*3+3),plt.imshow(images[i*3+2],'gray')
    plt.title(titles[i*3+2]), plt.xticks([]), plt.yticks([])
plt.show()

　　　

 

4. 圖像形狀變換

　　4.1 cv2.resize()   圖像縮放

cv2.resize() 放大和縮小圖像
    參數：
        src: 輸入圖像對象
        dsize：輸出矩陣/圖像的大小，為0時計算方式如下：dsize = Size(round(fx*src.cols),round(fy*src.rows))
        fx: 水平軸的縮放因子，為0時計算方式：  (double)dsize.width/src.cols
        fy: 垂直軸的縮放因子，為0時計算方式：  (double)dsize.heigh/src.rows
        interpolation：插值算法
            cv2.INTER_NEAREST : 最近鄰插值法
            cv2.INTER_LINEAR   默認值，雙線性插值法
            cv2.INTER_AREA        基於局部像素的重采樣（resampling using pixel area relation）。對於圖像抽取（image decimation）來說，這可能是一個更好的方法。但如果是放大圖像時，它和最近鄰法的效果類似。
            cv2.INTER_CUBIC        基於4x4像素鄰域的3次插值法
            cv2.INTER_LANCZOS4     基於8x8像素鄰域的Lanczos插值
                     
    cv2.INTER_AREA 適合於圖像縮小， cv2.INTER_CUBIC (slow) & cv2.INTER_LINEAR 適合於圖像放大

　　　　官網示例：

import cv2
import numpy as np

img = cv2.imread('messi5.jpg')

res = cv2.resize(img,None,fx=2, fy=2, interpolation = cv2.INTER_CUBIC)

#OR

height, width = img.shape[:2]
res = cv2.resize(img,(2*width, 2*height), interpolation = cv2.INTER_CUBIC)

　　4.2 cv2.warpAffine()     仿射變換

　　　　 仿射變換（從二維坐標到二維坐標之間的線性變換，且保持二維圖形的“平直性”和“平行性”。仿射變換可以通過一系列的原子變換的復合來實現，包括平移，縮放，翻轉，旋轉和剪切）

cv2.warpAffine()   仿射變換（從二維坐標到二維坐標之間的線性變換，且保持二維圖形的“平直性”和“平行性”。仿射變換可以通過一系列的原子變換的復合來實現，包括平移，縮放，翻轉，旋轉和剪切）
    參數：
        img: 圖像對象
        M：2*3 transformation matrix (轉變矩陣)
        dsize：輸出矩陣的大小,注意格式為（cols，rows）  即width對應cols，height對應rows
        flags：可選，插值算法標識符，有默認值INTER_LINEAR，
               如果插值算法為WARP_INVERSE_MAP, warpAffine函數使用如下矩陣進行圖像轉dst(x,y)=src(M11*x+M12*y+M13,M21*x+M22*y+M23)
        borderMode：可選， 邊界像素模式，有默認值BORDER_CONSTANT 
        borderValue:可選，邊界取值，有默認值Scalar()即0

　　　　　常用插值算法：

　　　仿射變換的本質：即一個矩陣A和向量B共同組成的轉變矩陣，和原圖像坐標相乘來得到新圖像的坐標，從而實現圖像移動，旋轉等。如下矩陣A和向量B組成的轉變矩陣M，用來對原圖像的坐標（x,y）進行轉變，得到新的坐標向量T

　　　　矩陣A和向量B

　　　　仿射變換（矩陣計算）：變換前坐標（x,y）

　　　　變換結果：變換后坐標（a00*x+a01 *y+b00, a10*x+a11*y+b10）

　　4.2.1 平移變換

　　　　了解了仿射變換的概念，平移變換只是采用了一個如下的轉變矩陣（transformation matrix）: 從（x,y）平移到（x+t_x, y+t_y）

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　

　　　　　官網使用示例：向左平移100，向下平移50

import cv2
import numpy as np

img = cv2.imread('messi5.jpg',0)
rows,cols = img.shape

M = np.float32([[1,0,100],[0,1,50]])
dst = cv2.warpAffine(img,M,(cols,rows))

cv2.imshow('img',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

　　4.2.2 放大和縮小

　　　　　放大和縮小指相對於原坐標（x,y）,變換為了（a*x, b*y）,即水平方向放大了a倍，水平方向放大了b倍，其對應的轉變矩陣如下：

　　　　　　　　　　　　

　　4.2.3 旋轉變換

　　　　　　將（x,y），以坐標原點為中心，順時針方向旋轉α得到(x_1,y₁)， 有如下關系x₁ = xcosα-ysinα, y₁ =xsinα+ycosα; 因此可以構建對應的轉變矩陣如下：

　　　　　　opencv將其擴展到，任意點center為中心進行順時針旋轉α，放大scale倍的，轉變矩陣如下：

　　　　　　　　　　　　

 　　　　　　通過getRotationMatrix2D()能得到轉變矩陣

　　cv2.getRotationMatrix2D()  返回2*3的轉變矩陣（浮點型）
    參數：
        center：旋轉的中心點坐標
        angle：旋轉角度，單位為度數，證書表示逆時針旋轉
        scale：同方向的放大倍數

　　4.2.4 仿射變換矩陣的計算

　　　　通過上述的平移，縮放，旋轉的組合變換即實現了仿射變換，上述多個變換的變換矩陣相乘即能得到組合變換的變換矩陣。同時該變換矩陣中涉及到六個未知數（2*3的矩陣），通過變換前后對應三組坐標，也可以求出變換矩陣，opencv提供了函數getAffineTransform()來計算變化矩陣

　　　　1> 矩陣相乘：將平移，旋轉和縮放的變換矩陣相乘，最后即為仿射變換矩陣

　　　　2> getAffineTransform()：根據變換前后三組坐標計算變換矩陣　　　　　

　　　　cv2.getAffineTransform()  返回2*3的轉變矩陣
    　 參數：
       　　 src：原圖像中的三組坐標，如np.float32([[50,50],[200,50],[50,200]])
        　　dst: 轉換后的對應三組坐標，如np.float32([[10,100],[200,50],[100,250]])

　　　　官網使用示例：　　　　　

img = cv2.imread('drawing.png')
rows,cols,ch = img.shape

pts1 = np.float32([[50,50],[200,50],[50,200]])
pts2 = np.float32([[10,100],[200,50],[100,250]])

M = cv2.getAffineTransform(pts1,pts2)

dst = cv2.warpAffine(img,M,(cols,rows))

plt.subplot(121),plt.imshow(img),plt.title('Input')
plt.subplot(122),plt.imshow(dst),plt.title('Output')
plt.show()

　　4.3 透視變換(persperctive transformation)

　　　　仿射變換都是在二維空間的變換，透視變換（投影變換）是在三維空間中發生了旋轉。需要前后四組坐標來計算對應的轉變矩陣，opencv提供了函數getPerspectiveTransform()來計算轉變矩陣，cv2.wrapPerspective()函數來進行透視變換。其對應參數如下：　

　　　　　cv2.getPerspectiveTransform()   返回3*3的轉變矩陣
        參數：    
            src：原圖像中的四組坐標，如 np.float32([[56,65],[368,52],[28,387],[389,390]])
            dst: 轉換后的對應四組坐標，如np.float32([[0,0],[300,0],[0,300],[300,300]])

            
        cv2.wrapPerspective()
        參數：    
            src: 圖像對象
            M：3*3 transformation matrix (轉變矩陣)
            dsize：輸出矩陣的大小，注意格式為（cols，rows）  即width對應cols，height對應rows
            flags：可選，插值算法標識符，有默認值INTER_LINEAR，
                   如果插值算法為WARP_INVERSE_MAP, warpAffine函數使用如下矩陣進行圖像轉dst(x,y)=src(M11*x+M12*y+M13,M21*x+M22*y+M23)
            borderMode：可選， 邊界像素模式，有默認值BORDER_CONSTANT 
            borderValue:可選，邊界取值，有默認值Scalar()即0

　　　官網使用示例：

img = cv2.imread('sudokusmall.png')
rows,cols,ch = img.shape

pts1 = np.float32([[56,65],[368,52],[28,387],[389,390]])
pts2 = np.float32([[0,0],[300,0],[0,300],[300,300]])

M = cv2.getPerspectiveTransform(pts1,pts2)

dst = cv2.warpPerspective(img,M,(300,300))

plt.subplot(121),plt.imshow(img),plt.title('Input')
plt.subplot(122),plt.imshow(dst),plt.title('Output')
plt.show()

　　　　　　

　　　從上圖中可以透視變換的一個應用，如果能找到原圖中紙張的四個頂點，將其轉換到新圖中紙張的四個頂點，能將歪斜的roi區域轉正，並進行放大；如在書籍，名片拍照上傳后進行識別時，是一個很好的圖片預處理方法。

 

 官方文檔：https://docs.opencv.org/3.0-beta/modules/imgproc/doc/miscellaneous_transformations.html?highlight=adaptivethreshold#cv2.adaptiveThreshold

 Tutorial：https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_gui/py_trackbar/py_trackbar.html#trackbar