图形的缩放的需求很普遍也很好理解，就是图形的放大和缩小
图形缩放的算法主要分为两种 ：
- 最近邻插值算法
- 双线性插值算法
最近邻插值算法
算法原理：先确定缩放系数，再将目标图形的坐标映射到源图形的坐标，最后取得相应的像素点像素值
比如：我需要将一幅400x400 的图形方法到 800*800，可知放大系数
Hscale = 800/400 = 2;
Vscale = 800/400 =2;
对于放大的后的图形中的任意一点，都可以映射到源图形中：
比如：求放大后的图形中坐标为 300，300处的像素值为:
point_srcx = point_dstx/Hscale = 300/2 = 150
point_srcy = point_dsty/Vscale = 300/2 = 150
循环映射所有的像素点就可以完成图形的放大和缩小
代码实现如下：
#include <iostream>
#include <opencv2/opencv.hpp>
using namespace std;
using namespace cv;
bool _nearestScaleOperate(Mat& src, Mat& dst, float Hscale, float Vscale)
{
int32_t dst_Lines = round(src.rows*Hscale);
int32_t dst_Columns = round(src.cols*Vscale);
dst = Mat(dst_Lines, dst_Columns, src.type());
if (src.channels() == 1) {
for (int32_t i = 0; i < dst_Lines; i++) {
for (int32_t j = 0; j < dst_Columns; j++) {
int32_t i_index = round(i / Hscale);
int32_t j_index = round(j / Vscale);
if (i_index > src.rows - 1)
i_index = src.rows - 1;
if (j_index > src.cols - 1)
j_index = src.cols - 1;
dst.at<uint8_t>(i, j) = src.at<uint8_t>(i_index, j_index);
}
}
}
// RGB channel 彩色图形的处理
else {
for (int32_t i = 0; i < dst_Lines; i++) {
for (int32_t j = 0; j < dst_Columns; j++) {
int32_t i_index = round(i / Hscale);
int32_t j_index = round(j / Vscale);
if (i_index > src.rows - 1)
i_index = src.rows - 1;
if (j_index > src.cols - 1)
j_index = src.cols - 1;
dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i_index, j_index)[0];
dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i_index, j_index)[1];
dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i_index, j_index)[2];
}
}
}
return true;
}
bool testnearestScale()
{
cout << "nearest scale demo" << endl;
const char *ImageName = "./demoImage.png";
Mat img = imread(ImageName, 1);
if (img.empty()) {
cout << "read image empty" << endl;
return false;
}
Mat dstimg;
_nearestScaleOperate(img, dstimg, 0.5, 0.5);
imshow("src_image", img);
imshow("dst_image", dstimg);
return true;
}
运行效果如下：
算法局限性：
最近邻插值算法是一种最基本最简单的图形插值算法，效果也最不好，放大图像后存在马赛克，缩小后图形也存在失真
原因是当由目标图形的坐标反推得到的源图的的坐标是一个浮点数的时候，采用了四舍五入的方法，直接采用了和这个浮点数最接近的象素的值，这种方法是很不科学的，当推得坐标值为 0.75的时候，不应该就简单的取为1，既然是0.75，比1要小0.25 ，比0要大0.75
双线性插值算法
基于上述的最近邻插值算法的局限性，目标象素值其实应该根据这个源图中虚拟的点四周的四个真实的点来按照一定的规律计算出来的，这样才能达到更好的缩放效果
双线型内插值算法就是这种图像缩放算法，它充分的利用了源图中虚拟点四周的四个真实存在的像素值来共同决定目标图中的一个像素值，因此缩放效果比简单的最邻近插值要好很多。
基本原理：
对于一个目的像素，设置坐标通过缩放系数变换得到的浮点坐标为(i+u，j+v) (其中i、j均为浮点坐标的整数部分，u、v为浮点坐标的小数部分，是取值[0,1)区间的浮点数)，
这个像素得值 f(i+u,j+v) 可由原图像中坐标为 (i，j)、(i+1，j)、(i，j+1)、(i+1，j+1)所对应的周围四个像素的值决定
公式为：
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)
算法代码优化
- 几何中心对齐
求目标图形变换到源图形的坐标：
point_srcX = point_dstX/Hscale
point_srcY = point_dstY/Vscale
优化为：
point_srcX = （point_dstX + 0.5）/Hscale -0.5
point_srcY = ( point_dstY + 0.5）/Vscale -0.5
这么做的目的是为了几何中心对齐的需要：
比如将 33 的图形放大为 99 我们希望缩放的中心为 坐标(4，4) 映射（1，1）
但是如果不进行中心对齐
Hscale = Vscale = 3
point_srcX=4/3 = 1.333
point_srcY=4/3 = 1.333
中心对齐后：
point_srcX=4+0.5/3 - 0.5= 1
point_srcY=4+0.5/3 - 0.5 = 1
符合我们的需求：
双线性插值是线性插值在二维时的推广，在两个方向上共做了三次线性插值
-
先计算 A点 C点的值，此时不考虑 Y轴方向的值，只考虑 X 轴上相邻两个点的相关性
A_C计算.png 再计算 B 点的值，此时不考虑X轴方向的值，只考虑 Y 轴上相邻两个点 A和C
opencv 实现算法代码如下：
#include <iostream>
#include <opencv2/opencv.hpp>
#include <math.h>
using namespace std;
using namespace cv;
bool _BilinearInterOperate(Mat& src, Mat& dst, float Hscale, float Vscale)
{
int32_t dst_Lines = round(src.rows*Hscale);
int32_t dst_Columns = round(src.cols*Vscale);
dst = Mat(dst_Lines, dst_Columns, src.type());
for (int32_t i = 0; i < dst_Lines; i++) {
// 几何中心对齐
double i_index = (i + 0.5) / Hscale - 0.5;
//防止边界溢出
if (i_index < 0)
i_index = 0;
if (i_index >= src.rows -1)
i_index = src.rows - 2;
// i1 是向上取整后的值
// i2 是向下取整
uint32_t i1 = floor(i_index);
uint32_t i2 = ceil(i_index);
float u = i_index - i1;
for (int32_t j = 0; j < dst_Columns; j++) {
// 几何中心对齐
double j_index = (j + 0.5) / Vscale - 0.5;
//防止边界溢出
if (j_index < 0)
j_index = 0;
if (j_index >= src.cols - 1)
j_index = src.cols - 2;
uint32_t j1 = floor(j_index);
uint32_t j2 = ceil(j_index);
double v = j_index - j1;
if (src.channels() == 1) {
dst.at<uint8_t>(i, j) = \
(1 - u)*(1 - v)*src.at<uint8_t>(i1, j1) + (1 - u)*v*src.at<uint8_t>(i1, j2)\
+ u*(1 - v)*src.at<uint8_t>(i2, j1) + u*v*src.at<uint8_t>(i2, j2);
} else {
dst.at<Vec3b>(i, j)[0] = \
(1 - u)*(1 - v)*src.at<Vec3b>(i1, j1)[0] + (1 - u)*v*src.at<Vec3b>(i1, j2)[0]\
+ u*(1 - v)*src.at<Vec3b>(i2, j1)[0] + u*v*src.at<Vec3b>(i2, j2)[0];
dst.at<Vec3b>(i, j)[1] = \
(1 - u)*(1 - v)*src.at<Vec3b>(i1, j1)[1] + (1 - u)*v*src.at<Vec3b>(i1, j2)[1]\
+ u*(1 - v)*src.at<Vec3b>(i2, j1)[1] + u*v*src.at<Vec3b>(i2, j2)[1];
dst.at<Vec3b>(i, j)[2] = \
(1 - u)*(1 - v)*src.at<Vec3b>(i1, j1)[2] + (1 - u)*v*src.at<Vec3b>(i1, j2)[2]\
+ u*(1 - v)*src.at<Vec3b>(i2, j1)[2] + u*v*src.at<Vec3b>(i2, j2)[2];
}
}
}
return true;
}
bool testBilinearInter() {
cout << "bilinearInter scale demo" << endl;
const char *ImageName = "C:/Users/86185/Documents/Visual Studio 2015/Projects/opencvdemo/x64/Debug/demoImage.png";
Mat img = imread(ImageName, 1);
if (img.empty()) {
cout << "read image empty" << endl;
return false;
}
Mat dstimg;
_BilinearInterOperate(img, dstimg, 1.2, 1.2);
imshow("src_image", img);
imshow("dst_image", dstimg);
return true;
}
显示效果：
