OpenCV】透視變換 Perspective Transformation（續）

時間  2019-11-06
標籤 opencv 變換 perspective transformation 简体版
原文   原文鏈接
載分

【OpenCV】透視變換 Perspective Transformation（續）

分類： 【圖像處理】 【編程語言】 2014-05-27 09:39 2776人閱讀 評論(13) 收藏 舉報

透視變換的原理和矩陣求解請參見前一篇《透視變換 Perspective Transformation》。在OpenCV中也實現了透視變換的公式求解和變換函數。編程

求解變換公式的函數：app

 

[cpp] view plain copy print ? 在CODE上查看代碼片 派生到個人代碼片
  1. Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[])  
Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[])
輸入原始圖像和變換以後的圖像的對應4個點，即可以獲得變換矩陣。以後用求解獲得的矩陣輸入perspectiveTransform即可以對一組點進行變換：

 

 

[cpp] view plain copy print ? 在CODE上查看代碼片 派生到個人代碼片
  1. void perspectiveTransform(InputArray src, OutputArray dst, InputArray m)  
void perspectiveTransform(InputArray src, OutputArray dst, InputArray m)
注意這裏src和dst的輸入並非圖像，而是圖像對應的座標。應用前一篇的例子，作個相反的變換：

 

 

[cpp] view plain copy print ? 在CODE上查看代碼片 派生到個人代碼片
  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. }  
int main( )
{
	Mat img=imread("boy.png");
	int img_height = img.rows;
	int img_width = img.cols;
	vector<Point2f> 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<Point2f> 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<<transform<<endl;
	vector<Point2f> ponits, points_trans;
	for(int i=0;i<img_height;i++){
		for(int j=0;j<img_width;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<img_height;i++){
		uchar* p = img.ptr<uchar>(i);
		for(int j=0;j<img_width;j++){
			int y = points_trans[count].y;
			int x = points_trans[count].x;
			uchar* t = img_trans.ptr<uchar>(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;
}

獲得變換以後的圖片：

 

注意這種將原圖變換到對應圖像上的方式會有一些沒有被填充的點，也就是右圖中黑色的小點。解決這種問題一是用差值的方式，再一種比較簡單就是不用原圖的點變換後對應找新圖的座標，而是直接在新圖上找反向變換原圖的點。提及來有點繞口，具體見前一篇《透視變換 Perspective Transformation》的代碼應該就能懂啦。less

除了getPerspectiveTransform()函數，OpenCV還提供了findHomography()的函數，不是用點來找，而是直接用透視平面來找變換公式。這個函數在特徵匹配的經典例子中有用到，也很是直觀：編程語言

 

[cpp] view plain copy print ? 在CODE上查看代碼片 派生到個人代碼片
  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. }  
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<KeyPoint> 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<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );

	//-- Localize the object from img_1 in img_2
	std::vector<Point2f> obj;
	std::vector<Point2f> scene;

	for( size_t i = 0; i < good_matches.size(); i++ )
	{
		//-- Get the keypoints from the good matches
		obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );
		scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );
	}

	Mat H = findHomography( obj, scene, RANSAC );

	//-- Get the corners from the image_1 ( the object to be "detected" )
	std::vector<Point2f> obj_corners(4);
	obj_corners[0] = Point(0,0); obj_corners[1] = Point( img_object.cols, 0 );
	obj_corners[2] = Point( img_object.cols, img_object.rows ); obj_corners[3] = Point( 0, img_object.rows );
	std::vector<Point2f> scene_corners(4);
	perspectiveTransform( obj_corners, scene_corners, H);
	//-- Draw lines between the corners (the mapped object in the scene - image_2 )
	Point2f offset( (float)img_object.cols, 0);
	line( img_matches, scene_corners[0] + offset, scene_corners[1] + offset, Scalar(0, 255, 0), 4 );
	line( img_matches, scene_corners[1] + offset, scene_corners[2] + offset, Scalar( 0, 255, 0), 4 );
	line( img_matches, scene_corners[2] + offset, scene_corners[3] + offset, Scalar( 0, 255, 0), 4 );
	line( img_matches, scene_corners[3] + offset, scene_corners[0] + offset, Scalar( 0, 255, 0), 4 );

	//-- Show detected matches
	imshow( "Good Matches & Object detection", img_matches );
	waitKey(0);
	return 0;
}

代碼運行效果：

 

 

findHomography()函數直接經過兩個平面上相匹配的特徵點求出變換公式，以後代碼又對原圖的四個邊緣點進行變換，在右圖上畫出對應的矩形。這個圖也很好地解釋了所謂透視變換的「Viewing Plane」。函數

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程