精华内容
下载资源
问答
  • 今天小编就为大家分享一篇Python-opencv 双线性插值实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 使用python对2维图像采用最邻近插值双线性插值算法实现旋转
  • 双线性插值python实现

    2019-10-13 15:55:51
    双线性插值python实现 #!/usr/bin/python # -*- coding: utf-8 -*- __author__ = 'Alex Wang' import numpy as np import cv2 import time ''' python implementation of bilinear interpolation ''' ...

    双线性插值python实现

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
     
    __author__ = 'Alex Wang'
     
    import numpy as np
    import cv2
    import time
     
     
    '''
    python implementation of bilinear interpolation
    '''
     
     
    def bilinear_interpolation(img,out_dim):
        src_h, src_w, channel = img.shape
        dst_h, dst_w = out_dim[1], out_dim[0]
        if src_h == dst_h and src_w == dst_w:
            return img.copy()
        dst_img = np.zeros((dst_h,dst_w,3),dtype=np.uint8)
        scale_x, scale_y = float(src_w) / dst_w, float(src_h) / dst_h
        for i in range(3):
            for dst_y in range(dst_h):
                for dst_x in range(dst_w):
     
                    # find the origin x and y coordinates of dst image x and y
                    # use geometric center symmetry
                    # if use direct way, src_x = dst_x * scale_x
                    src_x = (dst_x + 0.5) * scale_x - 0.5
                    src_y = (dst_y + 0.5) * scale_y - 0.5
     
                    # find the coordinates of the points which will be used to compute the interpolation
                    src_x0 = int(np.floor(src_x))
                    src_x1 = min(src_x0 + 1 ,src_w - 1)
                    src_y0 = int(np.floor(src_y))
                    src_y1 = min(src_y0 + 1, src_h - 1)
     
                    # calculate the interpolation
                    temp0 = (src_x1 - src_x) * img[src_y0,src_x0,i] + (src_x - src_x0) * img[src_y0,src_x1,i]
                    temp1 = (src_x1 - src_x) * img[src_y1,src_x0,i] + (src_x - src_x0) * img[src_y1,src_x1,i]
                    dst_img[dst_y,dst_x,i] = int((src_y1 - src_y) * temp0 + (src_y - src_y0) * temp1)
     
        return dst_img
     
     
    if __name__ == '__main__':
        img = cv2.imread('data/cat1.jpg')
        start = time.time()
        dst = bilinear_interpolation(img,(100,100))
        print 'cost %f seconds' % (time.time() - start)
        cv2.imshow('result',dst)
        cv2.waitKey()
    
    
    展开全文
  • 能够实现对一幅图像的最近邻、双线性、双三次三种插值
  • 双线性插值(python实现)

    千次阅读 2019-12-17 16:43:15
    线性插值 线性插值从字面上的意思理解就是,采用线性关系计算新插入的值的大小。更直观的,给定一个一元一次函数f(x)f(x)f(x)以及两个已知的点f(x1),f(x2)f(x_1),f(x_2)f(x1​),f(x2​),计算未知点f(x)f(x)f(x) ...

    线性插值

    线性插值从字面上的意思理解就是,采用线性关系计算新插入的值的大小。更直观的,给定一个一元一次函数 f ( x ) f(x) f(x)以及两个已知的点 f ( x 1 ) , f ( x 2 ) f(x_1),f(x_2) f(x1),f(x2),计算未知点 f ( x ) f(x) f(x)
    在这里插入图片描述
    使用斜率的关系
    f ( x 2 ) − f ( x 1 ) x 2 − x 1 = f ( x ) − f ( x 1 ) x − x 1 f ( x ) = ( x 2 − x ) x 2 − x 1 f ( x 1 ) + ( x − x 1 ) x 2 − x 1 f ( x 2 ) \frac{f(x_2)-f(x_1)}{x_2-x_1}=\frac{f(x)-f(x_1)}{x-x_1} \\ f(x)=\frac{(x_2-x)}{x_2-x_1}f(x_1)+\frac{(x-x_1)}{x_2-x_1}f(x_2) x2x1f(x2)f(x1)=xx1f(x)f(x1)f(x)=x2x1(x2x)f(x1)+x2x1(xx1)f(x2)

    双线性插值

    双线性插值也就是在线性插值的基础上进行了两个方向的计算:

    1.通过 Q 00 和 Q 01 Q00和Q01 Q00Q01线性插值计算出 R 0 R0 R0

    2.通过 Q 10 和 Q 11 Q10和Q11 Q10Q11线性插值计算出 R 1 R1 R1

    3.通过 R 0 和 R 1 R0和R1 R0R1线性插值计算出 P P P

    在这里插入图片描述

    整理后可得
    f ( R 0 ) = ( f ( Q 01 ) − f ( Q 00 ) ) ( w − w 0 ) w 1 − w 0 + f ( Q 00 ) f ( R 1 ) = ( f ( Q 11 ) − f ( Q 10 ) ) ( w − w 0 ) w 1 − w 0 + f ( Q 10 ) f ( P ) = ( f ( R 1 ) − f ( R 0 ) ) ( h − h 0 ) h 1 − h 0 + f ( R 0 ) f(R0)=\frac{(f(Q01)-f(Q00))(w-w0)}{w1-w0}+f(Q00) \\ f(R1)=\frac{(f(Q11)-f(Q10))(w-w0)}{w1-w0}+f(Q10) \\ f(P)=\frac{(f(R1)-f(R0))(h-h0)}{h1-h0}+f(R0) f(R0)=w1w0(f(Q01)f(Q00))(ww0)+f(Q00)f(R1)=w1w0(f(Q11)f(Q10))(ww0)+f(Q10)f(P)=h1h0(f(R1)f(R0))(hh0)+f(R0)
    最终
    f ( P ) = ( h − h 1 ) ( w − w 1 ) ( h 1 − h 0 ) ( w 1 − w 0 ) f ( Q 00 ) + ( h 1 − h ) ( w − w 0 ) ( h 1 − h 0 ) ( w 1 − w 0 ) f ( Q 01 ) + ( h − h 0 ) ( w 1 − w ) ( h 1 − h 0 ) ( w 1 − w 0 ) f ( Q 10 ) + ( h − h 0 ) ( w − w 0 ) ( h 1 − h 0 ) ( w 1 − w 0 ) f ( Q 11 ) f(P)=\frac{(h-h1)(w-w1)}{(h1-h0)(w1-w0)}f(Q00)+\frac{(h1-h)(w-w0)}{(h1-h0)(w1-w0)}f(Q01)\\ +\frac{(h-h0)(w1-w)}{(h1-h0)(w1-w0)}f(Q10)+\frac{(h-h0)(w-w0)}{(h1-h0)(w1-w0)}f(Q11) f(P)=h1h0)(w1w0)(hh1)(ww1)f(Q00)+h1h0)(w1w0)(h1h)(ww0)f(Q01)+h1h0)(w1w0)(hh0)(w1w)f(Q10)+h1h0)(w1w0)(hh0)(ww0)f(Q11)
    细心观察可以发现四个系数之和为1。

    要解决图像中的双线性插值的问题,只需要取距离 P P P点最近的四个点就可以直接带入公式求解,有了计算公式,现在只需要搞定 ( h , w ) (h,w) (h,w)从何而来?

    直接除以倍数

    既然线性插值一般都是要把图像放大,最简单的做法就是把放大后的图像的坐标点除以放大倍数。但是这样会导致几个问题:

    1. 放大的图像与原图不是中心匹配的;
    2. 放大后的图像坐标有一些无法投影到原图。
      1. 例如:在[0,1,2,3]->[0,1,2,3,4,5,6,7,8,9,10,11]中,10/3=3.33, 11/3=3.67 均无法映射到原图

    解决方案:

    使用numpy的linspace可以均匀的将放大后的坐标值映射到原始坐标范围。

    import numpy as np
    import imageio
    import matplotlib.pyplot as plt
    
    
    
    def bilinear_interpolation(image,rate=1.1):
        h,w,c = img.shape
        # 计算放大后的尺寸
        new_h = int(h*rate)
        new_w = int(w*rate)
        # 将放大后的坐标映射到原始坐标范围
        h_s = np.linspace(0,h-1,new_h-1)
        w_s = np.linspace(0,w-1,new_w-1)
        # 创建一个空白的放大后尺寸的图像
        new_img = np.zeros([new_h,new_w,c],dtype=np.uint8)
        # 逐像素的进行计算
        for i in range(new_h-2):
            for j in range(new_w-2):
                for k in range(c):
                    # 左上角坐标
                    h0,w0 = int(h_s[i]),int(w_s[j])
                    # 获得四个点的像素值
                    q_00 = img[h0][w0][k]
                    q_01 = img[h0][w0+1][k]
                    q_10 = img[h0][w0][k]
                    q_11 = img[h0+1][w0+1][k]
                    # 使用公式计算映射点像素值
                    new_img[i][j][k] = (h_s[i]-h0-1) * (w_s[j]-w0-1) * q_00 \
                                     + (h0+1-h_s[i]) * (w_s[j]-w0) * q_01 \
                                     + (h_s[i]-h0) * (w0+1-w_s[j]) * q_10 \
                                     + (h_s[i]-h0) * (w_s[j]-w0) * q_11 
        return new_img
    
    img = plt.imread('0.jpg')
    dst = bilinear_interpolation(img,1.5)
    imageio.imwrite('4.jpg',dst)
    展开全文
  • 最近写深度学习网络需要对feature map进行双线性插值,opencv的resize不能对图像进行批处理,网上找到的双线性插值的代码基本都是三重for循环实现的,效率太低下,干脆自己用numpy库的矩阵运算实现了一个。...

    最近写深度学习网络需要对feature map进行双线性插值,opencv的resize不能对图像进行批处理,网上找到的双线性插值的代码基本都是三重for循环实现的,效率太低下,干脆自己用numpy库的矩阵运算实现了一个。

    双线性插值原理参考:

    https://zhuanlan.zhihu.com/p/112030273

    感谢大佬Orz。

    本文知乎同款:https://zhuanlan.zhihu.com/p/266845896

    import numpy as np
    
    def bilinear_interpolate(source, scale=2, pad=0.5):
    	sour_shape = source.shape
    	(sh, sw) = (sour_shape[-2], sour_shape[-1])
    	padding = pad*np.ones((sour_shape[0], sour_shape[1], sh+1, sw+1))
    	padding[:,:,:-1,:-1] = source
    
    	(th, tw) = (round(scale*sh), round(scale*sw))
    
    	grid = np.array(np.meshgrid(np.arange(th), np.arange(tw)), dtype=np.float32)
    	xy = np.copy(grid)
    	xy[0] *= sh/th
    	xy[1] *= sw/tw
    	x = xy[0].flatten()
    	y = xy[1].flatten()
    
    	clip = np.floor(xy).astype(np.int)
    	cx = clip[0].flatten()
    	cy = clip[1].flatten()
    
    	f1 = padding[:,:,cx,cy]
    	f2 = padding[:,:,cx+1,cy]
    	f3 = padding[:,:,cx,cy+1]
    	f4 = padding[:,:,cx+1,cy+1]
    
    	a = cx+1-x
    	b = x-cx
    	c = cy+1-y
    	d = y-cy
    
    	fx1 = a*f1 + b*f2
    	fx2 = a*f3 + b*f4
    	fy = c*fx1 + d*fx2
    	fy = fy.reshape(fy.shape[0],fy.shape[1],tw,th).transpose((0,1,3,2))
    	return fy

    首先是采用np.meshgrid生成目标图像大小的网格,然后根据scale比例去计算目标图像的网格点对应到原图像的坐标(可能为小数),clip存储的值是待插值点p的左下角点坐标,通过clip可以计算得到待插值点p周围四个整点的坐标,通过该坐标到padding中去索引得到这四个点的灰度值f1, f2, f3, f4,之后就是根据双线性插值公式直接计算得到插值结果了。

    特别需要注意的地方是np.meshgrid生成的行列数与图像行列数是倒转的,因此最后fy.reshape恢复的时候最后两个维度必须是tw,th(正常思路下是先高(th)后宽(tw)但是这样就会出问题),再用np.transpose()函数去转置最后两个维度。

    最后用我家狗子照片测试一下:

    import numpy as np
    import cv2 as cv
    import matplotlib.pyplot as plt
    
    if __name__ == '__main__':
    	path_list = ['./dog.jpg']
    	imgs = []
    	for path in path_list:
    		im = cv.cvtColor(cv.imread(path), cv.COLOR_BGR2RGB)/255
    		imgs.append(im)
    	imgs = np.array(imgs).transpose((0,3,1,2))
    	interps_0d1 = bilinear_interpolate(imgs, scale=0.1)
    	interps_2d2 = bilinear_interpolate(imgs, scale=2.2)
    	for im,interp0,interp1 in zip(imgs,interps_0d1,interps_2d2):
    		plt.figure()
    		plt.subplot(131)
    		plt.imshow(im.transpose(1,2,0))
    		plt.subplot(132)
    		plt.imshow(interp0.transpose(1,2,0))
    		plt.title('scale to 0.1 times of the original image')
    		plt.subplot(133)
    		plt.imshow(interp1.transpose(1,2,0))
    		plt.title('scale to 2.2 times of the original image')
    		plt.show()

    放大和缩小都没有问题。

    展开全文
  • 基于Python的图像双线性插值

    千次阅读 2020-04-19 13:58:28
    双线性插值 对于曲面z=f(x,y),双线性插值是一种比较简单的插值方法。双线性插值需要已知曲面上的四个点,然后以此构建一张曲面片,得到双线性插值函数,进而可以根据该曲面片内部各个点处的横坐标和纵坐标来快速...
    • 双线性插值

    对于曲面z=f(x,y),双线性插值是一种比较简单的插值方法。双线性插值需要已知曲面上的四个点,然后以此构建一张曲面片,得到双线性插值函数,进而可以根据该曲面片内部各个点处的横坐标和纵坐标来快速计算该点的竖坐标。具体的计算公式如下:

       (1)

    其中各个坐标如下图所示:

    对于图像而言,相邻的四个像素,除了对角线上两个点外,其它点的距离都是1,因此上述公式中的各个点的横坐标和纵坐标可以归一化处理到区间[0,1],则上述插值公式就可以化简为:

                  (2)

    此公式即为图像的双线性插值公式。

    二、图像的双线性插值的Python实现

    import numpy as np

    from PIL import Image

    import matplotlib.pyplot as plt

    class ImageIntp( object ):

        mFileName = []

        mRatio    = 0

        def __init__( self, filename, ratio ):

            self.mFileName = filename

            self.mRatio    = ratio

        def getImageData( self ):

            I = np.array( Image.open( self.mFileName ) );

            return I

        def biLinearIntpFun( self, ILu, ILb, IRu, IRb, x, y ):

           

            z = x * ( ILb - ILu ) + y * ( IRu - ILu ) + x * y * ( ILu + IRb - IRu - ILb ) + ILu

            return z

       

        def ImageBiLinearIntp( self ):

            I = self.getImageData()

            r = self.mRatio

            [ m, n ] = np.shape( I )

            deltaR = 1

            if( r >= 2 ):

                deltaR = int(r )

            elif( r > 0 and r < 2 ):

                deltaR = 1

               

            mr = int( m * r - deltaR )

            nr = int( n * r - deltaR )

            IR = np.zeros( (mr, nr) )

            IR[mr-1][nr-1] = I[m-1][n-1]

            if( r == 1 ):

                IR = I

            for i in range( mr ):

                iyI =  i / r

                iI  = int( iyI )

                y   = iyI - iI

                for j in range( nr ):

                    jxI = j / r

                    jI  = int( jxI )

                    x   = jxI - jI

                    ILu = int(I[iI][jI])

                    ILb = int(I[iI+1][jI])

                    IRu = int(I[iI][jI+1])

                    IRb = int(I[iI+1][jI+1])

                    IR[i][j] = self.biLinearIntpFun( ILu, ILb, IRu, IRb, x, y )

            return IR

     

    def main():

         obj = ImageIntp( 'lena.bmp', 0.5 )

        IR = obj.ImageBiLinearIntp()

        plt.figure( 'Intpolation1' )

        plt.imshow( IR )

        plt.axis( 'off' )

        print( np.shape(IR) )

       

        obj = ImageIntp( 'lena.bmp', 1.6 )

        IR = obj.ImageBiLinearIntp()

        plt.figure( 'Intpolation2' )

        plt.imshow( IR )

        plt.axis( 'off' )

        print( np.shape(IR) )

       

        obj = ImageIntp( 'lena.bmp', 2 )

        IR = obj.ImageBiLinearIntp()

        plt.figure( 'Intpolation3' )

        plt.imshow( IR )

        plt.axis( 'off' )

        print( np.shape(IR) )

       

        obj = ImageIntp( 'lena.bmp', 2.5 )

        IR = obj.ImageBiLinearIntp()

        plt.figure( 'Intpolation4' )

        plt.imshow( IR )

        plt.axis( 'off' )

        print( np.shape(IR) )

     

    if __name__ == '__main__':

        main()

     

    作者:YangYF

    展开全文
  • python双线性插值代码

    千次阅读 2019-08-04 09:17:40
    双线性插值其实就是 根据需要resize的大小和原始图像的大小之比得到缩放比例,然后在求目标图的每一个像素的时候,根据这个比例找到其应该在原图的位置,这个位置可能会是小数,就用到该位置周围4个整数像素点的值来...
  • i = int(math.floor(new_coordinate[0])) new_j = int(math.floor(new_coordinate[1])) if new_j>=W or new_i >=H or new_i[i, j, :] = imgArray[new_i, new_j, :] return new_data 2)双线性插值 使用最近邻插值...
  • 双线性插值算法以及python实现

    万次阅读 2018-09-13 16:24:11
    双线性插值算法【文章主题内容为转载,代码为自己所写】,在这里也感谢一些大牛的博文。 http://www.cnblogs.com/linkr/p/3630902.html http://www.cnblogs.com/funny-world/p/3162003.html 双线性插值 &amp...
  • 图像缩放处理-双线性插值算法 一、概念 双线性插值,又称为双线性内插。在数学上,双线性插值是对线性插值在二维直角网格上的扩展,用于对双变量函数(例如 x 和 y)进行插值。其核心思想是在两个方向分别进行一次...
  • 我发现了很多关于这个主题和许多答案的问题,但是对于数据由网格上的样本(即矩形图像)组成并且表示为numpy数组的常见情况,没有一个是有效的。此函数可以将列表作为x和y坐标,并且无需循环即可执行查找和求和。...
  • 双线性插值法原理:① 何为线性插值插值就是在两个数之间插入一个数,线性插值原理图如下:在位置 x 进行线性插值,插入的值为f(x) ↑② 各种插值法:插值法的第一步都是相同的,计算目标图(dstImage)的坐标点...
  • 双线性插值理解与Python实现

    千次阅读 2019-05-20 20:45:36
    双线性插值 公式就是这么推来的,主要就是在x方向和y方向上都进行线性插值,利用临近点进行计算 在计算的时候利用了几何中心对齐来优化原来的直接缩放 __author__ = 'Alex Wang' import numpy as np import cv2 ...
  • [图像处理]双线性插值法及python实现

    千次阅读 多人点赞 2019-06-17 17:32:05
    双线性插值法及python实现 插值法是一种根据原图(source)图片信息构造目标图像(destination)的方法。而其中的双线性插值法是一种目前使用较多的插值方法,他在效果和计算量之间有较好的权衡,所以使用较为广泛。...
  • 双线性插值法原理: ① 何为线性插值插值就是在两个数之间插入一个数,线性插值原理图如下: 在位置 x 进行线性插值,插入的值为f(x) ↑ ② 各种插值法: 插值法的第一步都是相同的,计算目标图...
  • 里面包含邻近插值双线性插值的文档说明以及程序比较,很适合初学者的学习使用,可以很好的理解其中的原理!
  • 双线性插值(Python版)

    千次阅读 2018-05-22 22:02:59
    本文只是提供一下python版本实现,具体原理给出参考资料网址,应该已经有很多人写过相关的介绍了。 https://blog.csdn.net/jia20003/article/details/8014213 ... python现在实现的运行速度非常慢,还是C++用指针进行...
  • 图片的旋转方法算法以及双线性插值,最邻近插值法 图片的旋转方法算法以及双线性插值,最邻近插值
  • 主要介绍了python 图像插值 最近邻、双线性、双三次实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 动手实现双线性插值简单版本,详情见博文: https://blog.csdn.net/a435262767/article/details/103113635
  • (x - x1) * (y - y1) ) / ((x2 - x1) * (y2 - y1) + 0.0) 您可以通过添加以下内容来运行测试代码:if __name__ == '__main__': import doctest doctest.testmod() 在数据集上运行插值会产生:>>> n = [(54.5, 17....
  • 实现双线性插值
  • 最近在处理再分析资料网格数据时,需要用到插值方法,双线性插值速度比较快,所以考虑双线性插值方法。 双线性插值,故名思义就是在x和y方向分别进行线性插值双线性插值一般用于图像处理,对一个个像素块进行线性...
  • 利用C++实现了最近邻插值以及双线性插值的图像插值算法,将两种算法并成一个API,可以加深对于这两个插值算法的理解
  • 基本插值函数def interpolation(y0,x0, y1,x1, x):frac = (x - x0) / (x1 - x0)return y0*(1-frac) + y1 * frac步骤1:将原始坐标映射到新调整尺寸的图像def get_coords(im, W, H):h,w = im.shapex = np.arang...

空空如也

空空如也

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

双线性插值python

python 订阅