透视变换

【图像处理】透视变换 Perspective Transformation

透视变换(Perspective Transformation)是将图片投影到一个新的视平面(Viewing Plane)，也称作投影映射(Projective Mapping)。通用的变换公式为：

u,v是原始图片左边，对应得到变换后的图片坐标x,y,其中。
变换矩阵可以拆成4部分，表示线性变换，比如scaling，shearing和ratotion。用于平移，产生透视变换。所以可以理解成仿射等是透视变换的特殊形式。经过透视变换之后的图片通常不是平行四边形（除非映射视平面和原来平面平行的情况）。

重写之前的变换公式可以得到：

所以，已知变换对应的几个点就可以求取变换公式。反之，特定的变换公式也能新的变换后的图片。简单的看一个正方形到四边形的变换：
变换的4组对应点可以表示成：

根据变换公式得到：

定义几个辅助变量：

都为0时变换平面与原来是平行的，可以得到：

不为0时，得到：

求解出的变换矩阵就可以将一个正方形变换到四边形。反之，四边形变换到正方形也是一样的。于是，我们通过两次变换：四边形变换到正方形+正方形变换到四边形就可以将任意一个四边形变换到另一个四边形。

看一段代码：

 

[cpp] view plain copy
 
  1. PerspectiveTransform::PerspectiveTransform(float inA11, float inA21,   
  2.                                            float inA31, float inA12,   
  3.                                            float inA22, float inA32,   
  4.                                            float inA13, float inA23,   
  5.                                            float inA33) :   
  6.   a11(inA11), a12(inA12), a13(inA13), a21(inA21), a22(inA22), a23(inA23),  
  7.   a31(inA31), a32(inA32), a33(inA33) {}  
  8.   
  9. PerspectiveTransform PerspectiveTransform::quadrilateralToQuadrilateral(float x0, float y0, float x1, float y1,  
  10.     float x2, float y2, float x3, float y3, float x0p, float y0p, float x1p, float y1p, float x2p, float y2p,  
  11.     float x3p, float y3p) {  
  12.   PerspectiveTransform qToS = PerspectiveTransform::quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);  
  13.   PerspectiveTransform sToQ =  
  14.     PerspectiveTransform::squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);  
  15.   return sToQ.times(qToS);  
  16. }  
  17.   
  18. PerspectiveTransform PerspectiveTransform::squareToQuadrilateral(float x0, float y0, float x1, float y1, float x2,  
  19.     float y2, float x3, float y3) {  
  20.   float dx3 = x0 - x1 + x2 - x3;  
  21.   float dy3 = y0 - y1 + y2 - y3;  
  22.   if (dx3 == 0.0f && dy3 == 0.0f) {  
  23.     PerspectiveTransform result(PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f,  
  24.                                      0.0f, 1.0f));  
  25.     return result;  
  26.   } else {  
  27.     float dx1 = x1 - x2;  
  28.     float dx2 = x3 - x2;  
  29.     float dy1 = y1 - y2;  
  30.     float dy2 = y3 - y2;  
  31.     float denominator = dx1 * dy2 - dx2 * dy1;  
  32.     float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;  
  33.     float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;  
  34.     PerspectiveTransform result(PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0  
  35.                                      + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0f));  
  36.     return result;  
  37.   }  
  38. }  
  39.   
  40. PerspectiveTransform PerspectiveTransform::quadrilateralToSquare(float x0, float y0, float x1, float y1, float x2,  
  41.     float y2, float x3, float y3) {  
  42.   // Here, the adjoint serves as the inverse:  
  43.   return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3).buildAdjoint();  
  44. }  
  45.   
  46. PerspectiveTransform PerspectiveTransform::buildAdjoint() {  
  47.   // Adjoint is the transpose of the cofactor matrix:  
  48.   PerspectiveTransform result(PerspectiveTransform(a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32  
  49.                                    - a22 * a31, a13 * a32 - a12 * a33, a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22,  
  50.                                    a13 * a21 - a11 * a23, a11 * a22 - a12 * a21));  
  51.   return result;  
  52. }  
  53.   
  54. PerspectiveTransform PerspectiveTransform::times(PerspectiveTransform other) {  
  55.   PerspectiveTransform result(PerspectiveTransform(a11 * other.a11 + a21 * other.a12 + a31 * other.a13,  
  56.                                    a11 * other.a21 + a21 * other.a22 + a31 * other.a23, a11 * other.a31 + a21 * other.a32 + a31  
  57.                                    * other.a33, a12 * other.a11 + a22 * other.a12 + a32 * other.a13, a12 * other.a21 + a22  
  58.                                    * other.a22 + a32 * other.a23, a12 * other.a31 + a22 * other.a32 + a32 * other.a33, a13  
  59.                                    * other.a11 + a23 * other.a12 + a33 * other.a13, a13 * other.a21 + a23 * other.a22 + a33  
  60.                                    * other.a23, a13 * other.a31 + a23 * other.a32 + a33 * other.a33));  
  61.   return result;  
  62. }  
  63.   
  64. void PerspectiveTransform::transformPoints(vector<float> &points) {  
  65.   int max = points.size();  
  66.   for (int i = 0; i < max; i += 2) {  
  67.     float x = points[i];  
  68.     float y = points[i + 1];  
  69.     float denominator = a13 * x + a23 * y + a33;  
  70.     points[i] = (a11 * x + a21 * y + a31) / denominator;  
  71.     points[i + 1] = (a12 * x + a22 * y + a32) / denominator;  
  72.   }  
  73. }  

对一张透视图片变换回正面图的效果：

 

 

[cpp] view plain copy
 
  1. int main(){  
  2.     Mat img=imread("boy.png");  
  3.     int img_height = img.rows;  
  4.     int img_width = img.cols;  
  5.     Mat img_trans = Mat::zeros(img_height,img_width,CV_8UC3);  
  6.     PerspectiveTransform tansform = PerspectiveTransform::quadrilateralToQuadrilateral(  
  7.         0,0,  
  8.         img_width-1,0,  
  9.         0,img_height-1,  
  10.         img_width-1,img_height-1,  
  11.         150,250, // top left  
  12.         771,0, // top right  
  13.         0,1023,// bottom left  
  14.         650,1023  
  15.         );  
  16.     vector<float> ponits;  
  17.     for(int i=0;i<img_height;i++){  
  18.         for(int j=0;j<img_width;j++){  
  19.             ponits.push_back(j);  
  20.             ponits.push_back(i);  
  21.         }  
  22.     }  
  23.     tansform.transformPoints(ponits);  
  24.     for(int i=0;i<img_height;i++){  
  25.         uchar*  t= img_trans.ptr<uchar>(i);  
  26.         for (int j=0;j<img_width;j++){  
  27.             int tmp = i*img_width+j;  
  28.             int x = ponits[tmp*2];  
  29.             int y = ponits[tmp*2+1];  
  30.             if(x<0||x>(img_width-1)||y<0||y>(img_height-1))  
  31.                 continue;  
  32.             uchar* p = img.ptr<uchar>(y);  
  33.             t[j*3] = p[x*3];  
  34.             t[j*3+1] = p[x*3+1];  
  35.             t[j*3+2] = p[x*3+2];  
  36.         }  
  37.     }  
  38.     imwrite("trans.png",img_trans);  
  39.     return 0;  
  40. }  

 

 
 
另外在OpenCV中也实现了基础的透视变换操作，有关函数使用请见下一篇：【OpenCV】透视变换 Perspective Transformation（续）
 
 
 

（转载请注明作者和出处：http://blog.csdn.net/xiaowei_cqu 未经允许请勿用于商业用途）

 

透视变换的原理和矩阵求解请参见前一篇《透视变换 Perspective Transformation》。在OpenCV中也实现了透视变换的公式求解和变换函数。

求解变换公式的函数：

 

[cpp] view plain copy
 
  1. Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[])  
输入原始图像和变换之后的图像的对应4个点，便可以得到变换矩阵。之后用求解得到的矩阵输入perspectiveTransform便可以对一组点进行变换：

 

 

[cpp] view plain copy
 
  1. void perspectiveTransform(InputArray src, OutputArray dst, InputArray m)  
注意这里src和dst的输入并不是图像，而是图像对应的坐标。应用前一篇的例子，做个相反的变换：

 

 

[cpp] view plain copy
 
  1. int main( )  
  2. {  
  3.     Mat img=imread("boy.png");  
  4.     int img_height = img.rows;  
  5.     int img_width = img.cols;  
  6.     vector<Point2f> corners(4);  
  7.     corners[0] = Point2f(0,0);  
  8.     corners[1] = Point2f(img_width-1,0);  
  9.     corners[2] = Point2f(0,img_height-1);  
  10.     corners[3] = Point2f(img_width-1,img_height-1);  
  11.     vector<Point2f> corners_trans(4);  
  12.     corners_trans[0] = Point2f(150,250);  
  13.     corners_trans[1] = Point2f(771,0);  
  14.     corners_trans[2] = Point2f(0,img_height-1);  
  15.     corners_trans[3] = Point2f(650,img_height-1);  
  16.   
  17.     Mat transform = getPerspectiveTransform(corners,corners_trans);  
  18.     cout<<transform<<endl;  
  19.     vector<Point2f> ponits, points_trans;  
  20.     for(int i=0;i<img_height;i++){  
  21.         for(int j=0;j<img_width;j++){  
  22.             ponits.push_back(Point2f(j,i));  
  23.         }  
  24.     }  
  25.   
  26.     perspectiveTransform( ponits, points_trans, transform);  
  27.     Mat img_trans = Mat::zeros(img_height,img_width,CV_8UC3);  
  28.     int count = 0;  
  29.     for(int i=0;i<img_height;i++){  
  30.         uchar* p = img.ptr<uchar>(i);  
  31.         for(int j=0;j<img_width;j++){  
  32.             int y = points_trans[count].y;  
  33.             int x = points_trans[count].x;  
  34.             uchar* t = img_trans.ptr<uchar>(y);  
  35.             t[x*3]  = p[j*3];  
  36.             t[x*3+1]  = p[j*3+1];  
  37.             t[x*3+2]  = p[j*3+2];  
  38.             count++;  
  39.         }  
  40.     }  
  41.     imwrite("boy_trans.png",img_trans);  
  42.   
  43.     return 0;  
  44. }  

得到变换之后的图片：

 

注意这种将原图变换到对应图像上的方式会有一些没有被填充的点，也就是右图中黑色的小点。解决这种问题一是用差值的方式，再一种比较简单就是不用原图的点变换后对应找新图的坐标，而是直接在新图上找反向变换原图的点。说起来有点绕口，具体见前一篇《透视变换 Perspective Transformation》的代码应该就能懂啦。

除了getPerspectiveTransform()函数，OpenCV还提供了findHomography()的函数，不是用点来找，而是直接用透视平面来找变换公式。这个函数在特征匹配的经典例子中有用到，也非常直观：

 

[cpp] view plain copy
 
  1. int main( int argc, char** argv )  
  2. {  
  3.     Mat img_object = imread( argv[1], IMREAD_GRAYSCALE );  
  4.     Mat img_scene = imread( argv[2], IMREAD_GRAYSCALE );  
  5.     if( !img_object.data || !img_scene.data )  
  6.     { std::cout<< " --(!) Error reading images " << std::endl; return -1; }  
  7.   
  8.     //-- Step 1: Detect the keypoints using SURF Detector  
  9.     int minHessian = 400;  
  10.     SurfFeatureDetector detector( minHessian );  
  11.     std::vector<KeyPoint> keypoints_object, keypoints_scene;  
  12.     detector.detect( img_object, keypoints_object );  
  13.     detector.detect( img_scene, keypoints_scene );  
  14.   
  15.     //-- Step 2: Calculate descriptors (feature vectors)  
  16.     SurfDescriptorExtractor extractor;  
  17.     Mat descriptors_object, descriptors_scene;  
  18.     extractor.compute( img_object, keypoints_object, descriptors_object );  
  19.     extractor.compute( img_scene, keypoints_scene, descriptors_scene );  
  20.   
  21.     //-- Step 3: Matching descriptor vectors using FLANN matcher  
  22.     FlannBasedMatcher matcher;  
  23.     std::vector< DMatch > matches;  
  24.     matcher.match( descriptors_object, descriptors_scene, matches );  
  25.     double max_dist = 0; double min_dist = 100;  
  26.   
  27.     //-- Quick calculation of max and min distances between keypoints  
  28.     for( int i = 0; i < descriptors_object.rows; i++ )  
  29.     { double dist = matches[i].distance;  
  30.     if( dist < min_dist ) min_dist = dist;  
  31.     if( dist > max_dist ) max_dist = dist;  
  32.     }  
  33.   
  34.     printf("-- Max dist : %f \n", max_dist );  
  35.     printf("-- Min dist : %f \n", min_dist );  
  36.   
  37.     //-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist )  
  38.     std::vector< DMatch > good_matches;  
  39.   
  40.     for( int i = 0; i < descriptors_object.rows; i++ )  
  41.     { if( matches[i].distance < 3*min_dist )  
  42.     { good_matches.push_back( matches[i]); }  
  43.     }  
  44.   
  45.     Mat img_matches;  
  46.     drawMatches( img_object, keypoints_object, img_scene, keypoints_scene,  
  47.         good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),  
  48.         vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );  
  49.   
  50.     //-- Localize the object from img_1 in img_2  
  51.     std::vector<Point2f> obj;  
  52.     std::vector<Point2f> scene;  
  53.   
  54.     for( size_t i = 0; i < good_matches.size(); i++ )  
  55.     {  
  56.         //-- Get the keypoints from the good matches  
  57.         obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );  
  58.         scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );  
  59.     }  
  60.   
  61.     Mat H = findHomography( obj, scene, RANSAC );  
  62.   
  63.     //-- Get the corners from the image_1 ( the object to be "detected" )  
  64.     std::vector<Point2f> obj_corners(4);  
  65.     obj_corners[0] = Point(0,0); obj_corners[1] = Point( img_object.cols, 0 );  
  66.     obj_corners[2] = Point( img_object.cols, img_object.rows ); obj_corners[3] = Point( 0, img_object.rows );  
  67.     std::vector<Point2f> scene_corners(4);  
  68.     perspectiveTransform( obj_corners, scene_corners, H);  
  69.     //-- Draw lines between the corners (the mapped object in the scene - image_2 )  
  70.     Point2f offset( (float)img_object.cols, 0);  
  71.     line( img_matches, scene_corners[0] + offset, scene_corners[1] + offset, Scalar(0, 255, 0), 4 );  
  72.     line( img_matches, scene_corners[1] + offset, scene_corners[2] + offset, Scalar( 0, 255, 0), 4 );  
  73.     line( img_matches, scene_corners[2] + offset, scene_corners[3] + offset, Scalar( 0, 255, 0), 4 );  
  74.     line( img_matches, scene_corners[3] + offset, scene_corners[0] + offset, Scalar( 0, 255, 0), 4 );  
  75.   
  76.     //-- Show detected matches  
  77.     imshow( "Good Matches & Object detection", img_matches );  
  78.     waitKey(0);  
  79.     return 0;  
  80. }  

代码运行效果：

 

 

findHomography()函数直接通过两个平面上相匹配的特征点求出变换公式，之后代码又对原图的四个边缘点进行变换，在右图上画出对应的矩形。这个图也很好地解释了所谓透视变换的“Viewing Plane”。

 

 

（转载请注明作者和出处：http://blog.csdn.net/xiaowei_cqu 未经允许请勿用于商业用途）

posted @ 2016-07-04 16:45  菜鸡一枚  阅读(2886)  评论(0)  编辑  收藏  举报