前面的重建图边界有个方框，影响效果，这里改进一下，加上边界填充。
1。‘replicate’ 图像大小通过复制外边界的值来扩展
2。'same'切去一部分，让输出与输入图像的大小相同
卷积实现上面的两个参数：
void 卷积(卷积矩阵*filter,卷积矩阵*arr, 卷积矩阵*res)
{
int filterW=filter->width;
int filterH=filter->height;
int arrW=arr->width;
int arrH=arr->height;
float temp;
int tmpW=filterW*2+arrW;//扩展输入宽 + 2 个核宽
int tmpH=filterH*2+arrH;//扩展输入高
卷积矩阵 tmp(tmpW,tmpH);
//边宽高（单）
int w2=filterW;
int h2=filterH;
int i,j,m,n;
//复制输入
for (i=0; i<arrH; i++) //输入
{
for (j=0; j<arrW; j++)
{
tmp.data[(i+h2)*tmpW+(j+w2)] = arr->data[i*arrW+j];
}
}
//对输入扩展边界 ‘replicate’ 图像大小通过复制外边界的值来扩展
for(i=0;i<h2;i++)//拓展上面h2 行
for(j=0;j<tmpW;j++)
tmp.data[(i)*tmpW+(j)]
=tmp.data[(h2)*tmpW+(j)] ;
for(i=0;i<h2;i++)//拓展下面h2行
for(j=0;j<tmpW;j++)
tmp.data[(i+h2+arrH)*tmpW+(j)]
=tmp.data[(h2+arrH)*tmpW+(j)] ;
for(i=0;i<tmpH;i++)//拓展左边w2列
for(j=0;j<w2;j++)
tmp.data[(i)*tmpW+(j)]
=tmp.data[(i)*tmpW+(w2)] ;
for(i=0;i<tmpH;i++)//拓展右边w2列
for(j=0;j<w2;j++)
tmp.data[(i)*tmpW+(j+w2+arrW)]
=tmp.data[(i)*tmpW+(w2+arrW)] ;
//直接'same'切去一部分，让输出与输入图像的大小相同
for (i=h2; i<h2+arrH; i++) //输入
{
for (j=w2; j<w2+arrW; j++)
{
temp = 0;
for ( m=0; m<filterH; m++) //核
{
for (n=0; n<filterW; n++)
{
// if ((i-m)>=0 && (i-m)<tmpH && (j-n)>=0 && (j-n)<tmpW)
// {
temp += filter->data[m*filterW+n]*tmp.data[(i-m)*tmpW+(j-n)]; //积 和
//}else
//{
//
// cout<<"出错了"<<endl;
// }
}
}
res->data[(i-h2)*arrW+(j-w2)] = temp;
}
}
}效果图：
基本上和Matlab结果持平了
另外 在 --qq_29058565的博客《图像缩放之双三次插值法》--是2倍放大的，改一下放在这里。
2 倍双三次放大放用到 3 倍模型不知会有怎样效果？
//双三次插值缩放图片
/*
我们要做的就是求出BiCubic函数中的参数x,从而获得上面所说的16个像素所对应的系数。在学习双线性插
值法的时候，我们是把图像的行和列分开来理解的，那么在这里，我们也用这种方法描述如何求出a(i,j)对应
的系数k_ij。假设行系数为k_i,列系数为k_j。我们以a00位置为例：
首先，我们要求出当前像素与P点的位置，比如a00距离P(x+u,y+v)的距离为(1+u,1+v)。
那么我们可以得到：k_i_0=W(1+u),k_j_0=W(1+v).
同理我们可以得到所有行和列对应的系数：
k_i_0=W(1+u), k_i_1=W(u), k__i_2=W(1-u), k_i_3=W(2-u);
k_j_0=W(1+v), k_j_1=W(v), k_j_2=W(1-v), k_j_3=W(2-v);
这样我们就分别得到了行和列方向上的系数。
由k_i_j=k_i*k_j我们就可以得到每个像素a(i,j)对应的权值了。
最后通过求和公式可以得到目标图片B(X,Y)对应的像素值：
pixelB(X,Y)=pixelA(0,0)*k_0_0+pixelA(0,1)*k_0_1+…+pixelA(3,3)*k_3_3;
这里其实就是个求和公式，由于不知道怎么编辑公式，就这样表达了。
*/
/**********************10-9*******************************
功能：双三次插值缩放图片
数学原理：假设原图像A的大小为m*n,新图像B的大小为M*N
如果我们要求B（X,Y）处的像素值：
我们首先可以得到B（X,Y）在图像A中对应的位置（x,y）=(X*(m/M),Y*(N/n))
这个时候求得的x,y是小数值，我们可以通过这个小数值坐标找到距离最近的16个像素点，
利用所选择的基函数，求出对应的每个像素的权值，最终获得pixelB（X,Y）
**********************************************************/
//#include <opencv2\opencv.hpp>
//#include <iostream>
//#include <math.h>
//using namespace std;
//using namespace cv;
//BiCubic基函数
void getW_x(float w_x[4], float x);
void getW_y(float w_y[4], float y);
int 双三次2倍(IMAGE *imgs)
//int main(){
{
//Mat image = imread("lena.jpg");//源图像
float image_rows = imgs->getwidth();
float image_cols = imgs->getheight();
float Row_B = image_rows*2;
float Col_B = image_cols*2;
卷积矩阵 image= im2卷积矩阵(imgs);
卷积矩阵 biggerImage(Row_B, Col_B);
Row_B=biggerImage.width;
Col_B=biggerImage.height ;
// Mat biggerImage(Row_B, Col_B, CV_8UC3);
for (int i = 2; i < Row_B-4; i++){
for (int j = 2; j < Col_B-4; j++){
float x = i*(image_rows / Row_B);//放大后的图像的像素位置相对于源图像的位置
float y = j*(image_cols / Col_B);
/*if (int(x) > 0 && int(x) < image_rows - 2 && int(y)>0 && int(y) < image_cols - 2){*/
float w_x[4], w_y[4];//行列方向的加权系数
getW_x(w_x, x);
getW_y(w_y, y);
//Vec3f temp = { 0, 0, 0 };
float temp = 0;
for (int s = 0; s <= 3; s++){
for (int t = 0; t <= 3; t++){
//temp = temp + (Vec3f)(image.at<Vec3b>(int(x) + s - 1, int(y) + t - 1))*w_x[s] * w_y[t];
temp = temp + image.data[(int(x) + s - 1)*image_rows+( int(y) + t - 1)]*w_x[s] * w_y[t];
}
}
//biggerImage.at<Vec3b>(i, j) = (Vec3b)temp;
biggerImage.data[i*Row_B+ j] = temp;
}
}
//imshow("image", image);
//imshow("biggerImage", biggerImage);
//waitKey(0);
IMAGE tt= 卷积矩阵2im(&biggerImage);
*imgs=tt;
return 0;
}
/*计算系数*/
void getW_x(float w_x[4],float x){
float a = -0.5;
int X = (int)x;//取整数部分
float stemp_x[4];
stemp_x[0] = 1 + (x - X);
stemp_x[1] = x - X;
stemp_x[2] = 1 - (x - X);
stemp_x[3] = 2 - (x - X);
w_x[0] = a*abs(stemp_x[0] * stemp_x[0] * stemp_x[0]) - 5 * a*stemp_x[0] * stemp_x[0] + 8 * a*abs(stemp_x[0]) - 4 * a;
w_x[1] = (a + 2)*abs(stemp_x[1] * stemp_x[1] * stemp_x[1]) - (a + 3)*stemp_x[1] * stemp_x[1] + 1;
w_x[2] = (a + 2)*abs(stemp_x[2] * stemp_x[2] * stemp_x[2]) - (a + 3)*stemp_x[2] * stemp_x[2] + 1;
w_x[3] = a*abs(stemp_x[3] * stemp_x[3] * stemp_x[3]) - 5 * a*stemp_x[3] * stemp_x[3] + 8 * a*abs(stemp_x[3]) - 4 * a;
}
void getW_y(float w_y[4], float y){
float a = -0.5;
int Y = (int)y;
float stemp_y[4];
stemp_y[0] = 1.0 + (y - Y);
stemp_y[1] = y - Y;
stemp_y[2] = 1 - (y - Y);
stemp_y[3] = 2 - (y - Y);
w_y[0] = a*abs(stemp_y[0] * stemp_y[0] * stemp_y[0]) - 5 * a*stemp_y[0] * stemp_y[0] + 8 * a*abs(stemp_y[0]) - 4 * a;
w_y[1] = (a + 2)*abs(stemp_y[1] * stemp_y[1] * stemp_y[1]) - (a + 3)*stemp_y[1] * stemp_y[1] + 1;
w_y[2] = (a + 2)*abs(stemp_y[2] * stemp_y[2] * stemp_y[2]) - (a + 3)*stemp_y[2] * stemp_y[2] + 1;
w_y[3] = a*abs(stemp_y[3] * stemp_y[3] * stemp_y[3]) - 5 * a*stemp_y[3] * stemp_y[3] + 8 * a*abs(stemp_y[3]) - 4 * a;
}效果图：
扫描二维码关注公众号，回复：
2990936 查看本文章
啊，咋会这样呢？放大就有黑块，可能是我哪里翻译错了吧。
先这样吧。