利用SIFT和RANSAC算法（openCV框架）实现物体的检测与定位，并求出变换矩阵（findFundamentalMat和findHomography的比较）

最新推荐文章于 2022-07-10 11:01:38 发布
置顶 最新推荐文章于 2022-07-10 11:01:38 发布
阅读量4.3w 收藏 200
点赞数 30
分类专栏： 物体识别 文章标签： sift findFundamentalMat findHomography RANSAC openCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25352981/article/details/46914837
版权

本文目标是通过使用SIFT和RANSAC算法，完成特征点的正确匹配，并求出变换矩阵，通过变换矩阵计算出要识别物体的边界（文章中有部分源码，整个工程我也上传了，请点击这里）。

SIFT算法是目前公认的效果最好的特征点检测算法，关于该算法的就不多说了，网上的资料有很多，在此提供两个链接，一个是SIFT原文的译文，一个是关于SIFT算法的详细解释：

SIFT算法译文

SIFT算法详解

整个实现过程可以复述如下：提供两张初始图片，一幅为模板图像，一幅为测试图片，目的就是根据模板图片中的物体，检测出测试图片中的物体，并表示出物体的具体位置和大小，测试图片中的物体位置和大小，已经事先用白色方框标记。

首先，对两幅图片，都使用SIFT算法提取特征点，提取结果如下：（SIFT特征提取方法就用的是上文链接“SIFT算法详解”中提供的代码）


然后对特征点进行匹配，按照SIFT算法原文作者的思路，每个特征点产生一个128维的向量，计算向量之间的欧式距离，采用最近比次近的方式完成匹配，如果最近距离比上次近距离小于0.8，则认为这是一个正确的匹配， 否则认为匹配不成功。结果这种匹配后的情况如下图：


可以发现，仍然存在着很多错误的匹配点，所以再尝试用RANSAC算法消除错误匹配，尝试使用openCV中的findFundamentalMat函数消除错误匹配：


通过使用findFundamentalMat函数，函数返回一个3*3的矩阵，一开始我认为这个矩阵就是变换矩阵，只要将左图中的点与这个变换矩阵相乘，就可以得到右图中的对应点。但是这其实是不对的。

在这里有一个误解，就是findFundamentalMat函数确实可以使用RANSAC方法消除错误匹配，从名字上可以发现，这个函数的作用是返回基础矩阵的，基础矩阵和变换矩阵是两个不同的概念。基础矩阵描述是三维场景中的像点之间的对应关系（其实到现在为止这个函数求出的基础矩阵有个毛用我也不知道）。所以说，如果使用这个函数，这个实验也就能做到这一步了，没法再往下做了。

所以，为了得到变换矩阵，后来我才发现openCV中还有函数findHomography，这个函数才是真正的计算变换矩阵的函数，它的函数返回值才是真正的变换矩阵。

其实这个问题困扰了我很久，关于消除错误匹配的方法，网上查出来的多数都是通过findFundamentalMat函数来进行，所以我就想当然的认为该函数的返回值是变换矩阵了。而网上关于findHomography的介绍比较少，所以才会让人们误解findFundamentalMat会计算出变换矩阵了。

尝试用findHomography函数返回的矩阵，在模板图像中，已经用绿色方框标示出物体轮廓，根据物体的四个边界点，与变换矩阵相乘，即可得到变换后的物体的轮廓的四个边界点，将此边界点连接即为物体轮廓，如下图所示（绿色方框为事先标注的模板物体中的轮廓，白色方框为事先标注的测试图片中的轮廓，红色方框为经过绿色方框经变换矩阵变换后计算出的轮廓）：


从结果可以看出，这才是比较正确的结果。

实验过程中的主要代码如下（这是主要的代码，SIFT算法和一些其他的功能函数我都写在了其他的文件中）：

#include<math.h>
#include<time.h>

#include <windows.h>
#include <iostream>
using namespace std;
#include <cv.h>
#include <highgui.h>
#include <cxcore.h>
using namespace cv;
#include "sift.h"
#include "my_function.h"

int main()
{
	//加载两幅图片
	Mat src1 = imread("F:\\ylab\\image database\\camera\\obj01_001.jpg");
    Mat src2 = imread("F:\\ylab\\image database\\imagesTest2\\test01_.jpg");

	//这四个坐标是模板图像中绿色方框的四个顶点
	Point2f m1(173.0,0.0),m2(168.0,464.0),m3(507.0,464.0),m4(499.0,0.0);
	std::vector<Point2f> obj_corners(4);
	obj_corners[0] = cvPoint(173.0,0.0); 
    obj_corners[1] = cvPoint(168.0,464.0);
    obj_corners[2] = cvPoint(507.0,464.0); 
    obj_corners[3] = cvPoint(499.0,0.0);

	//原始图片比较大，我这里将图片同一处理成了640*480的大小
	Size certainsize=Size(640,480);
    Mat src_1;
	Mat src_2;
    resize(src1,src_1,certainsize);
	resize(src2,src_2,certainsize);

    //两个图像的特征点序列
	Vector<Keypoint> feature_1,feature_2;

	//采用sift算法，计算特征点序列，这个SIFT函数是在另外的文件中写好的
    Sift(src_1, feature_1, 1.6);
	Sift(src_2, feature_2, 1.6);

	//feature_dis为带有距离的特征点结构体序列
	Vector<Key_point> feature_dis_1;
	Vector<Key_point> feature_dis_2;
	Vector<Key_point> result;
	
	//对特征点进行匹配，这个Match_feature是我自己写的，就是采用最近比次近小于0.8即为合适的匹配，这种匹配方式
	//openCV中并没有，所以我就自己写了
	Match_feature(feature_1,feature_2,feature_dis_1,feature_dis_2);	
	
	printf("The number of features is %d\n",feature_1.size());
	printf("The number of the match features is %d\n",feature_dis_1.size());

	//从这里开始使用RANSAC方法进行运算
	//下面的程序都好无奈，所有的结构都只能转化成openCV的类型才能用openCV的函数。。
	Ptr<DescriptorMatcher> descriptor_matcher = DescriptorMatcher::create( "BruteForce" );//创建特征匹配器  
	int count=feature_dis_1.size();

	//把特征点序列转化成openCV能够使用的类型
	vector<KeyPoint>keypoints1,keypoints2;
	KeyPoint keyp;
	for(int i=0;i<count;i++)
	{
		keyp.pt.x=feature_dis_1[i].dx;
		keyp.pt.y=feature_dis_1[i].dy;
		keypoints1.push_back(keyp);
		keyp.pt.x=feature_dis_2[i].dx;
		keyp.pt.y=feature_dis_2[i].dy;
		keypoints2.push_back(keyp);
	}

	Mat descriptors1(count,FEATURE_ELEMENT_LENGTH, CV_32F);
	Mat descriptors2(count,FEATURE_ELEMENT_LENGTH, CV_32F);
	
	 for (int i=0; i<count; i++)
    {
		for(int j=0;j<FEATURE_ELEMENT_LENGTH;j++)
		{
			descriptors1.at<float>(i,j)=feature_dis_1[i].descriptor[j];
			descriptors2.at<float>(i,j)=feature_dis_2[i].descriptor[j];
		}
		  
    }

	Mat img_match;
	vector<DMatch> matches; 
    descriptor_matcher->match( descriptors1, descriptors2, matches ); 
    Mat img_matches;
	drawMatches(src_1,keypoints1,src_2,keypoints2,matches,img_matches);
	//其实我前面已经完成匹配了，到这里，用openCV自带的方式重新匹配了一遍，并且显示了一下
	imshow("SIFT",img_matches);
	//imwrite("F:\\ylab\\CSDN_image\\3.jpg",img_matches);
	
	Mat p1(feature_dis_1.size(),2,CV_32F);
	Mat p2(feature_dis_1.size(),2,CV_32F);
	for(int i=0;i<feature_dis_1.size();i++)
	{
		p1.at<float>(i,0)=feature_dis_1[i].dx;
		p1.at<float>(i,1)=feature_dis_1[i].dy;
		p2.at<float>(i,0)=feature_dis_2[i].dx;
		p2.at<float>(i,1)=feature_dis_2[i].dy;
	}
	// 用RANSAC方法计算F
    Mat m_Fundamental;
    // 上面这个变量是基本矩阵
    vector<uchar> m_RANSACStatus;
    // 上面这个变量已经定义过，用于存储RANSAC后每个点的状态

	//一开始使用findFundamentalMat函数，发现可以消除错误匹配，实现很好的效果，但是
	//就是函数返回值不是变换矩阵，而是没有什么用的基础矩阵
	m_Fundamental = findFundamentalMat(p1,p2,m_RANSACStatus,CV_FM_RANSAC);
	
	//这里使用findHomography函数，这个函数的返回值才是真正的变换矩阵
	Mat m_homography;
    vector<uchar> m;
    m_homography=findHomography(p1,p2,CV_RANSAC,3,m);                              

	//由变换矩阵，求得变换后的物体边界四个点
    std::vector<Point2f> scene_corners(4);
    perspectiveTransform( obj_corners, scene_corners, m_homography);
    line( src_2, scene_corners[0] , scene_corners[1] , Scalar(0, 0, 255), 2 );
    line( src_2, scene_corners[1] , scene_corners[2] , Scalar(0, 0, 255), 2 );
    line( src_2, scene_corners[2] , scene_corners[3] , Scalar(0, 0, 255), 2 );
    line( src_2, scene_corners[3] , scene_corners[0] , Scalar(0, 0, 255), 2 );
   
    

	int nr=m_Fundamental.rows; // number of rows  
    int nc=m_Fundamental.cols *m_Fundamental.channels(); // total number of elements per line 

	// 计算野点个数
    int OutlinerCount = 0;
    for (int i=0; i<Count; i++)
    {
         if (m_RANSACStatus[i] == 0) // 状态为0表示野点
         {
              OutlinerCount++;
         }
    }
 
    // 计算内点
     vector<Point2f> m_LeftInlier;
	 vector<Point2f> m_RightInlier;
	 vector<DMatch> m_InlierMatches;
	// 上面三个变量用于保存内点和匹配关系
	int ptCount = (int)matches.size();
	int InlinerCount = ptCount - OutlinerCount;
	m_InlierMatches.resize(InlinerCount);
	m_LeftInlier.resize(InlinerCount);
	m_RightInlier.resize(InlinerCount);
	InlinerCount = 0;
	for (int i=0; i<ptCount; i++)
	{
		 if (m_RANSACStatus[i] != 0)
		 {
		       m_LeftInlier[InlinerCount].x = p1.at<float>(i, 0);
		       m_LeftInlier[InlinerCount].y = p1.at<float>(i, 1);
		       m_RightInlier[InlinerCount].x = p2.at<float>(i, 0);
		      m_RightInlier[InlinerCount].y = p2.at<float>(i, 1);
		      m_InlierMatches[InlinerCount].queryIdx = InlinerCount;
		      m_InlierMatches[InlinerCount].trainIdx = InlinerCount;
		      InlinerCount++;
		   }
	}
 //   //printf("最终的匹配点个数为：%d\n",InlinerCount);
	 把内点转换为drawMatches可以使用的格式
	vector<KeyPoint> key1(InlinerCount);
	vector<KeyPoint> key2(InlinerCount);
	KeyPoint::convert(m_LeftInlier, key1);
	KeyPoint::convert(m_RightInlier, key2);
 
	// 显示计算F过后的内点匹配
	//Mat m_matLeftImage;
    //Mat m_matRightImage;
	// 以上两个变量保存的是左右两幅图像
	
	line(src_1,m1,m2,Scalar(0,255,0),2);
	line(src_1,m2,m3,Scalar(0,255,0),2);
	line(src_1,m3,m4,Scalar(0,255,0),2);
	line(src_1,m4,m1,Scalar(0,255,0),2);

	Mat OutImage;
	drawMatches(src_1, key1, src_2, key2, m_InlierMatches, OutImage);	
	imshow("SIFT_RANSAC",OutImage);	
	//imwrite("F:\\ylab\\CSDN_image\\5.jpg",OutImage);
    cvWaitKey( 0 );
	return 0;
}



 

确定有穷自动机
 

2015年7月17日   西安交通大学
 

 


                

        

        

    




    

      

        

            

              
                
                  确定有穷自动机
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    30
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    200
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  35
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
点云配准SIFT+SI+RANSAC+ICP

				
			

			

				

					点云兔子的博客
				

				

					02-20
					
					123
					
				

			

		

		

			
				
Spin Image（SI）是一种用于点云数据描述的特征描述子，广泛应用于三维点云配准、识别和重建等领域。它能够捕捉点云中的局部几何信息，具有旋转不变性和部分平移不变性等优点，是一种非常强大的特征描述子。Spin Image是一种强大的点云特征描述子，具有旋转不变性、局部几何信息捕捉等优点，适用于点云配准、目标识别和三维重建等多个领域。通过合理选择局部区域、建立参考框架和计算描述子，可以充分利用Spin Image描述点云的特征，从而实现各种三维场景分析和处理任务。

			
		

	



                

              
                



	

		

			

				
					
利用OpenCV(2.4.13)的SURF/SIFT + RANSAC + 加权融合实现图像拼接(vs17)

				
			

			

				

					10-16
				

			

		

		

			
				
利用OpenCV-2.4.13和vs2017实现SURF/SIFT + RANSAC + 线性加权融合来实现图像的左右拼接，上下也可以拼接，改一下adjustMat就可以(代码中是x偏移量，你换成y的偏移量，把值换成rows就好，同时在计算透视变换的时候Size参数改为(image02.cols, image02.rows  + image01.rows))，代码均有注释，同时将每一步结构都显示出来了，附有示例图片，直接就可以运行。

			
		

	



                


  
              

                


	

		

			

				
					
相机标定（张正友标定算法）解读与实战二

				
			

			

				

					@way
				

				

					12-10
					
					917
					
				

			

		

		

			
				
上一篇介绍了相机模型和畸变模型，有了这个基础就可以对相机标定进行讲解了。
张正友标定法，其实就是拍摄10几张不同姿态的棋盘格，就可以估算出相机的内参和棋盘格的姿态。利用了针孔相机模型和棋盘格三维平面的世界坐标与棋盘格图像的坐标之间的透视关系（单应性）进行计算的。
具体推导过程：
有2D点m 和 3D点M
m=[uv]M=[XYZ]
	m = \left[\begin{matrix} u \\ v \end{matrix}\right] M= \left[\begin{matrix} X \\ Y \\ Z 

			
		

	





	

		

			

				
					
计算机视觉之OpenCV求解基础矩阵（Fundamental）函数说明

				
			

			

				

					sunshine
				

				

					03-03
					
					7867
					
				

			

		

		

			
				
计算机视觉之OPENCV求解本质矩阵（Fundamental）函数说明
从两张图像的对应点计算本质矩阵
CV_EXPORTS_W Mat findFundamentalMat( InputArray points1, InputArray points2,
                                     int method = FM_RANSAC,
          ...

			
		

	



		

			
		



	

		

			

				
					
Python实现替换照片人物背景，精细到头发丝（附代码）

				
			

			

				

					Python数据之道
				

				

					07-10
					
					183
					
				

			

		

		

			
				
来源丨网络前言本文的github仓库地址为:https://github.com/Hy-1990/hy_bgmatting由于模型文件过大，没放在仓库中，本文下面有模型下载地址。项目说明项目结构我们先看一下项目的结构，如图：其中，model文件夹放的是模型文件，模型文件的下载地址为：https://drive.google.com/drive/folders/1NmyT...

			
		

	





	

		

			

				
					
基础矩阵与对极几何

				
			

			

				

					weixin_42646763的博客
				

				

					04-21
					
					283
					
				

			

		

		

			
				
基础矩阵与对极几何
估算基础矩阵
步骤：
导入两幅图像，并使用sift算法提取特征；
使用函数match_twosided连接两幅图的特征；
RANSAC去除错误点匹配；
归一化8点算法估计基础矩阵。这是通过对应点来计算基础矩阵的算法。
代码
# -*- coding: utf-8 -*-
from PIL import Image
from numpy import *
from pylab i...

			
		

	





	

		

			

				
					
findHomography()函数详解

					
热门推荐

				
			

			

				

					fengyeer20120的博客
				

				

					02-20
					
					8万+
					
				

			

		

		

			
				
findHomography： 计算多个二维点对之间的最优单映射变换矩阵 H（3行x3列） ，使用最小均方误差或者RANSAC方法

函数功能：找到两个平面之间的转换矩阵。


Mat cv::findHomography	(	InputArray 	srcPoints,
                                InputArray 	dstPoints,
        ...

			
		

	





	

		

			

				
					
使用OpenCV进行摄像机标定

				
			

			

				

					Lixam的专栏
				

				

					07-27
					
					2万+
					
				

			

		

		

			
				
Cv照相机定标和三维重建









目录
 [隐藏]

1 针孔相机模型和变形2 照相机定标

2.1 ProjectPoints22.2 FindHomography2.3 CalibrateCamera22.4 FindExtrinsicCameraParams22.5 Rodrigues22.6 Undistort22.7 InitUndistortMa

			
		

	





	

		

			

				
					
FindFundamentalMat(python)函数解析——三维视觉

				
			

			

				

					bb_sy_w的博客
				

				

					11-01
					
					8643
					
				

			

		

		

			
				
最近在入门三维视觉，在SFM算法的代码中看到了这个函数，没有找到满意的帖子，所以打算自己总结一下。
原理层面
什么是FundamentalMatrix？
基础矩阵（Fundamental Matrix，F）表达点到直线的关系。在对极几何中，就是左视图上一点x1到右视图上极线L2的关系，如下公式： L2=Fx1
根据对极几何原理，左视图上一点x1*在右视图上的匹配点 x2 一定在极线L2上，也就是：x2TL2= x2TFx1=0
给定一组匹配好的特征点集 x1和 x2 ，计算其基础矩阵过程包括以下四步：

坐

			
		

	





	

		

			

				
					
Opencv图像查找findHomography（python实现）

				
			

			

				

					Keep_Trying_Go的博客
				

				

					06-21
					
					5184
					
				

			

		

		

			
				
Opencv图像查找findHomography（python实现）

			
		

	





	

		

			

				
					
初始化解读

				
			

			

				

					qq_43066407的博客
				

				

					09-08
					
					450
					
				

			

		

		

			
				
VINS初始化
初始化代码说明
estimator.cpp
步骤一：estimator.processImage(image, img_msg->header)
说

			
		

	





	

		

			

				
					
Python和OpenCV 中基于SIFT、单应性、KNN和Ransac的 简单图像拼接算法

				
			

			

				

					06-07
				

			

		

		

			
				
我们使用尺度不变特征变换（SIFT）来提取输入图像的局部特征，使用K个最近邻算法来匹配这些特征，并使用随机样本一致性（Ransac）来计算单应矩阵，该矩阵将用于图像变形。最后，我们应用加权矩阵作为图像混合的掩码...

			
		

	





	

		

			

				
					
Image-Stitching-OpenCV:在Python和OpenCV中基于SIFT，单应性，KNN和Ransac的简单图像拼接算法

				
			

			

				

					05-25
				

			

		

		

			
				
 我们使用尺度不变特征变换（SIFT）来提取输入图像的局部特征，使用K最近邻算法来匹配这些特征，并使用随机样本共识（Ransac）计算单应图矩阵，该矩阵将用于图像变形。 最后，我们将加权矩阵用作图像融合的遮罩。...

			
		

	





	

		

			

				
					
基于python和opencv实现图像拼接并计算PSNR项目源码+项目使用说明.zip

				
			

			

				

					07-24
				

			

		

		

			
				
基于python和opencv实现图像拼接并计算PSNR项目源码+项目使用说明.zip 该项目是个人毕设项目，答辩评审分达到95分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。 该资源主要针对计算机...

			
		

	





	

		

			

				
					
基于SIFT算法的特征提取(VS2015+OpenCV2.4.13)

				
			

			

				

					12-18
				

			

		

		

			
				
基于SIFT算法的特征提取(VS2015+OpenCV2.4.13) 主要分为以下几个步骤：  (1) 读入两张图片并分别提取SIFT特征  (2) 利用k-d tree和BBF算法进行特征匹配查找 ...(3) 利用RANSAC算法筛选匹配点并计算变换矩阵

			
		

	





	

		

			

				
					
满意度调查行·知dr.pptx

				
			

			

				

					04-25
				

			

		

		

			
				
满意度调查行·知dr.pptx

			
		

	





	

		

			

				
					
基于B2C的网上拍卖系统_秒杀与竞价.zip

				
			

			

				

					04-25
				

			

		

		

			
				
基于B2C的网上拍卖系统主要用于帮助人们应用互联网方便快捷买到自己所中意的商品，并参与到秒杀与竞拍当中。
主要功能包括：
 1.前台模块
 （1）普通用户登录/注册。
（2）分类查看商品(普通商品与促销商品)
（3）查看商品详细信息 
（4）查看秒杀商品
 （5）查看竞拍商品   
（6）将商品加入购物车
 （7)购买，结算功能  （8）留言
 2.后台模块
 （1）修改密码    
  (2)商品管理:
     -- 编辑/删除
     -- 设置/取消促销
 （3)秒杀商品：设置/取消秒杀
 （4)竞拍商品：设置/取消竞拍
 （5)订单管理：查看订单
 （5)留言管理：查看/删除留言

项目访问路径:
前台：http://localhost:8080/sale
后台：http://localhost:8080/sale/user/adminlogin

			
		

	





	

		

			

				
					
分布式系统中Java后端开发技术及其应用实践.pdf

					
最新发布

				
			

			

				

					04-25
				

			

		

		

			
				
分布式系统的核心思想是复杂计算任务的拆分与并行计算，可有效减少计算时间、节约算力成本。以分布式系统中Java后端开发技术的应用为主题，分析分布式系统开发的需求，探讨Java技术栈、分布式监控与日志管理、云服务模型在分布式系统Java后端开发中的应用路径，旨在为分布式系统的设计与实现提供全面的理论分析和实践指导，以支持构建高效、稳定、可扩展的企业级Java应用。
随着云计算、大数据和人工智能技术的飞速发展，
分布式系统已成为支撑现代企业信息系统的基础架构。
Java 后端开发技术在构建分布式系统中扮演着至关重要的
角色，其应用价值和研究重点主要集中在微服务架构、容
器化技术、自动化部署、服务网格、无服务器计算、应用
程序编程接口（Application Programming Interface，
API）管理、数据一致性解决方案、分布式缓存、负载均衡、
复杂事件处理和分布式事务管理等方面[1]。Java平台以
其成熟的生态系统、跨平台的移植性、丰富的开源框架
和库以及稳定的性能，为分布式系统的开发提供了坚实
的基础[2]。深入探讨Java后端开发技术在分布式系统中
的应用实践，旨在为企

			
		

	





	

		

			

				
					
【微信小程序毕业设计】书店系统开发项目(源码+演示视频+说明).rar

				
			

			

				

					04-25
				

			

		

		

			
				
【微信小程序毕业设计】书店系统开发项目(源码+演示视频+说明).rar
【项目技术】
微信小程序开发工具+java后端+mysql

【演示视频-编号：246】
https://pan.quark.cn/s/cb634e7c02b5

【实现功能】
用户信息管理，图书信息管理，图书类型管理，图书留言管理，论坛信息管理等

			
		

	





	

		

			

				
					
请自行实现RANSAC算法和image warping算法，不能使用OpenCV库函数

				
			

			

				

					06-12
				

			

		

		

			
				
好的，下面是自行实现RANSAC算法和image warping算法的代码：

```python
import cv2
import numpy as np

# 图片路径
img_paths = ['img1.jpg', 'img2.jpg', 'img3.jpg']

# 读取图片
imgs = [cv2.imread(path) for path in img_paths]

# 定义SIFT特征点检测器
sift = cv2.xfeatures2d.SIFT_create()

# 定义匹配器
bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True)

# 匹配点对数量阈值
MIN_MATCH_COUNT = 10

# RANSAC算法参数
RANSAC_THRESH = 5
RANSAC_MAX_ITER = 2000
RANSAC_INLIERS_RATIO = 0.5

# 图像拼接参数
OFFSET = 500

# 循环处理每张非基准图像
for i in range(1, len(imgs)):
    # 特征点检测和匹配
    kp1, des1 = sift.detectAndCompute(imgs[i-1], None)
    kp2, des2 = sift.detectAndCompute(imgs[i], None)
    matches = bf.match(des1, des2)
    
    # 筛选匹配点对
    if len(matches) < MIN_MATCH_COUNT:
        continue
    
    # 将匹配点对转换为数组形式
    pts1 = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 2)
    pts2 = np.float32([kp2[m.trainIdx].pt for m in matches]).reshape(-1, 2)
    
    # RANSAC算法
    best_M = None
    best_inliers = -1
    for j in range(RANSAC_MAX_ITER):
        # 随机采样得到4个点
        indices = np.random.randint(0, len(matches), 4)
        src_pts = pts1[indices]
        dst_pts = pts2[indices]
        
        # 求解变换矩阵
        M = cv2.getPerspectiveTransform(src_pts, dst_pts)
        
        # 计算变换后的点
        dst_pts_transformed = cv2.perspectiveTransform(pts1.reshape(-1, 1, 2), M).reshape(-1, 2)
        
        # 计算误差
        errors = np.linalg.norm(pts2 - dst_pts_transformed, axis=1)
        
        # 统计内点数
        inliers = np.sum(errors < RANSAC_THRESH)
        
        # 更新最优解
        if inliers > best_inliers:
            best_M = M
            best_inliers = inliers
        
        # 判断是否达到终止条件
        if inliers / len(matches) > RANSAC_INLIERS_RATIO:
            break
    
    # 图像配准和image warping
    h1, w1 = imgs[i-1].shape[:2]
    h2, w2 = imgs[i].shape[:2]
    corners1 = np.float32([[0, 0], [0, h1], [w1, h1], [w1, 0]]).reshape(-1, 1, 2)
    corners2 = np.float32([[0, 0], [0, h2], [w2, h2], [w2, 0]]).reshape(-1, 1, 2)
    corners2_transformed = cv2.perspectiveTransform(corners2, best_M)
    corners = np.concatenate((corners1, corners2_transformed), axis=0)
    [xmin, ymin] = np.int32(corners.min(axis=0).ravel() - OFFSET)
    [xmax, ymax] = np.int32(corners.max(axis=0).ravel() + OFFSET)
    t = [-xmin, -ymin]
    Ht = np.array([[1, 0, t[0]], [0, 1, t[1]], [0, 0, 1]])
    img1_transformed = cv2.warpPerspective(imgs[i-1], Ht.dot(best_M), (xmax-xmin, ymax-ymin))
    img2_transformed = cv2.warpPerspective(imgs[i], Ht, (xmax-xmin, ymax-ymin))
    
    # 图像拼接
    img1_transformed[t[1]:h1+t[1], t[0]:w1+t[0]] = imgs[i-1]
    img2_transformed[t[1]:h2+t[1], t[0]:w2+t[0]] = imgs[i]
    base_img = np.zeros((ymax-ymin, xmax-xmin, 3), np.uint8)
    base_img[t[1]:h1+t[1], t[0]:w1+t[0]] = imgs[i-1]
    for j in range(t[1], h2+t[1]):
        for k in range(t[0], w2+t[0]):
            if np.sum(img2_transformed[j, k]) > 0:
                base_img[j, k] = img2_transformed[j, k]

# 保存拼接后的图像
cv2.imwrite('result.jpg', base_img)
```

需要注意的是，上述代码实现中的RANSAC算法和image warping算法是根据论文和算法描述实现的，可能与OpenCV库函数的实现略有不同。其中，RANSAC算法使用的是随机采样一致性算法（Random Sample Consensus, RANSAC），而image warping算法使用的是透视变换（Perspective Transformation）。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 35

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值