企业官网建设流程全解析

第一次过ORB_SLAM2的代码，其实还有很多算法细节还是没有弄明白，接下来的任务是弄明白具体算法并对其增加部分小功能O(∩_∩)O哈哈~

#ifndef LOOPCLOSING_H #define LOOPCLOSING_H #include "KeyFrame.h" #include "LocalMapping.h" #include "Map.h" #include "ORBVocabulary.h" #include "Tracking.h" #include "KeyFrameDatabase.h" #include <thread> #include <mutex> #include "Thirdparty/g2o/g2o/types/types_seven_dof_expmap.h" namespace ORB_SLAM2 { class Tracking; class LocalMapping; class KeyFrameDatabase; class LoopClosing { public: typedef pair<set<KeyFrame*>,int> ConsistentGroup; typedef map<KeyFrame*,g2o::Sim3,std::less<KeyFrame*>, Eigen::aligned_allocator<std::pair<const KeyFrame*, g2o::Sim3> > > KeyFrameAndPose; public: LoopClosing(Map* pMap, KeyFrameDatabase* pDB, ORBVocabulary* pVoc,const bool bFixScale); void SetTracker(Tracking* pTracker); void SetLocalMapper(LocalMapping* pLocalMapper); // Main function void Run(); void InsertKeyFrame(KeyFrame *pKF); void RequestReset(); // This function will run in a separate thread void RunGlobalBundleAdjustment(unsigned long nLoopKF); bool isRunningGBA(){ unique_lock<std::mutex> lock(mMutexGBA); return mbRunningGBA; } bool isFinishedGBA(){ unique_lock<std::mutex> lock(mMutexGBA); return mbFinishedGBA; } void RequestFinish(); bool isFinished(); EIGEN_MAKE_ALIGNED_OPERATOR_NEW protected: bool CheckNewKeyFrames(); bool DetectLoop(); bool ComputeSim3(); void SearchAndFuse(const KeyFrameAndPose &CorrectedPosesMap); void CorrectLoop(); void ResetIfRequested(); bool mbResetRequested; std::mutex mMutexReset; bool CheckFinish(); void SetFinish(); bool mbFinishRequested; bool mbFinished; std::mutex mMutexFinish; Map* mpMap; Tracking* mpTracker; KeyFrameDatabase* mpKeyFrameDB; ORBVocabulary* mpORBVocabulary; LocalMapping *mpLocalMapper; std::list<KeyFrame*> mlpLoopKeyFrameQueue; std::mutex mMutexLoopQueue; // Loop detector parameters float mnCovisibilityConsistencyTh; // Loop detector variables KeyFrame* mpCurrentKF; KeyFrame* mpMatchedKF; std::vector<ConsistentGroup> mvConsistentGroups; std::vector<KeyFrame*> mvpEnoughConsistentCandidates; std::vector<KeyFrame*> mvpCurrentConnectedKFs; std::vector<MapPoint*> mvpCurrentMatchedPoints; std::vector<MapPoint*> mvpLoopMapPoints; cv::Mat mScw; g2o::Sim3 mg2oScw; long unsigned int mLastLoopKFid; // Variables related to Global Bundle Adjustment bool mbRunningGBA; bool mbFinishedGBA; bool mbStopGBA; std::mutex mMutexGBA; std::thread* mpThreadGBA; // Fix scale in the stereo/RGB-D case bool mbFixScale; bool mnFullBAIdx; }; } //namespace ORB_SLAM #endif // LOOPCLOSING_H

#include "LoopClosing.h" #include "Sim3Solver.h" #include "Converter.h" #include "Optimizer.h" #include "ORBmatcher.h" #include<mutex> #include<thread> namespace ORB_SLAM2 { //构造函数，主要分两部分，回环检测，以及GlobalBundleAdjustment LoopClosing::LoopClosing(Map *pMap, KeyFrameDatabase *pDB, ORBVocabulary *pVoc, const bool bFixScale): mbResetRequested(false), mbFinishRequested(false), mbFinished(true), mpMap(pMap), mpKeyFrameDB(pDB), mpORBVocabulary(pVoc), mpMatchedKF(NULL), mLastLoopKFid(0), mbRunningGBA(false), mbFinishedGBA(true), mbStopGBA(false), mpThreadGBA(NULL), mbFixScale(bFixScale), mnFullBAIdx(0) { mnCovisibilityConsistencyTh = 3; } void LoopClosing::SetTracker(Tracking *pTracker) { mpTracker=pTracker; } void LoopClosing::SetLocalMapper(LocalMapping *pLocalMapper) { mpLocalMapper=pLocalMapper; } //我们需要在KeyFrameDataBase中寻找与mlpLoopKeyFrameQueue相似的闭环候选帧 //主要过程包括：寻找回环候选帧，检查候选帧连续性，计算sim3；闭环(地图点融合，位姿图优化) void LoopClosing::Run() { mbFinished =false; while(1) { // Check if there are keyframes in the queue //检查队列中是否有关键帧 if(CheckNewKeyFrames()) { // Detect loop candidates and check covisibility consistency //检测回环候选和检查一致性 if(DetectLoop()) { // Compute similarity transformation [sR|t] // In the stereo/RGBD case s=1 //计算旋转平移的相似性 if(ComputeSim3()) { // Perform loop fusion and pose graph optimization CorrectLoop(); } } } ResetIfRequested(); if(CheckFinish()) break; usleep(5000); } SetFinish(); } //LoopClosing中的关键帧是LocalMapping中送过来的：送来一帧，就检查一帧 void LoopClosing::InsertKeyFrame(KeyFrame *pKF) { unique_lock<mutex> lock(mMutexLoopQueue); if(pKF->mnId!=0) mlpLoopKeyFrameQueue.push_back(pKF); } //检查新的关键帧 bool LoopClosing::CheckNewKeyFrames() { unique_lock<mutex> lock(mMutexLoopQueue); return(!mlpLoopKeyFrameQueue.empty()); } //检测是否存在回环 bool LoopClosing::DetectLoop() { { unique_lock<mutex> lock(mMutexLoopQueue); mpCurrentKF = mlpLoopKeyFrameQueue.front(); mlpLoopKeyFrameQueue.pop_front(); // Avoid that a keyframe can be erased while it is being process by this thread mpCurrentKF->SetNotErase(); } //If the map contains less than 10 KF or less than 10 KF have passed from last loop detection if(mpCurrentKF->mnId<mLastLoopKFid+10) { mpKeyFrameDB->add(mpCurrentKF); mpCurrentKF->SetErase(); return false; } // Compute reference BoW similarity score // This is the lowest score to a connected keyframe in the covisibility graph // We will impose loop candidates to have a higher similarity than this //计算当前帧及其共视关键帧的词袋模型匹配得分，获得minScore const vector<KeyFrame*> vpConnectedKeyFrames = mpCurrentKF->GetVectorCovisibleKeyFrames(); const DBoW2::BowVector &CurrentBowVec = mpCurrentKF->mBowVec; float minScore = 1; for(size_t i=0; i<vpConnectedKeyFrames.size(); i++) { KeyFrame* pKF = vpConnectedKeyFrames[i]; if(pKF->isBad()) continue; const DBoW2::BowVector &BowVec = pKF->mBowVec; float score = mpORBVocabulary->score(CurrentBowVec, BowVec); if(score<minScore) minScore = score; } // Query the database imposing the minimum score //在除去当前帧共视关系的关键帧数据中，检测闭环候选帧(这个函数在KeyFrameDatabase中) //闭环候选帧删选过程： //1,BoW得分>minScore; //2,统计满足1的关键帧中有共同单子最多的单词数maxcommonwords //3,筛选出共同单词数大于mincommons(=0.8*maxcommons)的关键帧 //4,相连的关键帧分为一组，计算组得分（总分）,得到最大总分bestAccScore,筛选出总分大于minScoreToRetain(=0.75*bestAccScore)的组 //用得分最高的候选帧IAccScoreAndMathch代表该组，计算组得分的目的是剔除单独一帧得分较高，但是没有共视关键帧作为闭环来说不够鲁棒 //对于通过了闭环检测的关键帧，还需要通过连续性检测(连续三帧都通过上面的筛选)，才能作为闭环候选帧 vector<KeyFrame*> vpCandidateKFs = mpKeyFrameDB->DetectLoopCandidates(mpCurrentKF, minScore); // If there are no loop candidates, just add new keyframe and return false if(vpCandidateKFs.empty()) { mpKeyFrameDB->add(mpCurrentKF); mvConsistentGroups.clear(); mpCurrentKF->SetErase(); return false; } // For each loop candidate check consistency with previous loop candidates // Each candidate expands a covisibility group (keyframes connected to the loop candidate in the covisibility graph) // A group is consistent with a previous group if they share at least a keyframe // We must detect a consistent loop in several consecutive keyframes to accept it mvpEnoughConsistentCandidates.clear(); vector<ConsistentGroup> vCurrentConsistentGroups; vector<bool> vbConsistentGroup(mvConsistentGroups.size(),false); for(size_t i=0, iend=vpCandidateKFs.size(); i<iend; i++) { KeyFrame* pCandidateKF = vpCandidateKFs[i]; set<KeyFrame*> spCandidateGroup = pCandidateKF->GetConnectedKeyFrames(); spCandidateGroup.insert(pCandidateKF); bool bEnoughConsistent = false; bool bConsistentForSomeGroup = false; for(size_t iG=0, iendG=mvConsistentGroups.size(); iG<iendG; iG++) { set<KeyFrame*> sPreviousGroup = mvConsistentGroups[iG].first; bool bConsistent = false; for(set<KeyFrame*>::iterator sit=spCandidateGroup.begin(), send=spCandidateGroup.end(); sit!=send;sit++) { if(sPreviousGroup.count(*sit)) { bConsistent=true; bConsistentForSomeGroup=true; break; } } if(bConsistent) { int nPreviousConsistency = mvConsistentGroups[iG].second; int nCurrentConsistency = nPreviousConsistency + 1; if(!vbConsistentGroup[iG]) { ConsistentGroup cg = make_pair(spCandidateGroup,nCurrentConsistency); vCurrentConsistentGroups.push_back(cg); vbConsistentGroup[iG]=true; //this avoid to include the same group more than once } if(nCurrentConsistency>=mnCovisibilityConsistencyTh && !bEnoughConsistent) { mvpEnoughConsistentCandidates.push_back(pCandidateKF); bEnoughConsistent=true; //this avoid to insert the same candidate more than once } } } // If the group is not consistent with any previous group insert with consistency counter set to zero if(!bConsistentForSomeGroup) { ConsistentGroup cg = make_pair(spCandidateGroup,0); vCurrentConsistentGroups.push_back(cg); } } // Update Covisibility Consistent Groups mvConsistentGroups = vCurrentConsistentGroups; // Add Current Keyframe to database mpKeyFrameDB->add(mpCurrentKF); if(mvpEnoughConsistentCandidates.empty()) { mpCurrentKF->SetErase(); return false; } else { return true; } mpCurrentKF->SetErase(); return false; } //计算当前关键帧和闭环候选帧之间的Sim3,这个Sim3变换就是闭环前累计的尺度和位姿误差 //该误差也可以帮助检验该闭环在空间几何姿态上是否成立 bool LoopClosing::ComputeSim3() { // For each consistent loop candidate we try to compute a Sim3 const int nInitialCandidates = mvpEnoughConsistentCandidates.size(); // We compute first ORB matches for each candidate // If enough matches are found, we setup a Sim3Solver ORBmatcher matcher(0.75,true); vector<Sim3Solver*> vpSim3Solvers; vpSim3Solvers.resize(nInitialCandidates); vector<vector<MapPoint*> > vvpMapPointMatches; vvpMapPointMatches.resize(nInitialCandidates); vector<bool> vbDiscarded; vbDiscarded.resize(nInitialCandidates); int nCandidates=0; //candidates with enough matches for(int i=0; i<nInitialCandidates; i++) { KeyFrame* pKF = mvpEnoughConsistentCandidates[i]; // avoid that local mapping erase it while it is being processed in this thread pKF->SetNotErase(); if(pKF->isBad()) { vbDiscarded[i] = true; continue; } //通过SearchByBow搜索当前关键帧中和闭环候选帧匹配的地图点 //BoW通过将单词聚类到树结构node的方法，加快搜索匹配速度 int nmatches = matcher.SearchByBoW(mpCurrentKF,pKF,vvpMapPointMatches[i]); //若nmatches<20，剔除该候选帧，将匹配好的地图点放入当前帧对应的vvpMapPointMatches //注意这里使用Bow匹配较快，但是会有漏匹配 if(nmatches<20) { vbDiscarded[i] = true; continue; } else { Sim3Solver* pSolver = new Sim3Solver(mpCurrentKF,pKF,vvpMapPointMatches[i],mbFixScale); pSolver->SetRansacParameters(0.99,20,300);//至少20个inliers, 300次迭代 vpSim3Solvers[i] = pSolver; } nCandidates++; } bool bMatch = false; // Perform alternatively RANSAC iterations for each candidate // until one is succesful or all fail //RANSAC：利用上面匹配上的地图点（虽然匹配上了，但是空间位置相差了一个Sim3），用RANSAC方法求解Sim3位姿 //这里有可能求解不出Sim3,也就是虽然匹配满足，但是空间几何姿态不满足vvpMapPointMatchesvvpMapPointMatches while(nCandidates>0 && !bMatch) { for(int i=0; i<nInitialCandidates; i++) { if(vbDiscarded[i]) continue; KeyFrame* pKF = mvpEnoughConsistentCandidates[i]; // Perform 5 Ransac Iterations vector<bool> vbInliers; int nInliers; bool bNoMore; Sim3Solver* pSolver = vpSim3Solvers[i]; cv::Mat Scm = pSolver->iterate(5,bNoMore,vbInliers,nInliers); // If Ransac reachs max. iterations discard keyframe if(bNoMore) { vbDiscarded[i]=true; nCandidates--; } // If RANSAC returns a Sim3, perform a guided matching and optimize with all correspondences if(!Scm.empty()) { vector<MapPoint*> vpMapPointMatches(vvpMapPointMatches[i].size(), static_cast<MapPoint*>(NULL)); for(size_t j=0, jend=vbInliers.size(); j<jend; j++) { if(vbInliers[j]) vpMapPointMatches[j]=vvpMapPointMatches[i][j]; } //根据计算出的Sim3(s, R, t)，去找更多的匹配点(SearchBySim3),更新vpMapPointMatches cv::Mat R = pSolver->GetEstimatedRotation(); cv::Mat t = pSolver->GetEstimatedTranslation(); const float s = pSolver->GetEstimatedScale(); matcher.SearchBySim3(mpCurrentKF,pKF,vpMapPointMatches,s,R,t,7.5); //使用更新过的匹配，使用g2o优化Sim3位姿，这是内点数nInliers>20,才说明通过。 //一旦找到闭环帧mpMatchedKF,则break,跳过对其他候选帧的判断 g2o::Sim3 gScm(Converter::toMatrix3d(R),Converter::toVector3d(t),s); const int nInliers = Optimizer::OptimizeSim3(mpCurrentKF, pKF, vpMapPointMatches, gScm, 10, mbFixScale); // If optimization is succesful stop ransacs and continue if(nInliers>=20) { bMatch = true; mpMatchedKF = pKF; g2o::Sim3 gSmw(Converter::toMatrix3d(pKF->GetRotation()),Converter::toVector3d(pKF->GetTranslation()),1.0); mg2oScw = gScm*gSmw; mScw = Converter::toCvMat(mg2oScw); mvpCurrentMatchedPoints = vpMapPointMatches; break; } } } } if(!bMatch) { for(int i=0; i<nInitialCandidates; i++) mvpEnoughConsistentCandidates[i]->SetErase(); mpCurrentKF->SetErase(); return false; } // Retrieve MapPoints seen in Loop Keyframe and neighbors vector<KeyFrame*> vpLoopConnectedKFs = mpMatchedKF->GetVectorCovisibleKeyFrames(); vpLoopConnectedKFs.push_back(mpMatchedKF); mvpLoopMapPoints.clear(); for(vector<KeyFrame*>::iterator vit=vpLoopConnectedKFs.begin(); vit!=vpLoopConnectedKFs.end(); vit++) { KeyFrame* pKF = *vit; vector<MapPoint*> vpMapPoints = pKF->GetMapPointMatches(); for(size_t i=0, iend=vpMapPoints.size(); i<iend; i++) { MapPoint* pMP = vpMapPoints[i]; if(pMP) { if(!pMP->isBad() && pMP->mnLoopPointForKF!=mpCurrentKF->mnId) { mvpLoopMapPoints.push_back(pMP); pMP->mnLoopPointForKF=mpCurrentKF->mnId; } } } } // Find more matches projecting with the computed Sim3 //获取mpMatchedKF及其相连关键帧对应的地图的地图点。将这些地图点通过上面优化得到的Sim3(gScm>mScw) //变换投影到当前关键帧进行匹配，若匹配点>=40个，则返回true,进行闭环调整，否则，返回false, //线程暂停5ms后继续接收Tracking发送来的关键帧队列 //注意这里得到的当前关键帧中匹配上闭环关键帧共视地图点(mvpCurrentMatchedPoints) //将用于后面CorrectLoop时当时关键帧地图点的冲突融合 //到这里，不仅确保了当前关键帧与闭环帧之间匹配度高， //而且保证了闭环帧的共视图中的地图点和当前帧的特征点匹配度更高,说明该闭环帧是正确的 matcher.SearchByProjection(mpCurrentKF, mScw, mvpLoopMapPoints, mvpCurrentMatchedPoints,10); // If enough matches accept Loop int nTotalMatches = 0; for(size_t i=0; i<mvpCurrentMatchedPoints.size(); i++) { if(mvpCurrentMatchedPoints[i]) nTotalMatches++; } if(nTotalMatches>=40) { for(int i=0; i<nInitialCandidates; i++) if(mvpEnoughConsistentCandidates[i]!=mpMatchedKF) mvpEnoughConsistentCandidates[i]->SetErase(); return true; } else { for(int i=0; i<nInitialCandidates; i++) mvpEnoughConsistentCandidates[i]->SetErase(); mpCurrentKF->SetErase(); return false; } } //闭环纠正时，LocalMapper和Global BA必须停止。注意Global BA必须停止。 //注意Global BA使用的的是单独的线程 //分为两步，第一步LoopFusion,第二步Essential Graph优化 //其中Essential Graph包含三部分：1，共视关系很好的关键帧；2, spanning tree连接关系(父子关系) //3，闭环关键帧连接关系 void LoopClosing::CorrectLoop() { cout << "Loop detected!" << endl; // Send a stop signal to Local Mapping // Avoid new keyframes are inserted while correcting the loop mpLocalMapper->RequestStop(); // If a Global Bundle Adjustment is running, abort it if(isRunningGBA()) { unique_lock<mutex> lock(mMutexGBA); mbStopGBA = true; mnFullBAIdx++; if(mpThreadGBA) { mpThreadGBA->detach(); delete mpThreadGBA; } } // Wait until Local Mapping has effectively stopped while(!mpLocalMapper->isStopped()) { usleep(1000); } // Ensure current keyframe is updated mpCurrentKF->UpdateConnections(); // Retrive keyframes connected to the current keyframe and compute corrected Sim3 pose by propagation mvpCurrentConnectedKFs = mpCurrentKF->GetVectorCovisibleKeyFrames(); mvpCurrentConnectedKFs.push_back(mpCurrentKF); //使用计算出的Sim3对当前位姿进行调整，并且传播到当前帧相连的的关键帧 //(相连关键帧之间相对位姿是知道的，通过当前帧的Sim3计算相连关键帧的Sim3). //这样回环的两侧关键帧就对齐了，利用调整过的位姿更新这些向量关键帧对应的地图点 KeyFrameAndPose CorrectedSim3, NonCorrectedSim3; CorrectedSim3[mpCurrentKF]=mg2oScw; cv::Mat Twc = mpCurrentKF->GetPoseInverse(); { // Get Map Mutex unique_lock<mutex> lock(mpMap->mMutexMapUpdate); for(vector<KeyFrame*>::iterator vit=mvpCurrentConnectedKFs.begin(), vend=mvpCurrentConnectedKFs.end(); vit!=vend; vit++) { KeyFrame* pKFi = *vit; cv::Mat Tiw = pKFi->GetPose(); if(pKFi!=mpCurrentKF) { cv::Mat Tic = Tiw*Twc; cv::Mat Ric = Tic.rowRange(0,3).colRange(0,3); cv::Mat tic = Tic.rowRange(0,3).col(3); g2o::Sim3 g2oSic(Converter::toMatrix3d(Ric),Converter::toVector3d(tic),1.0); g2o::Sim3 g2oCorrectedSiw = g2oSic*mg2oScw; //Pose corrected with the Sim3 of the loop closure CorrectedSim3[pKFi]=g2oCorrectedSiw; } cv::Mat Riw = Tiw.rowRange(0,3).colRange(0,3); cv::Mat tiw = Tiw.rowRange(0,3).col(3); g2o::Sim3 g2oSiw(Converter::toMatrix3d(Riw),Converter::toVector3d(tiw),1.0); //Pose without correction NonCorrectedSim3[pKFi]=g2oSiw; } // Correct all MapPoints obsrved by current keyframe and neighbors, so that they align with the other side of the loop //利用调整过的位姿更新这些相连关键帧对应的地图点 for(KeyFrameAndPose::iterator mit=CorrectedSim3.begin(), mend=CorrectedSim3.end(); mit!=mend; mit++) { KeyFrame* pKFi = mit->first; g2o::Sim3 g2oCorrectedSiw = mit->second; g2o::Sim3 g2oCorrectedSwi = g2oCorrectedSiw.inverse(); g2o::Sim3 g2oSiw =NonCorrectedSim3[pKFi]; vector<MapPoint*> vpMPsi = pKFi->GetMapPointMatches(); for(size_t iMP=0, endMPi = vpMPsi.size(); iMP<endMPi; iMP++) { MapPoint* pMPi = vpMPsi[iMP]; if(!pMPi) continue; if(pMPi->isBad()) continue; if(pMPi->mnCorrectedByKF==mpCurrentKF->mnId) continue; // Project with non-corrected pose and project back with corrected pose //将闭环帧及其相连帧的地图点都投影到当前帧以及相连帧上 cv::Mat P3Dw = pMPi->GetWorldPos(); Eigen::Matrix<double,3,1> eigP3Dw = Converter::toVector3d(P3Dw); Eigen::Matrix<double,3,1> eigCorrectedP3Dw = g2oCorrectedSwi.map(g2oSiw.map(eigP3Dw)); cv::Mat cvCorrectedP3Dw = Converter::toCvMat(eigCorrectedP3Dw); pMPi->SetWorldPos(cvCorrectedP3Dw); pMPi->mnCorrectedByKF = mpCurrentKF->mnId; pMPi->mnCorrectedReference = pKFi->mnId; pMPi->UpdateNormalAndDepth(); } // Update keyframe pose with corrected Sim3. First transform Sim3 to SE3 (scale translation) Eigen::Matrix3d eigR = g2oCorrectedSiw.rotation().toRotationMatrix(); Eigen::Vector3d eigt = g2oCorrectedSiw.translation(); double s = g2oCorrectedSiw.scale(); eigt *=(1./s); //[R t/s;0 1] cv::Mat correctedTiw = Converter::toCvSE3(eigR,eigt); pKFi->SetPose(correctedTiw); // Make sure connections are updated pKFi->UpdateConnections(); } // Start Loop Fusion // Update matched map points and replace if duplicated //投影匹配上的和Sim3计算过的地图点进行融合(就是替换成高质量的) for(size_t i=0; i<mvpCurrentMatchedPoints.size(); i++) { if(mvpCurrentMatchedPoints[i]) { MapPoint* pLoopMP = mvpCurrentMatchedPoints[i]; MapPoint* pCurMP = mpCurrentKF->GetMapPoint(i); if(pCurMP) pCurMP->Replace(pLoopMP); else { mpCurrentKF->AddMapPoint(pLoopMP,i); pLoopMP->AddObservation(mpCurrentKF,i); pLoopMP->ComputeDistinctiveDescriptors(); } } } } // Project MapPoints observed in the neighborhood of the loop keyframe // into the current keyframe and neighbors using corrected poses. // Fuse duplications. SearchAndFuse(CorrectedSim3); // After the MapPoint fusion, new links in the covisibility graph will appear attaching both sides of the loop //涉及融合的关键帧还需要更新其在共视地图中的观测边关系，这是为了剥离出因为闭环产生新的连接关系LoopConnection //用于优化Essential Graph。添加当前帧与闭环匹配帧之间的边，该边不参与优化 map<KeyFrame*, set<KeyFrame*> > LoopConnections; for(vector<KeyFrame*>::iterator vit=mvpCurrentConnectedKFs.begin(), vend=mvpCurrentConnectedKFs.end(); vit!=vend; vit++) { KeyFrame* pKFi = *vit; vector<KeyFrame*> vpPreviousNeighbors = pKFi->GetVectorCovisibleKeyFrames(); // Update connections. Detect new links. pKFi->UpdateConnections(); LoopConnections[pKFi]=pKFi->GetConnectedKeyFrames(); for(vector<KeyFrame*>::iterator vit_prev=vpPreviousNeighbors.begin(), vend_prev=vpPreviousNeighbors.end(); vit_prev!=vend_prev; vit_prev++) { LoopConnections[pKFi].erase(*vit_prev); } for(vector<KeyFrame*>::iterator vit2=mvpCurrentConnectedKFs.begin(), vend2=mvpCurrentConnectedKFs.end(); vit2!=vend2; vit2++) { LoopConnections[pKFi].erase(*vit2); } } // Optimize graph //地图点是连接关键帧之间的枢纽，每次调整地图点位置后都需要更新关键帧的连接关系 //优化一些主要关键帧 Optimizer::OptimizeEssentialGraph(mpMap, mpMatchedKF, mpCurrentKF, NonCorrectedSim3, CorrectedSim3, LoopConnections, mbFixScale); mpMap->InformNewBigChange(); // Add loop edge mpMatchedKF->AddLoopEdge(mpCurrentKF); mpCurrentKF->AddLoopEdge(mpMatchedKF); // Launch a new thread to perform Global Bundle Adjustment //新开一个线程进行全局优化，全局优化可以优化所有的位姿与地图点 mbRunningGBA = true; mbFinishedGBA = false; mbStopGBA = false; mpThreadGBA = new thread(&LoopClosing::RunGlobalBundleAdjustment,this,mpCurrentKF->mnId); // Loop closed. Release Local Mapping. mpLocalMapper->Release(); mLastLoopKFid = mpCurrentKF->mnId; } void LoopClosing::SearchAndFuse(const KeyFrameAndPose &CorrectedPosesMap) { ORBmatcher matcher(0.8); for(KeyFrameAndPose::const_iterator mit=CorrectedPosesMap.begin(), mend=CorrectedPosesMap.end(); mit!=mend;mit++) { KeyFrame* pKF = mit->first; g2o::Sim3 g2oScw = mit->second; cv::Mat cvScw = Converter::toCvMat(g2oScw); vector<MapPoint*> vpReplacePoints(mvpLoopMapPoints.size(),static_cast<MapPoint*>(NULL)); matcher.Fuse(pKF,cvScw,mvpLoopMapPoints,4,vpReplacePoints); // Get Map Mutex unique_lock<mutex> lock(mpMap->mMutexMapUpdate); const int nLP = mvpLoopMapPoints.size(); for(int i=0; i<nLP;i++) { MapPoint* pRep = vpReplacePoints[i]; if(pRep) { pRep->Replace(mvpLoopMapPoints[i]); } } } } void LoopClosing::RequestReset() { { unique_lock<mutex> lock(mMutexReset); mbResetRequested = true; } while(1) { { unique_lock<mutex> lock2(mMutexReset); if(!mbResetRequested) break; } usleep(5000); } } void LoopClosing::ResetIfRequested() { unique_lock<mutex> lock(mMutexReset); if(mbResetRequested) { mlpLoopKeyFrameQueue.clear(); mLastLoopKFid=0; mbResetRequested=false; } } //进行全局BA void LoopClosing::RunGlobalBundleAdjustment(unsigned long nLoopKF) { cout << "Starting Global Bundle Adjustment" << endl; int idx = mnFullBAIdx; Optimizer::GlobalBundleAdjustemnt(mpMap,10,&mbStopGBA,nLoopKF,false); // Update all MapPoints and KeyFrames // Local Mapping was active during BA, that means that there might be new keyframes // not included in the Global BA and they are not consistent with the updated map. // We need to propagate the correction through the spanning tree { unique_lock<mutex> lock(mMutexGBA); if(idx!=mnFullBAIdx) return; if(!mbStopGBA) { cout << "Global Bundle Adjustment finished" << endl; cout << "Updating map ..." << endl; mpLocalMapper->RequestStop(); // Wait until Local Mapping has effectively stopped while(!mpLocalMapper->isStopped() && !mpLocalMapper->isFinished()) { usleep(1000); } // Get Map Mutex unique_lock<mutex> lock(mpMap->mMutexMapUpdate); // Correct keyframes starting at map first keyframe list<KeyFrame*> lpKFtoCheck(mpMap->mvpKeyFrameOrigins.begin(),mpMap->mvpKeyFrameOrigins.end()); while(!lpKFtoCheck.empty()) { KeyFrame* pKF = lpKFtoCheck.front(); const set<KeyFrame*> sChilds = pKF->GetChilds(); cv::Mat Twc = pKF->GetPoseInverse(); for(set<KeyFrame*>::const_iterator sit=sChilds.begin();sit!=sChilds.end();sit++) { KeyFrame* pChild = *sit; if(pChild->mnBAGlobalForKF!=nLoopKF) { cv::Mat Tchildc = pChild->GetPose()*Twc; pChild->mTcwGBA = Tchildc*pKF->mTcwGBA;//*Tcorc*pKF->mTcwGBA; pChild->mnBAGlobalForKF=nLoopKF; } lpKFtoCheck.push_back(pChild); } pKF->mTcwBefGBA = pKF->GetPose(); pKF->SetPose(pKF->mTcwGBA); lpKFtoCheck.pop_front(); } // Correct MapPoints const vector<MapPoint*> vpMPs = mpMap->GetAllMapPoints(); for(size_t i=0; i<vpMPs.size(); i++) { MapPoint* pMP = vpMPs[i]; if(pMP->isBad()) continue; if(pMP->mnBAGlobalForKF==nLoopKF) { // If optimized by Global BA, just update pMP->SetWorldPos(pMP->mPosGBA); } else { // Update according to the correction of its reference keyframe KeyFrame* pRefKF = pMP->GetReferenceKeyFrame(); if(pRefKF->mnBAGlobalForKF!=nLoopKF) continue; // Map to non-corrected camera cv::Mat Rcw = pRefKF->mTcwBefGBA.rowRange(0,3).colRange(0,3); cv::Mat tcw = pRefKF->mTcwBefGBA.rowRange(0,3).col(3); cv::Mat Xc = Rcw*pMP->GetWorldPos()+tcw; // Backproject using corrected camera cv::Mat Twc = pRefKF->GetPoseInverse(); cv::Mat Rwc = Twc.rowRange(0,3).colRange(0,3); cv::Mat twc = Twc.rowRange(0,3).col(3); pMP->SetWorldPos(Rwc*Xc+twc); } } mpMap->InformNewBigChange(); mpLocalMapper->Release(); cout << "Map updated!" << endl; } mbFinishedGBA = true; mbRunningGBA = false; } } void LoopClosing::RequestFinish() { unique_lock<mutex> lock(mMutexFinish); mbFinishRequested = true; } bool LoopClosing::CheckFinish() { unique_lock<mutex> lock(mMutexFinish); return mbFinishRequested; } void LoopClosing::SetFinish() { unique_lock<mutex> lock(mMutexFinish); mbFinished = true; } bool LoopClosing::isFinished() { unique_lock<mutex> lock(mMutexFinish); return mbFinished; } } //namespace ORB_SLAM