精华内容
下载资源
问答
  • 图像仿射变换python实现

    千次阅读 2020-03-18 21:54:21
    写文章不易,如果您觉得此... 仿射变换介绍: 请参考:图解图像仿射变换:https://www.cnblogs.com/wojianxin/p/12518393.html 图像仿射变换之图像平移:https://www.cnblogs.com/wojianxin/p/12519498.html 二...

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


    一. 仿射变换介绍:

        请参考:图解图像仿射变换: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


    七. 版权声明:

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

    展开全文
  • 写文章不易,如果您觉得此文对您有所帮助,请帮忙点赞、评论、收藏,感谢您! 一. 仿射变换介绍:  请参考:图解图像仿射变换... python实现仿射变换——图像平移 import cv2 import numpy as np # 图像仿射变换->图
  • 对像素点直接操作来实现仿射变换 第一部分:图片倒置 1.图片倒置就是将图片的像素点就行倒置,左上角的像素点 与对应右下角的像素点就行交换,经过这样的操作后,就实现了图片的倒置,下面给出操作的代码。 import...

    对像素点直接操作来实现仿射变换


    第一部分:图片倒置


    1.图片倒置就是将图片的像素点就行倒置,左上角的像素点 与对应右下角的像素点就行交换,经过这样的操作后,就实现了图片的倒置,下面给出操作的代码。

    import cv2
    import numpy as np
    
    img = cv2.imread("1.jpg")
    h,w = img.shape[:2]
    dst = np.zeros((h*2,w*2,3),np.uint8)
    for i in range(h):
    	for j in range(w):
    		dst[i,j] = img[i,j]
    		dst[h*2-i-1,w*2-j-1] = img[i,j]
    cv2.imshow("dst",dst)
    cv2.waitkey(0)
    
    

    在这里插入图片描述

    第二部分:镜像


    就想在照镜子一样,里面的你和镜子里面的一样,完全一样。
    转换成对像素操作就是上下像素点互换。

    import cv2
    import numpy as np
    
    img = cv2.imread("1.jpg")
    h,w = img.shape[:2]
    dst = np.zeros((h*2,w*2,3),np.uint8)
    for i in range(h):
    	for j in range(w):
    		dst[i,j] = img[i,j]
    		dst[h*2-i-1,j] = img[i,j]
    cv2.imshow("dst",dst)
    cv2.waitkey(0)
    
    

    在这里插入图片描述
    以上就是仿射变换的一般操作,还要其他的变换,例如:旋转等,当然也可以直接调用cv2提供的api直接实现,可以去查看一下官方的文档学习一下。

    Thank for your reading !

    展开全文
  • 图像的仿射变换原理及python实现

    万次阅读 多人点赞 2018-09-21 13:16:17
    1. 原理 ...仿射变换保持了二维图形的“平直性”(直线经仿射变换后依然为直线)和“平行性”(直线之间的相对位置关系保持不变,平行线经仿射变换后依然为平行线,且直线上点的位置顺序不会发生变化)...

    1. 原理

    1.1 原理

    仿射变换(Affine Transformation 或Affine Map)是一种二维坐标(x, y)到二维坐标(u, v)的线性变换,其数学表达式形式如下:
    在这里插入图片描述
    对应的齐次坐标矩阵表示形式为:
    在这里插入图片描述
    仿射变换保持了二维图形的“平直性”(直线经仿射变换后依然为直线)和“平行性”(直线之间的相对位置关系保持不变,平行线经仿射变换后依然为平行线,且直线上点的位置顺序不会发生变化)。非共线的三对对应点确定一个唯一的仿射变换。

    1.2 二维图像仿射变换

    图像处理中,可应用仿射变换对二维图像进行平移、缩放、旋转等操作。实例如下:
    在这里插入图片描述
    经仿射变换后,图像关键点依然构成三角形,但三角形形状已经发生变化。

    1.3 原子变换

    仿射变换通过一系列原子变换复合实现,具体包括:平移(Translation)、缩放(Scale)、旋转(Rotation)、翻转(Flip)和错切(Shear)。
    a. 平移
    在这里插入图片描述
    在这里插入图片描述
    b. 缩放
    在这里插入图片描述
    在这里插入图片描述
    c. 旋转
    在这里插入图片描述
    在这里插入图片描述
    d. 翻转
    在这里插入图片描述
    在这里插入图片描述
    e. 错切
    错切亦称为剪切或错位变换,包含水平错切和垂直错切,常用于产生弹性物体的变形处理。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    1.4 程序

    clc;
    clear all;close all;
    clc;
    
    image = imread('jyy.png');
    
    % u = 4 * x and v = 2 * y
    T = [4 0 0; 0 2 0; 0 0 1];
    
    % create spatial transformation structure.
    transformation = maketform('affine', T);
    
    % apply 2D spatial transformation to image.
    transformationResult = imtransform(image, transformation);
    

    结果示例:
    在这里插入图片描述
    在这里插入图片描述

    2. Python-opencv实现图像的几何变换

    2.1 写在前面

    二维与三维图像的几何变换在计算机图形学上有重要的应用,包括现在的许多图像界面的切换、二维与三维游戏画面控制等等都涉及到图像几何变换,就比如说在三维游戏中,控制角色三维移动的时候,画面是要跟着移动的,那么怎么移动,怎么让上一时刻的画面移动到这一时刻,这都是根据了你的移动量,然后找到三维坐标之间的对应关系,用这一时刻的坐标替换到上一时刻的坐标像素值实现图像的切换。
    图像的几何变换主要包括:平移、扩大与缩小、旋转、仿射、透视等等。图像变换是建立在矩阵运算基础上的,通过矩阵运算可以很快的找到对应关系。理解变换的原理需要理解变换的构造方法以及矩阵的运算方法,曾经写过matlab下的简单图像变换原理,里面有最基础的构造原理可以看看: matlab之原始处理图像几何变换

    2.2 图像的平移

    下面介绍的图像操作假设你已经知道了为什么需要用矩阵构造才能实现了(上面那个博客有介绍为什么)。那么关于偏移很简单,图像的平移,沿着x方向tx距离,y方向ty距离,那么需要构造移动矩阵:

    通过numpy来产生这个矩阵,并将其赋值给仿射函数cv2.warpAffine().
    仿射函数cv2.warpAffine()接受三个参数,需要变换的原始图像,移动矩阵M 以及变换的图像大小(这个大小如果不和原始图像大小相同,那么函数会自 动通过插值来调整像素间的关系)。
    一个例子如下:

    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    img = cv2.imread('flower.jpg')
    H = np.float32([[1,0,100],[0,1,50]])
    rows,cols = img.shape[:2]
    res = cv2.warpAffine(img,H,(rows,cols)) #需要图像、变换矩阵、变换后的大小
    plt.subplot(121)
    plt.imshow(img)
    plt.subplot(122)
    plt.imshow(res)
    

    在这里插入图片描述

    2.3 图像的扩大与缩小

    图像的扩大与缩小有专门的一个函数,cv2.resize(),那么关于伸缩需要确定的就是缩放比例,可以是x与y方向相同倍数,也可以单独设置x与y的缩放比例。另外一个就是在缩放以后图像必然就会变化,这就又涉及到一个插值问题。那么这个函数中,缩放有几种不同的插值(interpolation)方法,在缩小时推荐cv2.INTER_ARER,扩大是推荐cv2.INTER_CUBIC和cv2.INTER_LINEAR。默认都是cv2.INTER_LINEAR,比如:

    import cv2
    import matplotlib.pyplot as plt
    
    img = cv2.imread('flower.jpg')
    # 插值:interpolation
    # None本应该是放图像大小的位置的,后面设置了缩放比例,
    #所有就不要了
    res1 = cv2.resize(img,None,fx=2,fy=2,interpolation=cv2.INTER_CUBIC)
    #直接规定缩放大小,这个时候就不需要缩放因子
    height,width = img.shape[:2]
    res2 = cv2.resize(img,(2*width,2*height),interpolation=cv2.INTER_CUBIC)
    plt.subplot(131)
    plt.imshow(img)
    plt.subplot(132)
    plt.imshow(res1)
    plt.subplot(133)
    plt.imshow(res2)
    

    在这里插入图片描述
    通过坐标轴可以看到图像扩大了一倍,并且两种方法相同。

    2.4 图像的旋转

    图像的旋转矩阵一般为:
    在这里插入图片描述
    但是单纯的这个矩阵是在原点处进行变换的,为了能够在任意位置进行旋转变换,opencv采用了另一种方式:

    为了构造这个矩阵,opencv提供了一个函数:
    cv2.getRotationMatrix2D(),这个函数需要三个参数,旋转中心,旋转角度,旋转后图像的缩放比例,比如下例:

    import cv2
    import matplotlib.pyplot as plt
    
    img = cv2.imread('flower.jpg')
    rows,cols = img.shape[:2]
    #第一个参数旋转中心,第二个参数旋转角度,第三个参数:缩放比例
    M = cv2.getRotationMatrix2D((cols/2,rows/2),45,1)
    #第三个参数:变换后的图像大小
    res = cv2.warpAffine(img,M,(rows,cols))
    
    plt.subplot(121)
    plt.imshow(img)
    plt.subplot(122)
    plt.imshow(res)
    

    在这里插入图片描述

    2.5 图像的仿射

    图像的旋转加上拉升就是图像仿射变换,仿射变化也是需要一个M矩阵就可以,但是由于仿射变换比较复杂,一般直接找很难找到这个矩阵,opencv提供了根据变换前后三个点的对应关系来自动求解M。这个函数是
    M=cv2.getAffineTransform(pos1,pos2),其中两个位置就是变换前后的对应位置关系。输 出的就是仿射矩阵M。然后在使用函数cv2.warpAffine()。形象化的图如下(引用参考的)
    在这里插入图片描述
    一个例子比如:

    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    img = cv2.imread('flower.jpg')
    rows,cols = img.shape[:2]
    pts1 = np.float32([[50,50],[200,50],[50,200]])
    pts2 = np.float32([[10,100],[200,50],[100,250]])
    M = cv2.getAffineTransform(pts1,pts2)
    #第三个参数:变换后的图像大小
    res = cv2.warpAffine(img,M,(rows,cols))
    plt.subplot(121)
    plt.imshow(img)
    plt.subplot(122)
    plt.imshow(res)
    

    在这里插入图片描述

    2.6 图像的透射

    透视需要的是一个3*3的矩阵,同理opencv在构造这个矩阵的时候还是采用一种点对应的关系来通过函数自己寻找的,因为我们自己很难计算出来。这个函数是M = cv2.getPerspectiveTransform(pts1,pts2),其中pts需要变换前后的4个点对应位置。得到M后在通过函数cv2.warpPerspective(img,M,(200,200))进行。形象化的图如下(引用参考的)
    在这里插入图片描述
    一个例子如下:

    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    img = cv2.imread('flower.jpg')
    rows,cols = img.shape[:2]
    pts1 = np.float32([[56,65],[238,52],[28,237],[239,240]])
    pts2 = np.float32([[0,0],[200,0],[0,200],[200,200]])
    M = cv2.getPerspectiveTransform(pts1,pts2)
    res = cv2.warpPerspective(img,M,(200,200))
    plt.subplot(121)
    plt.imshow(img)
    plt.subplot(122)
    plt.imshow(res)
    

    在这里插入图片描述

    原文链接:
    图像几何变换之仿射变换
    Python下opencv使用笔记(三)(图像的几何变换)

    展开全文
  • python 仿射变换

    千次阅读 2019-05-29 15:15:57
    记录学习Python Computer Vision的过程 第三次 Homography(单应性变换) 图像变换的方法很多,单应性变换是其中一种方法,单应性变换会涉及到单应性矩阵。单应性变换的目标是通过给定的几个点(通常是4对点)来得到...

    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)。

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

    image

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

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

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

    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()会返回给定对应点对的最优仿射变换。

    图像扭曲

    对图像块应用仿射变换,我们将其称为图像扭曲。该操作不仅经常应用在计算机图形学,而且经常出现在计算机视觉算法中。扭曲操作可以使用SciPy工具包中的nadimage包来完成。使用这个包进行线性变换A和一个平移量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变量是图像变换目标坐标,它按照从左上角逆时针的顺序,定义第一幅图像的四个角的点在第二幅中的位置。

    原图:
    在这里插入图片描述
    在这里插入图片描述

    实验结果如下:
    在这里插入图片描述

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

    小结

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

    展开全文
  • 利用Python语言,定义一个类,完成对长方形进行仿射变换。类属性包括有长方形的高度Height、宽度Width,左上角坐标Left,Top。类操作包括有:x方向平移,y方向平移,xy同时平移,x方向拉伸,y方向拉伸,xy方向同比例...
  • 图像的仿射变换原理及示例(python)

    千次阅读 2019-03-19 22:56:26
    对图像块应用仿射变换,我们将其称为图像扭曲(或者仿射扭曲)。指的是在几何中,一个向量空间进行一次线性变换并接上一个平移,变换为另一个向量空间。下面会介绍仿射变换的原理及简单应用。 ...
  • python+opencv三点仿射变换

    千次阅读 2019-02-26 15:56:27
    一张图来表明要实现的功能: 说明:将一张正正方方的矩形图转换成平行四边形(甚至不规则四边形)的操作。...三个点的坐标就是6个数字,我们把6个数字设置成自己想要的位置,就可以实现三点仿射变换。我...
  • 利用Python实现图像的仿射变换   仿射变换通常用于图像的几何矫正、图像配准   在透视映射下,物体的形状会失真。例如,虽然原本矩形的窗户、书本,由于成像角度的原因,最终呈现在图像上,便会是另外一种不太...
  • python中利用opencv做仿射变换

    千次阅读 2018-10-18 23:49:10
    首先你需要清楚的就是你是以什么位置为中心点,以什么角度做仿射变换,例如,我就是在通过mtcnn获得人脸的五个关键点坐标后,以双眼的位置中心为中心点,以双眼的倾斜角度为纠正角度,对其做放...
  • 什么是仿射变换仿射变换就是图像的线性变换加上平移 用一幅图表示,就是  由 image1 到 image2 的转换经过了三个操作 旋转 (线性变换)缩放操作(线性变换)平移 (向量加) 如果没有了第3个平移的操作,那它就是...
  • python-opencv实现图像仿射变换

    千次阅读 2019-05-29 15:28:19
    python-opencv实现图像仿射变换的代码: 所需实现的功能: 对一幅二值图像中值为255的轮廓内的部分进行放大缩小操作,需保证中心点位置不变。 groundtruth = cv2.imread(groundtruth_path)[:, :, 0] h1, w1 = ...
  • 本节介绍了仿射变换的概念、类型、基本仿射变换矩阵、OpenCV-Python仿射变换相关的主要函数及语法说明,并提供了两种不同方式实现的图像旋转和任选三个点将圈定子图放大的示例。通过阅读相关内容可以有助于大家...
  • 1.图像的仿射变换 1)平移 2)放大和缩小 3)旋转 4)计算仿射变换矩阵 5)插值算法 6)Python实现 2.图像的投影变换 3.极坐标转换 总结 首先要了解OpenCV的坐标原点(0,0)是在坐标的左上角,实现集合变换需要...
  • 图像img的像素为534*300,img.shape = (300, 534, 3)。 需要引入: import cv2 as cv import numpy as np ...img.shape得到的(300, 534, 3),前者300是高度,y轴的值...cv2.warpAffine() 仿射变换(从二维坐标到二维
  • 一、仿射变换原理介绍 1、原理部分 2、代码实现部分以及部分主要函数解析 2.1 代码实现部分 ​2.2.主要函数 2.2.1.α通道原理 一、仿射变换原理介绍 在计算机视觉的应用里,有一个叫仿射变换的重要变换。...
  • 在前面实现了平移和缩放,还有一种常用的坐标变换,那就是旋转。比如拍摄的照片上传到电脑里,再打开时发现人的头在下面脚在上,这样肯定看不了,那么就需要把这个照片旋转180度才可以接受。由于旋转变换,都是绕着...
  • 缩放变换 缩放就是改变图像的大小,使用cv2.resize()函数。图像的大小可以手动指定,也可以使用缩放比例。cv2.resize()支持多种插值算法,默认使用的是cv2.INTER_LINEAR(不管放大和缩小)。缩小最适合使用:cv2....
  • 主要介绍了Python实现仿射密码的思路详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了Python 在OpenCV里实现仿射变换—坐标变换效果,本文通过一个例子给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • python实现基于SIFT算法的图像配准(仿射变换

    万次阅读 热门讨论 2019-04-23 16:59:12
    话不多说,直接上代码,可以用的话别忘了请喝可乐!(手动笑哭脸) 【用法】 第45、46行的输入: img1 = cv2.imread('sift/3....python的跨平台特性好,windows和macOS系统都可用。输出:三幅图像。窗口1、窗口2...
  • 返回值中的rotate是旋转后的CV图像,RotateMatrix是仿射变换矩阵(两行三列)。我们对需要旋转的点构造一个三行一列的矩阵,这样通过矩阵的乘法获得的另一个矩阵就是我们需要的旋转变换后的点的坐标。获得旋转后的点...
  • 空间变换中的仿射变换对应着五种变换,平移,缩放,旋转,翻转,错切。而这五种变化由原图像转变到变换图像的过程,可以用仿射变换矩阵进行描述。而这个变换过程可以用一个3*3的矩阵与原图进行相乘得到。 仿射变换...
  • OpenCV-Python仿射变换开发中遇到的坑

    千次阅读 2021-02-19 16:11:00
    本文介绍了老猿在使用OpenCV-Python进行仿射变换开发中遇到的坑,这些问题可能大家或多或少会碰到,这些问题涉及基本知识的理解、官方资料的坑等方面,希望能帮助到大家。
  • 一、图像仿射变换 1.原理 仿射变换(Affine Transformation 或Affine Map)是一种二维坐标(x, y)到二维坐标(u, v)的线性变换,转换过程坐标点的相对位置和属性不发生变换,是一个线性变换,该过程只发生旋转和...
  • 最后的人脸对齐尺寸分为两种:112X96尺寸和112X112尺寸,其中首先需要定死仿射变换后人脸在目标图上的坐标,然后直接变换。废话不多说,直接手撕代码。 # 该代码实现利用人脸的五点仿射变换实现人脸对齐 # 具体就是...
  • 对图像块应用仿射变换,我们将其称为图像扭曲(或者仿射扭曲)。该操作不仅经常应用在计算机图形学中,而且经常出现在计算机视觉算法中。 一、仿射变换原理 仿射变换能够保持图像的“平直性”,包括旋转,缩放,平移...
  • 仿射变换,又称仿射映射,是指在几何张,一个向量空间(vector space)进行一次线性变换(linear transformation)并拼上一个平移(Translation ),其矩阵表达形式(matrix formal)为: y⃗ m×1=Am×nx⃗ n×1...
  • 仿射变换过程,(x,y)表示原图像中的坐标,(x',y')表示目标图像的坐标 ↑ 二. 仿射变换倾斜算法原理: 原图像大小为h*w X-sharing: 倾斜之x轴逆时针旋转tx度时的图像仿射变换公式 ↑ Y-sharing: 倾斜...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,072
精华内容 2,028
关键字:

仿射变换python

python 订阅