Map

namespace ORB_SLAM3 {
    class Map;
}

Map();

Map(int initKFid);

void AddKeyFrame(KeyFrame* pKF);

void AddMapPoint(MapPoint* pMP);

void EraseKeyFrame(KeyFrame* pKF);

void EraseMapPoint(MapPoint* pMP);

void clear();

std::vector<KeyFrame*> GetAllKeyFrames();

std::vector<MapPoint*> GetAllMapPoints();

long unsigned KeyFramesInMap();

long unsigned int MapPointsInMap();

void SetReferenceMapPoints(const std::vector<MapPoint*> &vpMPs);

std::vector<MapPoint*> GetReferenceMapPoints();

long unsigned int GetId();

long unsigned int GetInitKFid();

void SetInitKFid(long unsigned int initKFif);

long unsigned int GetMaxKFid();

KeyFrame* GetOriginKF();

void ChangeId(long unsigned int nId);

void SetCurrentMap();

void SetStoredMap();

bool IsInUse();

void SetBad();

bool IsBad();

void InformNewBigChange();

int GetLastBigChangeIdx();

int GetMapChangeIndex();

void IncreaseChangeIndex();

int GetLastMapChange();
void SetLastMapChange(int currentChangeId);

void SetInertialSensor();

bool IsInertial();

void SetImuInitialized();

bool isImuInitialized();

void SetIniertialBA1();
void SetIniertialBA2();

bool GetIniertialBA1();
bool GetIniertialBA2();

void ApplyScaledRotation(const Sophus::SE3f &T, const float s, 
                         const bool bScaledVel=false);

// Map ID
long unsigned int mnId;
static long unsigned int nNextId;

// KeyFrames and MapPoints
std::set<KeyFrame*> mspKeyFrames;
std::set<MapPoint*> mspMapPoints;

// Reference MapPoints for tracking
std::vector<MapPoint*> mvpReferenceMapPoints;

// Initial KeyFrame
KeyFrame* mpKFinitial;
KeyFrame* mpKFlowerID;

long unsigned int mnInitKFid;
long unsigned int mnMaxKFid;

// KeyFrame origins
vector<KeyFrame*> mvpKeyFrameOrigins;
KeyFrame* mpFirstRegionKF;

bool mIsInUse;
bool mbBad;
bool mbFail;

bool mbIsInertial;
bool mbImuInitialized;
bool mbIMU_BA1;
bool mbIMU_BA2;

// Change indices
int mnMapChange;
int mnMapChangeNotified;
int mnBigChangeIdx;

// Thumbnail for visualization
static const int THUMB_WIDTH = 512;
static const int THUMB_HEIGHT = 512;
GLubyte* mThumbnail;
bool mHasTumbnail;

std::mutex mMutexMap;           // General map access
std::mutex mMutexMapUpdate;     // Map updates
std::mutex mMutexPointCreation; // MapPoint creation

// Backup vectors for serialization
std::vector<MapPoint*> mvpBackupMapPoints;
std::vector<KeyFrame*> mvpBackupKeyFrames;
vector<unsigned long int> mvBackupKeyFrameOriginsId;

unsigned long int mnBackupKFinitialID;
unsigned long int mnBackupKFlowerID;

void PreSave(std::set<GeometricCamera*> &spCams);

void PostLoad(KeyFrameDatabase* pKFDB, ORBVocabulary* pORBVoc, 
              map<unsigned int, GeometricCamera*> &mpCams);

// Create a new map
Map* pMap = new Map();

// Add KeyFrames and MapPoints
pMap->AddKeyFrame(pKF);
pMap->AddMapPoint(pMP);

// Query map contents
vector<KeyFrame*> vpKFs = pMap->GetAllKeyFrames();
vector<MapPoint*> vpMPs = pMap->GetAllMapPoints();

std::cout << "Map has " << pMap->KeyFramesInMap() 
          << " KeyFrames and " << pMap->MapPointsInMap() 
          << " MapPoints" << std::endl;

// Check if inertial
if (pMap->IsInertial()) {
    std::cout << "Map uses IMU" << std::endl;
}

// Notify big change after loop closure
pMap->InformNewBigChange();