C++ opencv 图像 扭曲旋转 双线性插值 双三次插值 和 畸变矫正 双线性插值 实现
程序下载链接：程序下载
老规矩，先上代码：
#include "opencv2/flann.hpp"
#include "opencv2/opencv_modules.hpp"
#include "opencv2/stitching/detail/matchers.hpp"
#include "opencv2/imgcodecs/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include 程序设计思路：
在设计图像扭曲的时候，先进行扭曲，再进行插值
首先定义距离函数
double GetDistence(double x, double y, double xm, double ym)
{
return sqrt(pow((x - xm), 2) + pow((y - ym), 2));
}
在这里图像扭曲使用了双线性插值
定义一个和原图像大小相同的Mat矩阵，初始化为0，用来接受赋值输出。这个
找到图像的中心点，xm,ym
然后对图像的像素点进行遍历处理
这里使用了图像的归一化和还原用来消除数据之间的影响
归一化在-1~+1之间是统计的坐标分布
归一化：
double X = x / ((row - 1) / 2.0) - 1.0;
double Y = y / ((col - 1) / 2.0) - 1.0;
归一化还原：
x_ = (x_ + 1.0)((row - 1) / 2.0);
y_ = (y_ + 1.0)((col - 1) / 2.0);
归一化结束之后，这里的r就是相对于中心的距离，也就是半径
r:double r = sqrt(X * X + Y * Y);
因为像素点归一化了，所以这个时候也要对规定的半径进行归一化，所以使用Radius/(row/2)
来将输入的半径归一化到0-1之间，记作R
如果r>R证明是是除了圆以外的边界，如果小于R证明是圆以内的像素点, R半径以外的就应该直接复制给Mat图像，
R以内的就应该进行旋转，然后插值，具体如下：
先进行角度计算，
Theta:double theta = RADIAN(amax)*(Radius - GetDistence(x, y, xm, ym)) / Radius;
得到的是旋转角
然后计算这个当前归一化的像素点进行旋转之后的位置，
double x_ = cos(theta)*X - sin(theta)*Y;
double y_ = sin(theta)*X + cos(theta)*Y;
得到位置之后进行归一化的还原，上面已经解释过。
对于超出图像边界的像素点，三个通道赋值0
if (x_ < 0 || y_ < 0 || x_ >= src.rows || y_ >= src.cols) {
for (int c = 0; c < 3; c++) {
imgAffine.at(x, y)[c] = saturate_cast(0);
}
}
对于像素边界以内的，这个时候使用双线性插值进行赋值。
在三个通道以内，图像的右和下方的边界进行原值赋值，这是考虑到半径正好等于图像的一半的情况，
然后获得右方，下方，右下方的像素点，进行计算，计算函数如下
得到的结果赋值给mat图像，然会给主函数，并且imgshow
测试结果：
双三次插值：
和双线性插值的使用的旋转函数相同，不同的地方在于插值的地方双三次插值时选用的最近的16个点，双线性是最近的四个点
首先写出三次卷积函数
float BiCubicPloy(float x)
{
float abs_x = abs(x);//取x的绝对值
float a = -0.5;
if (abs_x <= 1.0)
{
return (a + 2)pow(abs_x, 3) - (a + 3)pow(abs_x, 2) + 1;
}
else if (abs_x < 2.0)
{
return a * pow(abs_x, 3) - 5 * apow(abs_x, 2) + 8 * aabs_x - 4 * a;
}
else
return 0.0;
}
然后计算周围16个点的权重
```cpp
//取出映射到原图中的点的四周的16个点的坐标
int x0 = xi - 1;
int y0 = yi - 1;
int x1 = xi;
int y1 = yi;
int x2 = xi + 1;
int y2 = yi + 1;
int x3 = xi + 2;
int y3 = yi + 2;
//在范围内进行计算，将16个点的权重之和作为新像素点
if ((x0 >= 0) && (x3 < src.rows) && (y0 >= 0) && (y3 < src.cols))
{
//求出行和列所对应的系数
float dist_x0 = BiCubicPloy(xm - x0);
float dist_x1 = BiCubicPloy(xm - x1);
float dist_x2 = BiCubicPloy(xm - x2);
float dist_x3 = BiCubicPloy(xm - x3);
float dist_y0 = BiCubicPloy(ym - y0);
float dist_y1 = BiCubicPloy(ym - y1);
float dist_y2 = BiCubicPloy(ym - y2);
float dist_y3 = BiCubicPloy(ym - y3);
//k_i_j=k_i*k_j
float dist_x0y0 = dist_x0 * dist_y0;
float dist_x0y1 = dist_x0 * dist_y1;
float dist_x0y2 = dist_x0 * dist_y2;
float dist_x0y3 = dist_x0 * dist_y3;
float dist_x1y0 = dist_x1 * dist_y0;
float dist_x1y1 = dist_x1 * dist_y1;
float dist_x1y2 = dist_x1 * dist_y2;
float dist_x1y3 = dist_x1 * dist_y3;
float dist_x2y0 = dist_x2 * dist_y0;
float dist_x2y1 = dist_x2 * dist_y1;
float dist_x2y2 = dist_x2 * dist_y2;
float dist_x2y3 = dist_x2 * dist_y3;
float dist_x3y0 = dist_x3 * dist_y0;
float dist_x3y1 = dist_x3 * dist_y1;
float dist_x3y2 = dist_x3 * dist_y2;
float dist_x3y3 = dist_x3 * dist_y3;
imgAffine.at<Vec3b>(x, y) = (src.at<Vec3b>(x0, y0)*dist_x0y0 +
src.at<Vec3b>(x0, y1)*dist_x0y1 +
src.at<Vec3b>(x0, y2)*dist_x0y2 +
src.at<Vec3b>(x0, y3)*dist_x0y3 +
src.at<Vec3b>(x1, y0)*dist_x1y0 +
src.at<Vec3b>(x1, y1)*dist_x1y1 +
src.at<Vec3b>(x1, y2)*dist_x1y2 +
src.at<Vec3b>(x1, y3)*dist_x1y3 +
src.at<Vec3b>(x2, y0)*dist_x2y0 +
src.at<Vec3b>(x2, y1)*dist_x2y1 +
src.at<Vec3b>(x2, y2)*dist_x2y2 +
src.at<Vec3b>(x2, y3)*dist_x2y3 +
src.at<Vec3b>(x3, y0)*dist_x3y0 +
src.at<Vec3b>(x3, y1)*dist_x3y1 +
src.at<Vec3b>(x3, y2)*dist_x3y2 +
src.at<Vec3b>(x3, y3)*dist_x3y3);
}
}
输出结果：
对比：双线性和双三次插值对比
结果：双三次插值是一种更加复杂的插值方式，它能创造出比双线性插值更平滑的图像边缘 但是双三次插值更慢
畸变矫正：
鲜活的镜头中心在图像中的位置，一般中心都是最准确的
我们首先求出图像像素点距离镜头中心各个距离所对应的k值，使用四次多项式进行拟合
定义矫正参数：
//矫正参数
double r;//矫正前像素点跟镜头中心的距离
double s;//矫正后像素点跟镜头中心的距离
采用双先行擦和执法进行拟合
做越界判断
//越界判断
if (mCorrectPoint.y < 0 || mCorrectPoint.y >= img.rows - 1)
{
continue;
}
if (mCorrectPoint.x < 0 || mCorrectPoint.x >= img.cols - 1)
{
continue;
}
对三个通道的每一个通道的右方，下方，右下方的像素点进行双线性插值计算
src_a = cvPoint((int)mCorrectPoint.x, (int)mCorrectPoint.y);
src_b = cvPoint(src_a.x + 1, src_a.y);
src_c = cvPoint(src_a.x, src_a.y + 1);
src_d = cvPoint(src_a.x + 1, src_a.y + 1);
然后三通道赋值
drcimg.at<Vec3b>(row, cols)[0] =
img.at<Vec3b>(src_a.y, src_a.x)[0] * (1 - distance_to_a_x)*(1 - distance_to_a_y) +
img.at<Vec3b>(src_b.y, src_b.x)[0] * distance_to_a_x*(1 - distance_to_a_y) +
img.at<Vec3b>(src_c.y, src_c.x)[0] * distance_to_a_y*(1 - distance_to_a_x) +
img.at<Vec3b>(src_d.y, src_d.x)[0] * distance_to_a_y*distance_to_a_x;
drcimg.at<Vec3b>(row, cols)[1] =
img.at<Vec3b>(src_a.y, src_a.x)[1] * (1 - distance_to_a_x)*(1 - distance_to_a_y) +
img.at<Vec3b>(src_b.y, src_b.x)[1] * distance_to_a_x*(1 - distance_to_a_y) +
img.at<Vec3b>(src_c.y, src_c.x)[1] * distance_to_a_y*(1 - distance_to_a_x) +
img.at<Vec3b>(src_d.y, src_d.x)[1] * distance_to_a_y*distance_to_a_x;
drcimg.at<Vec3b>(row, cols)[2] =
img.at<Vec3b>(src_a.y, src_a.x)[2] * (1 - distance_to_a_x)*(1 - distance_to_a_y) +
img.at<Vec3b>(src_b.y, src_b.x)[2] * distance_to_a_x*(1 - distance_to_a_y) +
img.at<Vec3b>(src_c.y, src_c.x)[2] * distance_to_a_y*(1 - distance_to_a_x) +
img.at<Vec3b>(src_d.y, src_d.x)[2] * distance_to_a_y*distance_to_a_x;
得到结果：
