图像仿射变换

仿射变换

---

问题描述：读取图像，然后对图像多种仿射变换。

仿射变换-缩放与平移

现在我们可以利用$3\times 3$的矩阵来对图像进行多种仿射变换。

现，我们记原图像为$(x,y)$，变换后的图像为$(x^{\prime },y^{\prime })$。

对于二维空间上的坐标操作，其变换关系满足（在此处，我们可以将此变换操作理解为图像的放大缩小矩阵）下式：
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\end{array}\right)=\left(\begin{array}{cc}a& b\\ c& d\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)$$
另一方面，二维空间中的平移操作可按照下面的式子计算：
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\end{array}\right)=\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}{t}_x\\ t_y\end{array}\right)$$
把上面两个式子在三维空间中张开，就可以写作以下等式：
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ 1\end{array}\right)=\left(\begin{array}{ccc}a& b& t_x\\ c& d& t_y\\ 0& 0& 1\end{array}\right)\left(\begin{array}{c}x\\ y\\ 1\end{array}\right)$$

但是在实际操作的过程中，如果一个一个地计算原图像的像素的话，处理后的像素可能没有在原图像中有对应的坐标。因此，我们有必要对处理后的图像中各个像素进行仿射变换逆变换，取得变换后图像中的像素在原图像中的坐标。仿射变换的逆变换如下：
$$\left(\begin{array}{c}x\\ y\end{array}\right)=\frac{1}{ad-bc}\left(\begin{array}{cc}d& -b\\ -c& a\end{array}\right)\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\end{array}\right)-\left(\begin{array}{c}{t}_x\\ t_y\end{array}\right)$$
这回的平行移动操作使用下面的式子计算。$t_x$和$t_y$是像素移动的距离。
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ 1\end{array}\right)=\left(\begin{array}{ccc}1& 0& t_x\\ 0& 1& t_y\\ 0& 0& 1\end{array}\right)\left(\begin{array}{c}x\\ y\\ 1\end{array}\right)$$

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <math.h>

cv::Mat affine(cv::Mat img, double a, double b, double c, double d, double tx, double ty)
{
    int row = img.rows;
    int col = img.cols;
    int channel = img.channels();

    // get detriment
    double det = a * d - b * c;

    // Resize width and height
    int resized_col = (int)(col * a);
    int resized_row = (int)(row * d);

    cv::Mat new_image = cv::Mat::zeros(resized_row, resized_col, CV_8UC3);

    int pos_before_x, pos_before_y;

    // 仿射变换
    for (int i = 0; i < resized_row; i++)
    {
        for (int j = 0; j < resized_col; j++)
        {
            pos_before_x = (int)((d * j - b * i) / det - tx);
            if (pos_before_x < 0 || pos_before_x > col)
            {
                continue;
            }

            pos_before_y = int((-c * j + a * i) / det - ty);
            if (pos_before_y < 0 || pos_before_y > row)
            {
                continue;
            }

            for (int chan = 0; chan < channel; chan++)
            {
                new_image.at<cv::Vec3b>(i, j)[chan] = img.at<cv::Vec3b>(pos_before_y, pos_before_x)[chan];
            }
        }
    }

    return new_image;
}


int main(){
    // read image
    cv::Mat img = cv::imread("../fate.jpeg", cv::IMREAD_COLOR);

    // x向向右平移100，y向向上平移100
//    cv::Mat new_image = affine(img, 1, 0, 0, 1, 100, -100);
    // x向放大1.3倍再向右平移100，y向放大0.8倍再向上平移100
    cv::Mat new_image = affine(img, 1.3, 0, 0, 0.8, 100, -100);

//    cv::imwrite("../1-10/fate_affine.jpeg", new_image);
    cv::imwrite("../1-10/fate_affine1.jpeg", new_image);
    cv::imshow("vv", new_image);
    cv::waitKey(0);
    cv::destroyAllWindows();

    return 0;
}

输入图像 (fate.jpeg)	输出图像 (fate_trans.jpeg)	输出图像 (fate_trans_scale.jpeg)

仿射变换-旋转

1. 使用仿射变换，逆时针旋转$30$度。
2. 使用仿射变换，逆时针旋转$30$度并且能让全部图像显现（也就是说，单纯地做仿射变换会让图片边缘丢失，这一步中要让图像的边缘不丢失）。

可以借助二维旋转矩阵，利用下面的式子进行逆时针方向旋转$A$度的仿射变换：
$$\left(\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ 1\end{array}\right)=\left(\begin{array}{ccc}\cos (A)& -\sin (A)& t_x\\ \sin (A)& \cos (A)& t_y\\ 0& 0& 1\end{array}\right)\left(\begin{array}{c}x\\ y\\ 1\end{array}\right)$$

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <math.h>

cv::Mat affine(cv::Mat img, double a, double b, double c, double d, double tx, double ty, double theta)
{
    int row = img.rows;
    int col = img.cols;
    int channel = img.channels();

    // get detriment
    double det = a * d - b * c;

    if (theta != 0)
    {
        // 如果存在旋转就重新定义仿射矩阵参量
        double rad = theta / 180 * M_PI;
        a = std::cos(rad);
        b = -std::sin(rad);
        c = std::sin(rad);
        d = std::cos(rad);
        tx = 0;
        ty = 0;

        double det = a * d - b * c;

        // 定义旋转前后的中心，以及两个中心的偏移量
        double center_x = col / 2.;
        double center_y = row / 2.;
        double rot_center_x = (d * center_x - b * center_y) / det;
        double rot_center_y = (-c * center_x + a * center_y) / det;
        tx = rot_center_x - center_x;
        ty = rot_center_y - center_y;
    }

    // Resize width and height
    int resized_col = (int)(col * a);
    int resized_row = (int)(row * d);

    if (theta != 0) {
        resized_col = (int)(col);
        resized_row = (int)(row);
    }

    cv::Mat new_image = cv::Mat::zeros(resized_row, resized_col, CV_8UC3);

    int pos_before_x, pos_before_y;

    // 仿射变换
    for (int i = 0; i < resized_row; i++)
    {
        for (int j = 0; j < resized_col; j++)
        {
            pos_before_x = (int)((d * j - b * i) / det - tx);
            if (pos_before_x < 0 || pos_before_x >= col)
            {
                continue;
            }

            pos_before_y = int((-c * j + a * i) / det - ty);
            if (pos_before_y < 0 || pos_before_y >= row)
            {
                continue;
            }

            for (int chan = 0; chan < channel; chan++)
            {
                new_image.at<cv::Vec3b>(i, j)[chan] = img.at<cv::Vec3b>(pos_before_y, pos_before_x)[chan];
            }
        }
    }

    return new_image;
}


int main(){
    // read image
    cv::Mat img = cv::imread("../Neopolitan.png", cv::IMREAD_COLOR);

    // 先旋转50度，将其旋转后的图像拉回图像中心
    cv::Mat new_image = affine(img, 1, 0, 0, 1, 0, 0, 50);

//    cv::imwrite("../1-10/fate_affine.jpeg", new_image);
    cv::imwrite("../1-10/Neopolitan_rot.png", new_image);
    cv::imshow("vv", new_image);
    cv::waitKey(0);
    cv::destroyAllWindows();

    return 0;
}

输入图像 (Neopolitan.png)	输出图像 (Neopolitan_rot.png)

仿射变换-倾斜

1. 使用仿射变换，输出$x$轴倾斜$30$度的图像（$t_x=30$），这种变换被称为X-sharing。
2. 使用仿射变换，输出y轴倾斜$30$度的图像（$t_y=30$），这种变换被称为Y-sharing。
3. 使用仿射变换，输出$x$轴、$y$轴都倾斜$30$度的图像($t_x=30$，$t_y=30$)。

引入非正交参量$a$来表达倾斜，其值定义为$t_x{t}_y$与原图像的大小$hw$的比值，可以使用下面各式进行仿射变换：

• X-sharing
  $$\begin{gathered} a=\frac{t_x}{h} \\ \left[\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ 1\end{array}\right]=\left[\begin{array}{ccc}1& a& t_x\\ 0& 1& t_y\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}x\\ y\\ 1\end{array}\right] \end{gathered}$$

• Y-sharing
  $$\begin{gathered} a=\frac{t_y}{w} \\ \left[\begin{array}{c}{x}^{\prime }\\ y^{\prime }\\ 1\end{array}\right]=\left[\begin{array}{ccc}1& 0& t_x\\ a& 1& t_y\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}x\\ y\\ 1\end{array}\right] \end{gathered}$$

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <math.h>

cv::Mat affine(cv::Mat img, double a, double b, double c, double d, double tx, double ty, double theta, double dx, double dy)
{
    int row = img.rows;
    int col = img.cols;
    int channel = img.channels();

    // get detriment
    double det = a * d - b * c;

    if (dx != 0){
        b = dx / row;
    }
    if (dy != 0){
        c = dy / col;
    }

    if (theta != 0)
    {
        // 如果存在旋转就重新定义仿射矩阵参量
        double rad = theta / 180 * M_PI;
        a = std::cos(rad);
        b = -std::sin(rad);
        c = std::sin(rad);
        d = std::cos(rad);
        tx = 0;
        ty = 0;

        double det = a * d - b * c;

        // 定义旋转前后的中心，以及两个中心的偏移量
        double center_x = col / 2.;
        double center_y = row / 2.;
        double rot_center_x = (d * center_x - b * center_y) / det;
        double rot_center_y = (-c * center_x + a * center_y) / det;
        tx = rot_center_x - center_x;
        ty = rot_center_y - center_y;
    }

    // Resize width and height
    int resized_col = (int)(col * a + dx);
    int resized_row = (int)(row * d + dy);

    if (theta != 0) {
        resized_col = (int)(col + dx);
        resized_row = (int)(row + dy);
    }

    cv::Mat new_image = cv::Mat::zeros(resized_row, resized_col, CV_8UC3);

    int pos_before_x, pos_before_y;

    // 仿射变换
    for (int i = 0; i < resized_row; i++)
    {
        for (int j = 0; j < resized_col; j++)
        {
            pos_before_x = (int)((d * j - b * i) / det - tx);
            if (pos_before_x < 0 || pos_before_x >= col)
            {
                continue;
            }

            pos_before_y = int((-c * j + a * i) / det - ty);
            if (pos_before_y < 0 || pos_before_y >= row)
            {
                continue;
            }

            for (int chan = 0; chan < channel; chan++)
            {
                new_image.at<cv::Vec3b>(i, j)[chan] = img.at<cv::Vec3b>(pos_before_y, pos_before_x)[chan];
            }
        }
    }

    return new_image;
}


int main(){
    // read image
    cv::Mat img = cv::imread("../fate.jpeg", cv::IMREAD_COLOR);

    // 倾斜
    cv::Mat new_image = affine(img, 1, 0, 0, 1, 0, 0, 0, 60, 0);

//    cv::imwrite("../1-10/fate_affine.jpeg", new_image);
    cv::imwrite("../1-10/fate_test12.jpeg", new_image);
    cv::imshow("vv", new_image);
    cv::waitKey(0);
    cv::destroyAllWindows();

    return 0;
}

输入图像 (fate.jpeg)	输出图像 (fate_x.jpeg)	输出图像 (fate_y.jpeg)	输出图像 (fate_xy.jpeg)