五、图像处理之几何变换：最近邻域插值、双线性插值、双立方（三次卷积）插值的原理分析及其代码实现

一、数字图像几何变换

二、最近邻域插值

三、双线性插值

四、双立方（三次卷积）插值

五、代码实现

 

一、几何变换

图像几何变换是图像处理中非常基础实用的技能，主要包括图片位移、缩放、镜像、剪切、放射变换等， 在对图像进行空间变换的过程中，典型的情况是在对图像进行放大,旋转处理的时候，图像会出现失真的现象。这是由于在变换之后的图像中，存在着一些变换之前的图像中没有的像素位置。处理这一问题的方法被称为图像灰度级插值。常用的插值方式有三种：最近邻域插值、双线性插值、双三次插值。理论上来讲，最近邻域插值的效果最差，双三次插值的效果最好，双线性插值的效果介于两者之间。不过对于要求不是非常严格的图像插值而言，使用双线性插值通常就足够了。 插值，它根据已知的数据序列（也可以理解为坐标中一连串离散的点），找到其中的规律；然后根据找到的这个规律，来对其中尚未有数据记录的点进行数值估计。     基于这样一种功能，我目前知道的应用是：1）它可以对数据中的缺失进行合理的补偿；2）它可以对数据进行放大或者缩小。当然还有别的功能，这个大家自己遇到的说不定比我多很多。 import cv2 img =cv2.imread('C:/Users/maker/Pictures/website/img1.png') cv2.imshow('inputimage',img) imginfo = img.shape print("inputImageInfo:",imginfo) height = imginfo[0] width = imginfo[1] mode = imginfo[2] #1、放大 缩小，2、等比例放大，非等比例放大 dstHeight = int(height*0.5)  #相同系数0.5为等比例放大 dstWidth = int(width*0.5) #3、调用resize方法，opencv中有四种算法 #1）最近邻域差值 双线性插值 像素关系从采样 立方差值 dst = cv2.resize(img,(dstWidth,dstHeight)) dstImgInfo = dst.shape print("dstImageInfo:",dstImgInfo) cv2.imshow('dstimage',dst) cv2.waitKey(0)

二、最近邻差值

最临近插值的的思想很简单。对于通过反向变换得到的的一个浮点坐标，对其进行简单的取整，得到一个整数型坐标，这个整数型坐标对应的像素值就是目的像素的像 素值，也就是说，取浮点坐标最邻近的左上角点（对于DIB是右上角，因为它的扫描行是逆序存储的）对应的像素值。可见，最邻近插值简单且直观，但得到的图 像质量不高

下面用简单的模型来说明最近邻差值，越是简单的模型越适合用来举例子，我们就举个简单的图 像：3X3 的256级灰度图，也就是高为3个象素，宽也是3个象素的图像，每个象素的取值可以是 0－255，代表该像素的亮度，255代表最亮，也就是白色，0代表最暗，即黑色 。假如图像的象素矩阵如下图所示（这个原始图把它叫做源图，Source）：
234   38    22
67     44    12
89     65    63

这个矩阵中，元素坐标(x,y)是这样确定的，x从左到右，从0开始，y从上到下，也是从零开始，这是图象处理中最常用的坐标系，就是这样一个坐标：

  ----------------------＞X
  |
  |
  |
  |
  |
∨Y

如果想把这副图放大为 4X4大小的图像，那么该怎么做呢？首先假设我们有一个4*4的空矩阵，当然，矩阵的每个像素都是未知数，等待着我们去填充（这个将要被填充的图的叫做目标图,Destination）：

然后要往这个空的矩阵里面填值了，要填的值从哪里来来呢？是从源图中来，好，先填写目标图最左上角的象素，坐标为（0，0），那么该坐标对应源图中的坐标可以由如下公式得出：                                     
srcX=dstX* (srcWidth/dstWidth) , srcY = dstY * (srcHeight/dstHeight)
好了，套用公式，就可以找到对应的原图的坐标了(0*(3/4),0*(3/4))=>(0*0.75,0*0.75)=>(0,0)
,找到了源图的对应坐标,就可以把源图中坐标为(0,0)处的234象素值填进去目标图的(0,0)这个位置了。

接下来,如法炮制,寻找目标图中坐标为(1,0)的象素对应源图中的坐标,套用公式:
(1*0.75,0*0.75)=>(0.75,0)
结果发现,得到的坐标里面竟然有小数,这可怎么办?计算机里的图像可是数字图像,象素就是最小单位了,象素的坐标都是整数,从来没有小数坐标。这时候采用的一种策略就是采用四舍五入的方法（也可以采用直接舍掉小数位的方法），把非整数坐标转换成整数，好，那么按照四舍五入的方法就得到坐标（1，0），完整的运算过程就是这样的：
(1*0.75,0*0.75)=>(0.75,0)=>(1,0)
那么就可以再填一个象素到目标矩阵中了，同样是把源图中坐标为(1,0)处的像素值38填入目标图中的坐标。
         
依次填完每个象素，一幅放大后的图像就诞生了，像素矩阵如下所示：
234    38     22     22 
67      44     12     12 
89      65     63     63 
89      65     63     63  

这种放大图像的方法叫做最临近插值算法， 这是一种最基本、最简单的图像缩放算法，效果也是最不好的，放大后的图像有很严重的马赛克，缩小后的图像有很严重的失真；效果不好的根源就是其简单的最临 近插值方法引入了严重的图像失真，比如，当由目标图的坐标反推得到的源图的的坐标是一个浮点数的时候，采用了四舍五入的方法，直接采用了和这个浮点数最接 近的象素的值，这种方法是很不科学的，当推得坐标值为 0.75的时候，不应该就简单的取为1，既然是0.75，比1要小0.25 ，比0要大0.75 ,那么目标象素值其实应该根据这个源图中虚拟的点四周的四个真实的点来按照一定的规律计算出来的，这样才能达到更好的缩放效果。双线型内插值算法就是一种 比较好的图像缩放算法，它充分的利用了源图中虚拟点四周的四个真实存在的像素值来共同决定目标图中的一个像素值，因此缩放效果比简单的最邻近插值要好很 多。

#最近领域插值法Python代码实现
#src 10*20  dst 5*10
#目标图像上的点都可以来自原图像,套用如下公式
#srcX=dstX* (srcWidth/dstWidth) , srcY = dstY * (srcHeight/dstHeight)
#2=1* (10/5) , 4 = 2 * (20/10)
import cv2
import numpy as np
img =cv2.imread('C:/Users/maker/Pictures/website/img1.png')
cv2.imshow('inputimage',img)
imginfo = img.shape
print("inputImageInfo:",imginfo)
height = imginfo[0]
width = imginfo[1]
dstHeight = int(height/2)
dstWidth =  int(width/2)
dstImage = np.zeros((dstHeight,dstWidth,3),np.uint8) #0~255

for dstX in range(0,dstHeight):#行
    for dstY in range(0,dstWidth):#列
        srcX = int(dstX*(height*1.0/dstHeight))
        srcY = int(dstY*(width*1.0/dstWidth))
        dstImage[dstX,dstY] = img[srcX,srcY]
dstInfo = dstImage.shape
print("dstInfo:",dstInfo)
cv2.imshow('dst',dstImage)
cv2.waitKey(0)
 

三、双线性差值

1.为什么要用图像的插值？

在图像的放大和缩小的过程中，需要计算新图像像素点在原图的位置，如果计算的位置不是整数，就需要用到图像的内插，我们需要寻找在原图中最近得像素点赋值给新的像素点，这种方法很简单是最近邻插法，这种方法好理解、简单，但是不实用，会产生是真现象，产生棋盘格效应，更实用的方法就是双线性内插。

2.一维线性插值

我们已经知道（x0，y0）与（x1, y1）的值，并且已知 x 的值，要求 y 的值。根据初中的知识：

我们可以得到: .     

令：

则：

2.双线性内插法的推导过程

       双线性插值是做了二次一维的线性插值，我们用四个最近邻估计给定的灰度。我们新图像的像素点对应输入图像的（u0 , v0）(u0,v0不是整数)，则其必定落在原始图像四个像素点中间。四个像素点分别是（u' , v' ）、（u' , v' +1）、（u'+1 , v' ）、（u' +1, v'+1 ）。如下图1所示：

图1  图2 图3 图4

如图1所示：在红色平面内，在红色平面内，只有u' 是变量，v' 是常值，连线 g(u' , v' )、 g(u'+1 , v' )，相当于做一次一维线性插值，求出 g(u0, v' )的值。同理，如图3中，在蓝色的平面内我们可以再做一次一维线性插值，求出g(u0, v' +1)的值。同理如图4，在黑色的平面内，我们可以求出(u0, v0)对应的值g(u0, v0)的值。（双线性插值就是分别在 u、v方向上做线性插值）数学推导过程如下：

 

双线性内插值算法描述如下:
　　对于一个目的像素，设置坐 标通过反向变换得到的浮点坐标为(i+u,j+v) (其中i、j均为浮点坐标的整数部分，u、v为浮点坐标的小数部分，是取值[0,1)区间的浮点数)，则这个像素得值 f(i+u,j+v) 可由原图像中坐标为 (i,j)、(i+1,j)、(i,j+1)、(i+1,j+1)所对应的周围四个像素的值决定，即：

　　f(i+u,j+v) = (1-u)(1-v)f(i,j) + (1-u)vf(i,j+1) + u(1-v)f(i+1,j) + uvf(i+1,j+1)                          公式1

其中f(i,j)表示源图像(i,j)处的的像素值，以此类推。

下图中原图中只有(15,22)，(15,23)，(16,22)，(16,23)四个点，目标图像中新增了(15.2,22.3)这个点，双线性差值法则是根据这个新的点的周围四个点来确定这个点的值，

A1=20%*上 + 80%*下；B1 = 30%*左 + 70%*右

最终点的确定：A1*30%+A2*70%   B1*20% + B2*80%

 

比如，象刚才的例子，现在假如目标图的象素坐标为（1，1），那么反推得到的对应于源图的坐标是（0.75 , 0.75）, 这其实只是一个概念上的虚拟象素,实际在源图中并不存在这样一个象素,那么目标图的象素（1，1）的取值不能够由这个虚拟象素来决定，而只能由源图的这四 个象素共同决定：（0，0）（0，1）（1，0）（1，1），而由于（0.75,0.75）离（1，1）要更近一些，那么（1,1）所起的决定作用更大一 些，这从公式1中的系数uv=0.75×0.75就可以体现出来，而（0.75,0.75）离（0，0）最远，所以（0，0）所起的决定作用就要小一些， 公式中系数为(1-u)(1-v)=0.25×0.25也体现出了这一特点；

双线性内插值法计算量大，但缩放后图像质量高，不会出现像素值不连续的的情况。由于双线性插值具有低通滤波器的性质，使高频分量受损，所以可能会使图像轮廓在一定程度上变得模糊

四、双立方（三次卷积）插值

三次卷积法能够克服以上两种算法的不足，计算精度高，但计算亮大，他考虑一个浮点坐标(i+u,j+v)周围的16个邻点，

目的像素值f(i+u,j+v)可由如下插值公式得到：

　　　　f(i+u,j+v) = [A] * [B] * [C]

[A]=[ S(u + 1)　S(u + 0)　S(u - 1)　S(u - 2) ]

　　┏ f(i-1, j-1)　f(i-1, j+0)　f(i-1, j+1)　f(i-1, j+2) ┓
[B]=┃ f(i+0, j-1)　f(i+0, j+0)　f(i+0, j+1)　f(i+0, j+2) ┃
       ┃ f(i+1, j-1)　f(i+1, j+0)　f(i+1, j+1)　f(i+1, j+2) ┃
       ┗ f(i+2, j-1)　f(i+2, j+0)　f(i+2, j+1)　f(i+2, j+2) ┛

　　┏ S(v + 1) ┓
[C]=┃ S(v + 0) ┃
       ┃ S(v - 1) ┃
       ┗ S(v - 2) ┛

　　 ┏ 1-2*Abs(x)^2+Abs(x)^3　　　　　 , 0<=Abs(x)<1
S(x)=｛ 4-8*Abs(x)+5*Abs(x)^2-Abs(x)^3　, 1<=Abs(x)<2
        ┗ 0　　　　　　　　　　　　　　　 , Abs(x)>=2
S(x)是对 Sin(x*Pi)/x 的逼近（Pi是圆周率——π）

最邻近插值（近邻取样法）、双线性内插值、三次卷积法 等插值算法对于旋转变换、错切变换、一般线性变换 和 非线性变换 都适用。

五、代码实现

#图片的截切
import cv2
import numpy as np
img =cv2.imread('C:/Users/maker/Pictures/website/img1.png')
cv2.imshow('inputimage',img)
imginfo = img.shape
print("inputImageInfo:",imginfo)
dst = img[100:200,100:300]
cv2.imshow("datCut",dst)
cv2.waitKey(0)
        

C++代码实现可以参考：https://www.geek-share.com/detail/2626698565.html

双线性差值python实现：

1.定位像素点

先找到目标图像像素点(dst_x, dst_y)在源图像上的像素点位置(src_x, src_y)。 
一般是使用直接缩放： 
src_x=dst_x * scale_x (scale_x为源图像与目标图像宽比例) 
而我们这里使用几何中心对称： 
src_x = (dst_x + 0.5) * scale_x - 0.5 
然后找到上下左右最近邻的四个像素点用于计算插值。

2.两步插值

设(x,y)(x,y)为插值点在源图像的坐标，待计算插值为zz 
首先x方向上插值：相邻两点为(x0,y0)(x0,y0)、(x1,y0)(x1,y0)，像素值分别为z0=f(x0,y0)z0=f(x0,y0)、z1=f(x1,y0)z1=f(x1,y0)，从而有公式：z−z0x−x0=z1−z0x1−x0z−z0x−x0=z1−z0x1−x0，从而插值z=x1−xx1−x0z0+x−x0x1−x0z1z=x1−xx1−x0z0+x−x0x1−x0z1

然后y方向上插值：以上得到的上方插值zz记为ztopztop，同理可得下方插值为zbotzbot，那么最后插值为：Z=y1−yy1−y0ztop+y−y0y1−y0zbotZ=y1−yy1−y0ztop+y−y0y1−y0zbot

python实现

# coding=utf-8
import cv2
import numpy as np
import time

def resize(src, new_size):
    dst_w, dst_h = new_size # 目标图像宽高
    src_h, src_w = src.shape[:2] # 源图像宽高
    if src_h == dst_h and src_w == dst_w:
        return src.copy()
    scale_x = float(src_w) / dst_w # x缩放比例
    scale_y = float(src_h) / dst_h # y缩放比例
    # 遍历目标图像，插值
    dst = np.zeros((dst_h, dst_w, 3), dtype=np.uint8)
    for n in range(3): # 对channel循环
        for dst_y in range(dst_h): # 对height循环
            for dst_x in range(dst_w): # 对width循环
                # 目标在源上的坐标
                src_x = (dst_x + 0.5) * scale_x - 0.5
                src_y = (dst_y + 0.5) * scale_y - 0.5
                # 计算在源图上四个近邻点的位置
                src_x_0 = int(np.floor(src_x))
                src_y_0 = int(np.floor(src_y))
                src_x_1 = min(src_x_0 + 1, src_w - 1)
                src_y_1 = min(src_y_0 + 1, src_h - 1)
                # 双线性插值
                value0 = (src_x_1 - src_x) * src[src_y_0, src_x_0, n] + (src_x - src_x_0) * src[src_y_0, src_x_1, n]
                value1 = (src_x_1 - src_x) * src[src_y_1, src_x_0, n] + (src_x - src_x_0) * src[src_y_1, src_x_1, n]
                dst[dst_y, dst_x, n] = int((src_y_1 - src_y) * value0 + (src_y - src_y_0) * value1)
    return dst

if __name__ == '__main__':
    img_in = cv2.imread('C:/Users/maker/Pictures/website/img1.png')
    start = time.time()
    img_out = cv2.resize(img_in, (1000,500))
    print ('cost %f seconds' % (time.time() - start))
    cv2.imshow('src_image', img_in)
    cv2.imshow('dst_image', img_out)
    cv2.waitKey()

 

阅读更多