OpenCV】透视变换 Perspective Transformation（续）

载分

【OpenCV】透视变换 Perspective Transformation（续）

分类： 【图像处理】 【编程语言】 2014-05-27 09:39 2776人阅读 评论(13) 收藏 举报

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

求解变换公式的函数：

[cpp] view plaincopyprint?

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

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

[cpp] view plaincopyprint?

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

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

[cpp] view plaincopyprint?

  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. Mat transform = getPerspectiveTransform(corners,corners_trans);
  17. cout<<transform<<endl;
  18. vector<Point2f> ponits, points_trans;
  19. for(int i=0;i<img_height;i++){
  20. for(int j=0;j<img_width;j++){
  21. ponits.push_back(Point2f(j,i));
  22. }
  23. }
  24. perspectiveTransform( ponits, points_trans, transform);
  25. Mat img_trans = Mat::zeros(img_height,img_width,CV_8UC3);
  26. int count = 0;
  27. for(int i=0;i<img_height;i++){
  28. uchar* p = img.ptr<uchar>(i);
  29. for(int j=0;j<img_width;j++){
  30. int y = points_trans[count].y;
  31. int x = points_trans[count].x;
  32. uchar* t = img_trans.ptr<uchar>(y);
  33. t[x*3]  = p[j*3];
  34. t[x*3+1]  = p[j*3+1];
  35. t[x*3+2]  = p[j*3+2];
  36. count++;
  37. }
  38. }
  39. imwrite("boy_trans.png",img_trans);
  40. return 0;
  41. }
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》的代码应该就能懂啦。

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

[cpp] view
plaincopyprint?

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

OpenCV】透视变换 Perspective Transformation（续）,布布扣,bubuko.com

时间： 2024-10-22 07:46:36

OpenCV】透视变换 Perspective Transformation（续）的相关文章

【OpenCV】透视变换 Perspective Transformation（续）

透视变换的原理和矩阵求解请参见前一篇<透视变换 Perspective Transformation>.在OpenCV中也实现了透视变换的公式求解和变换函数. 求解变换公式的函数: Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[]) 输入原始图像和变换之后的图像的对应4个点,便可以得到变换矩阵.之后用求解得到的矩阵输入perspectiveTransform便可以对一组点进行变换: void perspec

opencv透视变换

opencv透视变换 实现透视变换 目标: 在这篇教程中你将学到: 1.如何进行透视变化 2.如何生存透视变换矩阵 理论: 什么是透视变换: 1.透视变换(Perspective Transformation)是将图片投影到一个新的视平面(Viewing Plane),也称作投影映射(Projective Mapping). 2.换算公式 u,v是原始图片左边,对应得到变换后的图片坐标x,y,其中.变换矩阵可以拆成4部分,表示线性变换,比如scaling,shearing和ratotion.用于

OpenCV Intro - Perspective Transform

透视变换(Perspective Transformation)是将图片投影到一个新的视平面(Viewing Plane),也称作投影映射(Projective Mapping).通用的变换公式为: u,v是原始图片左边,对应得到变换后的图片坐标x,y,其中.变换矩阵可以拆成4部分,表示线性变换,比如scaling,shearing和ratotion.用于平移,产生透视变换.所以可以理解成仿射等是透视变换的特殊形式.经过透视变换之后的图片通常不是平行四边形(除非映射视平面和原来平面平行的情况).

OpenCV 透视变换实例

参考文献: http://www.cnblogs.com/self-control/archive/2013/01/18/2867022.html http://opencv-code.com/tutorials/automatic-perspective-correction-for-quadrilateral-objects/ 透视变换: http://blog.csdn.net/xiaowei_cqu/article/details/26478135 具体流程为: a)载入图像→灰度化→边

Java基于opencv—透视变换矫正图像

很多时候我们拍摄的照片都会产生一点畸变的,就像下面的这张图 虽然不是很明显,但还是有一点畸变的,而我们要做的就是把它变成下面的这张图 效果看起来并不是很好,主要是四个顶点找的不准确,会有一些偏差,而且矫正后产生的目标图是倒着的,哪位好心人给说说为啥 因为我也没有测试畸变很大的图像,也不能保证方法适用于每个图像,这里仅提供我的思路供大家参考. 思路: 我们最重要的就是找到图像的四个顶点,有利用hough直线,求直线交点确定四个顶点,有采用寻找轮廓确定四个顶点等等:今天我提供的思路,也是采用寻找轮廓

opencv透视变换GetPerspectiveTransform的总结

对于透视变换,必须为map_matrix分配一个3x3数组,除了3x3矩阵和三个控点变为四个控点外,透视变化在其他方面与仿射变换完全类似.具体可以参考:点击打开链接 主要用到两个函数WarpPerspective和GetPerspectiveTransform. 1)WarpPerspective 对图像进行透视变换 void cvWarpPerspective( const CvArr* src, CvArr* dst,const CvMat* map_matrix, int flags=CV

透视变换

[图像处理]透视变换 Perspective Transformation 透视变换(Perspective Transformation)是将图片投影到一个新的视平面(Viewing Plane),也称作投影映射(Projective Mapping).通用的变换公式为: u,v是原始图片左边,对应得到变换后的图片坐标x,y,其中.变换矩阵可以拆成4部分,表示线性变换,比如scaling,shearing和ratotion.用于平移,产生透视变换.所以可以理解成仿射等是透视变换的特殊形式.经过

5.1-5.31推荐文章汇总

5.1-5.31推荐文章汇总 [移动开发] Android Volley完全解析(三),定制自己的Request guolin 雄踞AppStore榜首的游戏<别踩到白块儿>源代码分析和下载(一)touchsnow Cocos2d-x3.0游戏实例之<别救我>第四篇--乱入的主角笨木头 Android-自定义图像资源的使用(2)wwj_748 Android SQLite性能分析Horky <游戏脚本的设计与开发>-(RPG部分)3.6 队员列表和人物属性vipra C

仿射变换详解 warpAffine

今天遇到一个问题是关于仿射变换的,但是由于没有将仿射变换的具体原理型明白,看别人的代码看的很费解,最后终于在师兄的帮助下将原理弄明白了,我觉得最重要的是理解仿射变换可以看成是几种简单变换的复合实现, 具体实现形式即将几种简单变换的变换矩阵M相乘,这样就很容易理解啦 定义:仿射变换的功能是从二维坐标到二维坐标之间的线性变换,且保持二维图形的"平直性"和"平行性".仿射变换可以通过一系列的原子变换的复合来实现,包括平移,缩放,翻转,旋转和剪切. 这类变换可以用一个3*3