求解变换公式的函数：

Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[])

输入原始图像和变换之后的图像的对应4个点，便可以得到变换矩阵。之后用求解得到的矩阵输入perspectiveTransform便可以对一组点进行变换：

void perspectiveTransform(InputArray src, OutputArray dst, InputArray m)

注意这里src和dst的输入并不是图像，而是图像对应的坐标。应用前一篇的例子，做个相反的变换：

int main( )
{
?Mat img=imread("boy.png");
?int img_height = img.rows;
?int img_width = img.cols;
?vector corners(4);
?corners[0] = Point2f(0,0);
?corners[1] = Point2f(img_width-1,0);
?corners[2] = Point2f(0,img_height-1);
?corners[3] = Point2f(img_width-1,img_height-1);
?vector corners_trans(4);
?corners_trans[0] = Point2f(150,250);
?corners_trans[1] = Point2f(771,0);
?corners_trans[2] = Point2f(0,img_height-1);
?corners_trans[3] = Point2f(650,img_height-1);

?Mat transform = getPerspectiveTransform(corners,corners_trans);
?cout<?vector ponits, points_trans;
?for(int i=0;i? for(int j=0;j? ?ponits.push_back(Point2f(j,i));
? }
?}

?perspectiveTransform( ponits, points_trans, transform);
?Mat img_trans = Mat::zeros(img_height,img_width,CV_8UC3);
?int count = 0;
?for(int i=0;i? uchar* p = img.ptr(i);
? for(int j=0;j? ?int y = points_trans[count].y;
? ?int x = points_trans[count].x;
? ?uchar* t = img_trans.ptr(y);
? ?t[x*3]? = p[j*3];
? ?t[x*3+1]? = p[j*3+1];
? ?t[x*3+2]? = p[j*3+2];
? ?count++;
? }
?}
?imwrite("boy_trans.png",img_trans);

?return 0;
}

得到变换之后的图片：

?

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

int main( int argc, char** argv )
{
?Mat img_object = imread( argv[1], IMREAD_GRAYSCALE );
?Mat img_scene = imread( argv[2], IMREAD_GRAYSCALE );
?if( !img_object.data || !img_scene.data )
?{ std::cout<< " --(!) Error reading images " << std::endl; return -1; }

?//-- Step 1: Detect the keypoints using SURF Detector
?int minHessian = 400;
?SurfFeatureDetector detector( minHessian );
?std::vector keypoints_object, keypoints_scene;
?detector.detect( img_object, keypoints_object );
?detector.detect( img_scene, keypoints_scene );

?//-- Step 2: Calculate descriptors (feature vectors)
?SurfDescriptorExtractor extractor;
?Mat descriptors_object, descriptors_scene;
?extractor.compute( img_object, keypoints_object, descriptors_object );
?extractor.compute( img_scene, keypoints_scene, descriptors_scene );

?//-- Step 3: Matching descriptor vectors using FLANN matcher
?FlannBasedMatcher matcher;
?std::vector< DMatch > matches;
?matcher.match( descriptors_object, descriptors_scene, matches );
?double max_dist = 0; double min_dist = 100;

?//-- Quick calculation of max and min distances between keypoints
?for( int i = 0; i < descriptors_object.rows; i++ )
?{ double dist = matches[i].distance;
?if( dist < min_dist ) min_dist = dist;
?if( dist > max_dist ) max_dist = dist;
?}

?printf("-- Max dist : %f \n", max_dist );
?printf("-- Min dist : %f \n", min_dist );

?//-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist )
?std::vector< DMatch > good_matches;

?for( int i = 0; i < descriptors_object.rows; i++ )
?{ if( matches[i].distance < 3*min_dist )
?{ good_matches.push_back( matches[i]); }
?}

?Mat img_matches;
?drawMatches( img_object, keypoints_object, img_scene, keypoints_scene,
? good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
? vector(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );

?//-- Localize the object from img_1 in img_2
?std::vector obj;
?std::vector scene;