二次插值算法.pdf
，输出极小值点
，
极小值
;否则，即
时，输出极小值点
，极小值
。
如不满足上述迭代终止条件，则返回步骤(3)，再次缩短搜索区间，直至最后满足终止条件。
按上述步骤设计的二次插值法算法框图见图 3。
6
图3 算法框图中有几点需作些说明。
1.判别框
?若成立，按式(9)和式(10)则有
说明三个插值结点
、
、
在一条直线上;
(3)缩短搜索区间
缩短搜索区间的原则是：比较函数值 、 ，取其小者所对应的点作为新的 点，并以
此点左右两邻点分别取作新的 和 ，构成缩短后的新搜索区间
。其具体方
法则如图 2 所示，根据原区间中 和 的相对位置以及函数值 和 之比较有 a、b、 c、d 四种情况，图中阴影线部分表示丢去的区间。在对新区间三个新点的代号作依次 、
步骤(3)缩短搜索区间，直至初始点 第一次由 代替，使用判别式
?
进行终止判别才具意义。为此，算法框图中设置开关 K=0 和 K=1 分别表示初始点 第一次
由 代替前和后的状态。
8
7
2.判别框
?若不成立，说明 落在区间之外。
上述两种情况只是在区间已缩得很小，由于三个插值结点已十分接近，计算机的舍入误差才 可能使其发生。此时取 和 作为最优解应是合理的。
3.在初始搜索区间第一次插值或 仍为初始给定点时， 和 并不代表前后二次插值
函数极小点，因而判别式
并不能确切地反映该不该终止迭代，这时应进行
常用的插值多项式 为二次或三次多项式，分别称为二次插值法和三次插值法。这里我 们主要介绍二次插值法的计算公式。
假定目标函数在初始搜索区间 中有三点 、 和
，
其函数值分别为 、 和 (图 1}，且满足
，
，即满足函数值为两头大
中间小的性质。利用这三点及相应的函数值作一条二次曲线，其函数 式
为一个二次多项
（7）
把 取作区间
内的另一个计算点，比较 与 两点函数值的大小，在保持
两头大中间小的前提下缩短搜索区间，从而构成新的三点搜索区间，再继续按上述方
法进行三点二次插值运算，直到满足规定的精度要求为止，把得到的最后的 作为 的 近似极小值点。上述求极值点的方法称为三点二次插值法。
为便于计算，可将式(7)改写为
二次插值法亦是用于一元函数 线拟合方法的范畴。
一、基本原理
在确定的初始区间内搜索极小点的一种方法。它属于曲
在求解一元函数 的极小点时，常常利用一个低次插值多项式 来逼近原目标函数，
然后求该多项式的极小点(低次多项式的极小点比较容易计算)，并以此作为目标函数 的近似极小点。如果其近似的程度尚未达到所要求的精度时，可以反复使用此法，逐次拟合， 直到满足给定的精度时为止。
式中：
（8） （9）
二、迭代过程及算法框图 (1)确定初始插值结点
通常取初始搜索区间
的两端点
3
（10）
，
，
。
，构成三个初始插值结点 、 、
(2)计算二次插值函数极小点
按式(8)计算 ，并将 记作点 ，计算
。若本步骤为对初始搜索区间的
第一次插值或 点仍为初始给定点时，则进行下一步(3);否则转步骤(4)
、 的一般化处理后，计算其函数值，并令
，
，
，
返回步骤(2)。
图 2（a）
4
图 2（b）
图 2（c）
5
(4)判断迭代终止条件
图 2（d）
在一般情况下，因 是前一次插值函数的极小值点， 是本次插值函数的极小值点，若
和 的距离足够小时，即满足
，或 和 两者原函数值已很接
近，即满足
，则停止迭代，这时，若
（1）
式中 、 、 为待定系数。
1
图1 根据插值条件，插值函数 与原函数 在插值结点 、 、 处函数值相等，得
（2）
为求插值多项式
的极小点 ，可令其一阶导数为零，即
（3）
解式(3)即求得插值函数的极小点
（4）
式(4)中要确定的系数
可在方程组(2)中利用相邻两个方程消去 而得:
（5）
2
（6） 将式(5)、(6)代入式(4)便得插值函数极小值点 的计算公式：
计算方法课件：第2次课 计算方法插值
2.3.2 Lagrange插值公式
Lagrange插值多项式 令R[x]n+1表示所有的不高于n次的实系数
多项式和零多项式构成的集合，假设函数y=f(x) 的已知值(xi，yi)(yi=f(xi)，xi互异，i=0，1，…，
n)，寻找一个多项式p(x) R[x]n+1，满足：
p(xi)=f(xi)(i=0，1，…，n)
插值问题中的一个非常典型的问题
插值方法 8
2.1 问题的提出(数值预测)
计算函数值
Y
Q：函数关系复杂，没 有解析表达式，或者函数形 式未知。
常见的有：由观测数据
0
(离散数据)计算未观测到的
点的函数值。
X
0
——由观测数据构造一个适当的简单函数近似的代替
要寻求的函数——插值法。
代数插值——简单函数为代数多项式
内存在n+1阶有界导数，则当x [a,b]，必存在一点
ξ(a，b) ，使得
r(x)
f n1( )
(n 1)!
n
(x xk )
k 0
插值方法 25
证明——《数学分析》
误差分析 x偏离插值节点比较远，则误差大，尤
其是外推误差大； 被插函数足够光滑，否则导数过大，用
代数多项式插值不合适。
插值方法 26
谢谢！
插值方法
点x为插值点； 内插——插值点位于插值区间内的插值过程；
外插——插值点位于插值区间外的插值过程，也 叫外推。
插值方法 15
要求： 效率高 精度高 插值函数形式简单——多项式、有理分式。
代数插值法——g(x)=p(x)，为插值多项式 Lagrange插值公式 Aitken插值公式 Newton插值公式
求的二次插值多项式
第二章 插值法1．当1,1,2x =-时，()0,3,4f x =-,求()f x 的二次插值多项式。
解：0120121200102021101201220211,1,2,()0,()3,()4;()()1()(1)(2)()()2()()1()(1)(2)()()6()()1()(1)(1)()()3x x x f x f x f x x x x x l x x x x x x x x x x x l x x x x x x x x x x x l x x x x x x x ==-===-=--==-+-----==------==-+--则二次拉格朗日插值多项式为220()()k k k L x y l x ==∑0223()4()14(1)(2)(1)(1)23537623l x l x x x x x x x =-+=---+-+=+- 2．给出()ln f x x =的数值表用线性插值及二次插值计算的近似值。
解：由表格知，01234012340.4,0.5,0.6,0.7,0.8;()0.916291,()0.693147()0.510826,()0.356675()0.223144x x x x x f x f x f x f x f x ======-=-=-=-=-若采用线性插值法计算ln 0.54即(0.54)f ， 则0.50.540.6<<2112122111122()10(0.6)()10(0.5)()()()()()x x l x x x x x x l x x x x L x f x l x f x l x -==----==---=+6.93147(0.6) 5.10826(x x =--- 1(0.54)0.62021860.620219L ∴=-≈-若采用二次插值法计算ln 0.54时，1200102021101201220212001122()()()50(0.5)(0.6)()()()()()100(0.4)(0.6)()()()()()50(0.4)(0.5)()()()()()()()()()x x x x l x x x x x x x x x x x l x x x x x x x x x x x l x x x x x x x L x f x l x f x l x f x l x --==------==-------==----=++500.916291(0.5)(0.6)69.3147(0.4)(0.6)0.51082650(0.4)(0.5x x x x x x =-⨯--+---⨯--2(0.54)0.615319840.615320L ∴=-≈- 3．给全cos ,090x x ≤≤ 的函数表，步长1(1/60),h '== 若函数表具有5位有效数字，研究用线性插值求cos x 近似值时的总误差界。
halcon曲线插值算法
halcon曲线插值算法
Halcon是一个强大的机器视觉软件库，提供了多种曲线插值算法。
以下是Halcon 中常用的曲线插值算法：
线性插值：线性插值是最简单的插值方法，通过构造两条直线来连接已知的点。
虽然线性插值的计算速度较快，但对于非线性变化的曲线，其拟合效果可能不够理想。
二次插值：二次插值比线性插值更加复杂，通过构造二次多项式来逼近已知的点。
二次插值能够更好地处理非线性变化的曲线，但计算量较大。
样条插值：样条插值是一种更复杂的插值方法，通过构造样条函数（如三次样条函数）来逼近已知的点。
样条插值能够得到更加平滑的曲线，适合处理具有突变点的数据。
多项式插值：多项式插值是通过构造多项式来逼近已知的点。
多项式插值的拟合效果较好，但计算量较大，且容易受到噪声的影响。
立方插值：立方插值是一种较新的插值方法，通过构造立方多项式来逼近已知的点。
立方插值的拟合效果非常好，能够得到非常平滑的曲线，但计算量较大。
在选择合适的曲线插值算法时，需要考虑数据的特点、计算资源和精度要求等因素。
对于要求较高精度的应用，可以考虑使用立方插值或样条插值；对于计算资源有限的应用，可以考虑使用线性插值或二次插值。
二次插值算法
二次插值法亦是用于一元函数在确定的初始区间搜索极小点的一种方法。
它属于曲线拟合方法的畴。
一、基本原理在求解一元函数的极小点时，常常利用一个低次插值多项式来逼近原目标函数，然后求该多项式的极小点(低次多项式的极小点比较容易计算)，并以此作为目标函数的近似极小点。
如果其近似的程度尚未达到所要求的精度时，可以反复使用此法，逐次拟合，直到满足给定的精度时为止。
常用的插值多项式为二次或三次多项式，分别称为二次插值法和三次插值法。
这里我们主要介绍二次插值法的计算公式。
假定目标函数在初始搜索区间中有三点、和，其函数值分别为、和(图1}，且满足，，即满足函数值为两头大中间小的性质。
利用这三点及相应的函数值作一条二次曲线，其函数为一个二次多项式（1）式中、、为待定系数。
图1根据插值条件，插值函数与原函数在插值结点、、处函数值相等，得（2）为求插值多项式的极小点，可令其一阶导数为零，即（3）解式(3)即求得插值函数的极小点（4）式(4)中要确定的系数可在方程组(2)中利用相邻两个方程消去而得:（5）（6）将式(5)、(6)代入式(4)便得插值函数极小值点的计算公式：（7）把取作区间的另一个计算点，比较与两点函数值的大小，在保持两头大中间小的前提下缩短搜索区间，从而构成新的三点搜索区间，再继续按上述方法进行三点二次插值运算，直到满足规定的精度要求为止，把得到的最后的作为的近似极小值点。
上述求极值点的方法称为三点二次插值法。
为便于计算，可将式(7)改写为（8）式中：（9）（10）二、迭代过程及算法框图(1)确定初始插值结点通常取初始搜索区间的两端点及中点为，，。
计算函数值，，，构成三个初始插值结点、、。
(2)计算二次插值函数极小点按式(8)计算，并将记作点，计算。
若本步骤为对初始搜索区间的第一次插值或点仍为初始给定点时，则进行下一步(3);否则转步骤(4)(3)缩短搜索区间缩短搜索区间的原则是：比较函数值、，取其小者所对应的点作为新的点，并以此点左右两邻点分别取作新的和，构成缩短后的新搜索区间。
二次插值的粒子群优化算法
Ｓ ｃ ｈ ｏ ｏ ｌ ｏ ｆ Ｍａ ｔ ｈ ｅ ｍａ ｔ ｉ ｃ ｓ ａ ｎ ｄ Ｐ ｈ ｙ ｓ ｉ ｃ ｓ ， Ｂｏ ｈ ａ ｉ Ｕｎ ｉ ｖ ｅ ｒ ｓ ｉ ｔ ｙ ， Ｊ ｉ ｎ ｚ ｈ ｏ ｕ ， Ｌｉ ａ ｏ ｎ ｉ ｎ ｇ １ ２ １ ０ １ ３ ， Ｃｈ ｉ ｎ ａ
好 位 置相 比较 ， 更新 当前 个体 历 史最 好位 置 和全局 历 史 最好位 置 。对 ６ 个经 典 测试 函数 进行 数值 实验 ， 结果表 明该 算法提
高 了算法 的寻优 能力和 收敛 速度 。
关 键词 ： 粒子 群优 化 算法 ； 二 次插 值 ； 收敛速 度 ； 全局 最 优
ｇ ｒ ｅ ａ ｔ ｌ ｙ ｉ ｍｐ ｒ ｏ ｖ ｅ ｓ ｔ ｈ ｅ ｓ ｅ ａ ｒ ｃ ｈ ｉ ｎ ｇ ｅ ｉｃ ｆ ｉ ｅ ｎ ｃ ｙ ａ ｎ ｄ ｔ ｈｅ ｃ ｏ ｎ ｖ ｅ ｒ ｇ ｅ ｎ ｃ ｅ ｒ ａ ｔ ｅ ｏ ｆ ＰＳ Ｏ．
Ｋｅ ｙ ｗｏ ｒ ｄｓ ：Ｐａ ｒ ｔ ｉ ｃ ｌ ｅ Ｓ ｗａ ｒ ｍ Ｏｐ ｔ ｉ ｍｉ ｚ ａ ｔ ｉ ｏ ｎ； ｑ ｕ ａ ｄ ｒ ａ ｔ ｉ ｃ ｉ ｎ ｔ ｅ ｐ ｏｌ ｒ ａ ｔ ｉ ｏ ｎ ； ｃ ｏ ｎ ｖ ｅ ｒ ｇ ｅ ｎ ｃ ｅ ｓ ｐ ｅ ｅ ｃ ｈ； ｇ ｌ ｏ ｂ ａ ｌ ｏ ｐ ｔ ｉ ｍａ ｌ
Ｃ ｏ ｍ ｐ ｕ ｔ ｅ ｒ Ｅ ｎ ｇ ｉ ｎ ｅ ｅ ｒ ｉ ｎ ｇ ａ ｎ ｄ Ａ ｐ ｐ ｌ ｉ ｃ ａ ｔ ｉ ｏ ｎ ｓ 计 算 机工 程与 应用
＠理论 研 究、 研 发 设 计 ＠
二次 插 值 的粒 子 群 优 化 算 法
钱伟懿， 卢 静
计算方法(2)-插值法
2
2
yk1 2
f (xk
h
2
),
y
k
1 2
f (xk
h) 2
21
3.牛顿向后插值公式
Nn (xn
th)
yn
tyn
t(t 1) 2!
2
yn
t(t
1)
(t n!
n
1)
n
yn
(t 0)
插值余项
Rn
(xn
th)
t(t
1) (t (n 1)!
Nn (x0
th)
y0
ty0
t(t 1) 2!
2
y0Leabharlann 插值余项t(t
1)
(t n!
n
1)
n
y0
Rn (x0
th)
t(t
1) (t (n 1)!
n)
h n1
f
(n1) ( ),
(x0 , xn )
20
二.向后差分与牛顿向后插值公式
杂.
根据f(x)函数表或复杂的解析表达式构
造某个简单函数P(x)作为f(x)的近似.
2
2.问题的提法
1)已知条件 设函数y f (x)在区间[a,b]上
连 续, 且 在n 1个不 同点a x0 , x1, , xn b 上 分 别 取 值y0 , y1, , yn
线性插值与二次插值公式ppt课件
MATLAB计算程序
1
x=0:.6:1.8; y=erf(x);
0 .8
x=x';y=y';
A=[ones(4,1) x x.^2 x.^3]; 0.6
p=A\y;
0 .4
a0=p(1);a1=p(2); 0 .2
a2=p(3);a3=p(4);
t=0:.2:2;
0
0
0 .5
1
1 .5
2
u=a0+a1*t+a2*t.^2+a3*t.^3;
plot(x,y,'o',t,u)
12
拉格朗日插值的基函数构造法
n=1 线性插值问题 x
x0
x1
已知函数表 f(x)
y0
y1
求满足: L1(x0)=y0 , L1(x1)=y1的线性插值多项式 L1(x)
由过两点直线方程,得
L1( x)
y0
y1 x1
y0 x0
(x
x0 )
化为等价形式
L1( x)
当 x∈(0.5, 1)时
Erf ( x) 1 [( x 0.5) 0.8427 (1 x) 0.5205] 1 0.5
当 x∈(1, 1.5)时
Erf ( x) 1 [( x 1) 0.9661 (1.5 x) 0.8427] 1.5 1
3
实际问题中遇到的函数f(x)有的表达式复杂，有 的只提供了离散点上的函数值或导数值。为了进 一步分析问题的性质和变化规律，自然希望找到 一种简单函数p(x)，能近似描述函数f(x)的变化规 律，又便于处理。把这个函数p(x)称作f(x)的近似 函数。
二次插值算法范文
二次插值算法范文二次插值算法是一种在离散数据点之间进行数据估计的方法，它通过利用已知数据点及其相邻数据点的信息，来计算出两个数据点之间的值。
二次插值算法可以应用于图像处理、信号处理、数值分析等领域，在实际应用中具有很高的效率和准确性。
二次插值算法的基本原理是通过已知的数据点来构造一个二次函数，然后利用这个函数来估计两个数据点之间的值。
具体而言，假设我们有一组数据点{(x1, y1), (x2, y2), ..., (xn, yn)}，我们希望估计在一些位置x处的值y。
首先，我们选择x所在的两个已知数据点，假设它们分别为(xi, yi)和(xi+1, yi+1)，然后我们构造一个二次函数f(x) = ax^2 + bx + c，满足条件f(xi) = yi和f(xi+1) = yi+1、通过解这个方程组，我们可以得到二次函数的系数a、b和c，然后通过计算f(x)即可得到在位置x处的估计值y。
下面我们来具体讨论二次插值算法的实现。
首先，我们需要定义一个函数quadratic_interpolation，它接受三个参数：x, data和index。
其中x为需要估计的位置，data为已知的数据点集合，index为x所在的两个数据点的索引。
```pythondef quadratic_interpolation(x, data, index):x0, y0 = data[index]x1, y1 = data[index + 1]a=(y0-2*y1+y2)/((x0-x1)*(x0-x2))b=(y1-y0)/(x1-x0)-a*(x0+x1)c=y0-a*x0**2-b*x0return a*x**2 + b*x + c```在这段代码中，我们首先通过传入的index参数找到x所在的两个数据点，然后根据这两个数据点构造二次函数的系数a、b和c，并最终返回在位置x处的估计值。
接下来，我们可以使用这个二次插值算法来对一组数据进行插值。
高质量的快速图像缩放——二次线性插值和三次卷积插值
高质量的快速的图像缩放——二次线性插值和三次卷积插值限制条件:为了便于讨论，这里只处理32bit的ARGB颜色;代码使用C++;涉及到汇编优化的时候假定为x86平台;使用的编译器为vc2005;为了代码的可读性,没有加入异常处理代码;测试使用的CPU为AMD64x2 4200+(2.37G) 和Intel Core2 4400(2.00G);速度测试说明:只测试内存数据到内存数据的缩放测试图片都是800*600缩放到1024*768; fps表示每秒钟的帧数,值越大表示函数越快A: 近邻取样插值、二次线性插值、三次卷积插值缩放效果对比原图近邻取样缩放到0.6倍近邻取样缩放到1.6倍二次线性插值缩放到0.6倍二次线性插值缩放到1.6倍三次卷积插值缩放到0.6倍三次卷积插值缩放到1.6倍原图近邻取样缩放到8倍二次线性插值缩放到8倍三次卷积插值缩放到8倍二次线性插值(近似公式)近邻取样插值缩放简单、速度快，但很多时候缩放出的图片质量比较差(特别是对于人物、景色等)，图片的缩放有比较明显的锯齿；使用二次或更高次插值有利于改善缩放效果；B: 首先定义图像数据结构:#define asm __asmtypedef unsigned char TUInt8; // [0..255]struct TARGB32 //32 bit color{TUInt8 b,g,r,a; //a is alpha};struct TPicRegion //一块颜色数据区的描述，便于参数传递{TARGB32* pdata; //颜色数据首地址long byte_width; //一行数据的物理宽度(字节宽度)；//abs(byte_width)有可能大于等于width*sizeof(TARGB32);long width; //像素宽度long height; //像素高度};//那么访问一个点的函数可以写为：inline TARGB32& Pixels(const TPicRegion& pic,const long x,const long y){return ( (TARGB32*)((TUInt8*)pic.pdata+pic.byte_width*y) )[x];}二次线性差值C: 二次线性插值缩放原理和公式图示:缩放后图片原图片(宽DW,高DH) (宽SW,高SH)缩放映射原理:(Sx-0)/(SW-0)=(Dx-0)/(DW-0) (Sy-0)/(SH-0)=(Dy-0)/(DH-0)=> Sx=Dx*SW/DW Sy=Dy*SH/DH聚焦看看(Sx,Sy)坐标点(Sx,Sy为浮点数)附近的情况；对于近邻取样插值的缩放算法，直接取Color0颜色作为缩放后点的颜色；二次线性插值需要考虑(Sx,Sy)坐标点周围的4个颜色值Color0\Color1\Color2\Color3，把(Sx,Sy)到A\B\C\D坐标点的距离作为系数来把4个颜色混合出缩放后点的颜色；(u=Sx-floor(Sx); v=Sy-floor(Sy); 说明:floor函数的返回值为小于等于参数的最大整数) 二次线性插值公式为:tmpColor0=Color0*(1-u) + Color2*u;tmpColor1=Color1*(1-u) + Color3*u;DstColor =tmpColor0*(1-v) + tmpColor2*v;展开公式为:pm0=(1-u)*(1-v);pm1=v*(1-u);pm2=u*(1-v);pm3=u*v;则颜色混合公式为:DstColor = Color0*pm0 + Color1*pm1 + Color2*pm2 + Color3*pm3;参数函数图示：二次线性插值函数图示对于上面的公式，它将图片向右下各移动了半个像素，需要对此做一个修正；=> Sx=(Dx+0.5)*SW/DW-0.5; Sy=(Dy+0.5)*SH/DH-0.5;而实际的程序,还需要考虑到边界(访问源图片可能超界)对于算法的影响,边界的处理可能有各种方案(不处理边界或边界回绕或边界饱和或边界映射或用背景颜色混合等;文章中默认使用边界饱和来处理超界);比如: 边界饱和函数://访问一个点的函数，(x,y)坐标可能超出图片边界； //边界处理模式:边界饱和inline TARGB32 Pixels_Bound(const TPicRegion& pic,long x,long y){//assert((pic.width>0)&&(pic.height>0));bool IsInPic=true;if (x<0) {x=0; IsInPic=false; }else if (x>=pic.width ) {x=pic.width -1; IsInPic=false; }if (y<0) {y=0; IsInPic=false; }else if (y>=pic.height) {y=pic.height-1; IsInPic=false; }TARGB32 result=Pixels(pic,x,y);if (!IsInPic) result.a=0;return result;}D: 二次线性插值缩放算法的一个参考实现：PicZoom_BilInear0该函数并没有做什么优化，只是一个简单的浮点实现版本；inline void Bilinear0(const TPicRegion& pic,float fx,float fy,TARGB32* result){long x=(long)fx; if (x>fx) --x; //x=floor(fx);long y=(long)fy; if (y>fy) --y; //y=floor(fy);TARGB32 Color0=Pixels_Bound(pic,x,y);TARGB32 Color2=Pixels_Bound(pic,x+1,y);TARGB32 Color1=Pixels_Bound(pic,x,y+1);TARGB32 Color3=Pixels_Bound(pic,x+1,y+1);float u=fx-x;float v=fy-y;float pm3=u*v;float pm2=u*(1-v);float pm1=v*(1-u);float pm0=(1-u)*(1-v);result->a=(pm0*Color0.a+pm1*Color1.a+pm2*Color2.a+pm3*Color3.a);result->r=(pm0*Color0.r+pm1*Color1.r+pm2*Color2.r+pm3*Color3.r);result->g=(pm0*Color0.g+pm1*Color1.g+pm2*Color2.g+pm3*Color3.g);result->b=(pm0*Color0.b+pm1*Color1.b+pm2*Color2.b+pm3*Color3.b);}void PicZoom_Bilinear0(const TPicRegion& Dst,const TPicRegion& Src){if ( (0==Dst.width)||(0==Dst.height)||(0==Src.width)||(0==Src.height)) return;unsigned long dst_width=Dst.width;TARGB32* pDstLine=Dst.pdata;for (unsigned long y=0;y<Dst.height;++y){float srcy=(y+0.4999999)*Src.height/Dst.height-0.5;for (unsigned long x=0;x<dst_width;++x){float srcx=(x+0.4999999)*Src.width/Dst.width-0.5;Bilinear0(Src,srcx,srcy,&pDstLine[x]);}((TUInt8*&)pDstLine)+=Dst.byte_width;}}//////////////////////////////////////////////////////////////////////////////// //速度测试://============================================================================== // PicZoom_BilInear0 8.3 fps//////////////////////////////////////////////////////////////////////////////// E: 浮点计算改为定点数实现：PicZoom_BilInear1inline void Bilinear1(const TPicRegion& pic,const long x_16,const long y_16,TARGB32* result){long x=x_16>>16;long y=y_16>>16;TARGB32 Color0=Pixels_Bound(pic,x,y);TARGB32 Color2=Pixels_Bound(pic,x+1,y);TARGB32 Color1=Pixels_Bound(pic,x,y+1);TARGB32 Color3=Pixels_Bound(pic,x+1,y+1);unsigned long u_8=(x_16 & 0xFFFF)>>8;unsigned long v_8=(y_16 & 0xFFFF)>>8;unsigned long pm3_16=(u_8*v_8);unsigned long pm2_16=(u_8*(unsigned long)(255-v_8));unsigned long pm1_16=(v_8*(unsigned long)(255-u_8));unsigned long pm0_16=((255-u_8)*(255-v_8));result->a=((pm0_16*Color0.a+pm1_16*Color1.a+pm2_16*Color2.a+pm3_16*Color3.a)>>16);result->r=((pm0_16*Color0.r+pm1_16*Color1.r+pm2_16*Color2.r+pm3_16*Color3.r)>>16);result->g=((pm0_16*Color0.g+pm1_16*Color1.g+pm2_16*Color2.g+pm3_16*Color3.g)>>16);result->b=((pm0_16*Color0.b+pm1_16*Color1.b+pm2_16*Color2.b+pm3_16*Color3.b)>>16);}void PicZoom_Bilinear1(const TPicRegion& Dst,const TPicRegion& Src){if ( (0==Dst.width)||(0==Dst.height)||(0==Src.width)||(0==Src.height)) return;long xrIntFloat_16=((Src.width)<<16)/Dst.width+1;long yrIntFloat_16=((Src.height)<<16)/Dst.height+1;const long csDErrorX=-(1<<15)+(xrIntFloat_16>>1);const long csDErrorY=-(1<<15)+(yrIntFloat_16>>1);unsigned long dst_width=Dst.width;TARGB32* pDstLine=Dst.pdata;long srcy_16=csDErrorY;long y;for (y=0;y<Dst.height;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear1(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}}//////////////////////////////////////////////////////////////////////////////////速度测试://==============================================================================// PicZoom_BilInear1 17.7 fps//////////////////////////////////////////////////////////////////////////////// F: 边界访问超界的问题二次线性插值需要考略边界访问超界的问题，我们可以将边界区域和内部区域分开处理，这样就可以优化内部的插值实现函数了：比如不需要判断访问超界、减少颜色数据复制、减少一些不必要的重复坐标计算等等inline void Bilinear2_Fast(TARGB32* PColor0,TARGB32* PColor1,unsigned long u_8,unsigned long v_8,TARGB32* result){unsigned long pm3_16=u_8*v_8;unsigned long pm2_16=(u_8<<8)-pm3_16;unsigned long pm1_16=(v_8<<8)-pm3_16;unsigned long pm0_16=(1<<16)-pm1_16-pm2_16-pm3_16;result->a=((pm0_16*PColor0[0].a+pm2_16*PColor0[1].a+pm1_16*PColor1[0].a+pm3_16*PColor1[1].a)>>16);result->r=((pm0_16*PColor0[0].r+pm2_16*PColor0[1].r+pm1_16*PColor1[0].r+pm3_16*PColor1[1].r)>>16);result->g=((pm0_16*PColor0[0].g+pm2_16*PColor0[1].g+pm1_16*PColor1[0].g+pm3_16*PColor1[1].g)>>16);result->b=((pm0_16*PColor0[0].b+pm2_16*PColor0[1].b+pm1_16*PColor1[0].b+pm3_16*PColor1[1].b)>>16);}inline void Bilinear2_Border(const TPicRegion& pic,const long x_16, const long y_16,TARGB32* result){long x=(x_16>>16);long y=(y_16>>16);unsigned long u_16=((unsigned short)(x_16));unsigned long v_16=((unsigned short)(y_16));TARGB32 pixel[4];pixel[0]=Pixels_Bound(pic,x,y);pixel[1]=Pixels_Bound(pic,x+1,y);pixel[2]=Pixels_Bound(pic,x,y+1);pixel[3]=Pixels_Bound(pic,x+1,y+1);Bilinear2_Fast(&pixel[0],&pixel[2],u_16>>8,v_16>>8,result);}void PicZoom_Bilinear2(const TPicRegion& Dst,const TPicRegion& Src){if ( (0==Dst.width)||(0==Dst.height)||(0==Src.width)||(0==Src.height)) return;long xrIntFloat_16=((Src.width)<<16)/Dst.width+1;long yrIntFloat_16=((Src.height)<<16)/Dst.height+1;const long csDErrorX=-(1<<15)+(xrIntFloat_16>>1);const long csDErrorY=-(1<<15)+(yrIntFloat_16>>1);unsigned long dst_width=Dst.width;//计算出需要特殊处理的边界long border_y0=-csDErrorY/yrIntFloat_16+1;//y0+y*yr>=0; y0=csDErrorY => y>=-csDErrorY/yrif (border_y0>=Dst.height) border_y0=Dst.height;long border_x0=-csDErrorX/xrIntFloat_16+1;if (border_x0>=Dst.width ) border_x0=Dst.width;long border_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+y*yr<=(height-2) => y<=(height-2-csDErrorY)/yrif (border_y1<border_y0) border_y1=border_y0;long border_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;if (border_x1<border_x0) border_x1=border_x0;TARGB32* pDstLine=Dst.pdata;long Src_byte_width=Src.byte_width;long srcy_16=csDErrorY;long y;for (y=0;y<border_y0;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y0;y<border_y1;++y){long srcx_16=csDErrorX;long x;for (x=0;x<border_x0;++x){Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}{unsigned long v_8=(srcy_16 & 0xFFFF)>>8;TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;for (unsigned long x=border_x0;x<border_x1;++x){TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];TARGB32* PColor1=(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width); Bilinear2_Fast(PColor0,PColor1,(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);srcx_16+=xrIntFloat_16;}}for (x=border_x1;x<dst_width;++x){Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y1;y<Dst.height;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}}//////////////////////////////////////////////////////////////////////////////////速度测试://==============================================================================// PicZoom_BilInear2 43.4 fps////////////////////////////////////////////////////////////////////////////////F' 补充: 二次线性插值(近似公式)如果不想处理边界访问超界问题，可以考虑扩大源图片的尺寸，加一个边框(“哨兵”优化)；这样插值算法就不用考虑边界问题了，程序写起来也简单很多!如果对缩放结果的边界像素级精度要求不是太高，我还有一个方案，一个稍微改变的缩放公式:Sx=Dx*(SW-1)/DW；Sy=Dy*(SH-1)/DH；(源图片宽和高:SW>=2;SH>=2)证明这个公式不会造成内存访问超界:要求Dx=DW-1时: sx+1=int( (dw-1)/dw*(dw-1) ) +1 <= (sw-1)有: int( (sw-1)*(dw-1)/dw ) <=sw-2(sw-1)*(dw-1)/dw <(sw-1)(dw-1) /dw<1(dw-1) <dw比如，按这个公式的一个简单实现: (缩放效果见前面的"二次线性插值(近似公式)"图示)void PicZoom_ftBilinear_Common(const TPicRegion& Dst,const TPicRegion& Src){if ( (0==Dst.width)||(0==Dst.height)||(2>Src.width)||(2>Src.height)) return;long xrIntFloat_16=((Src.width-1)<<16)/Dst.width;long yrIntFloat_16=((Src.height-1)<<16)/Dst.height;unsigned long dst_width=Dst.width;long Src_byte_width=Src.byte_width;TARGB32* pDstLine=Dst.pdata;long srcy_16=0;for (unsigned long y=0;y<Dst.height;++y){unsigned long v_8=(srcy_16 & 0xFFFF)>>8;TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;long srcx_16=0;for (unsigned long x=0;x<dst_width;++x){TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];Bilinear_Fast_Common(PColor0,(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width),(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);srcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}}G: 模拟单指令多数据处理利用单指令多数据处理的MMX指令一般都可以加快颜色的运算；在使用MMX改写之前，利用32bit寄存器(或变量)来模拟单指令多数据处理；数据储存原理:一个颜色数据分量只有一个字节,用2个字节来储存单个颜色分量的计算结果，对于很多颜色计算来说精度就够了；那么一个32bit寄存器(或变量)就可以储存2个计算出的临时颜色分量；从而达到了单个指令两路数据处理的目的;单个指令两路数据处理的计算:乘法：((0x00AA*a)<<16) | (0x00BB*a) = 0x00AA00BB * a可见只要保证0x00AA*a和0x00BB*a都小于(1<<16)那么乘法可以直接使用无符号数乘法了加法: ((0x00AA+0x00CC)<<16) | (0x00BB+0x00DD) = 0x00AA00BB + 0x00CC00DD 可见只要0x00AA+0x00CC和0x00BB+0x00DD小于(1<<16)那么加法可以直接使用无符号数加法了(移位、减法等稍微复杂一点,因为这里没有用到就不推导运算公式了)inline void Bilinear_Fast_Common(TARGB32* PColor0,TARGB32* PColor1, unsigned long u_8,unsigned long v_8,TARGB32* result){unsigned long pm3_8=(u_8*v_8)>>8;unsigned long pm2_8=u_8-pm3_8;unsigned long pm1_8=v_8-pm3_8;unsigned long pm0_8=256-pm1_8-pm2_8-pm3_8;unsigned long Color=*(unsigned long*)(PColor0);unsigned long BR=(Color & 0x00FF00FF)*pm0_8;unsigned long GA=((Color & 0xFF00FF00)>>8)*pm0_8;Color=((unsigned long*)(PColor0))[1];GA+=((Color & 0xFF00FF00)>>8)*pm2_8;BR+=(Color & 0x00FF00FF)*pm2_8;Color=*(unsigned long*)(PColor1);GA+=((Color & 0xFF00FF00)>>8)*pm1_8;BR+=(Color & 0x00FF00FF)*pm1_8;Color=((unsigned long*)(PColor1))[1];GA+=((Color & 0xFF00FF00)>>8)*pm3_8;BR+=(Color & 0x00FF00FF)*pm3_8;*(unsigned long*)(result)=(GA & 0xFF00FF00)|((BR & 0xFF00FF00)>>8); }inline void Bilinear_Border_Common(const TPicRegion& pic,const long x_16,const long y_16,TARGB32* result){long x=(x_16>>16);long y=(y_16>>16);unsigned long u_16=((unsigned short)(x_16));unsigned long v_16=((unsigned short)(y_16));TARGB32 pixel[4];pixel[0]=Pixels_Bound(pic,x,y);pixel[1]=Pixels_Bound(pic,x+1,y);pixel[2]=Pixels_Bound(pic,x,y+1);pixel[3]=Pixels_Bound(pic,x+1,y+1);Bilinear_Fast_Common(&pixel[0],&pixel[2],u_16>>8,v_16>>8,result);}void PicZoom_Bilinear_Common(const TPicRegion& Dst,const TPicRegion& Src) {if ( (0==Dst.width)||(0==Dst.height)||(0==Src.width)||(0==Src.height)) return;long xrIntFloat_16=((Src.width)<<16)/Dst.width+1;long yrIntFloat_16=((Src.height)<<16)/Dst.height+1;const long csDErrorX=-(1<<15)+(xrIntFloat_16>>1);const long csDErrorY=-(1<<15)+(yrIntFloat_16>>1);unsigned long dst_width=Dst.width;//计算出需要特殊处理的边界long border_y0=-csDErrorY/yrIntFloat_16+1;//y0+y*yr>=0; y0=csDErrorY => y>=-csDErrorY/yrif (border_y0>=Dst.height) border_y0=Dst.height;long border_x0=-csDErrorX/xrIntFloat_16+1;if (border_x0>=Dst.width ) border_x0=Dst.width;long border_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+y*yr<=(height-2) => y<=(height-2-csDErrorY)/yrif (border_y1<border_y0) border_y1=border_y0;long border_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;if (border_x1<border_x0) border_x1=border_x0;TARGB32* pDstLine=Dst.pdata;long Src_byte_width=Src.byte_width;long srcy_16=csDErrorY;long y;for (y=0;y<border_y0;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y0;y<border_y1;++y){long srcx_16=csDErrorX;long x;for (x=0;x<border_x0;++x){Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}{unsigned long v_8=(srcy_16 & 0xFFFF)>>8;TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;for (unsigned long x=border_x0;x<border_x1;++x){TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];TARGB32* PColor1=(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width);Bilinear_Fast_Common(PColor0,PColor1,(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);srcx_16+=xrIntFloat_16;}}for (x=border_x1;x<dst_width;++x){Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y1;y<Dst.height;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}}//////////////////////////////////////////////////////////////////////////////////速度测试://============================================================================== // PicZoom_BilInear_Common 65.3 fps//////////////////////////////////////////////////////////////////////////////// H: 使用MMX指令改写:PicZoom_Bilinear_MMXinline void Bilinear_Fast_MMX(TARGB32* PColor0,TARGB32* PColor1, unsigned long u_8,unsigned long v_8,TARGB32* result){asm{MOVD MM6,v_8MOVD MM5,u_8mov edx,PColor0mov eax,PColor1PXOR mm7,mm7MOVD MM2,dword ptr [eax]MOVD MM0,dword ptr [eax+4]PUNPCKLWD MM5,MM5PUNPCKLWD MM6,MM6MOVD MM3,dword ptr [edx]MOVD MM1,dword ptr [edx+4]PUNPCKLDQ MM5,MM5PUNPCKLBW MM0,MM7PUNPCKLBW MM1,MM7PUNPCKLBW MM2,MM7PUNPCKLBW MM3,MM7PSUBw MM0,MM2PSUBw MM1,MM3PSLLw MM2,8PSLLw MM3,8PMULlw MM0,MM5PMULlw MM1,MM5PUNPCKLDQ MM6,MM6PADDw MM0,MM2PADDw MM1,MM3PSRLw MM0,8PSRLw MM1,8PSUBw MM0,MM1PSLLw MM1,8PMULlw MM0,MM6mov eax,resultPADDw MM0,MM1PSRLw MM0,8PACKUSwb MM0,MM7movd [eax],MM0//emms}}void Bilinear_Border_MMX(const TPicRegion& pic,const long x_16,const long y_16,TARGB32* result){long x=(x_16>>16);long y=(y_16>>16);unsigned long u_16=((unsigned short)(x_16));unsigned long v_16=((unsigned short)(y_16));TARGB32 pixel[4];pixel[0]=Pixels_Bound(pic,x,y);pixel[1]=Pixels_Bound(pic,x+1,y);pixel[2]=Pixels_Bound(pic,x,y+1);pixel[3]=Pixels_Bound(pic,x+1,y+1);Bilinear_Fast_MMX(&pixel[0],&pixel[2],u_16>>8,v_16>>8,result);}void PicZoom_Bilinear_MMX(const TPicRegion& Dst,const TPicRegion& Src) {if ( (0==Dst.width)||(0==Dst.height)||(0==Src.width)||(0==Src.height)) return;long xrIntFloat_16=((Src.width)<<16)/Dst.width+1;long yrIntFloat_16=((Src.height)<<16)/Dst.height+1;const long csDErrorX=-(1<<15)+(xrIntFloat_16>>1);const long csDErrorY=-(1<<15)+(yrIntFloat_16>>1);unsigned long dst_width=Dst.width;//计算出需要特殊处理的边界long border_y0=-csDErrorY/yrIntFloat_16+1;//y0+y*yr>=0; y0=csDErrorY => y>=-csDErrorY/yrif (border_y0>=Dst.height) border_y0=Dst.height;long border_x0=-csDErrorX/xrIntFloat_16+1;if (border_x0>=Dst.width ) border_x0=Dst.width;long border_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+y*yr<=(height-2) => y<=(height-2-csDErrorY)/yrif (border_y1<border_y0) border_y1=border_y0;long border_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;if (border_x1<border_x0) border_x1=border_x0;TARGB32* pDstLine=Dst.pdata;long Src_byte_width=Src.byte_width;long srcy_16=csDErrorY;long y;for (y=0;y<border_y0;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]); //border srcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y0;y<border_y1;++y){long srcx_16=csDErrorX;long x;for (x=0;x<border_x0;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}{unsigned long v_8=(srcy_16 & 0xFFFF)>>8;TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;for (unsigned long x=border_x0;x<border_x1;++x){TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];TARGB32* PColor1=(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width);Bilinear_Fast_MMX(PColor0,PColor1,(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);srcx_16+=xrIntFloat_16;}}for (x=border_x1;x<dst_width;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y1;y<Dst.height;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}asm emms}//////////////////////////////////////////////////////////////////////////////// //速度测试://============================================================================== // PicZoom_BilInear_MMX 132.9 fps//////////////////////////////////////////////////////////////////////////////// H': 对BilInear_MMX简单改进:PicZoom_Bilinear_MMX_Exvoid PicZoom_Bilinear_MMX_Ex(const TPicRegion& Dst,const TPicRegion& Src){if ( (0==Dst.width)||(0==Dst.height)||(0==Src.width)||(0==Src.height)) return;long xrIntFloat_16=((Src.width)<<16)/Dst.width+1;long yrIntFloat_16=((Src.height)<<16)/Dst.height+1;const long csDErrorX=-(1<<15)+(xrIntFloat_16>>1);const long csDErrorY=-(1<<15)+(yrIntFloat_16>>1);unsigned long dst_width=Dst.width;//计算出需要特殊处理的边界long border_y0=-csDErrorY/yrIntFloat_16+1;//y0+y*yr>=0; y0=csDErrorY => y>=-csDErrorY/yrif (border_y0>=Dst.height) border_y0=Dst.height;long border_x0=-csDErrorX/xrIntFloat_16+1;if (border_x0>=Dst.width ) border_x0=Dst.width;long border_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+y*yr<=(height-2) => y<=(height-2-csDErrorY)/yrif (border_y1<border_y0) border_y1=border_y0;long border_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;if (border_x1<border_x0) border_x1=border_x0;TARGB32* pDstLine=Dst.pdata;long Src_byte_width=Src.byte_width;long srcy_16=csDErrorY;long y;for (y=0;y<border_y0;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y0;y<border_y1;++y){long srcx_16=csDErrorX;long x;for (x=0;x<border_x0;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}{long dst_width_fast=border_x1-border_x0;if (dst_width_fast>0){unsigned long v_8=(srcy_16 & 0xFFFF)>>8;TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;TARGB32* PSrcLineColorNext= (TARGB32*)((TUInt8*)(PSrcLineColor)+ Src_byte_width) ;TARGB32* pDstLine_Fast=&pDstLine[border_x0];asm{movd mm6,v_8pxor mm7,mm7 //mm7=0PUNPCKLWD MM6,MM6PUNPCKLDQ MM6,MM6//mm6=v_8mov esi,PSrcLineColormov ecx,PSrcLineColorNextmov edx,srcx_16mov ebx,dst_width_fastmov edi,pDstLine_Fastlea edi,[edi+ebx*4]push ebpmov ebp,xrIntFloat_16neg ebxloop_start:mov eax,edxshl eax,16shr eax,24//== movzx eax,dh //eax=u_8MOVD MM5,eaxmov eax,edxshr eax,16 //srcx_16>>16MOVD MM2,dword ptr [ecx+eax*4]MOVD MM0,dword ptr [ecx+eax*4+4]PUNPCKLWD MM5,MM5MOVD MM3,dword ptr [esi+eax*4]MOVD MM1,dword ptr [esi+eax*4+4]PUNPCKLDQ MM5,MM5 //mm5=u_8PUNPCKLBW MM0,MM7PUNPCKLBW MM1,MM7PUNPCKLBW MM2,MM7PUNPCKLBW MM3,MM7PSUBw MM0,MM2PSUBw MM1,MM3PSLLw MM2,8PSLLw MM3,8PMULlw MM0,MM5PMULlw MM1,MM5PADDw MM0,MM2PADDw MM1,MM3PSRLw MM0,8PSRLw MM1,8PSUBw MM0,MM1PSLLw MM1,8PMULlw MM0,MM6PADDw MM0,MM1PSRLw MM0,8PACKUSwb MM0,MM7MOVd dword ptr [edi+ebx*4],MM0 //write DstColor add edx,ebp //srcx_16+=xrIntFloat_16inc ebxjnz loop_startpop ebpmov srcx_16,edx}}}for (x=border_x1;x<dst_width;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);//bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}for (y=border_y1;y<Dst.height;++y){long srcx_16=csDErrorX;for (unsigned long x=0;x<dst_width;++x){Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]); //bordersrcx_16+=xrIntFloat_16;}srcy_16+=yrIntFloat_16;((TUInt8*&)pDstLine)+=Dst.byte_width;}asm emms}//////////////////////////////////////////////////////////////////////////////// //速度测试://============================================================================== // PicZoom_Bilinear_MMX_Ex 157.0 fps//////////////////////////////////////////////////////////////////////////////// I: 把测试成绩放在一起：//////////////////////////////////////////////////////////////////////////////// //CPU: AMD64x2 4200+(2.37G) zoom 800*600 to 1024*768//============================================================================== // StretchBlt 232.7 fps// PicZoom3_SSE 711.7 fps//// PicZoom_BilInear0 8.3 fps// PicZoom_BilInear1 17.7 fps// PicZoom_BilInear2 43.4 fps// PicZoom_BilInear_Common 65.3 fps// PicZoom_BilInear_MMX 132.9 fps// PicZoom_BilInear_MMX_Ex 157.0 fps////////////////////////////////////////////////////////////////////////////////补充Intel Core2 4400上的测试成绩://////////////////////////////////////////////////////////////////////////////// //CPU: Intel Core2 4400(2.00G) zoom 800*600 to 1024*768//============================================================================== // PicZoom3_SSE 1099.7 fps//// PicZoom_BilInear1 24.2 fps// PicZoom_BilInear2 54.3 fps// PicZoom_BilInear_Common 59.8 fps// PicZoom_BilInear_MMX 118.4 fps// PicZoom_BilInear_MMX_Ex 142.9 fps//////////////////////////////////////////////////////////////////////////////// 三次卷积插值J: 三次卷积插值原理二次线性插值缩放出的图片很多时候让人感觉变得模糊(术语叫低通滤波)，特别是在放大的时候；使用三次卷积插值来改善插值结果；三次卷积插值考虑映射点周围16个点(4x4)的颜色来计算最终的混合颜色，如图；P(0,0)所在像素为映射的点，加上它周围的15个点，按一定系数混合得到最终输出结果；混合公式参见PicZoom_ThreeOrder0的实现；插值曲线公式sin(x*PI)/(x*PI),如图:三次卷积插值曲线sin(x*PI)/(x*PI) （其中PI=3.1415926...）K: 三次卷积插值缩放算法的一个参考实现：PicZoom_ThreeOrder0 该函数并没有做过多的优化，只是一个简单的浮点实现版本;inline double SinXDivX(double x){//该函数计算插值曲线sin(x*PI)/(x*PI)的值 //PI=3.1415926535897932385;//下面是它的近似拟合表达式const float a = -1;//a还可以取 a=-2,-1,-0.75,-0.5等等，起到调节锐化或模糊程度的作用if (x<0) x=-x; //x=abs(x);double x2=x*x;double x3=x2*x;if (x<=1)return (a+2)*x3 - (a+3)*x2 + 1;else if (x<=2)return a*x3 - (5*a)*x2 + (8*a)*x - (4*a);elsereturn 0;}inline TUInt8 border_color(long Color){if (Color<=0)return 0;else if (Color>=255)return 255;elsereturn Color;}void ThreeOrder0(const TPicRegion& pic,const float fx,const float fy,TARGB32* result){long x0=(long)fx; if (x0>fx) --x0; //x0=floor(fx);long y0=(long)fy; if (y0>fy) --y0; //y0=floor(fy);float fu=fx-x0;float fv=fy-y0;TARGB32 pixel[16];long i,j;for (i=0;i<4;++i){for (j=0;j<4;++j){long x=x0-1+j;long y=y0-1+i;pixel[i*4+j]=Pixels_Bound(pic,x,y);}}。
2次插值
，并求这个插值函数
该法是以目标函数的二次插值函数的极小点作为新的中间插入点，进行区 是以目标函数的二次插值函数的极小点作为新的中间插入点， 的一维搜索方法。 间缩小的一维搜索方法。 α 设一元函数 f (α ) ，在单峰区间 [ α 1 , α 3 ] 内取一点 2 且 α 1 < α 2 < α 3 这三点对应的函数值分别为
之值代入式 将B，C之值代入式(2-32)，可求得 ， 之值代入 ，
α2 2 2 B 1 (α 2 − α32 ) f1 + (α32 − α12 ) f 2 + (α12 − α 2 ) f3 α =− = 2C 2 (α 2 − α3 ) f1 + (α3 − α1 ) f 2 + (α1 − α 2 ) f3
∗
图2-25（a） （ ）
图2-25 （b） ）
图2-25（c） （ ）
图2-25（d） （ ）
判断迭代终止条件
α 在一般情况下，因α 2 是前一次插值函数的极小值点， * 是本次插值函数的极 在一般情况下， 是前一次插值函数的极小值点， p * * * α 小值点， 的距离足够小时， 小值点，若α p 和α 2 的距离足够小时，即满足 α p − α 2 ≤ ε ，或 α p 和 2 两者原函数 值已很接近， 则停止迭代，这时， 值已很接近，即满足 | f 4 − f 2 |≤ ε ，则停止迭代，这时，若 f 4 < f 2 ，输出极小 值点 4 = α ∗ ，极小值 = f (α ∗ ) ; α f4 ∗ 否则， 否则，即 f 4 ≥ f 2 时，输出极小值点α 2 = α ，极小值 f 2 = f (α ∗ ) 。如不 满足上述迭代终止条件，则返回步骤(3)，再次缩短搜索区间，直至最后满足终止 满足上述迭代终止条件，则返回步骤 ，再次缩短搜索区间， 条件。 条件。