图像处理 插值

2017-12-16 21:03:33 JNingWei 阅读数 58262

Syntax

cv2.resize(src, dsize[, dst[, fx[, fy[, interpolation]]]]) → dst

interpolation 选项 所用的插值方法
INTER_NEAREST 最近邻插值
INTER_LINEAR 双线性插值(默认设置)
INTER_AREA 使用像素区域关系进行重采样。 它可能是图像抽取的首选方法,因为它会产生无云纹理的结果。 但是当图像缩放时,它类似于INTER_NEAREST方法。
INTER_CUBIC 4x4像素邻域的双三次插值
INTER_LANCZOS4 8x8像素邻域的Lanczos插值

INTER_NEAREST | 最近邻插值

在一维空间中,最近点插值就相当于四舍五入取整。在二维图像中,像素点的坐标都是整数,该方法就是选取离目标点最近的点。

会在一定程度上损失 空间对称性(Alignment),在 RoI Pooling 中使用。

这里写图片描述

INTER_LINEAR | 双线性插值(默认设置)

在两个方向分别进行一次线性插值。

这里写图片描述

在图像处理的时候,我们先根据

srcX = dstX* (srcWidth/dstWidth)
srcY = dstY * (srcHeight/dstHeight)

来计算目标像素在源图像中的位置,这里计算的srcX和srcY一般都是浮点数,比如 f(1.2, 3.4)这个像素点是虚拟存在的,先找到与它临近的四个实际存在的像素点

(1,3) (2,3)
(1,4) (2,4)

写成 f(i+u,j+v) 的形式,则 u=0.2,v=0.4, i=1, j=3

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) 

保证了 空间对称性(Alignment),在 RoI Align 中使用。

这里写图片描述

INTER_AREA | 使用像素区域关系进行重采样。

略。

INTER_CUBIC | 4x4像素邻域的双三次插值

略。

INTER_LANCZOS4 | 8x8像素邻域的Lanczos插值

在x,y方向分别对相邻的八个点进行插值,也就是计算加权和,所以它是一个8x8的描述子。

Code

# coding=utf-8

import cv2
"""
INTER_NEAREST | 最近邻插值
INTER_LINEAR | 双线性插值(默认设置)
INTER_AREA |  使用像素区域关系进行重采样
INTER_CUBIC  | 4x4像素邻域的双三次插值
INTER_LANCZOS4 |  8x8像素邻域的Lanczos插值
"""

if __name__ == '__main__':
    img = cv2.imread("girl.jpg")
    height, width = img.shape[:2]

    # 缩小图像
    size = (int(width*0.8), int(height*0.7))
    shrink_NEAREST = cv2.resize(img, size, interpolation=cv2.INTER_NEAREST)
    shrink_LINEAR = cv2.resize(img, size, interpolation=cv2.INTER_LINEAR)
    shrink_AREA = cv2.resize(img, size, interpolation=cv2.INTER_AREA)
    shrink_CUBIC = cv2.resize(img, size, interpolation=cv2.INTER_CUBIC)
    shrink_LANCZOS4 = cv2.resize(img, size, interpolation=cv2.INTER_LANCZOS4)

    # 放大图像
    fx = 1.2
    fy = 1.1
    enlarge_NEAREST = cv2.resize(img, (0, 0), fx=fx, fy=fy, interpolation=cv2.INTER_NEAREST)
    enlarge_LINEAR = cv2.resize(img, (0, 0), fx=fx, fy=fy, interpolation=cv2.INTER_LINEAR)
    enlarge_AREA = cv2.resize(img, (0, 0), fx=fx, fy=fy, interpolation=cv2.INTER_AREA)
    enlarge_CUBIC = cv2.resize(img, (0, 0), fx=fx, fy=fy, interpolation=cv2.INTER_CUBIC)
    enlarge_LANCZOS4 = cv2.resize(img, (0, 0), fx=fx, fy=fy, interpolation=cv2.INTER_LANCZOS4)

    # 保存图像
    cv2.imwrite("shrink_NEAREST.jpg", shrink_NEAREST)
    cv2.imwrite("shrink_LINEAR.jpg", shrink_LINEAR)
    cv2.imwrite("shrink_AREA.jpg", shrink_AREA)
    cv2.imwrite("shrink_CUBIC.jpg", shrink_CUBIC)
    cv2.imwrite("shrink_LANCZOS4.jpg", shrink_LANCZOS4)

    cv2.imwrite("enlarge_NEAREST.jpg", enlarge_NEAREST)
    cv2.imwrite("enlarge_LINEAR.jpg", enlarge_LINEAR)
    cv2.imwrite("enlarge_AREA.jpg", enlarge_AREA)
    cv2.imwrite("enlarge_CUBIC.jpg", enlarge_CUBIC)
    cv2.imwrite("enlarge_LANCZOS4.jpg", enlarge_LANCZOS4)

Demo

原图像:
这里写图片描述

利用插值缩小

最近邻插值
这里写图片描述

双线性插值(默认设置)
这里写图片描述

使用像素区域关系进行重采样
这里写图片描述

4x4像素邻域的双三次插值
这里写图片描述

8x8像素邻域的Lanczos插值
这里写图片描述

利用插值放大

最近邻插值
这里写图片描述

双线性插值(默认设置)
这里写图片描述

使用像素区域关系进行重采样
这里写图片描述

4x4像素邻域的双三次插值
这里写图片描述

8x8像素邻域的Lanczos插值
这里写图片描述

2018-11-15 01:02:57 ytffhew 阅读数 1198

分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

               

常用的插值方法                                                                                                                                                        

1、最邻近元法

  这是最简单的一种插值方法,不需要计算,在待求象素的四邻象素中,将距离待求象素最近的邻象素灰度赋给待求象素。设i+u, j+v(i, j为正整数, u, v为大于零小于1的小数,下同)为待求象素坐标,则待求象素灰度的值 f(i+u, j+v) 如下图所示:

 

 

如果(i+u, j+v)落在A区,即u<0.5, v<0.5,则将左上角象素的灰度值赋给待求象素,同理,落在B区则赋予右上角的象素灰度值,落在C区则赋予左下角象素的灰度值,落在D区则赋予右下角象素的灰度值。

最邻近元法计算量较小,但可能会造成插值生成的图像灰度上的不连续,在灰度变化的地方可能出现明显的锯齿状。

 

2、双线性内插法

双线性内插法是利用待求象素四个邻象素的灰度在两个方向上作线性内插,如下图所示:

 

 

对于 (i, j+v),f(i, j) 到 f(i, j+1) 的灰度变化为线性关系,则有:

      f(i, j+v) = [f(i, j+1) - f(i, j)] * v + f(i, j)

同理对于 (i+1, j+v) 则有:

                  f(i+1, j+v) = [f(i+1, j+1) - f(i+1, j)] * v + f(i+1, j)

从f(i, j+v) 到 f(i+1, j+v) 的灰度变化也为线性关系,由此可推导出待求象素灰度的计算式如下:

                  f(i+u, j+v) = (1-u) * (1-v) * f(i, j) + (1-u) * v * f(i, j+1) + u * (1-v) * f(i+1, j) + u * v * f(i+1, j+1)

双线性内插法的计算比最邻近点法复杂,计算量较大,但没有灰度不连续的缺点,结果基本令人满意。它具有低通滤波性质,使高频分量受损,图像轮廓可能会有一点模糊。

 

3、三次内插法

该方法利用三次多项式S(x)求逼近理论上最佳插值函数sin(x)/x, 其数学表达式为:

待求像素(x, y)的灰度值由其周围16个灰度值加权内插得到,如下图:

 

 

待求像素的灰度计算式如下:

 

f(x, y) = f(i+u, j+v) = ABC

 

其中: 

 

三次曲线插值方法计算量较大,但插值后的图像效果最好。


插值方法总结:                                                                                                                                                       

“Inverse Distance to a Power(反距离加权插值法)”、
“Kriging(克里金插值法)”、
“Minimum Curvature(最小曲率)”、
“Modified Shepard's Method(改进谢别德法)”、
“Natural Neighbor(自然邻点插值法)”、
“Nearest Neighbor(最近邻点插值法)”、
“Polynomial Regression(多元回归法)”、
“Radial Basis Function(径向基函数法)”、
“Triangulation with Linear Interpolation(线性插值三角网法)”、
“Moving Average(移动平均法)”、
“Local Polynomial(局部多项式法)”

1、距离倒数乘方法
距离倒数乘方格网化方法是一个加权平均插值法,可以进行确切的或者圆滑的方式插值。方次参数控制着权系数如何随着离开一个格网结点距离的增加而下降。对于一个较大的方次,较近的数据点被给定一个较高的权重份额,对于一个较小的方次,权重比较均匀地分配给各数据点。
计算一个格网结点时给予一个特定数据点的权值与指定方次的从结点到观测点的该结点被赋予距离倒数成比例。当计算一个格网结点时,配给的权重是一个分数,所 有权重的总和等于1.0。当一个观测点与一个格网结点重合时,该观测点被给予一个实际为 1.0 的权重,所有其它观测点被给予一个几乎为 0.0 的权重。换言之,该结点被赋给与观测点一致的值。这就是一个准确插值。
距离倒数法的特征之一是要在格网区域内产生围绕观测点位置的"牛眼"。用距离倒数格网化时可以指定一个圆滑参数。大于零的圆滑参数保证,对于一个特定的结 点,没有哪个观测点被赋予全部的权值,即使观测点与该结点重合也是如此。圆滑参数通过修匀已被插值的格网来降低"牛眼"影响。

2、克里金法
克里金法是一种在许多领域都很有用的地质统计格网化方法。克里金法试图那样表示隐含在你的数据中的趋势,例如,高点会是沿一个脊连接,而不是被牛眼形等值线所孤立。
克里金法中包含了几个因子:变化图模型,漂移类型 和矿块效应。

3、最小曲率法
最小曲率法广泛用于地球科学。用最小曲率法生成的插值面类似于一个通过各个数据值的,具有最小弯曲量的长条形薄弹性片。最小曲率法,试图在尽可能严格地尊重数据的同时,生成尽可能圆滑的曲面。
使用最小曲率法时要涉及到两个参数:最大残差参数和最大循环次数参数来控制最小曲率的收敛标准。

4、多元回归法
多元回归被用来确定你的数据的大规模的趋势和图案。你可以用几个选项来确定你需要的趋势面类型。多元回归实际上不是插值器,因为它并不试图预测未知的 Z 值。它实际上是一个趋势面分析作图程序。
使用多元回归法时要涉及到曲面定义和指定XY的最高方次设置,曲面定义是选择采用的数据的多项式类型,这些类型分别是简单平面、双线性鞍、二次曲面、三次曲面和用户定义的多项式。参数设置是指定多项式方程中 X 和 Y组元的最高方次 。

5、径向基本函数法
径向基本函数法是多个数据插值方法的组合。根据适应你的数据和生成一个圆滑曲面的能力,其中的复二次函数被许多人认为是最好的方法。所有径向基本函数法都 是准确的插值器,它们都要为尊重你的数据而努力。为了试图生成一个更圆滑的曲面,对所有这些方法你都可以引入一个圆滑系数。你可以指定的函数类似于克里金 中的变化图。当对一个格网结点插值时,这些个函数给数据点规定了一套最佳权重。

6、谢别德法
谢别德法使用距离倒数加权的最小二乘方的方法。因此,它与距离倒数乘方插值器相似,但它利用了局部最小二乘方来消除或减少所生成等值线的"牛眼"外观。谢别德法可以是一个准确或圆滑插值器。
在用谢别德法作为格网化方法时要涉及到圆滑参数的设置。圆滑参数是使谢别德法能够象一个圆滑插值器那样工作。当你增加圆滑参数的值时,圆滑的效果越好。

7、三角网/线形插值法
三角网插值器是一种严密的插值器,它的工作路线与手工绘制等值线相近。这种方法是通过在数据点之间连线以建立起若干个三角形来工作的。原始数据点的连结方法是这样:所有三角形的边都不能与另外的三角形相交。其结果构成了一张覆盖格网范围的,由三角形拼接起来的网。
每一个三角形定义了一个覆盖该三角形内格网结点的面。三角形的倾斜和标高由定义这个三角形的三个原始数据点确定。给定三角形内的全部结点都要受到该三角形的表面的限制。因为原始数据点被用来定义各个三角形,所以你的数据是很受到尊重的。


8.自然邻点插值法
自然邻点插值法(NaturalNeighbor)是Surfer7.0才有的网格化新方法。自然邻点插值法广泛应用于一些研究领域中。其基本原理是对于 一组泰森(Thiessen)多边形,当在数据集中加入一个新的数据点(目标)时,就会修改这些泰森多边形,而使用邻点的权重平均值将决定待插点的权重, 待插点的权重和目标泰森多边形成比例。实际上,在这些多边形中,有一些多边形的尺寸将缩小,并且没有一个多边形的大小会增加。同时,自然邻点插值法 在数据点凸起的位置并不外推等值线(如泰森多边形的轮廓线)。

9.最近邻点插值法
最近邻点插值法(NearestNeighbor)又称泰森多边形方法,泰森多边形(Thiesen,又叫Dirichlet或Voronoi多边形)分 析法是荷兰气象学家A.H.Thiessen提出的一种分析方法。最初用于从离散分布气象站的降雨量数据中计算平均降雨量,现在GIS和地理分析中经常采 用泰森多边形进行快速的赋值。实际上,最近邻点插值的一个隐含的假设条件是任一网格点p(x,y)的属性值都使用距它最近的位置点的属性值,用每一 个网格节点的最邻点值作为待的节点值。当数据已经是均匀间隔分布,要先将数据转换为SURFER的网格文件,可以应用最近邻点插值法;或者在一个文 件中,数据紧密完整,只有少数点没有取值,可用最近邻点插值法来填充无值的数据点。有时需要排除网格文件中的无值数据的区域,在搜索椭圆 (SearchEllipse)设置一个值,对无数据区域赋予该网格文件里的空白值。设置的搜索半径的大小要小于该网格文件数据值之间的距离,所有的无数 据网格节点都被赋予空白值。在使用最近邻点插值网格化法,将一个规则间隔的XYZ数据转换为一个网格文件时,可设置网格间隔和XYZ数据的数据点之间的间 距相等。最近邻点插值网格化法没有选项,它是均质且无变化的,对均匀间隔的数据进行插值很有用,同时,它对填充无值数据的区域很有效。


Reference                                                                                                                      

http://blog.csdn.net/coy_wang/article/details/5027872

http://blog.sina.com.cn/s/blog_6e51df7f0100vb4b.html

           

给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

这里写图片描述
2019-05-22 20:27:48 huangshangcheng 阅读数 942

 

    假设有一副图像A,像素为 m×n。如果要将其缩放为原来的a倍变成图像B,其像素为 a*m×a*n=M×N(*代表乘法运算),将会涉及到插值的问题,常见的插值方法有三种最邻近插值、双线性插值、双立方插值。

一、最邻近插值

如图,假设原始图像A为 4×4 的像素,缩放后的图像B为 3×3 的像素。其中A中每个像素块的值我们都已经知道,而B中每个像素块的值都不知道,只要利用图像A求出B中每个像素块的值,我们的工作就完成了。可以一个 一个 的来求,假 如要先求B中第1行,第2列的像素块值的大小  g(1,2)  的话。对于最邻近插值话很简单,找到A图像中某一个像素块的值直接给B就行,重要的是找出要把A中哪一个像素块的值给 g(1,2)。就是用下面的求法。(g(x,y)为B图像中(x,y)处的像素值,f(x,y)为A图像中(x,y)处的像素值)

g(1,2)=f(\frac{1}{3}*4,\frac{2}{3}*4)=f(1.33,2.66)

直接四舍五入得

g(1,2)=f(1,3)

所以只要把A图像中第1行第3列的像素块的值赋值给B图像中第1行第2列的像素块即可,通过这种方式可以求出图像B中所有像素块的值。

推广到一般情况

为求B图像中位于(x,y)处的像素值,则有

g(x,y)=f(\frac{x}{M}*m,\frac{y}{N}*n)=f(\frac{x}{a},\frac{y}{a})           a为缩放倍数,m×n为原始图像大小,M×N为缩放后图像大小

当然如果所求结果不是整数直接四舍五入就好。

双线性插值

    对于最邻近插值还可以这样理解,看下图。由g(x,y)=f(\frac{x}{M}*m,\frac{y}{N}*n)=f(\frac{x}{a},\frac{y}{a})可以得到,图像B中的点(x,y)对应于图像A中的(\frac{x}{a},\frac{y}{a}),假设就是下图中的H点。所谓最邻近插值,就是说图像B中(x,y)点的像素值只和离H点(H点是在图像A中)最近的像素点的值有关,也就是点(i,j)处的像素值。

双线性插值呢,它不仅仅只是和离H点最近的像素点的值有关,而是和H点周围的4个像素点的值都有关。这4个像素点也就是(i,j)、(i+1,j)、(i,j+1)、(i+1,j+1)。具体进行双线性插值的步骤:

1、先进行水平方向的插值,也就是利用上图中(i,j)和(i+1,j)两点的像素值求出X点的像素值;利用(i,j+1)和(i+1,j+1)两点的像素值求出Y点的像素值。(点X、Y、H在一条竖线上,即横坐标相同)

2、再进行竖直方向上的插值,也就是利用XY两点的像素值求出H点的像素值,也就是我们要求的图像B中(x,y)处的像素值。这应该也是为什么这种插值方法叫作双线性插值的原因了吧。

我们首先要把H点的坐标写成这这种形式(i+u,j+v),其中i、j是整数(i,j也代表图像A中的第几个像素点);u、v是小数。至于H点坐标怎么求前面说过。分别把X、Y、H点的像素值记作f(X)f(Y)f(H);同理f(i,j)f(i+1,j)f(i,j+1)、g(if(i+1,j+1)分别代表相应四个位置的像素值。

f(X)=f(i,j)+u\ast (f(i,i+1)-f(i,j))

f(Y)=f(i,j+1)+u\ast (f(i+1,i+1)-f(i,j+1))

f(H)=f(X)+v*(f(Y)-f(X))

当然,你也可以把f(X),f(Y)代入第三个式子得到一个计算公式。(*代表乘法运算)

还可以拿最开始的那个简单例子来计算一下,要求图像B中第1行第2列位置处的像素值。通过g(x,y)=f(\frac{x}{M}*m,\frac{y}{N}*n)=f(\frac{x}{a},\frac{y}{a})可以得到H点的坐标为(1+0.33,2+0.66),所以就是你懂得。太简单懒得写,反正记住f(x,y)是已知的,当然这里的x、y都是整数。最后求出的f(H)也就是我们要找的图像B中第1行第2列位置处的像素值。

双立方插值

未完,待续

2018-08-27 19:27:30 helimin12345 阅读数 16946

sensor、codec、display device都是基于pixel的,高分辨率图像能呈现更多的detail,由于sensor制造和chip的限制,我们需要用到图像插值(scaler/resize)技术,这种方法代价小,使用方便。同时,该技术还可以放大用户希望看到的感兴趣区域。图像缩放算法往往基于插值实现,常见的图像插值算法包括最近邻插值(Nearest-neighbor)、双线性插值(Bilinear)、双立方插值(bicubic)、lanczos插值、方向插值(Edge-directed interpolation)、example-based插值、深度学习等算法。
插值缩放的原理是基于目标分辨率中的点,将其按照缩放关系对应到源图像中,寻找源图像中的点(不一定是整像素点),然后通过源图像中的相关点插值得到目标点。本篇文章,我们介绍Nearest-neighbor和Bilinear插值的原理及C实现。
插值算法原理如下:
这里写图片描述
1. Nearest-neighbor
最近邻插值,是指将目标图像中的点,对应到源图像中后,找到最相邻的整数点,作为插值后的输出。如下图所示,P为目标图像对应到源图像中的点,Q11、Q12、Q21、Q22是P点周围4个整数点,Q12与P离的最近,因此P点的值等于Q12的值。这里写图片描述
由于图像中像素具有邻域相关性,因此,用这种拷贝的方法会产生明显的锯齿。
2. Bilinear
双线性插值使用周围4个点插值得到输出,双线性插值,是指在xy方法上,都是基于线性距离来插值的。
如图1,目标图像中的一点对应到源图像中点P(x,y),我们先在x方向插值:
这里写图片描述
然后,进行y方向插值:
这里写图片描述
可以验证,先进行y方向插值再进行x方向插值,结果也是一样的。值得一提的是,双线性插值在单个方向上是线性的,但对整幅图像来说是非线性的。

3. C实现
使用VS2010,工程包含三个文件,如下:
这里写图片描述

main.cpp

#include <string.h>
#include <iostream>
#include "resize.h"

int main()
{
	const char *input_file = "D:\\simuTest\\teststream\\00_YUV_data\\01_DIT_title\\data.yuv";		//absolute path
	const char *output_file = "D:\\simuTest\\teststream\\00_YUV_data\\01_DIT_title\\data_out2.yuv";	//absolute path	
	int src_width = 720;
	int src_height = 480;
	int dst_width = 1920;
	int dst_height = 1080;
	int resize_type = 1;		//0:nearest, 1:bilinear

	resize(input_file, src_width, src_height, output_file, dst_width, dst_height, resize_type);
	return 0;
}

resize.cpp

#include "resize.h"

int clip3(int data, int min, int max)
{
	return (data > max) ? max : ((data < min) ? min : data);
	if(data > max)
		return max;
	else if(data > min)
		return data;
	else
		return min;
}

//bilinear takes 4 pixels (2×2) into account
/*
* 函数名:	bilinearHorScaler
* 说明:	水平方向双线性插值
* 参数:
*/
void bilinearHorScaler(int *src_image, int *dst_image, int src_width, int src_height, int dst_width, int dst_height)
{
	double resizeX = (double)dst_width / src_width;
	for(int ver = 0; ver < dst_height; ++ver){
		for(int hor = 0; hor < dst_width; ++hor){
			double srcCoorX = hor / resizeX;
			double weight1 = srcCoorX - (double)((int)srcCoorX);
			double weight2 = (double)((int)(srcCoorX + 1)) - srcCoorX;
			double dstValue = *(src_image + src_width * ver + clip3((int)srcCoorX, 0, src_width - 1)) * weight2 + *(src_image + src_width * ver + clip3((int)(srcCoorX + 1), 0, src_width - 1)) * weight1;
			*(dst_image + dst_width * ver + hor) = clip3((uint8)dstValue, 0, 255);
		}
	}
}

/*
* 函数名:	bilinearVerScaler
* 说明:	垂直方向双线性插值
* 参数:
*/
void bilinearVerScaler(int *src_image, int *dst_image, int src_width, int src_height, int dst_width, int dst_height)
{
	double resizeY = (double)dst_height / src_height;
	for(int ver = 0; ver < dst_height; ++ver){
		for(int hor = 0; hor < dst_width; ++hor){
			double srcCoorY = ver / resizeY;
			double weight1 = srcCoorY - (double)((int)srcCoorY);
			double weight2 = (double)((int)(srcCoorY + 1)) - srcCoorY;
			double dstValue = *(src_image + src_width * clip3((int)srcCoorY, 0, src_height - 1) + hor) * weight2 + *(src_image + src_width * clip3((int)(srcCoorY + 1), 0, src_height - 1) + hor) * weight1;
			*(dst_image + dst_width * ver + hor) = clip3((uint8)dstValue, 0, 255);
		}
	}
}

/*
* 函数名:	yuv420p_NearestScaler
* 说明:	最近邻插值
* 参数:
*/
void nearestScaler(int *src_image, int *dst_image, int src_width, int src_height, int dst_width, int dst_height)
{
	double resizeX = (double)dst_width /src_width;			//水平缩放系数
	double resizeY = (double)dst_height / src_height;			//垂直缩放系数
	int srcX = 0;
	int srcY = 0;
	for(int ver = 0; ver < dst_height; ++ver) {
		for(int hor = 0; hor < dst_width; ++hor) {
			srcX = clip3(int(hor/resizeX + 0.5), 0, src_width - 1);
			srcY = clip3(int(ver/resizeY + 0.5), 0, src_height - 1);
			*(dst_image + dst_width * ver + hor) = *(src_image + src_width * srcY + srcX);
		}
	}
}

void resize(const char *input_file, int src_width, int src_height, const char *output_file, int dst_width, int dst_height, int resize_type)
{
	//define and init src buffer
	int *src_y = new int[src_width * src_height];
	int *src_cb = new int[src_width * src_height / 4];
	int *src_cr = new int[src_width * src_height / 4];
	memset(src_y, 0, sizeof(int) * src_width * src_height);
	memset(src_cb, 0, sizeof(int) * src_width * src_height / 4);
	memset(src_cr, 0, sizeof(int) * src_width * src_height / 4);

	//define and init dst buffer
	int *dst_y = new int[dst_width * dst_height];
	int *dst_cb = new int[dst_width * dst_height / 4];
	int *dst_cr = new int[dst_width * dst_height / 4];
	memset(dst_y, 0, sizeof(int) * dst_width * dst_height);
	memset(dst_cb, 0, sizeof(int) * dst_width * dst_height / 4);
	memset(dst_cr, 0, sizeof(int) * dst_width * dst_height / 4);

	//define and init mid buffer
	int *mid_y = new int[dst_width * src_height];
	int *mid_cb = new int[dst_width * src_height / 4];
	int *mid_cr = new int[dst_width * src_height / 4];
	memset(mid_y, 0, sizeof(int) * dst_width * src_height);
	memset(mid_cb, 0, sizeof(int) * dst_width * src_height / 4);
	memset(mid_cr, 0, sizeof(int) * dst_width * src_height / 4);

	uint8 *data_in_8bit = new uint8[src_width * src_height * 3 / 2];
	memset(data_in_8bit, 0, sizeof(uint8) * src_width * src_height * 3 / 2);

	uint8 *data_out_8bit = new uint8[dst_width * dst_height * 3 / 2];
	memset(data_out_8bit, 0, sizeof(uint8) * dst_width * dst_height * 3 / 2);

	FILE *fp_in = fopen(input_file,"rb");
	if(NULL == fp_in)
	{
		//exit(0);
		printf("open file failure");
	}
	FILE *fp_out = fopen(output_file, "wb+");

	//data read
	fread(data_in_8bit, sizeof(uint8), src_width * src_height * 3 / 2, fp_in);
	//Y component
	for(int ver = 0; ver < src_height; ver++)
	{
		for(int hor =0; hor < src_width; hor++)
		{
			src_y[ver * src_width + hor] = data_in_8bit[ver * src_width + hor];
		}
	}
	//c component YUV420P
	for(int ver = 0; ver < src_height / 2; ver++)
	{
		for(int hor =0; hor < src_width / 2; hor++)
		{
			src_cb[ver * (src_width / 2) + hor] = data_in_8bit[src_height * src_width + ver * src_width / 2 + hor];
			src_cr[ver * (src_width / 2) + hor] = data_in_8bit[src_height * src_width + src_height * src_width / 4 + ver * src_width / 2 + hor];
		}
	}

	//resize
	if(0 == resize_type)
	{
		nearestScaler(src_y, dst_y, src_width, src_height, dst_width, dst_height);
		nearestScaler(src_cb, dst_cb, src_width / 2, src_height / 2, dst_width / 2, dst_height / 2);
		nearestScaler(src_cr, dst_cr, src_width / 2, src_height / 2, dst_width / 2, dst_height / 2);
	}
	else if(1 == resize_type)
	{
		bilinearHorScaler(src_y, mid_y, src_width, src_height, dst_width, src_height);
		bilinearHorScaler(src_cb, mid_cb, src_width / 2, src_height / 2, dst_width / 2, src_height / 2);
		bilinearHorScaler(src_cr, mid_cr, src_width / 2, src_height / 2, dst_width / 2, src_height / 2);

		bilinearVerScaler(mid_y, dst_y, dst_width, src_height, dst_width, dst_height);
		bilinearVerScaler(mid_cb, dst_cb, dst_width / 2, src_height / 2, dst_width / 2, dst_height / 2);
		bilinearVerScaler(mid_cr, dst_cr, dst_width / 2, src_height / 2, dst_width / 2, dst_height / 2);
	}	
	else
	{
		nearestScaler(src_y, dst_y, src_width, src_height, dst_width, dst_height);
		nearestScaler(src_cb, dst_cb, src_width / 2, src_height / 2, dst_width / 2, dst_height / 2);
		nearestScaler(src_cr, dst_cr, src_width / 2, src_height / 2, dst_width / 2, dst_height / 2);
	}

	//data write
	for(int ver = 0; ver < dst_height; ver++)
	{
		for(int hor =0; hor < dst_width; hor++)
		{
			data_out_8bit[ver * dst_width + hor] = clip3(dst_y[ver * dst_width + hor], 0, 255);
		}
	}

	for(int ver = 0; ver < dst_height / 2; ver++)
	{
		for(int hor = 0; hor < dst_width / 2; hor++)
		{
			data_out_8bit[dst_height * dst_width + ver * dst_width / 2 + hor] = clip3(dst_cb[ver * (dst_width / 2) + hor], 0, 255);
			data_out_8bit[dst_height * dst_width + dst_height * dst_width / 4 + ver * dst_width / 2 + hor] = clip3(dst_cr[ver * (dst_width / 2) + hor], 0, 255);
		}
	}
	fwrite(data_out_8bit, sizeof(uint8), dst_width * dst_height * 3 / 2, fp_out);

	delete [] src_y;
	delete [] src_cb;
	delete [] src_cr;
	delete [] dst_y;
	delete [] dst_cb;
	delete [] dst_cr;
	delete [] mid_y;
	delete [] mid_cb;
	delete [] mid_cr;
	delete [] data_in_8bit;
	delete [] data_out_8bit;
	fclose(fp_in);
	fclose(fp_out);

}

resize.h

#ifndef RESIZE_H
#define RESIZE_H

#include <stdio.h>
#include <string.h>

typedef unsigned char uint8;
typedef unsigned short uint16;

int clip3(int data, int min, int max);
void bilinearHorScaler(int *src_image, int *dst_image, int src_width, int src_height, int dst_width, int dst_height);
void bilinearVerScaler(int *src_image, int *dst_image, int src_width, int src_height, int dst_width, int dst_height);
void nearestScaler(int *src_image, int *dst_image, int src_width, int src_height, int dst_width, int dst_height);
void resize(const char *input_file, int src_width, int src_height, const char *output_file, int dst_width, int dst_height, int resize_type);

#endif

效果比较
将720x480分辨率图像放大到1080p,1:1截取局部画面如下,左边是最近邻放大的效果,右边是双线性效果,可以看到,双线性放大的锯齿要明显比最近邻小。
这里写图片描述

Matlab
常用的matlab缩放方法有两种,如下

  1. B = imresize(A, scale, method) B = imresize(A, 0.5, ‘bicubic’)使用双立方插值将宽高各缩小1/2
  2. B = imresize(A, outputSize, method) B = imresize(A, [1080,1920], ‘bilinear’)使用双线性插值缩放到1920x1080分辨率
    这里写图片描述

Opencv
常用的opencv中resize调用方法也有两种

  1. dsize=0,指定fx和fy,此时目标图像大小会自动计算出,dsize=Size(round(fxsrc.cols),round(fysrc,rows))
resize(src, dst, Size(0, 0), 0.5, 0.5, 2);		//缩小为原来的1/2,使用双立方插值(2)
  1. fx和fy为0,指定dsize
resize(src, dst, Size(1024,1024), 0, 0, 1);		//缩放到1024x1024分辨率,使用双线性插值(1)

Opencv提供5种插值方法有5种:最近邻、双线性、双立方、面积关联、兰佐斯。
Resize函数声名及插值方式玫举定义:

CV_EXPORTS_W void resize( InputArray src, OutputArray dst,
                          Size dsize, double fx=0, double fy=0,
                          int interpolation=INTER_LINEAR );

enum
{
    INTER_NEAREST=CV_INTER_NN, //!< nearest neighbor interpolation
    INTER_LINEAR=CV_INTER_LINEAR, //!< bilinear interpolation
    INTER_CUBIC=CV_INTER_CUBIC, //!< bicubic interpolation
    INTER_AREA=CV_INTER_AREA, //!< area-based (or super) interpolation
    INTER_LANCZOS4=CV_INTER_LANCZOS4, //!< Lanczos interpolation over 8x8 neighborhood
    INTER_MAX=7,
    WARP_INVERSE_MAP=CV_WARP_INVERSE_MAP
};

enum
{
    CV_INTER_NN        =0,
    CV_INTER_LINEAR    =1,
    CV_INTER_CUBIC     =2,
    CV_INTER_AREA      =3,
    CV_INTER_LANCZOS4  =4
};

参考
[1] https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation
[2] https://en.wikipedia.org/wiki/Bilinear_interpolation

2009-12-17 21:53:00 coy_wang 阅读数 63411

在做数字图像处理时,经常会碰到小数象素坐标的取值问题,这时就需要依据邻近象素的值来对该坐标进行插值。比如:做地图投影转换,对目标图像的一个象素进行坐标变换到源图像上对应的点时,变换出来的对应的坐标是一个小数,再比如做图像的几何校正,也会碰到同样的问题。以下是对常用的三种数字图像插值方法进行介绍。

1、最邻近元法

  这是最简单的一种插值方法,不需要计算,在待求象素的四邻象素中,将距离待求象素最近的邻象素灰度赋给待求象素。设i+u, j+v(i, j为正整数, u, v为大于零小于1的小数,下同)为待求象素坐标,则待求象素灰度的值 f(i+u, j+v) 如下图所示:

 

 

如果(i+u, j+v)落在A区,即u<0.5, v<0.5,则将左上角象素的灰度值赋给待求象素,同理,落在B区则赋予右上角的象素灰度值,落在C区则赋予左下角象素的灰度值,落在D区则赋予右下角象素的灰度值。

最邻近元法计算量较小,但可能会造成插值生成的图像灰度上的不连续,在灰度变化的地方可能出现明显的锯齿状。

 

2、双线性内插法

双线性内插法是利用待求象素四个邻象素的灰度在两个方向上作线性内插,如下图所示:

 

 

对于 (i, j+v),f(i, j) 到 f(i, j+1) 的灰度变化为线性关系,则有:

      f(i, j+v) = [f(i, j+1) - f(i, j)] * v + f(i, j)

同理对于 (i+1, j+v) 则有:

                  f(i+1, j+v) = [f(i+1, j+1) - f(i+1, j)] * v + f(i+1, j)

从f(i, j+v) 到 f(i+1, j+v) 的灰度变化也为线性关系,由此可推导出待求象素灰度的计算式如下:

                  f(i+u, j+v) = (1-u) * (1-v) * f(i, j) + (1-u) * v * f(i, j+1) + u * (1-v) * f(i+1, j) + u * v * f(i+1, j+1)

双线性内插法的计算比最邻近点法复杂,计算量较大,但没有灰度不连续的缺点,结果基本令人满意。它具有低通滤波性质,使高频分量受损,图像轮廓可能会有一点模糊。

 

3、三次内插法

该方法利用三次多项式S(x)求逼近理论上最佳插值函数sin(x)/x, 其数学表达式为:

待求像素(x, y)的灰度值由其周围16个灰度值加权内插得到,如下图:

 

 

待求像素的灰度计算式如下:

 

f(x, y) = f(i+u, j+v) = ABC

 

其中

 

三次曲线插值方法计算量较大,但插值后的图像效果最好。