图像投影(透视)变换

在我们看到一个小票之后，视角可能不是正对着的，那么我们怎样通过opencv来对图像做出处理，让图像变成正对着的呢？

目标

大致思路

如下图，对图像进行轮廓检测，找出目标的轮廓，做出近似，然后找出四个坐标，我们可以根据四个点坐标，然后计算X+Y和X-Y,我们可以发现，X+Y最大的就是3号点，最小就是1号点，X-Y最大的就是2号点，最小就是4号点，这样我们四个点就确定好了，然后传入到我们函数中就可以自动转化好了。

在此之前我们介绍几个要用到的函数

resize

这个函数可以对图像做出等比变化，非常好用。

def resize(image,width=None,height=None,inter=cv2.INTER_AREA):
    dim = None
    (h, w) = image.shape[:2]
    if width is None and height is None:
        return image
    if width is None:
        r = height / float(h)
        dim = (int(w * r), height)
    else:
        r = width / float(w)
        dim = (width, int(h * r))
    resized = cv2.resize(image, dim, interpolation=inter)
    return resized
#图片调整

图片展示

这个在后面展示图片时非常方便，因为我们要重复的展示图片，所以这里写一个这个函数是非常有必要的。

def cv_show(name,img):
    cv2.imshow(name, img)
    cv2.waitKey(0)

找出坐标

这个函数可以找出函数的四个点的坐标。

def order_points(pts):
    rect = np.zeros((4, 2), dtype="float32")
    s = pts.sum(axis=1)
    rect[0] = pts[np.argmin(s)]
    rect[2] = pts[np.argmax(s)]
    diff = np.diff(pts, axis=1)
    rect[1] = pts[np.argmin(diff)]
    rect[3] = pts[np.argmax(diff)]
    return rect

坐标转化

这个是根据先前找出的四个点坐标，然后转化为新坐标系下的图像四个点坐标，其中长宽都是原图片较长的那一个，这里也进行了求取和对比。

def four_point_transform(image, pts):
    rect = order_points(pts)
    (tl, tr, br, bl) = rect
    widthA = np.sqrt(((br[0] - bl[0]) ** 2) +((br[1] - bl[1]) ** 2))
    widthB=np.sqrt(((tr[0] - tl[0]) ** 2) +((tr[1] - tl[1]) ** 2))
    maxWidth = max(int(widthA), int(widthB))
    heightA = np.sqrt(((tr[0] - br[0]) ** 2) +((tr[1] - br[1]) ** 2))
    heightB=np.sqrt(((tl[0] - bl[0]) ** 2) +((tl[1] - bl[1]) ** 2))
    maxHeight = max(int(heightA), int(heightB))

    dst=np.array([[0,0],[maxWidth-1,0],[maxWidth-1,maxHeight-1],[0,maxHeight-1]],dtype="float32")
    M=cv2.getPerspectiveTransform(rect,dst)
    warped = cv2.warpPerspective(image, M, (maxWidth,maxHeight))
    return warped

实现代码

image=cv2.imread('fapiao.jpg')
cv_show('image',image)

ratio=image.shape[0]/500.0
orig=image.copy()
image=resize(orig,height=500)
cv_show('image',image)
print('"STEP 1:轮廓检测')
gray=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
edges=cv2.threshold(gray,0,255,cv2.THRESH_BINARY|cv2.THRESH_OTSU)[1]
cnts=cv2.findContours(edges.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)[-2]
image_conts=cv2.drawContours(image.copy(),cnts,-1,(0,255,0),1)
cv_show('image_conts',image_conts)

print('"STEP 2:获取最大值')
screenCnt1 = sorted(cnts,key=cv2.contourArea,reverse=True)[0] # 获取面积最大的轮威print(screenCnt.shape)
print(screenCnt1.shape)
peri = cv2.arcLength(screenCnt1, closed=True) # 计算轮廓周长screenCnt =cv2.approxPolyDP(screenCnt,0.05 *peri, closed: True) # 轮廓近似print(screencnt.shape)
screenCnt=cv2.approxPolyDP(screenCnt1,0.05*peri,closed=True)
print(screenCnt.shape)
image_contour = cv2.drawContours(image.copy(), contours= [screenCnt],contourIdx=-1,color= (0, 255,0), thickness= 2)
cv_show('image_contour',image_contour)
warped = four_point_transform(orig,screenCnt.reshape(4,2)*ratio)
cv2.imwrite('warped.jpg',warped)
cv2.namedWindow('warped',cv2.WINDOW_NORMAL)
cv2.imshow('warped',warped)
cv2.waitKey(0)

这个先传入了一个图片，然后进行熟悉的操作，灰度图处理，二值化，轮廓检测，根据面积找出我们的目标，进行近似，这里主要就是

    M=cv2.getPerspectiveTransform(rect,dst)
    warped = cv2.warpPerspective(image, M, (maxWidth,maxHeight))

这两个代码，一个是得到当前坐标转化为目标位置的参数

可以看到这里的M

就是坐标之间转化的参数（权重参数）

然后这个的warped = cv2.warpPerspective(image, M, (maxWidth,maxHeight))就可以获得我们转化好的图片了。

还有要注意这一点

这里原本的是4*1*2的矩阵要转化为4*2的这样刚好对应四个点的坐标。

结果展示

这里看着好像不那么清楚，所以先我们进行了一下形态学转化变得的更清晰了一点。

形态学转化优化

gray1=cv2.cvtColor(warped,cv2.COLOR_BGR2GRAY)
warped1=cv2.threshold(gray1,100,255,cv2.THRESH_BINARY)[1]
warped1=resize(warped1,height=500)
cv_show('warped1',warped1)
kernel=np.ones((2,2),np.uint8)
erosion = cv2.erode(warped1,kernel,iterations=1)
cv_show('erosion',erosion)
rotated_image1 =np.rot90(erosion, k=1)
cv_show('rotated_image1',rotated_image1)

这里我先进行了灰度图和二值化处理，然后不知道怎么回事图片有点大，我有进行了一次缩放，然后再进行了一次腐蚀，有人可能会说为什么要进行腐蚀呢？我们的目的不是要让线条更粗一点吗？原因是之前我们的处理都是对黑底白字进行处理的，也就是说，我们的膨胀处理是让白色更粗，但是我们这里是让黑字更明显，所以这里用来腐蚀来处理，如果这个进行了二值化处理并把黑白调换了，那么用膨胀就是可以的。