MapPoint

namespace ORB_SLAM3 {
    class MapPoint;
}

MapPoint(const Eigen::Vector3f &Pos, KeyFrame* pRefKF, Map* pMap);

MapPoint(const double invDepth, cv::Point2f uv_init, KeyFrame* pRefKF, 
         KeyFrame* pHostKF, Map* pMap);

MapPoint(const Eigen::Vector3f &Pos, Map* pMap, Frame* pFrame, const int &idxF);

void SetWorldPos(const Eigen::Vector3f &Pos);

Eigen::Vector3f GetWorldPos();

Eigen::Vector3f GetNormal();

void SetNormalVector(const Eigen::Vector3f& normal);

void UpdateNormalAndDepth();

KeyFrame* GetReferenceKeyFrame();

void AddObservation(KeyFrame* pKF, int idx);

void EraseObservation(KeyFrame* pKF);

std::map<KeyFrame*, std::tuple<int,int>> GetObservations();

int Observations();

bool IsInKeyFrame(KeyFrame* pKF);

std::tuple<int,int> GetIndexInKeyFrame(KeyFrame* pKF);

void PrintObservations();

void ComputeDistinctiveDescriptors();

cv::Mat GetDescriptor();

void SetBadFlag();

bool isBad();

void Replace(MapPoint* pMP);

MapPoint* GetReplaced();

void IncreaseVisible(int n=1);

void IncreaseFound(int n=1);

float GetFoundRatio();

int GetFound();

float GetMinDistanceInvariance();

float GetMaxDistanceInvariance();

int PredictScale(const float &currentDist, KeyFrame* pKF);

int PredictScale(const float &currentDist, Frame* pF);

Map* GetMap();

void UpdateMap(Map* pMap);

long unsigned int mnId;          // Unique MapPoint ID
static long unsigned int nNextId; // Next ID to assign
long int mnFirstKFid;             // ID of first observing KeyFrame
long int mnFirstFrame;            // ID of first observing Frame
unsigned int mnOriginMapId;       // Origin map ID

// 3D position in world coordinates
Eigen::Vector3f mWorldPos;

// Mean viewing direction
Eigen::Vector3f mNormalVector;

// Scale invariance distances
float mfMinDistance;
float mfMaxDistance;

// KeyFrames observing the point and keypoint indices
std::map<KeyFrame*, std::tuple<int,int>> mObservations;

// Number of observations
int nObs;

// Reference KeyFrame
KeyFrame* mpRefKF;

// Best descriptor for fast matching
cv::Mat mDescriptor;

int mnVisible;  // Times visible
int mnFound;    // Times found/matched

bool mbBad;              // Bad flag
MapPoint* mpReplaced;    // Replacement MapPoint

Map* mpMap;

// Projected coordinates in current frame
float mTrackProjX, mTrackProjY;
float mTrackProjXR, mTrackProjYR;  // Right image (stereo)

// Depth in current frame
float mTrackDepth, mTrackDepthR;

// Visibility in current frame
bool mbTrackInView, mbTrackInViewR;

// Predicted scale level
int mnTrackScaleLevel, mnTrackScaleLevelR;

// Viewing angle cosine
float mTrackViewCos, mTrackViewCosR;

// Last frame seen
long unsigned int mnLastFrameSeen;
long unsigned int mnTrackReferenceForFrame;

// Local mapping
long unsigned int mnBALocalForKF;
long unsigned int mnFuseCandidateForKF;

// Loop closing
long unsigned int mnLoopPointForKF;
long unsigned int mnCorrectedByKF;
long unsigned int mnCorrectedReference;
Eigen::Vector3f mPosGBA;           // Position after global BA
long unsigned int mnBAGlobalForKF;

// Merging
long unsigned int mnBALocalForMerge;
Eigen::Vector3f mPosMerge;
Eigen::Vector3f mNormalVectorMerge;

double mInvDepth;      // Inverse depth
double mInitU, mInitV; // Initial pixel coordinates  
KeyFrame* mpHostKF;    // Host KeyFrame

std::mutex mMutexPos;       // Position access
std::mutex mMutexFeatures;  // Features and observations
std::mutex mMutexMap;       // Map pointer
static std::mutex mGlobalMutex; // Global operations

// Backup for serialization
std::map<long unsigned int, int> mBackupObservationsId1;
std::map<long unsigned int, int> mBackupObservationsId2;
long unsigned int mBackupRefKFId;
long long int mBackupReplacedId;

void PreSave(set<KeyFrame*>& spKF, set<MapPoint*>& spMP);

void PostLoad(map<long unsigned int, KeyFrame*>& mpKFid, 
              map<long unsigned int, MapPoint*>& mpMPid);

// Create MapPoint from triangulation
Eigen::Vector3f worldPos = Triangulate(kp1, kp2, Tcw1, Tcw2);
MapPoint* pMP = new MapPoint(worldPos, pRefKF, pMap);

// Add observations
pMP->AddObservation(pKF1, idx1);
pMP->AddObservation(pKF2, idx2);

// Compute distinctive descriptor
pMP->ComputeDistinctiveDescriptors();

// Update geometric properties
pMP->UpdateNormalAndDepth();

// Check quality
if (pMP->Observations() < 2) {
    pMP->SetBadFlag();
    return;
}

// Get info
Eigen::Vector3f pos = pMP->GetWorldPos();
Eigen::Vector3f normal = pMP->GetNormal();
float foundRatio = pMP->GetFoundRatio();

std::cout << "MapPoint observed by " << pMP->Observations() 
          << " KeyFrames, found ratio: " << foundRatio << std::endl;

// Predict scale for matching
float dist = (pos - cameraPos).norm();
int predictedLevel = pMP->PredictScale(dist, pKF);