opencv 實現任意角度的透視變換

opencv中提供了getPerspectiveTransform函數來獲取由四對點間的轉換矩陣，輸出矩陣爲3*3， 同時也提供了warpPerspective函數來對通過變換矩陣來對圖像進行透視變換的操作，同時還提供了perspectiveTransform來提供對點的轉換：

getPerspectiveTransform：

Calculates a perspective transform from four pairs of the corresponding points.
C++: Mat getPerspectiveTransform(InputArray src, InputArray dst)
C++: Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[])
Python: cv2.getPerspectiveTransform(src, dst) → retval

perspectiveTransform：

Performs the perspective matrix transformation of vectors.


C++: void perspectiveTransform(InputArray src, OutputArray dst, InputArray m)
Python: cv2.perspectiveTransform(src, m[, dst]) → dst
C: void cvPerspectiveTransform(const CvArr* src, CvArr* dst, const CvMat* mat)
Parameters:
src – input two-channel or three-channel floating-point array; each element is a 2D/3D vector to be transformed.
dst – output array of the same size and type as src.
m – 3x3 or 4x4 floating-point transformation matrix.

warpPerspective：

Applies a perspective transformation to an image.


C++: void warpPerspective(InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
Python: cv2.warpPerspective(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]) → dst
C: void cvWarpPerspective(const CvArr* src, CvArr* dst, const CvMat* map_matrix, int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, CvScalar fillval=cvScalarAll(0) )
Parameters:
src – input image.
dst – output image that has the size dsize and the same type as src .
M – 3\times 3 transformation matrix.
dsize – size of the output image.
flags – combination of interpolation methods (INTER_LINEAR or INTER_NEAREST) and the optional flag WARP_INVERSE_MAP, that sets M as the inverse transformation ( \texttt{dst}\rightarrow\texttt{src} ).
borderMode – pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).
borderValue – value used in case of a constant border; by default, it equals 0.

本文爲方便，採用的python + opencv 實現，代碼及效果如下

#-*- coding:utf-8 -*-
import cv2
import numpy as np

def rad(x):
    return x*np.pi/180

img = cv2.imread("b.jpg")
cv2.imshow("original", img)

#擴展圖像，保證內容不超出可視範圍
img = cv2.copyMakeBorder(img,200,200,200,200,cv2.BORDER_CONSTANT,0)
w,h=img.shape[0:2]

anglex=45
angley = 45
anglez = 0
fov = 42
while 1:
    #鏡頭與圖像間的距離，21爲半可視角，算z的距離是爲了保證在此可視角度下恰好顯示整幅圖像
    z=np.sqrt(w**2 + h**2)/2/np.tan(rad(fov/2))
    #齊次變換矩陣
    rx = np.array([[1,                  0,                          0,                          0],
                   [0,                  np.cos(rad(anglex)),        -np.sin(rad(anglex)),       0],
                   [0,                 -np.sin(rad(anglex)),        np.cos(rad(anglex)),        0,],
                   [0,                  0,                          0,                          1]], np.float32)

    ry = np.array([[np.cos(rad(angley)), 0,                         np.sin(rad(angley)),       0],
                   [0,                   1,                         0,                          0],
                   [-np.sin(rad(angley)),0,                         np.cos(rad(angley)),        0,],
                   [0,                   0,                         0,                          1]], np.float32)

    rz = np.array([[np.cos(rad(anglez)), np.sin(rad(anglez)),      0,                          0],
                   [-np.sin(rad(anglez)), np.cos(rad(anglez)),      0,                          0],
                   [0,                  0,                          1,                          0],
                   [0,                  0,                          0,                          1]], np.float32)

    r = rx.dot(ry).dot(rz)

    #四對點的生成
    pcenter = np.array([h/2, w/2, 0, 0], np.float32)
    
    p1 = np.array([0,0,  0,0], np.float32) - pcenter
    p2 = np.array([w,0,  0,0], np.float32) - pcenter
    p3 = np.array([0,h,  0,0], np.float32) - pcenter
    p4 = np.array([w,h,  0,0], np.float32) - pcenter
    
    dst1 = r.dot(p1)
    dst2 = r.dot(p2)
    dst3 = r.dot(p3)
    dst4 = r.dot(p4)

    list_dst = [dst1, dst2, dst3, dst4]

    org = np.array([[0,0],
                    [w,0],
                    [0,h],
                    [w,h]], np.float32)
    
    dst = np.zeros((4,2), np.float32)

    #投影至成像平面
    for i in range(4):
        dst[i,0] = list_dst[i][0]*z/(z-list_dst[i][2]) + pcenter[0]
        dst[i,1] = list_dst[i][1]*z/(z-list_dst[i][2]) + pcenter[1]

    warpR = cv2.getPerspectiveTransform(org, dst)

    result = cv2.warpPerspective(img, warpR, (h,w))
    cv2.imshow("result", result)
    c=cv2.waitKey(30)
    
    #anglex += 3            #auto rotate
    #anglez += 1             #auto rotate
    #angley += 2            #auto rotate

    #鍵盤控制
    if 27 == c:             #Esc quit
        break;
    if c == ord('w'):
        anglex += 1
    if c == ord('s'):
        anglex -= 1
    if c == ord('a'):
        angley += 1
        #dx=0
    if c == ord('d'):
        angley -= 1
    if c == ord('u'):
        anglez += 1
    if c == ord('p'):
        anglez -= 1
    if c == ord('t'):
        fov +=1
    if c == ord('r'):
        fov -=1
    if c == ord(' '):
        anglex=angley=anglez=0
    if c == ord('q'):
        print("======================================")
        print( '旋轉矩陣：\n',r)
        print("angle alpha: ",anglex, 'angle beta: ',angley, "dz: ",anglez, ": ",z)


cv2.destroyAllWindows()

效果圖：

原圖：