ORB-SLAM2算法12之单目初始化Initializer

0 引言

ORB-SLAM2算法7详细了解了System主类和多线程、ORB-SLAM2学习笔记8详细了解了图像特征点提取和描述子的生成、ORB-SLAM2算法9详细了解了图像帧、ORB-SLAM2算法10详细了解了图像关键帧及ORB-SLAM2算法11详细了解了地图点，本文主要学习ORB-SLAM2中的单目初始化Initializer类。

本文用到了2D-2D对极约束，并涉及到基本矩阵、本质矩阵和单应矩阵的定义，及如何从本质矩阵或单应矩阵恢复相机运动的位姿R，t，比如八点法、奇异值分解SVD等数学原理。详细参考如下：

👉 2D-2D对极约束中的基本矩阵、本质矩阵和单应矩阵

1 单目初始化Initializer

1.1 构造函数

Initializer类的构造函数主要用于初始化成员变量和参数设置。

构造函数接受三个参数：

• const Frame &ReferenceFrame：参考帧。它是一个Frame类的对象，包含了参考帧的相关信息，如图像、相机内参等。通过参考帧的相机内参，构造函数将其克隆为成员变量mK，以便在后续的初始化过程中使用。

• float sigma：描述子距离阈值。在特征点匹配阶段，如果两个特征点的描述子之间的汉明距离小于阈值sigma，则认为它们是匹配的特征点。

• int iterations：RANSAC迭代的次数。在运动估计阶段，为了估计相机的初始位姿和三维点云，使用了RANSAC算法。iterations参数指定了RANSAC算法的迭代次数。

// 根据参考帧构造初始化器Initializer::Initializer(const Frame &ReferenceFrame, float sigma, int iterations)
{//从参考帧中获取相机的内参数矩阵mK = ReferenceFrame.mK.clone();// 从参考帧中获取去畸变后的特征点mvKeys1 = ReferenceFrame.mvKeysUn;//获取估计误差mSigma = sigma;mSigma2 = sigma*sigma;//最大迭代次数mMaxIterations = iterations;
}

1.2 成员函数

Initializer类中主要的成员函数一览表：

成员函数	类型	定义
bool Initializer::Initialize(const Frame &CurrentFrame, const vector<int> &vMatches12, cv::Mat &R21, cv::Mat &t21,vector<cv::Point3f> &vP3D, vector<bool> &vbTriangulated)	public	计算基础矩阵和单应性矩阵，选取最佳的来恢复出最开始两帧之间的相对姿态，并进行三角化得到初始地图点
void Initializer::FindHomography(vector<bool> &vbMatchesInliers, float &score, cv::Mat &H21)	public	计算单应矩阵，假设场景为平面情况下通过前两帧求取Homography矩阵，并得到该模型的评分
void Initializer::FindFundamental(vector<bool> &vbMatchesInliers, float &score, cv::Mat &F21)	public	计算基础矩阵，假设场景为非平面情况下通过前两帧求取Fundamental矩阵，得到该模型的评分
cv::Mat Initializer::ComputeH21(const vector<cv::Point2f> &vP1, const vector<cv::Point2f> &vP2)	public	用DLT方法求解单应矩阵H
cv::Mat Initializer::ComputeF21(const vector<cv::Point2f> &vP1, const vector<cv::Point2f> &vP2)	public	根据特征点匹配求fundamental matrix（normalized 8点法）
float Initializer::CheckHomography(const cv::Mat &H21, const cv::Mat &H12, vector<bool> &vbMatchesInliers, float sigma)	public	对给定的homography matrix打分,需要使用到卡方检验的知识
float Initializer::CheckFundamental(const cv::Mat &F21, vector<bool> &vbMatchesInliers, float sigma)	public	对给定的Fundamental matrix打分,需要使用到卡方检验的知识
bool Initializer::ReconstructF(vector<bool> &vbMatchesInliers, cv::Mat &F21, cv::Mat &K,cv::Mat &R21, cv::Mat &t21, vector<cv::Point3f> &vP3D, vector<bool> &vbTriangulated, float minParallax, int minTriangulated)	public	从基础矩阵F中求解位姿R，t及三维点
bool Initializer::ReconstructH(vector<bool> &vbMatchesInliers, cv::Mat &H21, cv::Mat &K,cv::Mat &R21, cv::Mat &t21, vector<cv::Point3f> &vP3D, vector<bool> &vbTriangulated, float minParallax, int minTriangulated)	public	用单应矩阵H矩阵恢复R, t和三维点
void Initializer::Triangulate(const cv::KeyPoint &kp1, const cv::KeyPoint &kp2, const cv::Mat &P1, const cv::Mat &P2, cv::Mat &x3D)	public	给定投影矩阵P1,P2和图像上的匹配特征点点kp1,kp2，从而计算三维点坐标
void Initializer::Normalize(const vector<cv::KeyPoint> &vKeys, vector<cv::Point2f> &vNormalizedPoints, cv::Mat &T)	public	归一化特征点到同一尺度，作为后续normalize DLT的输入
int Initializer::CheckRT(const cv::Mat &R, const cv::Mat &t, const vector<cv::KeyPoint> &vKeys1, const vector<cv::KeyPoint> &vKeys2,const vector<Match> &vMatches12, vector<bool> &vbMatchesInliers,const cv::Mat &K, vector<cv::Point3f> &vP3D, float th2, vector<bool> &vbGood, float &parallax)	public	用位姿来对特征匹配点三角化，从中筛选中合格的三维点
void Initializer::DecomposeE(const cv::Mat &E, cv::Mat &R1, cv::Mat &R2, cv::Mat &t)	public	分解本质矩阵Essential得到R,t

1.2.1 Initialize

Initialize初始化主要用到了如下的成员函数，它们的关系如下图：

该函数包含了单目初始化类的所有流程，主要步骤如下：

1. 重新记录特征点对的匹配关系；
2. 在所有匹配特征点对中随机选择8对匹配特征点为一组，用于估计H矩阵和F矩阵；
3. 计算fundamental 矩阵和homography 矩阵，为了加速分别开了线程计算；
4. 计算得分比例来判断选取哪个模型来求位姿R,t，并对匹配的特征点进行三角化。

输入参数：

• CurrentFrame：当前帧
• vMatches12：参考帧(1)与当前帧(2)图像中特征点的匹配关系
• R21：相机从参考帧到当前帧的旋转
• t21：相机从参考帧到当前帧的平移
• vP3D：三角化测量之后的三维地图点
• vbTriangulated：标记三角化点是否有效，有效为true

输出参数：

• true：该帧可以成功初始化，返回true
• false：该帧不满足初始化条件，返回false

// 计算基础矩阵和单应矩阵，选取最佳的来恢复出最开始两帧之间的相对姿态，并进行三角化得到初始地图点bool Initializer::Initialize(const Frame &CurrentFrame, const vector<int> &vMatches12, cv::Mat &R21, cv::Mat &t21,vector<cv::Point3f> &vP3D, vector<bool> &vbTriangulated)
{// Fill structures with current keypoints and matches with reference frame// Reference Frame: 1, Current Frame: 2//获取当前帧的去畸变之后的特征点mvKeys2 = CurrentFrame.mvKeysUn;// mvMatches12记录匹配上的特征点对，记录的是帧2在帧1的匹配索引mvMatches12.clear();// 预分配空间，大小和关键点数目一致mvKeys2.size()mvMatches12.reserve(mvKeys2.size());// 记录参考帧1中的每个特征点是否有匹配的特征点// 这个成员变量后面没有用到，后面只关心匹配上的特征点 	mvbMatched1.resize(mvKeys1.size());// Step 1 重新记录特征点对的匹配关系存储在mvMatches12，是否有匹配存储在mvbMatched1// 将vMatches12（有冗余） 转化为 mvMatches12（只记录了匹配关系）for(size_t i=0, iend=vMatches12.size();i<iend; i++){//vMatches12[i]解释：i表示帧1中关键点的索引值，vMatches12[i]的值为帧2的关键点索引值//没有匹配关系的话，vMatches12[i]值为 -1if(vMatches12[i]>=0){//mvMatches12 中只记录有匹配关系的特征点对的索引值//i表示帧1中关键点的索引值，vMatches12[i]的值为帧2的关键点索引值mvMatches12.push_back(make_pair(i,vMatches12[i]));//标记参考帧1中的这个特征点有匹配关系mvbMatched1[i]=true;}else//标记参考帧1中的这个特征点没有匹配关系mvbMatched1[i]=false;}// 有匹配的特征点的对数const int N = mvMatches12.size();// Indices for minimum set selection// 新建一个容器vAllIndices存储特征点索引，并预分配空间vector<size_t> vAllIndices;vAllIndices.reserve(N);//在RANSAC的某次迭代中，还可以被抽取来作为数据样本的特征点对的索引，所以这里起的名字叫做可用的索引vector<size_t> vAvailableIndices;//初始化所有特征点对的索引，索引值0到N-1for(int i=0; i<N; i++){vAllIndices.push_back(i);}// Generate sets of 8 points for each RANSAC iteration// Step 2 在所有匹配特征点对中随机选择8对匹配特征点为一组，用于估计H矩阵和F矩阵// 共选择 mMaxIterations (默认200) 组//mvSets用于保存每次迭代时所使用的向量mvSets = vector< vector<size_t> >(mMaxIterations,		//最大的RANSAC迭代次数vector<size_t>(8,0));	//这个则是第二维元素的初始值，也就是第一维。这里其实也是一个第一维的构造函数，第一维vector有8项，每项的初始值为0.//用于进行随机数据样本采样，设置随机数种子DUtils::Random::SeedRandOnce(0);//开始每一次的迭代 for(int it=0; it<mMaxIterations; it++){//迭代开始的时候，所有的点都是可用的vAvailableIndices = vAllIndices;// Select a minimum set//选择最小的数据样本集，使用八点法求，所以这里就循环了八次for(size_t j=0; j<8; j++){// 随机产生一对点的id,范围从0到N-1int randi = DUtils::Random::RandomInt(0,vAvailableIndices.size()-1);// idx表示哪一个索引对应的特征点对被选中int idx = vAvailableIndices[randi];//将本次迭代这个选中的第j个特征点对的索引添加到mvSets中mvSets[it][j] = idx;// 由于这对点在本次迭代中已经被使用了,所以我们为了避免再次抽到这个点,就在"点的可选列表"中,// 将这个点原来所在的位置用vector最后一个元素的信息覆盖,并且删除尾部的元素// 这样就相当于将这个点的信息从"点的可用列表"中直接删除了vAvailableIndices[randi] = vAvailableIndices.back();vAvailableIndices.pop_back();}//依次提取出8个特征点对}//迭代mMaxIterations次，选取各自迭代时需要用到的最小数据集// Launch threads to compute in parallel a fundamental matrix and a homography// Step 3 计算fundamental 矩阵 和homography 矩阵，为了加速分别开了线程计算 //这两个变量用于标记在H和F的计算中哪些特征点对被认为是Inliervector<bool> vbMatchesInliersH, vbMatchesInliersF;//计算出来的单应矩阵和基础矩阵的RANSAC评分，这里其实是采用重投影误差来计算的float SH, SF; //score for H and F//这两个是经过RANSAC算法后计算出来的单应矩阵和基础矩阵cv::Mat H, F; // 构造线程来计算H矩阵及其得分// thread方法比较特殊，在传递引用的时候，外层需要用ref来进行引用传递，否则就是浅拷贝thread threadH(&Initializer::FindHomography,	//该线程的主函数this,							//由于主函数为类的成员函数，所以第一个参数就应该是当前对象的this指针ref(vbMatchesInliersH), 			//输出，特征点对的Inlier标记ref(SH), 						//输出，计算的单应矩阵的RANSAC评分ref(H));							//输出，计算的单应矩阵结果// 计算fundamental matrix并打分，参数定义和H是一样的，这里不再赘述thread threadF(&Initializer::FindFundamental,this,ref(vbMatchesInliersF), ref(SF), ref(F));// Wait until both threads have finished//等待两个计算线程结束threadH.join();threadF.join();// Compute ratio of scores// Step 4 计算得分比例来判断选取哪个模型来求位姿R,t//通过这个规则来判断谁的评分占比更多一些，注意不是简单的比较绝对评分大小，而是看评分的占比float RH = SH/(SH+SF);			//RH=Ratio of Homography// Try to reconstruct from homography or fundamental depending on the ratio (0.40-0.45)// 注意这里更倾向于用H矩阵恢复位姿。如果单应矩阵的评分占比达到了0.4以上,则从单应矩阵恢复运动,否则从基础矩阵恢复运动if(RH>0.40)//更偏向于平面，此时从单应矩阵恢复，函数ReconstructH返回bool型结果return ReconstructH(vbMatchesInliersH,	//输入，匹配成功的特征点对Inliers标记H,					//输入，前面RANSAC计算后的单应矩阵mK,					//输入，相机的内参数矩阵R21,t21,			//输出，计算出来的相机从参考帧1到当前帧2所发生的旋转和位移变换vP3D,				//特征点对经过三角测量之后的空间坐标，也就是地图点vbTriangulated,		//特征点对是否成功三角化的标记1.0,				//这个对应的形参为minParallax，即认为某对特征点的三角化测量中，认为其测量有效时//需要满足的最小视差角（如果视差角过小则会引起非常大的观测误差）,单位是角度50);				//为了进行运动恢复，所需要的最少的三角化测量成功的点个数else //if(pF_HF>0.6)// 更偏向于非平面，从基础矩阵恢复return ReconstructF(vbMatchesInliersF,F,mK,R21,t21,vP3D,vbTriangulated,1.0,50);//一般地程序不应该执行到这里，如果执行到这里说明程序跑飞了return false;
}

1.2.2 FindHomography

FindHomography主要用到了如下的成员函数，它们的关系如下图：

该成员函数主要计算单应矩阵：

1. 将当前帧和参考帧中的特征点坐标进行归一化；
2. 选择8个归一化后的点对进行迭代；
3. 八点法计算单应矩阵；
4. 利用重投影误差为当次RANSAC的结果评分；
5. 更新具有最优评分的单应矩阵计算结果，并且保存所对应的特征点的内点标记。

// 计算单应矩阵，假设场景为平面情况下通过前两帧求取Homography矩阵，并得到该模型的评分void Initializer::FindHomography(vector<bool> &vbMatchesInliers, float &score, cv::Mat &H21)
{// Number of putative matches//匹配的特征点对总数const int N = mvMatches12.size();// Normalize coordinates// Step 1 将当前帧和参考帧中的特征点坐标进行归一化，主要是平移和尺度变换// 具体来说,就是将mvKeys1和mvKey2归一化到均值为0，一阶绝对矩为1，归一化矩阵分别为T1、T2// 这里所谓的一阶绝对矩其实就是随机变量到取值的中心的绝对值的平均值// 归一化矩阵就是把上述归一化的操作用矩阵来表示。这样特征点坐标乘归一化矩阵可以得到归一化后的坐标//归一化后的参考帧1和当前帧2中的特征点坐标vector<cv::Point2f> vPn1, vPn2;// 记录各自的归一化矩阵cv::Mat T1, T2;Normalize(mvKeys1,vPn1, T1);Normalize(mvKeys2,vPn2, T2);//这里求的逆在后面的代码中要用到，辅助进行原始尺度的恢复cv::Mat T2inv = T2.inv();// Best Results variables// 记录最佳评分score = 0.0;// 取得历史最佳评分时,特征点对的inliers标记vbMatchesInliers = vector<bool>(N,false);// Iteration variables//某次迭代中，参考帧的特征点坐标vector<cv::Point2f> vPn1i(8);//某次迭代中，当前帧的特征点坐标vector<cv::Point2f> vPn2i(8);//以及计算出来的单应矩阵、及其逆矩阵cv::Mat H21i, H12i;// 每次RANSAC记录Inliers与得分vector<bool> vbCurrentInliers(N,false);float currentScore;// Perform all RANSAC iterations and save the solution with highest score//下面进行每次的RANSAC迭代for(int it=0; it<mMaxIterations; it++){// Select a minimum set// Step 2 选择8个归一化之后的点对进行迭代for(size_t j=0; j<8; j++){//从mvSets中获取当前次迭代的某个特征点对的索引信息int idx = mvSets[it][j];// vPn1i和vPn2i为匹配的特征点对的归一化后的坐标// 首先根据这个特征点对的索引信息分别找到两个特征点在各自图像特征点向量中的索引，然后读取其归一化之后的特征点坐标vPn1i[j] = vPn1[mvMatches12[idx].first];    //first存储在参考帧1中的特征点索引vPn2i[j] = vPn2[mvMatches12[idx].second];   //second存储在参考帧1中的特征点索引}//读取8对特征点的归一化之后的坐标// Step 3 八点法计算单应矩阵// 利用生成的8个归一化特征点对, 调用函数 Initializer::ComputeH21() 使用八点法计算单应矩阵  // 关于为什么计算之前要对特征点进行归一化，后面又恢复这个矩阵的尺度？// 可以在《计算机视觉中的多视图几何》这本书中P193页中找到答案// 书中这里说,8点算法成功的关键是在构造解的方称之前应对输入的数据认真进行适当的归一化cv::Mat Hn = ComputeH21(vPn1i,vPn2i);// 单应矩阵原理：X2=H21*X1，其中X1,X2 为归一化后的特征点    // 特征点归一化：vPn1 = T1 * mvKeys1, vPn2 = T2 * mvKeys2  得到:T2 * mvKeys2 =  Hn * T1 * mvKeys1   // 进一步得到:mvKeys2  = T2.inv * Hn * T1 * mvKeys1H21i = T2inv*Hn*T1;//然后计算逆H12i = H21i.inv();// Step 4 利用重投影误差为当次RANSAC的结果评分currentScore = CheckHomography(H21i, H12i, 			//输入，单应矩阵的计算结果vbCurrentInliers, 	//输出，特征点对的Inliers标记mSigma);				//TODO  测量误差，在Initializer类对象构造的时候，由外部给定的// Step 5 更新具有最优评分的单应矩阵计算结果,并且保存所对应的特征点对的内点标记if(currentScore>score){//如果当前的结果得分更高，那么就更新最优计算结果H21 = H21i.clone();//保存匹配好的特征点对的Inliers标记vbMatchesInliers = vbCurrentInliers;//更新历史最优评分score = currentScore;}}
}

1.2.3 FindFundamental

FindFundamental主要用到了如下的成员函数，它们的关系如下图：

该成员函数主要计算单应矩阵：

1. 将当前帧和参考帧中的特征点坐标进行归一化；
2. 选择8个归一化之后的点对进行迭代；
3. 八点法计算基础矩阵；
4. 利用重投影误差为当次RANSAC的结果评分；
5. 更新具有最优评分的基础矩阵计算结果,并且保存所对应的特征点对的内点标记。

// 计算基础矩阵，假设场景为非平面情况下通过前两帧求取Fundamental矩阵，得到该模型的评分void Initializer::FindFundamental(vector<bool> &vbMatchesInliers, float &score, cv::Mat &F21)
{// 计算基础矩阵,其过程和上面的计算单应矩阵的过程十分相似.// Number of putative matches// 匹配的特征点对总数// const int N = vbMatchesInliers.size();  // !源代码出错！请使用下面代替const int N = mvMatches12.size();// Normalize coordinates// Step 1 将当前帧和参考帧中的特征点坐标进行归一化，主要是平移和尺度变换// 具体来说,就是将mvKeys1和mvKey2归一化到均值为0，一阶绝对矩为1，归一化矩阵分别为T1、T2// 这里所谓的一阶绝对矩其实就是随机变量到取值的中心的绝对值的平均值// 归一化矩阵就是把上述归一化的操作用矩阵来表示。这样特征点坐标乘归一化矩阵可以得到归一化后的坐标vector<cv::Point2f> vPn1, vPn2;cv::Mat T1, T2;Normalize(mvKeys1,vPn1, T1);Normalize(mvKeys2,vPn2, T2);// ! 注意这里取的是归一化矩阵T2的转置,因为基础矩阵的定义和单应矩阵不同，两者去归一化的计算也不相同cv::Mat T2t = T2.t();// Best Results variables//最优结果score = 0.0;vbMatchesInliers = vector<bool>(N,false);// Iteration variables// 某次迭代中，参考帧的特征点坐标vector<cv::Point2f> vPn1i(8);// 某次迭代中，当前帧的特征点坐标vector<cv::Point2f> vPn2i(8);// 某次迭代中，计算的基础矩阵cv::Mat F21i;// 每次RANSAC记录的Inliers与得分vector<bool> vbCurrentInliers(N,false);float currentScore;// Perform all RANSAC iterations and save the solution with highest score// 下面进行每次的RANSAC迭代for(int it=0; it<mMaxIterations; it++){// Select a minimum set// Step 2 选择8个归一化之后的点对进行迭代for(int j=0; j<8; j++){int idx = mvSets[it][j];// vPn1i和vPn2i为匹配的特征点对的归一化后的坐标// 首先根据这个特征点对的索引信息分别找到两个特征点在各自图像特征点向量中的索引，然后读取其归一化之后的特征点坐标vPn1i[j] = vPn1[mvMatches12[idx].first];        //first存储在参考帧1中的特征点索引vPn2i[j] = vPn2[mvMatches12[idx].second];       //second存储在参考帧1中的特征点索引}// Step 3 八点法计算基础矩阵cv::Mat Fn = ComputeF21(vPn1i,vPn2i);// 基础矩阵约束：p2^t*F21*p1 = 0，其中p1,p2 为齐次化特征点坐标    // 特征点归一化：vPn1 = T1 * mvKeys1, vPn2 = T2 * mvKeys2  // 根据基础矩阵约束得到:(T2 * mvKeys2)^t* Hn * T1 * mvKeys1 = 0   // 进一步得到:mvKeys2^t * T2^t * Hn * T1 * mvKeys1 = 0F21i = T2t*Fn*T1;// Step 4 利用重投影误差为当次RANSAC的结果评分currentScore = CheckFundamental(F21i, vbCurrentInliers, mSigma);// Step 5 更新具有最优评分的基础矩阵计算结果,并且保存所对应的特征点对的内点标记if(currentScore>score){//如果当前的结果得分更高，那么就更新最优计算结果F21 = F21i.clone();vbMatchesInliers = vbCurrentInliers;score = currentScore;}}
}

1.2.4 ReconstructH

ReconstructH主要用到了如下的成员函数，它们的关系如下图：

该成员函数主要用单应矩阵恢复R，t和三维点，常见的两种方法分别是Faugeras SVD-based decomposition 和 Zhang SVD-based decomposition，ORB-SLAM2中使用了前者，直接调用的OpenCV库中的SVD函数。

输入/输出参数：

• vbMatchesInliers：匹配点对的内点标记
• H21：从参考帧到当前帧的单应矩阵
• K：相机的内参数矩阵
• R21：计算出来的相机旋转
• t21：计算出来的相机平移
• vP3D：世界坐标系下，三角化测量特征点对之后得到的特征点的空间坐标
• vbTriangulated：特征点是否成功三角化的标记
• minParallax：对特征点的三角化测量中，认为其测量有效时需要满足的最小视差角（如果视差角过小则会引起非常大的观测误差）,单位是角度
• minTriangulated：为了进行运动恢复，所需要的最少的三角化测量成功的点个数

返回值：

• true：单应矩阵成功计算出位姿和三维点
• false：初始化失败

// 用单应矩阵H矩阵恢复R, t和三维点bool Initializer::ReconstructH(vector<bool> &vbMatchesInliers, cv::Mat &H21, cv::Mat &K,cv::Mat &R21, cv::Mat &t21, vector<cv::Point3f> &vP3D, vector<bool> &vbTriangulated, float minParallax, int minTriangulated)
{// 目的 ：通过单应矩阵H恢复两帧图像之间的旋转矩阵R和平移向量T// 参考 ：Motion and structure from motion in a piecewise plannar environment.//        International Journal of Pattern Recognition and Artificial Intelligence, 1988// https://www.researchgate.net/publication/243764888_Motion_and_Structure_from_Motion_in_a_Piecewise_Planar_Environment// 流程://      1. 根据H矩阵的奇异值d'= d2 或者 d' = -d2 分别计算 H 矩阵分解的 8 组解//        1.1 讨论 d' > 0 时的 4 组解//        1.2 讨论 d' < 0 时的 4 组解//      2. 对 8 组解进行验证，并选择产生相机前方最多3D点的解为最优解// 统计匹配的特征点对中属于内点(Inlier)或有效点个数int N=0;for(size_t i=0, iend = vbMatchesInliers.size() ; i<iend; i++)if(vbMatchesInliers[i])N++;// We recover 8 motion hypotheses using the method of Faugeras et al.// Motion and structure from motion in a piecewise planar environment.// International Journal of Pattern Recognition and Artificial Intelligence, 1988// 参考SLAM十四讲第二版p170-p171// H = K * (R - t * n / d) * K_inv// 其中: K表示内参数矩阵//       K_inv 表示内参数矩阵的逆//       R 和 t 表示旋转和平移向量//       n 表示平面法向量// 令 H = K * A * K_inv// 则 A = k_inv * H * kcv::Mat invK = K.inv();cv::Mat A = invK*H21*K;// 对矩阵A进行SVD分解// A 等待被进行奇异值分解的矩阵// w 奇异值矩阵// U 奇异值分解左矩阵// Vt 奇异值分解右矩阵，注意函数返回的是转置// cv::SVD::FULL_UV 全部分解// A = U * w * Vtcv::Mat U,w,Vt,V;cv::SVD::compute(A, w, U, Vt, cv::SVD::FULL_UV);// 根据文献eq(8)，计算关联变量V=Vt.t();// 计算变量s = det(U) * det(V)// 因为det(V)==det(Vt), 所以 s = det(U) * det(Vt)float s = cv::determinant(U)*cv::determinant(Vt);// 取得矩阵的各个奇异值float d1 = w.at<float>(0);float d2 = w.at<float>(1);float d3 = w.at<float>(2);// SVD分解正常情况下特征值di应该是正的，且满足d1>=d2>=d3if(d1/d2<1.00001 || d2/d3<1.00001) {return false;}// 在ORBSLAM中没有对奇异值 d1 d2 d3按照论文中描述的关系进行分类讨论, 而是直接进行了计算// 定义8中情况下的旋转矩阵、平移向量和空间向量vector<cv::Mat> vR, vt, vn;vR.reserve(8);vt.reserve(8);vn.reserve(8);// Step 1.1 讨论 d' > 0 时的 4 组解// 根据论文eq.(12)有// x1 = e1 * sqrt((d1 * d1 - d2 * d2) / (d1 * d1 - d3 * d3))// x2 = 0// x3 = e3 * sqrt((d2 * d2 - d2 * d2) / (d1 * d1 - d3 * d3))// 令 aux1 = sqrt((d1*d1-d2*d2)/(d1*d1-d3*d3))//    aux3 = sqrt((d2*d2-d3*d3)/(d1*d1-d3*d3))// 则// x1 = e1 * aux1// x3 = e3 * aux2// 因为 e1,e2,e3 = 1 or -1// 所以有x1和x3有四种组合// x1 =  {aux1,aux1,-aux1,-aux1}// x3 =  {aux3,-aux3,aux3,-aux3}float aux1 = sqrt((d1*d1-d2*d2)/(d1*d1-d3*d3));float aux3 = sqrt((d2*d2-d3*d3)/(d1*d1-d3*d3));float x1[] = {aux1,aux1,-aux1,-aux1};float x3[] = {aux3,-aux3,aux3,-aux3};// 根据论文eq.(13)有// sin(theta) = e1 * e3 * sqrt(( d1 * d1 - d2 * d2) * (d2 * d2 - d3 * d3)) /(d1 + d3)/d2// cos(theta) = (d2* d2 + d1 * d3) / (d1 + d3) / d2 // 令  aux_stheta = sqrt((d1*d1-d2*d2)*(d2*d2-d3*d3))/((d1+d3)*d2)// 则  sin(theta) = e1 * e3 * aux_stheta//     cos(theta) = (d2*d2+d1*d3)/((d1+d3)*d2)// 因为 e1 e2 e3 = 1 or -1// 所以 sin(theta) = {aux_stheta, -aux_stheta, -aux_stheta, aux_stheta}float aux_stheta = sqrt((d1*d1-d2*d2)*(d2*d2-d3*d3))/((d1+d3)*d2);float ctheta = (d2*d2+d1*d3)/((d1+d3)*d2);float stheta[] = {aux_stheta, -aux_stheta, -aux_stheta, aux_stheta};// 计算旋转矩阵 R'//根据不同的e1 e3组合所得出来的四种R t的解//      | ctheta      0   -aux_stheta|       | aux1|// Rp = |    0        1       0      |  tp = |  0  |//      | aux_stheta  0    ctheta    |       |-aux3|//      | ctheta      0    aux_stheta|       | aux1|// Rp = |    0        1       0      |  tp = |  0  |//      |-aux_stheta  0    ctheta    |       | aux3|//      | ctheta      0    aux_stheta|       |-aux1|// Rp = |    0        1       0      |  tp = |  0  |//      |-aux_stheta  0    ctheta    |       |-aux3|//      | ctheta      0   -aux_stheta|       |-aux1|// Rp = |    0        1       0      |  tp = |  0  |//      | aux_stheta  0    ctheta    |       | aux3|// 开始遍历这四种情况中的每一种for(int i=0; i<4; i++){//生成Rp，就是eq.(8) 的 R'cv::Mat Rp=cv::Mat::eye(3,3,CV_32F);Rp.at<float>(0,0)=ctheta;Rp.at<float>(0,2)=-stheta[i];Rp.at<float>(2,0)=stheta[i];        Rp.at<float>(2,2)=ctheta;// eq.(8) 计算Rcv::Mat R = s*U*Rp*Vt;// 保存vR.push_back(R);// eq. (14) 生成tp cv::Mat tp(3,1,CV_32F);tp.at<float>(0)=x1[i];tp.at<float>(1)=0;tp.at<float>(2)=-x3[i];tp*=d1-d3;// 这里虽然对t有归一化，并没有决定单目整个SLAM过程的尺度// 因为CreateInitialMapMonocular函数对3D点深度会缩放，然后反过来对 t 有改变// eq.(8)恢复原始的tcv::Mat t = U*tp;vt.push_back(t/cv::norm(t));// 构造法向量npcv::Mat np(3,1,CV_32F);np.at<float>(0)=x1[i];np.at<float>(1)=0;np.at<float>(2)=x3[i];// eq.(8) 恢复原始的法向量cv::Mat n = V*np;//看PPT 16页的图，保持平面法向量向上if(n.at<float>(2)<0)n=-n;// 添加到vectorvn.push_back(n);}// Step 1.2 讨论 d' < 0 时的 4 组解float aux_sphi = sqrt((d1*d1-d2*d2)*(d2*d2-d3*d3))/((d1-d3)*d2);// cos_theta项float cphi = (d1*d3-d2*d2)/((d1-d3)*d2);// 考虑到e1,e2的取值，这里的sin_theta有两种可能的解float sphi[] = {aux_sphi, -aux_sphi, -aux_sphi, aux_sphi};// 对于每种由e1 e3取值的组合而形成的四种解的情况for(int i=0; i<4; i++){// 计算旋转矩阵 R'cv::Mat Rp=cv::Mat::eye(3,3,CV_32F);Rp.at<float>(0,0)=cphi;Rp.at<float>(0,2)=sphi[i];Rp.at<float>(1,1)=-1;Rp.at<float>(2,0)=sphi[i];Rp.at<float>(2,2)=-cphi;// 恢复出原来的Rcv::Mat R = s*U*Rp*Vt;// 然后添加到vector中vR.push_back(R);// 构造tpcv::Mat tp(3,1,CV_32F);tp.at<float>(0)=x1[i];tp.at<float>(1)=0;tp.at<float>(2)=x3[i];tp*=d1+d3;// 恢复出原来的tcv::Mat t = U*tp;// 归一化之后加入到vector中,要提供给上面的平移矩阵都是要进行过归一化的vt.push_back(t/cv::norm(t));// 构造法向量npcv::Mat np(3,1,CV_32F);np.at<float>(0)=x1[i];np.at<float>(1)=0;np.at<float>(2)=x3[i];// 恢复出原来的法向量cv::Mat n = V*np;// 保证法向量指向上方if(n.at<float>(2)<0)n=-n;// 添加到vector中vn.push_back(n);}// 最好的good点int bestGood = 0;// 其次最好的good点int secondBestGood = 0;    // 最好的解的索引，初始值为-1int bestSolutionIdx = -1;// 最大的视差角float bestParallax = -1;// 存储最好解对应的，对特征点对进行三角化测量的结果vector<cv::Point3f> bestP3D;// 最佳解所对应的，那些可以被三角化测量的点的标记vector<bool> bestTriangulated;// Instead of applying the visibility constraints proposed in the WFaugeras' paper (which could fail for points seen with low parallax)// We reconstruct all hypotheses and check in terms of triangulated points and parallax// Step 2. 对 8 组解进行验证，并选择产生相机前方最多3D点的解为最优解for(size_t i=0; i<8; i++){// 第i组解对应的比较大的视差角float parallaxi;// 三角化测量之后的特征点的空间坐标vector<cv::Point3f> vP3Di;// 特征点对是否被三角化的标记vector<bool> vbTriangulatedi;// 调用 Initializer::CheckRT(), 计算good点的数目int nGood = CheckRT(vR[i],vt[i],                    //当前组解的旋转矩阵和平移向量mvKeys1,mvKeys2,                //特征点mvMatches12,vbMatchesInliers,   //特征匹配关系以及Inlier标记K,                              //相机的内参数矩阵vP3Di,                          //存储三角化测量之后的特征点空间坐标的4.0*mSigma2,                    //三角化过程中允许的最大重投影误差vbTriangulatedi,                //特征点是否被成功进行三角测量的标记parallaxi);                     // 这组解在三角化测量的时候的比较大的视差角// 更新历史最优和次优的解// 保留最优的和次优的解.保存次优解的目的是看看最优解是否突出if(nGood>bestGood){// 如果当前组解的good点数是历史最优，那么之前的历史最优就变成了历史次优secondBestGood = bestGood;// 更新历史最优点bestGood = nGood;// 最优解的组索引为i（就是当前次遍历）bestSolutionIdx = i;// 更新变量bestParallax = parallaxi;bestP3D = vP3Di;bestTriangulated = vbTriangulatedi;}// 如果当前组的good计数小于历史最优但却大于历史次优else if(nGood>secondBestGood){// 说明当前组解是历史次优点，更新之secondBestGood = nGood;}}// Step 3 选择最优解。要满足下面的四个条件// 1. good点数最优解明显大于次优解，这里取0.75经验值// 2. 视角差大于规定的阈值// 3. good点数要大于规定的最小的被三角化的点数量// 4. good数要足够多，达到总数的90%以上if(secondBestGood<0.75*bestGood &&      bestParallax>=minParallax &&bestGood>minTriangulated && bestGood>0.9*N){// 从最佳的解的索引访问到R，tvR[bestSolutionIdx].copyTo(R21);vt[bestSolutionIdx].copyTo(t21);// 获得最佳解时，成功三角化的三维点，以后作为初始地图点使用vP3D = bestP3D;// 获取特征点的被成功进行三角化的标记vbTriangulated = bestTriangulated;//返回真，找到了最好的解return true;}return false;
}

1.2.5 ReconstructF

ReconstructF主要用到了如下的成员函数，它们的关系如下图：

该成员函数主要用基础矩阵恢复R，t和三维点，F分解出E，E有四组解，选择计算的有效三维点（在摄像头前方、投影误差小于阈值、视差角大于阈值）最多的作为最优的解。

输入/输出参数：

• vbMatchesInliers：匹配好的特征点对的Inliers标记
• F21：从参考帧到当前帧的基础矩阵
• K：相机的内参数矩阵
• R21：计算出来的相机旋转
• t21：计算出来的相机平移
• vP3D：世界坐标系下，三角化测量特征点对之后得到的特征点的空间坐标
• vbTriangulated：特征点是否成功三角化的标记
• minParallax：对特征点的三角化测量中，认为其测量有效时需要满足的最小视差角（如果视差角过小则会引起非常大的观测误差）,单位是角度
• minTriangulated：为了进行运动恢复，所需要的最少的三角化测量成功的点个数

返回值：

• true：基础矩阵成功计算出位姿和三维点
• false：初始化失败

// 从基础矩阵F中求解位姿R，t及三维点bool Initializer::ReconstructF(vector<bool> &vbMatchesInliers, cv::Mat &F21, cv::Mat &K,cv::Mat &R21, cv::Mat &t21, vector<cv::Point3f> &vP3D, vector<bool> &vbTriangulated, float minParallax, int minTriangulated)
{// Step 1 统计有效匹配点个数，并用 N 表示// vbMatchesInliers 中存储匹配点对是否是有效int N=0;for(size_t i=0, iend = vbMatchesInliers.size() ; i<iend; i++)if(vbMatchesInliers[i]) N++;// Step 2 根据基础矩阵和相机的内参数矩阵计算本质矩阵cv::Mat E21 = K.t()*F21*K;// 定义本质矩阵分解结果，形成四组解,分别是：// (R1, t) (R1, -t) (R2, t) (R2, -t)cv::Mat R1, R2, t;// Step 3 从本质矩阵求解两个R解和两个t解，共四组解// 不过由于两个t解互为相反数，因此这里先只获取一个// 虽然这个函数对t有归一化，但并没有决定单目整个SLAM过程的尺度. // 因为 CreateInitialMapMonocular 函数对3D点深度会缩放，然后反过来对 t 有改变.//注意下文中的符号“'”表示矩阵的转置//                          |0 -1  0|// E = U Sigma V'   let W = |1  0  0|//                          |0  0  1|// 得到4个解 E = [R|t]// R1 = UWV' R2 = UW'V' t1 = U3 t2 = -U3DecomposeE(E21,R1,R2,t);  cv::Mat t1=t;cv::Mat t2=-t;// Reconstruct with the 4 hyphoteses and check// Step 4 分别验证求解的4种R和t的组合，选出最佳组合// 原理：若某一组合使恢复得到的3D点位于相机正前方的数量最多，那么该组合就是最佳组合// 实现：根据计算的解组合成为四种情况,并依次调用 Initializer::CheckRT() 进行检查,得到可以进行三角化测量的点的数目// 定义四组解分别在对同一匹配点集进行三角化测量之后的特征点空间坐标vector<cv::Point3f> vP3D1, vP3D2, vP3D3, vP3D4;// 定义四组解分别对同一匹配点集的有效三角化结果，True or Falsevector<bool> vbTriangulated1,vbTriangulated2,vbTriangulated3, vbTriangulated4;// 定义四种解对应的比较大的特征点对视差角float parallax1,parallax2, parallax3, parallax4;// Step 4.1 使用同样的匹配点分别检查四组解，记录当前计算的3D点在摄像头前方且投影误差小于阈值的个数，记为有效3D点个数int nGood1 = CheckRT(R1,t1,							//当前组解mvKeys1,mvKeys2,				//参考帧和当前帧中的特征点mvMatches12, vbMatchesInliers,	//特征点的匹配关系和Inliers标记K, 							//相机的内参数矩阵vP3D1,							//存储三角化以后特征点的空间坐标4.0*mSigma2,					//三角化测量过程中允许的最大重投影误差vbTriangulated1,				//参考帧中被成功进行三角化测量的特征点的标记parallax1);					//认为某对特征点三角化测量有效的比较大的视差角int nGood2 = CheckRT(R2,t1,mvKeys1,mvKeys2,mvMatches12,vbMatchesInliers,K, vP3D2, 4.0*mSigma2, vbTriangulated2, parallax2);int nGood3 = CheckRT(R1,t2,mvKeys1,mvKeys2,mvMatches12,vbMatchesInliers,K, vP3D3, 4.0*mSigma2, vbTriangulated3, parallax3);int nGood4 = CheckRT(R2,t2,mvKeys1,mvKeys2,mvMatches12,vbMatchesInliers,K, vP3D4, 4.0*mSigma2, vbTriangulated4, parallax4);// Step 4.2 选取最大可三角化测量的点的数目int maxGood = max(nGood1,max(nGood2,max(nGood3,nGood4)));// 重置变量，并在后面赋值为最佳R和TR21 = cv::Mat();t21 = cv::Mat();// Step 4.3 确定最小的可以三角化的点数 // 在0.9倍的内点数 和 指定值minTriangulated =50 中取最大的，也就是说至少50个int nMinGood = max(static_cast<int>(0.9*N), minTriangulated);// 统计四组解中重建的有效3D点个数 > 0.7 * maxGood 的解的数目// 如果有多个解同时满足该条件，认为结果太接近，nsimilar++，nsimilar>1就认为有问题了，后面返回falseint nsimilar = 0;if(nGood1>0.7*maxGood)nsimilar++;if(nGood2>0.7*maxGood)nsimilar++;if(nGood3>0.7*maxGood)nsimilar++;if(nGood4>0.7*maxGood)nsimilar++;// Step 4.4 四个结果中如果没有明显的最优结果，或者没有足够数量的三角化点，则返回失败// 条件1: 如果四组解能够重建的最多3D点个数小于所要求的最少3D点个数（mMinGood），失败// 条件2: 如果存在两组及以上的解能三角化出 >0.7*maxGood的点，说明没有明显最优结果，失败if(maxGood<nMinGood || nsimilar>1)	{return false;}//  Step 4.5 选择最佳解记录结果// 条件1: 有效重建最多的3D点，即maxGood == nGoodx，也即是位于相机前方的3D点个数最多// 条件2: 三角化视差角 parallax 必须大于最小视差角 minParallax，角度越大3D点越稳定//看看最好的good点是在哪种解的条件下发生的if(maxGood==nGood1){//如果该种解下的parallax大于函数参数中给定的最小值if(parallax1>minParallax){// 存储3D坐标vP3D = vP3D1;// 获取特征点向量的三角化测量标记vbTriangulated = vbTriangulated1;// 存储相机姿态R1.copyTo(R21);t1.copyTo(t21);// 结束return true;}}else if(maxGood==nGood2){if(parallax2>minParallax){vP3D = vP3D2;vbTriangulated = vbTriangulated2;R2.copyTo(R21);t1.copyTo(t21);return true;}}else if(maxGood==nGood3){if(parallax3>minParallax){vP3D = vP3D3;vbTriangulated = vbTriangulated3;R1.copyTo(R21);t2.copyTo(t21);return true;}}else if(maxGood==nGood4){if(parallax4>minParallax){vP3D = vP3D4;vbTriangulated = vbTriangulated4;R2.copyTo(R21);t2.copyTo(t21);return true;}}// 如果有最优解但是不满足对应的parallax>minParallax，那么返回false表示求解失败return false;
}

2 总结

Initializer类是用于单目相机初始化的关键类之一。它的主要任务是通过对初始帧进行特征匹配和运动估计，来估计相机的初始位姿和场景的初始三维点云。

以下是Initializer类的主要功能和流程：

1. 在构造函数中，Initializer类接受ORB特征提取器和描述子、相机内参、视差阈值等参数，并进行初始化；

2. Initializer类的核心方法是Initialize()，它接收两个帧作为输入：第一帧（帧1）和第二帧（帧2）。初始化过程分为两个阶段：特征匹配和运动估计；

3. 在特征匹配阶段，Initializer使用ORB特征提取器对帧1和帧2提取特征点和描述子。然后，通过基于描述子的光流法进行特征点匹配，得到匹配的特征点对；

4. 在运动估计阶段，Initializer使用匹配的特征点对进行运动估计。它首先计算两个相邻帧之间的基础矩阵和单应矩阵，然后通过基础矩阵和单应矩阵恢复出帧2相对于帧1的运动（旋转和平移）；

5. 接下来，Initializer使用三角化方法对匹配的特征点对进行三维重建，得到初始的稀疏三维点云；

6. 最后，Initializer通过对三维点云的筛选和剔除外点，以及对相机运动的评估，进一步优化初始位姿和三维点云。

总结来说，Initializer类通过特征匹配和运动估计的过程，估计相机的初始位姿和场景的初始三维点云，为ORB-SLAM2的后续跟踪和建图阶段提供了重要的初始信息。

Reference:

• https://github.com/raulmur/ORB_SLAM2
• https://github.com/electech6/ORB_SLAM2_detailed_comments/tree/master
• 2D-2D对极约束中的基本矩阵、本质矩阵和单应矩阵

须知少时凌云志，曾许人间第一流。

⭐️👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍🌔