Frame

namespace ORB_SLAM3 {
    class Frame;
}

Frame(const cv::Mat &imGray, const double &timeStamp, ORBextractor* extractor,
      ORBVocabulary* voc, GeometricCamera* pCamera, cv::Mat &distCoef, 
      const float &bf, const float &thDepth, Frame* pPrevF = NULL, 
      const IMU::Calib &ImuCalib = IMU::Calib());

Frame(const cv::Mat &imLeft, const cv::Mat &imRight, const double &timeStamp, 
      ORBextractor* extractorLeft, ORBextractor* extractorRight, 
      ORBVocabulary* voc, cv::Mat &K, cv::Mat &distCoef, const float &bf, 
      const float &thDepth, GeometricCamera* pCamera, Frame* pPrevF = NULL, 
      const IMU::Calib &ImuCalib = IMU::Calib());

Frame(const cv::Mat &imGray, const cv::Mat &imDepth, const double &timeStamp, 
      ORBextractor* extractor, ORBVocabulary* voc, cv::Mat &K, cv::Mat &distCoef, 
      const float &bf, const float &thDepth, GeometricCamera* pCamera, 
      Frame* pPrevF = NULL, const IMU::Calib &ImuCalib = IMU::Calib());

void ExtractORB(int flag, const cv::Mat &im, const int x0, const int x1);

void ComputeBoW();

void SetPose(const Sophus::SE3<float> &Tcw);

Sophus::SE3<float> GetPose() const;

Eigen::Vector3f GetCameraCenter();

Eigen::Matrix3f GetRotationInverse();

void SetVelocity(Eigen::Vector3f Vw);

Eigen::Vector3f GetVelocity() const;

void SetImuPoseVelocity(const Eigen::Matrix3f &Rwb, const Eigen::Vector3f &twb, 
                        const Eigen::Vector3f &Vwb);

Eigen::Matrix<float,3,1> GetImuPosition() const;

void ComputeStereoMatches();

void ComputeStereoFromRGBD(const cv::Mat &imDepth);

bool UnprojectStereo(const int &i, Eigen::Vector3f &x3D);

vector<size_t> GetFeaturesInArea(const float &x, const float &y, const float &r, 
                                  const int minLevel=-1, const int maxLevel=-1, 
                                  const bool bRight = false) const;

bool isInFrustum(MapPoint* pMP, float viewingCosLimit);

// Number of keypoints
int N;

// Keypoints (original and undistorted)
std::vector<cv::KeyPoint> mvKeys, mvKeysRight;
std::vector<cv::KeyPoint> mvKeysUn;

// ORB descriptors
cv::Mat mDescriptors, mDescriptorsRight;

// MapPoint associations
std::vector<MapPoint*> mvpMapPoints;

// Stereo coordinates and depth
std::vector<float> mvuRight;
std::vector<float> mvDepth;

// BoW representation
DBoW2::BowVector mBowVec;
DBoW2::FeatureVector mFeatVec;
ORBVocabulary* mpORBvocabulary;

// Calibration matrix
cv::Mat mK;
Eigen::Matrix3f mK_;

// Focal lengths and principal point
static float fx, fy, cx, cy;
static float invfx, invfy;

// Distortion coefficients
cv::Mat mDistCoef;

// Stereo baseline * fx
float mbf;

// Stereo baseline (meters)
float mb;

// Camera pose (world to camera)
Sophus::SE3<float> mTcw;

// Rotation and translation components
Eigen::Matrix<float,3,3> mRcw, mRwc;
Eigen::Matrix<float,3,1> mtcw, mOw;

// Pose validity flag
bool mbHasPose;

// IMU velocity
Eigen::Vector3f mVw;
bool mbHasVelocity;

// IMU bias and calibration
IMU::Bias mImuBias;
IMU::Calib mImuCalib;

// Preintegrated IMU measurements
IMU::Preintegrated* mpImuPreintegrated;
IMU::Preintegrated* mpImuPreintegratedFrame;

// Frame identification
static long unsigned int nNextId;
long unsigned int mnId;
double mTimeStamp;

// Reference keyframe
KeyFrame* mpReferenceKF;

// Previous frame
Frame* mpPrevFrame;

// Last keyframe
KeyFrame* mpLastKeyFrame;

#define FRAME_GRID_ROWS 48
#define FRAME_GRID_COLS 64

// Grid for feature matching acceleration
static float mfGridElementWidthInv;
static float mfGridElementHeightInv;
std::vector<std::size_t> mGrid[FRAME_GRID_COLS][FRAME_GRID_ROWS];

// Scale pyramid parameters
int mnScaleLevels;
float mfScaleFactor;
float mfLogScaleFactor;
vector<float> mvScaleFactors;
vector<float> mvInvScaleFactors;
vector<float> mvLevelSigma2;
vector<float> mvInvLevelSigma2;

// Create a monocular frame
cv::Mat image = cv::imread("frame.jpg", cv::IMREAD_GRAYSCALE);
Frame frame(image, timestamp, pORBextractor, pVocabulary, 
            pCamera, distCoef, bf, depthThreshold);

// Extract features
frame.ComputeBoW();

// Set pose from tracking
Sophus::SE3f Tcw = ComputePose(frame);
frame.SetPose(Tcw);

// Get camera center
Eigen::Vector3f camCenter = frame.GetCameraCenter();

// Find features in region
vector<size_t> indices = frame.GetFeaturesInArea(x, y, radius);