【图像处理】图像的基础几何变换

原文链接：https://cloud.tencent.com/developer/inventory/1883/article/1730924

1. 几何变换的基本概念

图像几何变换又称为图像空间变换，它将一副图像中的坐标位置映射到另一幅图像中的新坐标位置。我们学习几何变换就是确定这种空间映射关系，以及映射过程中的变化参数。图像的几何变换改变了像素的空间位置，建立一种原图像像素与变换后图像像素之间的映射关系，通过这种映射关系能够实现下面两种计算：

原图像任意像素计算该像素在变换后图像的坐标位置
变换后图像的任意像素在原图像的坐标位置

对于第一种计算，只要给出原图像上的任意像素坐标，都能通过对应的映射关系获得到该像素在变换后图像的坐标位置。将这种输入图像坐标映射到输出的过程称为向前映射 。反过来，知道任意变换后图像上的像素坐标，计算其在原图像的像素坐标，将输出图像映射到输入的过程称为向后映射。

但是，在使用向前映射处理几何变换时却有一些不足，通常会产生两个问题：映射不完全，映射重叠

映射不完全：输入图像的像素总数小于输出图像，这样输出图像中的一些像素找不到在原图像中的映射。

上图只有(0,0),(0,2),(2,0),(2,2)四个坐标根据映射关系在原图像中找到了相对应的像素，其余的12个坐标没有有效值。

映射重叠：根据映射关系，输入图像的多个像素映射到输出图像的同一个像素上。
上图左上角的四个像素(0,0),(0,1),(1,0),(1,1)都会映射到输出图像的(0,0)上，那么(0,0)究竟取那个像素值呢？

要解决上述两个问题可以使用向后映射，使用输出图像的坐标反过来推算改坐标对应于原图像中的坐标位置。这样，输出图像的每个像素都可以通过映射关系在原图像找到唯一对应的像素，而不会出现映射不完全和映射重叠。所以，一般使用向后映射来处理图像的几何变换。

从上面也可以看出，向前映射之所以会出现问题，主要是由于图像像素的总数发生了变化，也就是图像的大小改变了。在一些图像大小不会发生变化的变换中，向前映射还是很有效的。

2. 图像平移

图像的平移变换就是将图像所有的像素坐标分别加上指定的水平偏移量和垂直偏移量。平移变换根据是否改变图像大小分为两种，直接丢弃或者通过加目标图像尺寸的方法使图像能够包含这些点。

2.1 平移变换原理

假设原来的像素的位置坐标为（x0,y0），经过平移量（△x，△y）后，坐标变为（x1,y1），如下所示：

用数学式子表示可以表示为：
x 1 = x 0 + Δ x x1 = x0 + \Delta x x1=x0+Δx
y 1 = y 0 + Δ y y1 = y0 + \Delta y y1=y0+Δy

用矩阵表示为：

本来使用二维矩阵就可以了的，但是为了适应像素、拓展适应性，这里使用三维的向量。

式子中，矩阵称为平移变换矩阵（因子），△x和△y为平移量。

2.2 基于OpenCV的实现

图像的平移变换实现还是很简单的，这里不再赘述.

平移后图像的大小不变

cpp 复制代码

void GeometricTrans::translateTransform(cv::Mat const& src, cv::Mat& dst, int dx, int dy)
{
    CV_Assert(src.depth() == CV_8U);

    const int rows = src.rows;
    const int cols = src.cols;

    dst.create(rows, cols, src.type());

    Vec3b *p;
    for (int i = 0; i < rows; i++)
    {
        p = dst.ptr<Vec3b>(i);
        for (int j = 0; j < cols; j++)
        {
            //平移后坐标映射到原图像
            int x = j - dx;
            int y = i - dy;

            //保证映射后的坐标在原图像范围内
            if (x >= 0 && y >= 0 && x < cols && y < rows)
                p[j] = src.ptr<Vec3b>(y)[x];
        }
    }
}

平移后图像的大小变化

cpp 复制代码

void GeometricTrans::translateTransformSize(cv::Mat const& src, cv::Mat& dst, int dx, int dy)
{
    CV_Assert(src.depth() == CV_8U);

    const int rows = src.rows + abs(dy); //输出图像的大小
    const int cols = src.cols + abs(dx);

    dst.create(rows, cols, src.type());
    Vec3b *p;
    for (int i = 0; i < rows; i++)
    {
        p = dst.ptr<Vec3b>(i);
        for (int j = 0; j < cols; j++)
        {
            int x = j - dx;
            int y = i - dy;

            if (x >= 0 && y >= 0 && x < src.cols && y < src.rows)
                p[j] = src.ptr<Vec3b>(y)[x];
        }
    }
}

ps：这里图像变换的代码以三通道图像为例，单通道的于此类似，代码中没有做处理。

示例：

cpp 复制代码

#include "stdafx.h"

#include <iostream>
#include <opencv2\core\core.hpp>
#include <opencv2\highgui\highgui.hpp>
#include <opencv2\imgproc\imgproc.hpp>

using namespace std;
using namespace cv;

void translateTransform(cv::Mat const& src, cv::Mat& dst, int dx, int dy)//平移后大小不变
{
	CV_Assert(src.depth() == CV_8U);

	const int rows = src.rows;
	const int cols = src.cols;

	dst.create(rows, cols, src.type());

	Vec3b *p;
	for (int i = 0; i < rows; i++)
	{
		p = dst.ptr<Vec3b>(i);
		for (int j = 0; j < cols; j++)
		{
			//平移后坐标映射到原图像
			int x = j - dx;
			int y = i - dy;

			//保证映射后的坐标在原图像范围内
			if (x >= 0 && y >= 0 && x < cols && y < rows)
				p[j] = src.ptr<Vec3b>(y)[x];
		}
	}
}
void translateTransformSize(cv::Mat const& src, cv::Mat& dst, int dx, int dy)//平移后大小变化
{
	CV_Assert(src.depth() == CV_8U);

	const int rows = src.rows + abs(dy); //输出图像的大小
	const int cols = src.cols + abs(dx);

	dst.create(rows, cols, src.type());
	Vec3b *p;
	for (int i = 0; i < rows; i++)
	{
		p = dst.ptr<Vec3b>(i);
		for (int j = 0; j < cols; j++)
		{
			int x = j - dx;
			int y = i - dy;

			if (x >= 0 && y >= 0 && x < src.cols && y < src.rows)
				p[j] = src.ptr<Vec3b>(y)[x];
		}
	}
}


int main()
{
	Mat srcImage, dstImage0, dstImage1, dstImage2;
	int xOffset, yOffset;		//x和y方向的平移量
	srcImage = imread("111.jpg");
	if (!srcImage.data)
	{
		cout << "读入图片错误！" << endl;
		return -1;
	}

	cout << "请输入x方向和y方向的平移量：";
	cin >> xOffset >> yOffset;
	int rowNumber = srcImage.rows;
	int colNumber = srcImage.cols;

	translateTransform(srcImage, dstImage0, xOffset, yOffset);
	translateTransformSize(srcImage, dstImage1, xOffset, yOffset);

	imshow("原图像", srcImage);
	imshow("不丢弃平移后的图像", dstImage0);
	imshow("丢弃平移后的图像", dstImage1);
	waitKey();
	return 0;
}

在输入框输入200，200后结果为

3. 图像的镜像变换

图像的镜像变换分为两种：水平镜像和垂直镜像。水平镜像以图像垂直中线为轴，将图像的像素进行对换，也就是将图像的左半部和右半部对调。垂直镜像则是以图像的水平中线为轴，将图像的上半部分和下班部分对调。

3.1 变换原理

水平变换

向前映射其逆变换为

向后映射其逆变换为

3.2 基于OpenCV的实现

水平镜像的实现

cpp 复制代码

void GeometricTrans::hMirrorTrans(const Mat &src, Mat &dst)
{
    CV_Assert(src.depth() == CV_8U);
    dst.create(src.rows, src.cols, src.type());

    int rows = src.rows;
    int cols = src.cols;

    switch (src.channels())
    {
    case 1:
        const uchar *origal;
        uchar *p;
        for (int i = 0; i < rows; i++){
            origal = src.ptr<uchar>(i);
            p = dst.ptr<uchar>(i);
            for (int j = 0; j < cols; j++){
                p[j] = origal[cols - 1 - j];
            }
        }
        break;
    case 3:
        const Vec3b *origal3;
        Vec3b *p3;
        for (int i = 0; i < rows; i++) {
            origal3 = src.ptr<Vec3b>(i);
            p3 = dst.ptr<Vec3b>(i);
            for(int j = 0; j < cols; j++){
                p3[j] = origal3[cols - 1 - j];
            }
        }
        break;
    default:
        break;
    }
    
}

分别对三通道图像和单通道图像做了处理，由于比较类似以后的代码只处理三通道图像，不再做特别说明。

在水平镜像变换时，遍历了整个图像，然后根据映射关系对每个像素都做了处理。实际上，水平镜像变换就是将图像坐标的列换到右边，右边的列换到左边，是可以以列为单位做变换的。同样垂直镜像变换也如此，可以以行为单位进行变换。

垂直镜像变换

cpp 复制代码

void GeometricTrans::vMirrorTrans(const Mat &src, Mat &dst)
{
    CV_Assert(src.depth() == CV_8U);
    dst.create(src.rows, src.cols, src.type());

    int rows = src.rows;

    for (int i = 0; i < rows; i++)
        src.row(rows - i - 1).copyTo(dst.row(i));
}

上面一行代码是变换的核心代码，从原图像中取出第i行，并将其复制到目标图像。

示例：

cpp 复制代码

#include "stdafx.h"

#include <iostream>
#include <opencv2\core\core.hpp>
#include <opencv2\highgui\highgui.hpp>
#include <opencv2\imgproc\imgproc.hpp>

using namespace std;
using namespace cv;
void hMirrorTrans(const Mat &src, Mat &dst)
{
	CV_Assert(src.depth() == CV_8U);
	dst.create(src.rows, src.cols, src.type());

	int rows = src.rows;
	int cols = src.cols;

	switch (src.channels())
	{
	case 1:
		const uchar *origal;
		uchar *p;
		for (int i = 0; i < rows; i++) {
			origal = src.ptr<uchar>(i);
			p = dst.ptr<uchar>(i);
			for (int j = 0; j < cols; j++) {
				p[j] = origal[cols - 1 - j];
			}
		}
		break;
	case 3:
		const Vec3b *origal3;
		Vec3b *p3;
		for (int i = 0; i < rows; i++) {
			origal3 = src.ptr<Vec3b>(i);
			p3 = dst.ptr<Vec3b>(i);
			for (int j = 0; j < cols; j++) {
				p3[j] = origal3[cols - 1 - j];
			}
		}
		break;
	default:
		break;
	}

}
void vMirrorTrans(const Mat &src, Mat &dst)
{
	CV_Assert(src.depth() == CV_8U);
	dst.create(src.rows, src.cols, src.type());

	int rows = src.rows;

	for (int i = 0; i < rows; i++)
		src.row(rows - i - 1).copyTo(dst.row(i));
}
int main()
{
	Mat srcImage, dstImage, dstImage1;;
	srcImage = imread("111.jpg");
	if (!srcImage.data)
	{
		cout << "读入图片错误！" << endl;
		return -1;
	}
	hMirrorTrans(srcImage, dstImage);
	vMirrorTrans(srcImage, dstImage1);
	imshow("原图像", srcImage);
	imshow("水平镜像后的图像", dstImage);
	imshow("垂直镜像后的图像", dstImage1);
	waitKey();
	return 0;
}

程序运行结果如下：

4. 图像缩放

图像的缩放指的是将图像的尺寸变小或变大的过程，也就是减少或增加原图像数据的像素个数。简单来说，就是通过增加或删除像素点来改变图像的尺寸。当图像缩小时，图像会变得更加清晰，当图像放大时，图像的质量会有所下降，因此需要进行插值处理。

4.1 缩放原理

设水平缩放系数为sx，垂直缩放系数为sy，(x0,y0)为缩放前坐标，(x,y)为缩放后坐标，其缩放的坐标映射关系：

{ x = x 0 × s x y = y 0 × s y \begin{cases} x = x_0 \times sx \\ y = y_0 \times sy \end{cases} {x=x0×sxy=y0×sy

矩阵表示的形式为：