Tracking

Tracking(System* pSys, 
         ORBVocabulary* pVoc, 
         FrameDrawer* pFrameDrawer, 
         MapDrawer* pMapDrawer, 
         Atlas* pAtlas,
         KeyFrameDatabase* pKFDB, 
         const string &strSettingPath, 
         const int sensor, 
         Settings* settings, 
         const string &_nameSeq = std::string())

enum eTrackingState {
    SYSTEM_NOT_READY = -1,
    NO_IMAGES_YET = 0,
    NOT_INITIALIZED = 1,
    OK = 2,
    RECENTLY_LOST = 3,
    LOST = 4,
    OK_KLT = 5
}

Sophus::SE3f GrabImageMonocular(const cv::Mat &im, 
                                const double &timestamp, 
                                string filename)

Sophus::SE3f GrabImageStereo(const cv::Mat &imRectLeft,
                             const cv::Mat &imRectRight, 
                             const double &timestamp, 
                             string filename)

Sophus::SE3f GrabImageRGBD(const cv::Mat &imRGB,
                           const cv::Mat &imD, 
                           const double &timestamp, 
                           string filename)

void GrabImuData(const IMU::Point &imuMeasurement)

void SetLocalMapper(LocalMapping* pLocalMapper)

void SetLoopClosing(LoopClosing* pLoopClosing)

void SetViewer(Viewer* pViewer)

void ChangeCalibration(const string &strSettingPath)

void InformOnlyTracking(const bool &flag)

void SetStepByStep(bool bSet)

bool GetStepByStep()

void Reset(bool bLocMap = false)

void ResetActiveMap(bool bLocMap = false)

void CreateMapInAtlas()

KeyFrame* GetLastKeyFrame()

int GetMatchesInliers()

vector<MapPoint*> GetLocalMapMPS()

float GetImageScale()

int GetNumberDataset()

void UpdateFrameIMU(const float s, 
                   const IMU::Bias &b, 
                   KeyFrame* pCurrentKeyFrame)

void SaveSubTrajectory(string strNameFile_frames, 
                       string strNameFile_kf, 
                       string strFolder = "")
void SaveSubTrajectory(string strNameFile_frames, 
                       string strNameFile_kf, 
                       Map* pMap)

void NewDataset()

bool ParseCamParamFile(cv::FileStorage &fSettings)

bool ParseORBParamFile(cv::FileStorage &fSettings)

bool ParseIMUParamFile(cv::FileStorage &fSettings)

eTrackingState mState;              // Current tracking state
eTrackingState mLastProcessedState;  // Last processed state
int mSensor;                         // Sensor type

Frame mCurrentFrame;  // Current frame being processed
Frame mLastFrame;     // Previous frame
cv::Mat mImGray;      // Current grayscale image
cv::Mat mImRight;     // Right image (for stereo)

list<Sophus::SE3f> mlRelativeFramePoses;  // Relative frame poses
list<KeyFrame*> mlpReferences;            // Reference keyframes
list<double> mlFrameTimes;                // Frame timestamps
list<bool> mlbLost;                       // Lost tracking flags

bool mbOnlyTracking;  // True if in localization-only mode
bool mbVO;            // True if doing visual odometry
int mTrackedFr;       // Number of tracked frames

// Tracking is typically created and managed by the System class
// Direct usage example:

ORB_SLAM3::Tracking tracker(pSystem, pVocabulary, pFrameDrawer, 
                            pMapDrawer, pAtlas, pKeyFrameDB, 
                            "config.yaml", 
                            ORB_SLAM3::System::MONOCULAR,
                            pSettings);

tracker.SetLocalMapper(pLocalMapper);
tracker.SetLoopClosing(pLoopClosing);
tracker.SetViewer(pViewer);

// Process a frame
cv::Mat image = cv::imread("frame.png", cv::IMREAD_GRAYSCALE);
Sophus::SE3f pose = tracker.GrabImageMonocular(image, timestamp, "frame.png");

if (tracker.mState == ORB_SLAM3::Tracking::OK) {
    std::cout << "Tracking OK" << std::endl;
    std::cout << "Inliers: " << tracker.GetMatchesInliers() << std::endl;
} else if (tracker.mState == ORB_SLAM3::Tracking::LOST) {
    std::cout << "Tracking lost, attempting relocalization" << std::endl;
}