perspective transform透视矩阵快速求法+矩形矫正

算了半天一直在思考如何快速把矩阵算出来，网上基本都是在说边长为1的正方形的变换方式=。=   不怎么用得上…… 公式推导推半天，计算还麻烦。。。。

++++++++++++++++++++++++++++++

对于透视变换：

其中我们在使用的时候最重要的是算出系数……………………  这里我们按照i=1计算

找了半天找到了这一篇论文：http://www.ixueshu.com/document/027c165d22e18077318947a18e7f9386.html

里面提到我们可以将公式

改写成的模式。

那么根据矩形矫正前后的8个顶点可以得到公式：

那么只要计算中间8x8矩阵的逆，乘上变换后的uv矩阵，就可以求出所有待定系数。其中点的检测需要用到hough算法，点和点之间的对应我做了个交互，不然太麻烦了。。。。

矩阵求逆代码：其中N为8

 #include <iostream>
 using namespace std;
 #define N 8    //测试矩阵维数定义

 //按第一行展开计算|A|
 double getA(double arcs[N][N], int n)
 {
     if (n == )
     {
         return arcs[][];
     }
     double ans = ;
     double temp[N][N] = { 0.0 };
     int i, j, k;
     for (i = ; i<n; i++)
     {
         for (j = ; j<n - ; j++)
         {
             for (k = ; k<n - ; k++)
             {
                 temp[j][k] = arcs[j + ][(k >= i) ? k +  : k];

             }
         }
         double t = getA(temp, n - );
         if (i %  == )
         {
             ans += arcs[][i] * t;
         }
         else
         {
             ans -= arcs[][i] * t;
         }
     }
     return ans;
 }

 //计算每一行每一列的每个元素所对应的余子式，组成A*
 void  getAStart(double arcs[N][N], int n, double ans[N][N])
 {
     if (n == )
     {
         ans[][] = ;
         return;
     }
     int i, j, k, t;
     double temp[N][N];
     for (i = ; i<n; i++)
     {
         for (j = ; j<n; j++)
         {
             for (k = ; k<n - ; k++)
             {
                 for (t = ; t<n - ; t++)
                 {
                     temp[k][t] = arcs[k >= i ? k +  : k][t >= j ? t +  : t];
                 }
             }

             ans[j][i] = getA(temp, n - );  //此处顺便进行了转置
             if ((i + j) %  == )
             {
                 ans[j][i] = -ans[j][i];
             }
         }
     }
 }

 //得到给定矩阵src的逆矩阵保存到des中。
 bool GetMatrixInverse(double src[N][N], int n, double des[N][N])
 {
     double flag = getA(src, n);
     double t[N][N];
     if ( == flag)
     {
         cout << "原矩阵行列式为0，无法求逆。请重新运行" << endl;
         return false;//如果算出矩阵的行列式为0，则不往下进行
     }
     else
     {
         getAStart(src, n, t);
         for (int i = ; i<n; i++)
         {
             for (int j = ; j<n; j++)
             {
                 des[i][j] = t[i][j] / flag;
             }

         }
     }

     return true;
 }

主函数内代码：（仅部分）

vector<pair<int, int>> P ,newPoint; //P 变换后标准A4的点  newPoint 变换前的点   计算时候计算变换后变换到变换前

//省略中间数值插入和输出图片构成

P.push_back(make_pair(, ));
    P.push_back(make_pair((int)len1, ));
    P.push_back(make_pair((int)len1, (int)len2));
    P.push_back(make_pair(, (int)len2));

    int uv[] = { newPoint[].first, newPoint[].second,
        newPoint[].first, newPoint[].second,
        newPoint[].first, newPoint[].second,
        newPoint[].first, newPoint[].second };

    double src[][] =
    { { P[].first, P[].second, , , , , -newPoint[].first*P[].first, -newPoint[].first*P[].second },
    { , , , P[].first, P[].second, , -newPoint[].second*P[].first, -newPoint[].second*P[].second },

    { P[].first, P[].second, , , , , -newPoint[].first*P[].first, -newPoint[].first*P[].second },
    { , , , P[].first, P[].second, , -newPoint[].second*P[].first, -newPoint[].second*P[].second },

    { P[].first, P[].second, , , , , -newPoint[].first*P[].first, -newPoint[].first*P[].second },
    { , , , P[].first, P[].second, , -newPoint[].second*P[].first, -newPoint[].second*P[].second },

    { P[].first, P[].second, , , , , -newPoint[].first*P[].first, -newPoint[].first*P[].second },
    { , , , P[].first, P[].second, , -newPoint[].second*P[].first, -newPoint[].second*P[].second } };

    double matrix_after[N][N]{};
    bool flag = GetMatrixInverse(src, N, matrix_after);
    if (false == flag) {
        cout << "求不出系数" << endl;
        return;
    }

    cout << "逆矩阵：" << endl;

    for (int i = ; i<; i++)
    {
        for (int j = ; j<; j++)
        {
            cout << matrix_after[i][j] << " ";
            //cout << *(*(matrix_after+i)+j)<<" ";
        }
        cout << endl;
    }

    double xs[];
    for (int i = ; i < ; i++) {
        double sum = ;
        for (int t = ; t < ; t++) {
            sum += matrix_after[i][t] * uv[t];
        }
        xs[i] = sum;
    }
        //矩形矫正  没有用双线性插值
    cimg_forXY(outputimg, x, y) {
        double px = xs[] * x + xs[] * y + xs[];
        double py = xs[] * x + xs[] * y + xs[];
        double p = xs[] * x + xs[] * y + ;

        int u = px / p;
        int v = py / p;

        outputimg(x, y, ) = paint(u, v, );
        outputimg(x, y, ) = paint(u, v, );
        outputimg(x, y, ) = paint(u, v, );
    }

以上~

基本实验了一下：

结果：

还可以吧。。。