1.4 Python图像的坐标变换-仿射变换

1 算法原理

图像的几何变换，也就是矩阵乘法。

通过仿射变换将图片中的每个像素点按照一定的规律映射到新的位置，仿射变换可以由一个矩阵A和一个向量B给出：

原像素点坐标(x,y)，经过仿射变换后的点的坐标是T（u,v），则矩阵仿射变换基本算法原理：

齐次坐标矩阵表示形式为：

2 代码

运行代码说明

1.要改变代码中的地址，我的地址说明，我是把待处理图片统一放在一个（同级）image文件夹，用os.listdir(base)读取图片名称列表，base是存放图片文件夹的相对路径，也可以是绝对路径

最后在os.path.join(base,path)代码中合并base和图片名称，得到完整图片地址

2.如果想更改为读取同目录下图片，可以将读取图片路径的几句代码可以改为

原来

base = r'../image'
paths = os.listdir(base)
for path in paths:
	img = cv.imread(os.path.join(base,path), 1)

改为

paths = ['img1.jpg','img2.jpg','img3.png'......]
for path in paths:
    print(path)
    # 读取图片 1 是加载彩色图像。任何图像的透明度都会被忽视。它是默认标志。
    img = cv.imread(path, 1)

3.注意最后的plt.savefig('1.new' + path)是保存plt图像，如果不使用可以注释掉

import os

import numpy as np
import cv2
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号

base = r'../image'  # 注意，我是通过循环一次性处理3张图片的
paths = os.listdir(base)
for path in paths:
    img = cv2.imread(os.path.join(base,path), 1)
    height, width = img.shape[:2]  # 405x413
    # 在原图像和目标图像上各选择三个点
    matSrc = np.float32([[0, 0],[0, height-10],[width-1, 0]])
    matDst = np.float32([[0, 0],[90, height-90],[width-30, 30]])
    # 得到变换矩阵
    matAffine = cv2.getAffineTransform(matSrc, matDst)
    # 进行仿射变换
    dst = cv2.warpAffine(img, matAffine, (width,height))

    fig = plt.figure()
    ax1 = fig.add_subplot(121)
    ax1.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    ax1.set_title('原图')
    ax2 = fig.add_subplot(122)
    ax2.imshow(cv2.cvtColor(dst, cv2.COLOR_BGR2RGB))
    ax2.set_title('仿射变换')
    # plt.savefig('4.new' + path)
    plt.show()  # 显示图片

3 效果

写文章不易，如果您觉得此文对您有所帮助，请帮忙点赞、评论、收藏，感谢您！

一. 仿射变换介绍：

    请参考：图解图像仿射变换：https://www.cnblogs.com/wojianxin/p/12518393.html

                  图像仿射变换之图像平移：https://www.cnblogs.com/wojianxin/p/12519498.html

二. 仿射变换 公式：

仿射变换过程，(x,y)表示原图像中的坐标，(x',y')表示目标图像的坐标 ↑

三. 实验：利用我的上一篇文章（https://www.jianshu.com/p/1cfb3fac3798）的算法实现图像仿射变换——图像缩放

        要实现其他功能的仿射变换，请读者照葫芦画瓢，自行举一反三：

实验目标，将输入图像在x方向上放大至原来的1.5倍，在y方向上缩小为原来的0.6倍。并沿x轴负向移动30像素，y轴正向移动100像素。

实验代码：

import cv2
import numpy as np

# Affine Transformation
def affine(img, a, b, c, d, tx, ty):
	H, W, C = img.shape

	# temporary image
	tem = img.copy()
	img = np.zeros((H+2, W+2, C), dtype=np.float32)
	img[1:H+1, 1:W+1] = tem

	# get new image shape
	H_new = np.round(H * d).astype(np.int)
	W_new = np.round(W * a).astype(np.int)
	out = np.zeros((H_new+1, W_new+1, C), dtype=np.float32)

	# get position of new image
	x_new = np.tile(np.arange(W_new), (H_new, 1))
	y_new = np.arange(H_new).repeat(W_new).reshape(H_new, -1)

	# get position of original image by affine
	adbc = a * d - b * c
	x = np.round((d * x_new  - b * y_new) / adbc).astype(np.int) - tx + 1
	y = np.round((-c * x_new + a * y_new) / adbc).astype(np.int) - ty + 1

	x = np.minimum(np.maximum(x, 0), W+1).astype(np.int)
	y = np.minimum(np.maximum(y, 0), H+1).astype(np.int)

	# assgin pixcel to new image
	out[y_new, x_new] = img[y, x]

	out = out[:H_new, :W_new]
	out = out.astype(np.uint8)

	return out

# Read image
image = cv2.imread("../paojie.jpg").astype(np.float32)
# Affine
out = affine(image, a=1.5, b=0, c=0, d=0.6, tx=-30, ty=100)
# Save result
cv2.imshow("result", out)
cv2.imwrite("out.jpg", out)
cv2.waitKey(0)
cv2.destroyAllWindows()

四. 实验中的难点，晦涩难懂的代码讲解：

    可以参考：https://www.cnblogs.com/wojianxin/p/12519498.html  或者

                      https://www.jianshu.com/p/1cfb3fac3798

五. 实验结果：

原图 ↑

仿射变换结果(x*1.5-30,y*0.6+100) ↑

六. 参考文献：

        https://www.jianshu.com/p/464370cd6408

        https://www.cnblogs.com/wojianxin/p/12520069.html

七. 版权声明：

    未经作者允许，请勿随意转载抄袭，抄袭情节严重者，作者将考虑追究其法律责任，创作不易，感谢您的理解和配合！

PCV-chapter03

记录学习Python Computer Vision的过程

第三次

Homography（单应性变换）

图像变换的方法很多，单应性变换是其中一种方法，单应性变换会涉及到单应性矩阵。单应性变换的目标是通过给定的几个点（通常是4对点）来得到单应性矩阵。单应性变换是将一个平面内的点映射到另一个平面内的二维投影变换。平面指的是图像或者三维中平面表面，单应性变换的具有很强的实用性，比如图像标配，图像纠正和纹理扭曲，以及创建全景图像。

基础变换

• 刚体变换(rigid transformation): 旋转和平移变换/rotation,translation, 3个自由度，点与点之间的距离不变
• 相似变换(similarity transformation): 增加了缩放尺度, 四个自由度，点与点之间的距离比不变。
• 仿射变换(affine transformation): 仿射变换和相似变换近似，不同之处在于相似变换具有单一旋转因子和单一缩放因子，仿射变换具有两个旋转因子和两个缩放因子，因此具有6个自由度. 不具有保角性和保持距离比的性质，但是原图平行线变换后仍然是平行线.
• 投影变换(projective transformation): 也叫作单应性变换。投影变换是齐次坐标下非奇异的线性变换。然而在非齐次坐标系下却是非线性的，这说明齐次坐标的发明是很有价值的。投影变换比仿射变换多2个自由度，具有8个自由度。上面提到的仿射变换具有的“不变”性质，在投影变换中已不复存在了。尽管如此，它还是有一项不变性，那就是在原图中保持共线的3个点，变换后仍旧共线。
• 透视变换: 将3D空间点投影成2D点的变换

Affine Transformation（仿射变换）

仿射变换就是说一种二维坐标到二维坐标之间的线性变换，然后在变换后还能保持图形的平直性和平行性，通俗的说就是变换后的图形中，直线还是直线，圆弧还是圆弧，而且图形间的相对位置，平行线还有直线的交角都不会改变，一条直线上的几段线段之间的比例关系保持不变。但是这里要提一下，仿射变换不会保持原来的线段长度，和夹角角度不变。

仿射变换可以通过一系列的原子变换的复合来实现，包括：平移（Translation）、缩放（Scale）、翻转（Flip）、旋转（Rotation）和剪切（Shear）。

仿射变换可以用下面公式表示：

在上面这个公式中你可以实现平移、缩放、翻转、旋转等变换后的坐标

所以说仿射变换可以理解为经过对坐标轴的放缩，旋转，平移后原坐标在在新坐标域中的值
更简洁的说：仿射变换=线性变换+平移

我们有许多种方法来求这个仿射变换矩阵。下面我们使用对应点来计算仿射变换矩阵，下面是具体函数

def Haffine_from_points(fp,tp):
    """ Find H, affine transformation, such that 
        tp is affine transf of fp. """
    
    if fp.shape != tp.shape:
        raise RuntimeError('number of points do not match')
        
    # condition points
    # --from points--
    m = mean(fp[:2], axis=1)
    maxstd = max(std(fp[:2], axis=1)) + 1e-9
    C1 = diag([1/maxstd, 1/maxstd, 1]) 
    C1[0][2] = -m[0]/maxstd
    C1[1][2] = -m[1]/maxstd
    fp_cond = dot(C1,fp)
    
    # --to points--
    m = mean(tp[:2], axis=1)
    C2 = C1.copy() #must use same scaling for both point sets
    C2[0][2] = -m[0]/maxstd
    C2[1][2] = -m[1]/maxstd
    tp_cond = dot(C2,tp)
    
    # conditioned points have mean zero, so translation is zero
    A = concatenate((fp_cond[:2],tp_cond[:2]), axis=0)
    U,S,V = linalg.svd(A.T)
    
    # create B and C matrices as Hartley-Zisserman (2:nd ed) p 130.
    tmp = V[:2].T
    B = tmp[:2]
    C = tmp[2:4]
    
    tmp2 = concatenate((dot(C,linalg.pinv(B)),zeros((2,1))), axis=1) 
    H = vstack((tmp2,[0,0,1]))
    
    # decondition
    H = dot(linalg.inv(C2),dot(H,C1))
    
    return H / H[2,2]

该函数有有以下参数：

• fp：图像固定点坐标
• tp ：图像变换目标坐标

我们能够使用函数Haffine_from_points()来求出仿射变换,函数Haffine_from_points()会返回给定对应点对的最优仿射变换。

图像扭曲

对图像块应用仿射变换，我们将其称为图像扭曲。该操作不仅经常应用在计算机图形学，而且经常出现在计算机视觉算法中。扭曲操作可以使用ＳｃｉＰｙ工具包中的ｎａｄｉｍａｇｅ包来完成。使用这个包进行线性变换Ａ和一个平移量b来对图像块应用仿射变换。演示代码如下：

from scipy import ndimage
from PIL import Image
from pylab import *

im = array(Image.open(r'C:\Users\ZQQ\Desktop\advanced\study\computervision\images\ch02\j03.jpg').convert('L'))
H = array([[1.4,0.05,-100],[0.05,1.5,-100],[0,0,1]])
im2 = ndimage.affine_transform(im,H[:2,:2],(H[0,2],H[1,2]))

figure()
gray()
subplot(121)
axis('off')
imshow(im)
subplot(122)
axis('off')
imshow(im2)
show()

原图：

结果：

Alpha通道

在仿射扭曲的例子中有一个简单的应用是将图像或者图像的一部分放置在另一幅图像中，使得它们能够和指定的区域或者标记物对齐。将扭曲的图像和第二幅图像融合，我们就创建了alpha图像。该图像定义了每个像素从各个图像中获取的像素值成分多少。我们基于以下事实，扭曲的图像是在扭曲区域边界之外以0来填充的图像，来创建一个二值的alpha图像。

在计算机图形学中，一个RGB颜色模型的真彩图形，用由红、绿、蓝三个色彩信息通道合成的，每个通道用了8位色彩深度，共计24位，包含了所有彩色信息。为实现图形的透明效果，采取在图形文件的处理与存储中附加上另一个8位信息的方法，这个附加的代表图形中各个素点透明度的通道信息就被叫做Alpha通道。

Alpha通道使用8位二进制数，就可以表示256级灰度，即256级的透明度。白色（值为255）的Alpha像素用以定义不透明的彩色像素，而黑色（值为0）的Alpha通道像素用以定义透明像素，介于黑白之间的灰度（值为30-255）的Alpha像素用以定义不同程度的半透明像素。因而通过一个32位总线的图形卡来显示带Alpha通道的图形，就可能呈现出透明或半透明的视觉效果。

事实上，我们把需要组合的颜色计算出不含Alpha分量的原始RGB分量然后相加便可。如：两幅图像分别为A和B，由这两幅图像组合而成的图像称为C，则可用如下四元组表示图A和B，三元组表示图像C：

• A：（Ra，Ga，Ba，Alphaa）
• B：（Rb，Gb，Bb，Alphab）
• C：（Rc，Gc，Bc）

根据上述算法，则：

• Rc=RaAlphaa+RbAlphab
• Gc=GaAlphaa+GbAlphab
• Bc=BaAlphaa+BbAlphab

这就是两图像混合后的三原色分量。如果有多幅图像需要混合，则按照以上方法两幅两幅地进行混合。

图像中的图像

使用仿射变换将一幅图像放置到另一幅图像中

代码如下：

 # -*- coding: utf-8 -*-
from PCV.geometry import warp, homography
from PIL import  Image
from pylab import *
from scipy import ndimage

# example of affine warp of im1 onto im2

im1 = array(Image.open(r'C:\Users\ZQQ\Desktop\advanced\study\computervision\images\ch03\03.jpg').convert('L'))
im2 = array(Image.open(r'C:\Users\ZQQ\Desktop\advanced\study\computervision\images\ch03\01.jpg').convert('L'))
# set to points
tp = array([[280,574,574,280],[340,340,735,735],[1,1,1,1]])
#tp = array([[675,826,826,677],[55,52,281,277],[1,1,1,1]])
im3 = warp.image_in_image(im1,im2,tp)
figure()
gray()
subplot(141)
axis('off')
imshow(im1)
subplot(142)
axis('off')
imshow(im2)
subplot(143)
axis('off')
imshow(im3)

# set from points to corners of im1
m,n = im1.shape[:2]
fp = array([[0,m,m,0],[0,0,n,n],[1,1,1,1]])
# first triangle
tp2 = tp[:,:3]
fp2 = fp[:,:3]
# compute H
H = homography.Haffine_from_points(tp2,fp2)
im1_t = ndimage.affine_transform(im1,H[:2,:2],
(H[0,2],H[1,2]),im2.shape[:2])
# alpha for triangle
alpha = warp.alpha_for_triangle(tp2,im2.shape[0],im2.shape[1])
im3 = (1-alpha)*im2 + alpha*im1_t
# second triangle
tp2 = tp[:,[0,2,3]]
fp2 = fp[:,[0,2,3]]
# compute H
H = homography.Haffine_from_points(tp2,fp2)
im1_t = ndimage.affine_transform(im1,H[:2,:2],
(H[0,2],H[1,2]),im2.shape[:2])
# alpha for triangle
alpha = warp.alpha_for_triangle(tp2,im2.shape[0],im2.shape[1])
im4 = (1-alpha)*im3 + alpha*im1_t
subplot(144)
imshow(im4)
axis('off')
show()

在其中定义的tp变量是图像变换目标坐标，它按照从左上角逆时针的顺序，定义第一幅图像的四个角的点在第二幅中的位置。

原图：

实验结果如下：

在上面的例子中，对应点对为图像和教室幕布的角点。仿射变换可以将一幅图像进行扭曲，是这对应点对可以完美匹配上。这是因为，仿射变换具有六个自由度。

小结

本次实验主要学习了仿射变换，和应用仿射变换