"Image Processing" perspective transformation Perspective transformation_ Image processing

Source: Internet
Author: User

The Perspective Transformation (Perspective transformation) is the projection of a picture into a new visual plane (viewing Plane), also known as a projection map (projective Mapping). The General transformation formula is:


U,v is the original picture to the left, corresponding to get the transformed picture coordinates x,y, which.
The transformation matrix can be divided into 4 parts, representing linear transformations, such as scaling,shearing and ratotion. For panning, resulting in perspective transformations. So it can be understood that affine is a special form of perspective transformation. A picture after a perspective transformation is usually not a parallelogram (unless the mapped visual plane is parallel to the original plane).

Before you rewrite the transformation formula, you can get:


Therefore, we can find the transformation formula by a few points corresponding to the transformation. Conversely, a particular transformation formula can also be transformed by a new image. Simply look at the transformation of a square to a quadrilateral:
The 4 sets of corresponding points of the transformation can be expressed as:

According to the transformation formula:


Define several auxiliary variables:


All for 0 o'clock the transformation plane is parallel to the original, and can be obtained:


Not for 0 o'clock, get:


The transformed matrix can transform a square to a quadrilateral. Conversely, the quadrilateral transformation to the square is the same. So we can transform any quadrilateral to another quadrilateral by two transformations: quadrilateral transformation to square + square transformation to quadrilateral.


Read a piece of code:

[cpp]  View Plain  copy   Perspectivetransform::P erspectivetransform (float ina11, float  inA21,                                                 float inA31, float  ina12,                                                 float ina22, float ina32,                                                  float inA13, float inA23,                                             &NBSP;&NBSP;&NBSP;&NBSP;&NBSP;FLOAT&NBSP;INA33)  :      a11 (inA11),  a12 (inA12 ),  a13 (inA13),  a21 (inA21),  a22 (inA22),  a23 (inA23),     a31 (inA31),  a32 (inA32),  a33 (inA33)  {}      perspectivetransform  Perspectivetransform::quadrilateraltoquadrilateral (FLOAT&NBSP;X0,&NBSP;FLOAT&NBSP;Y0,&NBSP;FLOAT&NBSP;X1,  float y1,       float x2, float y2, float x3,  float y3, float x0p, float y0p, float x1p, float y1p,  float x2p, float y2p,       float x3p, float y3p)  {      Perspectivetransform qtos = perspectivetransform::quadrilateraltosquare (X0,&NBSP;Y0,&NBSP;X1, &NBSP;Y1,&NBSP;X2,&NBSP;Y2,&NBSP;X3,&NBSP;Y3);     perspectivetransform stoq =        perspectivetransform::squaretoquadrilateral (x0p, y0p, x1p,  y1p, x2p, y2p, x3p, y3p);     return stoq.times (QToS);   }      perspectivetransform perspectivetransform::squaretoquadrilateral (float x0,  float y0, float x1, float y1, float x2,       &NBSP;FLOAT&NBSP;Y2,&NBSP;FLOAT&NBSP;X3,&NBSP;FLOAT&NBSP;Y3)  {     float dx3  = x0 - x1 + x2 - x3;     float dy3 =  y0 - y1 + y2 - y3;     if  (dx3 == 0.0f && dy3  == 0.0f)  {       perspectivetransform result ( Perspectivetransform (x1 - x0, x2 - x1, x0, y1 - y0, y2  - y1, y0, 0.0f,                                          0.0f, 1.0f));       return  result;     } else {       float dx1  = x1 - x2;       float dx2 = x3 -  x2;       float dy1 = y1 - y2;        float dy2 = y3 - y2;       float denominator = dx1 *  dy2 - dx2 * dy1;       float a13 =  (dx3 &NBSP;*&NBSP;DY2&NBSP;-&NBSP;DX2&NBSP;*&NBSP;DY3)  / denominator;        float a23 =  (dx1 * dy3 - dx3 * dy1)  / denominator;        perspectivetransform result (Perspectivetransform (x1 - x0  + a13 * x1, x3 - x0 + a23 * x3, x0, y1  - y0                                          + a13 * y1, y3 - y0 + a23 * y3 , y0, a13, a23, 1.0f));       return result;     }  }       Perspectivetransform perspectivetransform::quadrilateraltosquare (float x0,  float y0, float x1, float y1, float x2,       &NBSP;FLOAT&NBSP;Y2,&NBSP;FLOAT&NBSP;X3,&NBSP;FLOAT&NBSP;Y3)  {     // Here,  the adjoint serves as the inverse:     return  Squaretoquadrilateral (X0, y0, x1, y1, x2, y2, x3, y3). BuildAdjoint ();   }      perspectivetransform perspectivetransform::buildadjoint ()  {      // adjoint is the transpose of the cofactor matrix:      perspectivetransform result (Perspectivetransform (a22 * a33 -  A23 * a32, a23 * a31 - a21 * a33, a21 * a32                                        - a22 *  a31, a13 * a32 - a12 * a33, a11 * a33 - a13  * a31, a12 * a31 - a11 * a32, a12 * a23 -  a13 * a22,                                        a13 * a21 - a11 * a23, a11 * a22 &NBSP;-&NBSP;A12&NBSP;*&NBSP;A21);     return result;  }       PerspectivetranSform perspectivetransform::times (perspectivetransform other)  {      Perspectivetransform result (Perspectivetransform (a11 * other.a11 + a21 *  other.a12 + a31 * other.a13,                                        a11 * other.a21 + a21 *  other.a22 + a31 * other.a23, a11 * other.a31 + a21 *  other.a32 + a31                                        * other.a33, a12 * other.a11 + a22 *  other.a12 + a32 * other.a13, a12 * other.a21 + a22                                        * other.a22 + a32  * other.a23, a12 * other.a31 + a22 * other.a32 + a32 *  other.a33, a13                                        * other.a11 + a23 * other.a12 + a33 *  other.a13, a13 * other.a21 + a23 * other.a22 + a33                          &Nbsp;             * other.a23, a13 &NBSP;*&NBSP;OTHER.A31&NBSP;+&NBSP;A23&NBSP;*&NBSP;OTHER.A32&NBSP;+&NBSP;A33&NBSP;*&NBSP;OTHER.A33));      return result;  }      void perspectivetransform:: Transformpoints (vector<float> &points)  {     int max =  Points.size ();     for  (int i = 0; i < max; i &NBSP;+=&NBSP;2)  {       float x = points[i];       float y = points[i + 1];        float denominator = a13 * x + a23 * y + a33;        points[i] =  (a11 * x + a21 * y + &NBSP;A31)  / denominator;       points[i + 1] =  (a12 * x + &NBSP;A22&NBSP;*&NBSP;Y&NBSP;+&NBSP;A32)  / denominator;     }  }    Change the effect of a perspective picture back to a positive image:

[cpp]  View Plain  copy   Int main () {       mat img=imread (" Boy.png ");       int img_height = img.rows;        int img_width = img.cols;       mat img_ Trans = mat::zeros (IMG_HEIGHT,IMG_WIDTH,CV_8UC3);        Perspectivetransform tansform = perspectivetransform::quadrilateraltoquadrilateral (           0,0,            img_width-1,0,           0,img_height-1,           img_width-1,img_height-1,            150,250, // top left            771,0, // top right           0,1023,// bottom left            650,1023            );       vector<float> ponits;        for (int i=0;i (i);            for  (int j=0;j (img_width-1) | | y<0| | Y> (img_height-1))                     continue;                uchar* p = img.ptr<uchar> (y);                t[j*3] = p[x*3];                t[j*3+1] = p[x*3+1];                t[j*3+2] = p[x*3+2];           }        }       imwrite ("Trans.png", Img_trans);        return 0;  }  



In addition, the basic perspective transformation operation is also implemented in OpenCV, see next: "OpenCV" Perspective Transformation Perspective Transformation (cont.)


(reprint please indicate author and origin: Http://blog.csdn.net/xiaowei_cqu do not use for commercial use without permission)
from:http://blog.csdn.net/xiaowei_cqu/article/details/26471527

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.