-----------------------------转载自jia20003的博客"
-----------------------------------
一：数学原理
如果已知一个函数f(x)以及它在x=0,x=1处的导数，那么函数可以在[0,1]之间插值，当函数
表达为三次多项式时我们称之谓立方插值。一个三次多项式及其导数：
f(x) =ax^3 +bx^2 + cx + d
f’(x)=3ax^2 + 2bx +c
多项式在x=0, x=1处值及其导数值为：
f(0)= d;
f(1)= a + b + c + d;
f’(0)=c
f’(1)=3a + 2b + c
上述的四个等式可以等价的变换为:
a= 2f(0) – 2f(1) + f’(0) + f’(1)
b= -3f(0) + 3f(1) – 2f’(0) – f’(1)
c= f’(0)
d= f’(1)
假设你有四个点值p0, p1, p2, p3分别在x=-1, x=0, x=1, x=2, 把值分别指定到f(0), f(1), f’(0),
f’(1)中为:
f(0)= p1
f(1)= p2
f’(0)= (p2 – p0)/2
f’(1)= (p3-p1)/2
这个我们的立方插值公式变成:
f(p0,p1,p2,p3, x) = (-1/2p0 + 3/2p1 -3/2p2+ 1/2p3)x^3 + (p0-5/2p1 + 2p2 -1/2d)x^2 + (-1/2p0 +
1/2p2)x + p1
双立方插值是立方插值在二维空间的表达, 插值公式可以表述为:
G(x, y) = f (f (p00, p01, p02, p03, y), f(p10,p11, p12, p13, y), f(p20, p21, p22, p23, y), f(p30, p31, p32, p33, y), x)
解出其中的16个参数，即可得带G(x, y)目标插值点的值。
二：双立方插值优缺点
双立方插值在图像放大过程可以保留更多的图像细节，放大以后的图像带有反锯齿的功能，
同时图像和源图像相比效果更加真实, 缺点是计算量比较大，是常见的三种图像放大算法中
计算量最大的一种，据说Photoshop的图像放大就是基本双立方插值的优化算法
三：程序运行效果如下：
四：关键代码解析
不想解释太多，最重要的是代入计算的是浮点数坐标的小数部分，即 x, y的取值范围均在[0,1]之间
五：基于Java的程序完全源代码
package cn.edu.jxau.luoweifu;
public class BiCubicInterpolationScale {
private static double a00, a01, a02, a03;
private static double a10, a11, a12, a13;
private static double a20, a21, a22, a23;
private static double a30, a31, a32, a33;
private static int srcWidth;
private static int srcHeight;
/**
* 双立方插值
* @param inPixelsData 像素矩阵数组
* @param srcW 原图像的宽
* @param srcH 原图像的高
* @param destW 目标图像的宽
* @param destH 目标图像的高
* @return 处理后的推三矩阵数组
*/
public static int[] imgScale(int[] inPixelsData, int srcW, int srcH, int destW, int destH) {
double[][][] input3DData = processOneToThreeDeminsion(inPixelsData, srcH, srcW);
int[][][] outputThreeDeminsionData = new int[destH][destW][4];
double[][] tempPixels = new double[4][4];
float rowRatio = ((float)srcH)/((float)destH);
float colRatio = ((float)srcW)/((float)destW);
srcWidth = srcW;
srcHeight = srcH;
for(int row=0; row<destH; row++) {
// convert to three dimension data
double srcRow = ((float)row)*rowRatio;
double j = Math.floor(srcRow);
double t = srcRow - j;
for(int col=0; col<destW; col++) {
double srcCol = ((float)col)*colRatio;
double k = Math.floor(srcCol);
double u = srcCol - k;
for(int i=0; i<4; i++) {
tempPixels[0][0] = getRGBValue(input3DData,j-1, k-1,i);
tempPixels[0][1] = getRGBValue(input3DData,j-1, k, i);
tempPixels[0][2] = getRGBValue(input3DData, j-1,k+1, i);
tempPixels[0][3] = getRGBValue(input3DData, j-1, k+2,i);
tempPixels[1][0] = getRGBValue(input3DData, j, k-1, i);
tempPixels[1][1] = getRGBValue(input3DData, j, k, i);
tempPixels[1][2] = getRGBValue(input3DData, j, k+1, i);
tempPixels[1][3] = getRGBValue(input3DData, j, k+2, i);
tempPixels[2][0] = getRGBValue(input3DData, j+1,k-1,i);
tempPixels[2][1] = getRGBValue(input3DData, j+1, k, i);
tempPixels[2][2] = getRGBValue(input3DData, j+1, k+1, i);
tempPixels[2][3] = getRGBValue(input3DData, j+1, k+2, i);
tempPixels[3][0] = getRGBValue(input3DData, j+2, k-1, i);
tempPixels[3][1] = getRGBValue(input3DData, j+2, k, i);
tempPixels[3][2] = getRGBValue(input3DData, j+2, k+1, i);
tempPixels[3][3] = getRGBValue(input3DData, j+2, k+2, i);
// update coefficients
updateCoefficients(tempPixels);
outputThreeDeminsionData[row][col][i] = getPixelValue(getValue(t, u));
}
}
}
return convertToOneDim(outputThreeDeminsionData, destW, destH);
}
private static double getRGBValue(double[][][] input3DData, double row, double col, int index) {
if(col >= srcWidth) {
col = srcWidth - 1;
}
if(col < 0) {
col = 0;
}
if(row >= srcHeight) {
row = srcHeight - 1;
}
if(row < 0) {
row = 0;
}
return input3DData[(int)row][(int)col][index];
}
private static int getPixelValue(double pixelValue) {
return pixelValue < 0 ? 0: pixelValue >255.0d ?255:(int)pixelValue;
}
private static void updateCoefficients (double[][] p) {
a00 = p[1][1];
a01 = -.5*p[1][0] + .5*p[1][2];
a02 = p[1][0] - 2.5*p[1][1] + 2*p[1][2] - .5*p[1][3];
a03 = -.5*p[1][0] + 1.5*p[1][1] - 1.5*p[1][2] + .5*p[1][3];
a10 = -.5*p[0][1] + .5*p[2][1];
a11 = .25*p[0][0] - .25*p[0][2] - .25*p[2][0] + .25*p[2][2];
a12 = -.5*p[0][0] + 1.25*p[0][1] - p[0][2] + .25*p[0][3] + .5*p[2][0] - 1.25*p[2][1] + p[2][2] - .25*p[2][3];
a13 = .25*p[0][0] - .75*p[0][1] + .75*p[0][2] - .25*p[0][3] - .25*p[2][0] + .75*p[2][1] - .75*p[2][2] + .25*p[2][3];
a20 = p[0][1] - 2.5*p[1][1] + 2*p[2][1] - .5*p[3][1];
a21 = -.5*p[0][0] + .5*p[0][2] + 1.25*p[1][0] - 1.25*p[1][2] - p[2][0] + p[2][2] + .25*p[3][0] - .25*p[3][2];
a22 = p[0][0] - 2.5*p[0][1] + 2*p[0][2] - .5*p[0][3] - 2.5*p[1][0] + 6.25*p[1][1] - 5*p[1][2] + 1.25*p[1][3] + 2*p[2][0] - 5*p[2][1] + 4*p[2][2] - p[2][3] - .5*p[3][0] + 1.25*p[3][1] - p[3][2] + .25*p[3][3];
a23 = -.5*p[0][0] + 1.5*p[0][1] - 1.5*p[0][2] + .5*p[0][3] + 1.25*p[1][0] - 3.75*p[1][1] + 3.75*p[1][2] - 1.25*p[1][3] - p[2][0] + 3*p[2][1] - 3*p[2][2] + p[2][3] + .25*p[3][0] - .75*p[3][1] + .75*p[3][2] - .25*p[3][3];
a30 = -.5*p[0][1] + 1.5*p[1][1] - 1.5*p[2][1] + .5*p[3][1];
a31 = .25*p[0][0] - .25*p[0][2] - .75*p[1][0] + .75*p[1][2] + .75*p[2][0] - .75*p[2][2] - .25*p[3][0] + .25*p[3][2];
a32 = -.5*p[0][0] + 1.25*p[0][1] - p[0][2] + .25*p[0][3] + 1.5*p[1][0] - 3.75*p[1][1] + 3*p[1][2] - .75*p[1][3] - 1.5*p[2][0] + 3.75*p[2][1] - 3*p[2][2] + .75*p[2][3] + .5*p[3][0] - 1.25*p[3][1] + p[3][2] - .25*p[3][3];
a33 = .25*p[0][0] - .75*p[0][1] + .75*p[0][2] - .25*p[0][3] - .75*p[1][0] + 2.25*p[1][1] - 2.25*p[1][2] + .75*p[1][3] + .75*p[2][0] - 2.25*p[2][1] + 2.25*p[2][2] - .75*p[2][3] - .25*p[3][0] + .75*p[3][1] - .75*p[3][2] + .25*p[3][3];
}
private static double getValue (double x, double y) {
double x2 = x * x;
double x3 = x2 * x;
double y2 = y * y;
double y3 = y2 * y;
return (a00 + a01 * y + a02 * y2 + a03 * y3) +
(a10 + a11 * y + a12 * y2 + a13 * y3) * x +
(a20 + a21 * y + a22 * y2 + a23 * y3) * x2 +
(a30 + a31 * y + a32 * y2 + a33 * y3) * x3;
}
/* <p> The purpose of this method is to convert the data in the 3D array of ints back into </p>
* <p> the 1d array of type int. </p>
*
*/
private static int[] convertToOneDim(int[][][] data, int imgCols, int imgRows) {
// Create the 1D array of type int to be populated with pixel data
int[] oneDPix = new int[imgCols * imgRows * 4];
// Move the data into the 1D array. Note the
// use of the bitwise OR operator and the
// bitwise left-shift operators to put the
// four 8-bit bytes into each int.
for (int row = 0, cnt = 0; row < imgRows; row++) {
for (int col = 0; col < imgCols; col++) {
oneDPix[cnt] = ((data[row][col][0] << 24) & 0xFF000000)
| ((data[row][col][1] << 16) & 0x00FF0000)
| ((data[row][col][2] << 8) & 0x0000FF00)
| ((data[row][col][3]) & 0x000000FF);
cnt++;
}// end for loop on col
}// end for loop on row
return oneDPix;
}// end convertToOneDim
private static double [][][] processOneToThreeDeminsion(int[] oneDPix2, int imgRows, int imgCols) {
double[][][] tempData = new double[imgRows][imgCols][4];
for(int row=0; row<imgRows; row++) {
// per row processing
int[] aRow = new int[imgCols];
for (int col = 0; col < imgCols; col++) {
int element = row * imgCols + col;
aRow[col] = oneDPix2[element];
}
// convert to three dimension data
for(int col=0; col<imgCols; col++) {
tempData[row][col][0] = (aRow[col] >> 24) & 0xFF; // alpha
tempData[row][col][1] = (aRow[col] >> 16) & 0xFF; // red
tempData[row][col][2] = (aRow[col] >> 8) & 0xFF; // green
tempData[row][col][3] = (aRow[col]) & 0xFF; // blue
}
}
return tempData;
}
/*public static void main(String args[]) {
}*/
}
分享到：
相关推荐
双立方线性插值是一种高级的图像缩放技术，它在计算机图形学和图像处理领域广泛应用。该算法通过考虑像素邻域内的更高阶导数来提高图像细节的平滑度和保真度，从而实现更高质量的插值效果。本文将深入探讨双立方线性...
双立方插值算法实现图片的任意比例缩放，Java程序完整可运行，从图片的读取到如片的反写
双立方插值是一种高级的图像缩放技术，广泛应用于图像处理和计算机图形学领域。它通过在原始像素数据上执行一种三次多项式插值运算，来生成新的像素点的色彩值，从而在放大或缩小图像时能保持较高的图像质量，减少...
彩色图像插值放大是计算机图形学和数字图像处理领域中的一个重要技术，主要用于将低分辨率的图像转换为高分辨率，以增强图像的清晰度和细节。在这个过程中，图像的像素数量会增加，但新像素的值需要通过现有像素的值...
图像缩放算法之双立方插值的matlab实现，效果非常好。
通过实验比较不同插值算法对图像缩放后的效果，研究结果表明双立方插值法在保持图像质量方面具有明显的优势，尤其在放大图像时，能够有效减少失真并保持更多的图像细节。但是，这种优势是以较高的计算复杂度为代价的...
虽然与图像插值直接关联不大，但在图像处理的某些特定场景下，如体积渲染或3D图像缩放，它可能会起到重要作用。 总的来说，理解并熟练运用这些插值方法对于进行图像处理和分析至关重要。MATLAB提供的工具和自定义...
在Photoshop等图像编辑软件中，插值被广泛用于提供高质量的图像放大和缩小效果，确保图像在变换过程中尽可能地保留原有的清晰度和细节。 1. 插值的基本原理 插值的核心是通过已知的数据点（即图像中原有的像素）...
而放大则需要通过插值算法生成新的像素值，以保持图像的视觉质量。 在Visual C++中，我们可以使用MFC库的CImage类来处理图像。CImage类提供了一系列的成员函数，如Load、Save、Draw等，用于读取、保存和显示图像。...
在图像处理领域，局部放大与...综上所述，实现图像局部放大与缩小的关键在于选择合适的放大算法、处理坐标映射以及防止图像闪烁。通过深入理解这些概念，并结合编程库或框架，我们可以构建出高效、流畅的图像放大功能。
为了解决这个问题，我们可以采用插值放大算法。插值是一种数学方法，它通过已知的有限数据点来估计未知数据点。在图像处理中，插值用于在原始图像像素之间插入新的像素值，从而实现高质量的图像放大。 本教程将详细...
在图像处理领域，插值算法是一种关键的技术，用于解决图像缩放、旋转等几何变换时产生的新像素点值计算问题。当对图像进行变换时，可能会出现非整数坐标点，这些点在原始图像上没有对应的像素值。此时，插值算法就是...
本文将分析和比较三种最常用的图像插值算法：最近邻插值、双线性插值和立方卷积插值。 最近邻插值算法是最早的图像插值方法之一。该算法的核心思想是将输出图像中的每个像素点直接映射到输入图像中距离最近的一个...
### 3D8——光立方：深度解析3D LED光立方的设计与应用 #### 设计课题的任务要求 在“3D8——光立方”的设计课题中，首要目标是精细地控制512个LED灯的亮灭状态，实现对LED光立方的精准操控。这一要求不仅考验了...
这种方法通过考虑邻近像素的值，以更平滑的方式进行插值，从而在放大或缩小图像时保持较高的视觉质量。在图像去噪中，双立方插值可以帮助减少高频噪声，同时尽可能保留图像的边缘和细节。 其次，稀疏表示是近年来...
3. **图像的转置**：图像转置，也称作转90度，是将图像的行与列互换，就像将图像旋转了90度一样。这在矩阵表示中可以通过转置矩阵来实现，即交换矩阵的行和列。 4. **图像的缩放**：图像缩放可以放大或缩小图像的...
在IT领域，尤其是在图像处理与数据插值技术中，C#作为一门强大的编程语言，提供了丰富的功能来实现复杂的算法，如双线性插值（Bilinear Interpolation）和双立方卷积插值（Bicubic Convolution Interpolation）。...
在J2ME（Java 2 Micro Edition）平台上，实现图片的放大和缩小主要涉及到图像处理中的插值算法。本文将详细介绍如何使用“最近邻域法”这一简单的插值算法来处理图像的缩放操作。 1. **最近邻域法插值算法**： ...
#### 二、常用数字图像插值算法分析 **1. 最近邻点法** 最近邻点法是最简单的插值算法之一。它的原理是在二维图像中选取待采样点周围四个像素点中距离最近的一个像素点的灰度值作为待采样点的灰度值。这种方法的...