【OpenCV C++20 学习笔记】图片重映射-remapping

原理

图片重映射就是将图片中的像素从一个位置移动到另一个位置，从而形成新的图片。
要实现图片重映射，就有必要使用插值和非整数的像素位置，因此原图和结果图之间不可能总是存在像素的一一对应的。
用公式表示重映射的过程，如下：
$$g(x,y)=f(h(x,y))$$

• $g(x,y)$是重映射之后的结果图
• $f()$是原图
• $h(x,y)$是在$(x,y)$像素上的重映射操作

比如，对图片$I$进行如下重映射操作：
$$h(x,y)=(I.cols-x,y)$$
通过用总列数减去当前列数，可以实现图片在$x$方向的翻转，就像下面的2张图一样：

API

在OpenCV中，提供了专门的重映射方法cv::remap()，其函数原型如下：

void cv::remap(	InputArray		src,
				OutputArray		dst,
				InputArray		map1,
				InputArray		map2,
				int				interpolation,
				int				borderMode = BORDER_CONSTANT,
				const Scalar&	borderValue = Scalar())
1
2
3
4
5
6
7

• 虽然该函数提供了map1和map2两个map参数，但是可以只有map1用来提供$(x,y)$两个方向上的重映射矩阵；或者map1提供$x$上的重映射矩阵、而map2提供$y$上的重映射矩阵；
• interpolation参数指定插值方法，包括：双线性插值(INTER_LINEAR)、双三次插值(INTER_CUBIC)、最近邻插值(INTER_NEARES)等；注意，在该函数中不能使用INTER_AREA, INTER_LINEAR_EXACT, INTER_NEAREST_EXACT，这3中插值方法
• borderMode为边框扩充方法，默认是BORDER_CONSTANT，即单一颜色边框；当该参数取BORDER_TRANSPARENT值的时候，表示重映射后超出原图范围的像素将不会被函数修改
• borderValue只有在borderMode = BORDER_CONSTANT的时候才需要提供，用来指定边框的颜色。

注意：该函数目前只支持小于$32767\times 32767$尺寸的输入图和输出图。

实现

重映射的关键就是建立映射矩阵。映射矩阵要和原图具有相同的尺寸：

	//导入原图
	Mat src{ imread("chicky_512.png", IMREAD_COLOR) };

	Mat map_x(src.size(), CV_32FC1);//建立x方向上的空映射矩阵
	Mat map_y(src.size(), CV_32FC1);//建立y方向上的空映射矩阵
1
2
3
4
5

接下来就是往映射矩阵里面填值了。
这个例子中我们分别建立下面4种重映射矩阵：

缩小成原来的一半并在中间显示

这种重映射的算法如下：
对于第$i$列、第$j$行的像素，如果：$\frac{src.cols}{4}<i<\frac{3\cdot src.cols}{4}$且$\frac{src.rows}{4}<i<\frac{3\cdot src.rows}{4}$
$$h(i,j)=(2\times i-src.cols/2+0.5,2\times j-src.rows/2+0.5)$$
经过上面的计算，连续的整数就会变成相差2的浮点数或整数数列。这样行和列就只有原来的一半了。
而不满足$\frac{src.cols}{4}<i<\frac{3\cdot src.cols}{4}$且$\frac{src.rows}{4}<i<\frac{3\cdot src.rows}{4}$条件，即位于原图的最外围1/4的像素点，全部设为0，即黑色。
所以，重映射矩阵中只要将上式的计算结果储存到相应位置就可以了（x方向和y方向分开储存）其实现代码如下：

void zoomOutMap(Mat& map_x, Mat& map_y)
{
	for (int i{ 0 }; i < map_x.rows; i++) {
		for (int j{ 0 }; j < map_x.cols; j++) {
			//判断是否满足位置条件
			if (j > map_x.cols * 0.25 && j<map_x.cols * 0.75 && i>map_x.rows * 0.25 && i < map_x.rows * 0.75) {
				//储存计算结果
				map_x.at<float>(i, j) = 2 * (j - map_x.cols * 0.25f) + 0.5f;
				map_y.at<float>(i, j) = 2 * (i - map_y.rows * 0.25f) + 0.5f;
			}
			else {//不满组则设为0
				map_x.at<float>(i, j) = 0;
				map_y.at<float>(i, j) = 0;
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

调用函数完成重映射矩阵的初始化，然后进行重映射：

Mat zoomOut{ src.size(), src.type() };	//结果图片
zoomOutMap(map_x, map_y);				//调用重映射矩阵初始化函数
//重映射方法
remap(src, zoomOut, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0));
1
2
3
4

结果如下：

上下翻转

上下翻转的重映射算法如下：
$$h(i,j)=(i,src.rows-j)$$
用总行数减去当前行数，就可以实现上下翻转了。
重映射矩阵的实现代码如下：

void upDownMap(Mat& map_x, Mat& map_y)
{
	for (int i{ 0 }; i < map_x.rows; i++) {
		for (int j{ 0 }; j < map_x.cols; j++) {
			map_x.at<float>(i, j) = static_cast<float>(j);
			map_y.at<float>(i, j) = static_cast<float>(map_x.rows - i);
		}
	}
}
1
2
3
4
5
6
7
8
9

调用函数初始化重映射矩阵，然后进行重映射操作：

Mat upDown;
upDownMap(map_x, map_y);
remap(src, upDown, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0));
1
2
3

结果如下：

左右翻转

左右翻转的重映射算法与上下翻转的类似：
$$h(i,j)=(src.cols-i,j)$$
其重映射矩阵的实现代码如下：

void leftRightMap(Mat& map_x, Mat& map_y)
{
	for (int i{ 0 }; i < map_x.rows; i++) {
		for (int j{ 0 }; j < map_x.cols; j++) {
			map_x.at<float>(i, j) = static_cast<float>(map_x.cols - j);
			map_y.at<float>(i, j) = static_cast<float>(i);
		}
	}
}
1
2
3
4
5
6
7
8
9

调用函数对重映射矩阵进行初始化，然后进行重映射操作：

Mat leftRight;
leftRightMap(map_x, map_y);
remap(src, leftRight, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0));
1
2
3

上下翻转+左右翻转

将两个重映射算法合并
$$h(i,j)=(src.cols-i,src.rows-j)$$
其重映射矩阵的实现代码如下：

void reverseMap(Mat& map_x, Mat& map_y)
{
	for (int i{ 0 }; i < map_x.rows; i++) {
		for (int j{ 0 }; j < map_x.cols; j++) {
			map_x.at<float>(i, j) = static_cast<float>(map_x.cols - j);
			map_y.at<float>(i, j) = static_cast<float>(map_x.rows - i);
		}
	}
}
1
2
3
4
5
6
7
8
9

调用函数对重映射矩阵进行初始化，然后进行重映射操作：

Mat reverse;
reverseMap(map_x, map_y);
remap(src, reverse, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0));
1
2
3

结果如下：