WAIKeyFrame Class Reference

AR Keyframe node class. More...

#include <WAIKeyFrame.h>

Public Member Functions
	WAIKeyFrame (const cv::Mat &Tcw, unsigned long id, bool fixKF, float fx, float fy, float cx, float cy, size_t N, const std::vector< cv::KeyPoint > &vKeysUn, const cv::Mat &descriptors, WAIOrbVocabulary *vocabulary, int nScaleLevels, float fScaleFactor, const std::vector< float > &vScaleFactors, const std::vector< float > &vLevelSigma2, const std::vector< float > &vInvLevelSigma2, int nMinX, int nMinY, int nMaxX, int nMaxY, const cv::Mat &KB)
	keyframe generation during map loading More...
	WAIKeyFrame (WAIFrame &F, bool retainImg=true)
	keyframe generation from frame More...
void	SetPose (const cv::Mat &Tcw)
cv::Mat	GetPose ()
cv::Mat	GetPoseInverse ()
cv::Mat	GetCameraCenter ()
cv::Mat	GetRotation ()
cv::Mat	GetTranslation ()
void	ComputeBoW (WAIOrbVocabulary *vocabulary)
void	SetBowVector (WAIBowVector &bow)
void	AddConnection (WAIKeyFrame *pKF, int weight)
void	EraseConnection (WAIKeyFrame *pKF)
void	FindAndUpdateConnections (bool buildSpanningTree=true)
void	UpdateConnections (std::map< WAIKeyFrame *, int > KFcounter, bool buildSpanningTree)
void	UpdateBestCovisibles ()
std::set< WAIKeyFrame * >	GetConnectedKeyFrames ()
std::vector< WAIKeyFrame * >	GetVectorCovisibleKeyFrames ()
std::vector< WAIKeyFrame * >	GetBestCovisibilityKeyFrames (const int &N)
std::vector< WAIKeyFrame * >	GetCovisiblesByWeight (const int &w)
int	GetWeight (WAIKeyFrame *pKF)
const std::map< WAIKeyFrame *, int > &	GetConnectedKfWeights ()
void	AddChild (WAIKeyFrame *pKF)
void	EraseChild (WAIKeyFrame *pKF)
void	ChangeParent (WAIKeyFrame *pKF)
std::set< WAIKeyFrame * >	GetChilds ()
WAIKeyFrame *	GetParent ()
bool	hasChild (WAIKeyFrame *pKF)
void	AddLoopEdge (WAIKeyFrame *pKF)
std::set< WAIKeyFrame * >	GetLoopEdges ()
void	AddMapPoint (WAIMapPoint *pMP, size_t idx)
void	EraseMapPointMatch (WAIMapPoint *pMP)
void	EraseMapPointMatch (const size_t &idx)
void	ReplaceMapPointMatch (const size_t &idx, WAIMapPoint *pMP)
std::set< WAIMapPoint * >	GetMapPoints ()
std::vector< WAIMapPoint * >	GetMapPointMatches ()
int	TrackedMapPoints (const int &minObs)
WAIMapPoint *	GetMapPoint (const size_t &idx)
bool	hasMapPoint (WAIMapPoint *mp)
bool	isFixed () const
std::vector< size_t >	GetFeaturesInArea (const float &x, const float &y, const float &r) const
bool	IsInImage (const float &x, const float &y) const
void	SetNotErase ()
void	SetErase ()
void	SetBadFlag ()
bool	isBad ()
bool	findChildRecursive (WAIKeyFrame *kf)
float	ComputeSceneMedianDepth (const int q)
size_t	getSizeOfCvMat (const cv::Mat &mat)
size_t	getSizeOf ()
void	setTexturePath (const std::string &path)
const std::string &	getTexturePath ()
cv::Mat	getObjectMatrix ()
	get visual representation as SLPoints More...

Static Public Member Functions
static bool	weightComp (int a, int b)
static bool	lId (WAIKeyFrame *pKF1, WAIKeyFrame *pKF2)

Public Attributes
long unsigned int	mnId
const long unsigned int	mnFrameId
const double	mTimeStamp
const bool	_fixed = false
const int	mnGridCols
const int	mnGridRows
const float	mfGridElementWidthInv
const float	mfGridElementHeightInv
long unsigned int	mnMarker [7]
long unsigned int	mnLoopQuery = 0
int	mnLoopWords = 0
float	mLoopScore = -1.0
long unsigned int	mnRelocQuery = 0
int	mnRelocWords = 0
float	mRelocScore = -1.0f
cv::Mat	mTcwGBA
cv::Mat	mTcwRefGBA
const float	fx
const float	fy
const float	cx
const float	cy
const float	invfx
const float	invfy
const int	N = 0
const std::vector< cv::KeyPoint >	mvKeysUn
const cv::Mat	mDescriptors
WAIBowVector	mBowVec
WAIFeatVector	mFeatVec
cv::Mat	mTcp
const int	mnScaleLevels
const float	mfScaleFactor
const float	mfLogScaleFactor
const std::vector< float >	mvScaleFactors
const std::vector< float >	mvLevelSigma2
const std::vector< float >	mvInvLevelSigma2
const int	mnMinX
const int	mnMinY
const int	mnMaxX
const int	mnMaxY
const cv::Mat	mK
cv::Mat	imgGray
std::mutex	mMutexPose
std::mutex	mMutexConnections
std::mutex	mMutexFeatures

Static Public Attributes
static long unsigned int	nNextId = 0

Protected Attributes
cv::Mat	_Twc
cv::Mat	_Tcw
cv::Mat	Ow
	camera center More...
std::vector< WAIMapPoint * >	mvpMapPoints
std::vector< std::size_t >	mGrid [FRAME_GRID_COLS][FRAME_GRID_ROWS]
std::map< WAIKeyFrame *, int >	mConnectedKeyFrameWeights
std::vector< WAIKeyFrame * >	mvpOrderedConnectedKeyFrames
std::vector< int >	mvOrderedWeights
bool	mbFirstConnection = true
WAIKeyFrame *	mpParent = NULL
std::set< WAIKeyFrame * >	mspChildrens
std::set< WAIKeyFrame * >	mspLoopEdges
bool	mbNotErase
bool	mbToBeErased
bool	mbBad

Private Member Functions
void	AssignFeaturesToGrid ()
	this is a function from Frame, but we need it here for map loading More...
bool	PosInGrid (const cv::KeyPoint &kp, int &posX, int &posY)
	this is a function from Frame, but we need it here for map loading More...

Private Attributes
std::string	_pathToTexture

Detailed Description

AR Keyframe node class.

A Keyframe is a camera with a position and additional information about key- points that were found in this frame. It also contains descriptors for the found keypoints.

Definition at line 59 of file WAIKeyFrame.h.

Constructor & Destructor Documentation

WAIKeyFrame() [1/2]

WAIKeyFrame::WAIKeyFrame	(	const cv::Mat &	Tcw,
		unsigned long	id,
		bool	fixKF,
		float	fx,
		float	fy,
		float	cx,
		float	cy,
		size_t	N,
		const std::vector< cv::KeyPoint > &	vKeysUn,
		const cv::Mat &	descriptors,
		WAIOrbVocabulary *	vocabulary,
		int	nScaleLevels,
		float	fScaleFactor,
		const std::vector< float > &	vScaleFactors,
		const std::vector< float > &	vLevelSigma2,
		const std::vector< float > &	vInvLevelSigma2,
		int	nMinX,
		int	nMinY,
		int	nMaxX,
		int	nMaxY,
		const cv::Mat &	KB
	)

keyframe generation during map loading

load an existing keyframe (used during file load)

Definition at line 40 of file WAIKeyFrame.cpp.

  : mnId(id),
    mnFrameId(0),
    mTimeStamp(0),
    mnGridCols(FRAME_GRID_COLS),
    mnGridRows(FRAME_GRID_ROWS),
    mfGridElementWidthInv(static_cast<float>(FRAME_GRID_COLS) / (nMaxX - nMinX)),
    mfGridElementHeightInv(static_cast<float>(FRAME_GRID_ROWS) / (nMaxY - nMinY)),
    _fixed(fixKF),
    mnLoopQuery(0),
    mnLoopWords(0),
    mnRelocQuery(0),
    mnRelocWords(0),
    fx(fx),
    fy(fy),
    cx(cx),
    cy(cy),
    invfx(1 / fx),
    invfy(1 / fy),
    N((int)N),
    mvKeysUn(vKeysUn),
    mDescriptors(descriptors.clone()),
    mnScaleLevels(nScaleLevels),
    mfScaleFactor(fScaleFactor),
    mfLogScaleFactor(log(fScaleFactor)),
    mvScaleFactors(vScaleFactors),
    mvLevelSigma2(vLevelSigma2),
    mvInvLevelSigma2(vInvLevelSigma2),
    mnMinX(nMinX),
    mnMinY(nMinY),
    mnMaxX(nMaxX),
    mnMaxY(nMaxY),
    mK(K.clone()),
    mbFirstConnection(true),
    mpParent(NULL),
    mbNotErase(false),
    mbToBeErased(false),
    mbBad(false)
{
    mnMarker[0] = 0;
    mnMarker[1] = 0;
    mnMarker[2] = 0;
    mnMarker[3] = 0;
    mnMarker[4] = 0;
    mnMarker[5] = 0;
    mnMarker[6] = 0;
    //Update next id so we never have twice the same id and especially only one with 0 (this is important)
    if (id >= nNextId)
        nNextId = id + 1;
 
    mvpMapPoints = vector<WAIMapPoint*>(N, static_cast<WAIMapPoint*>(NULL));
    //set camera position
    SetPose(Tcw);
 
    //compute mBowVec and mFeatVec
    ComputeBoW(vocabulary);
 
    //assign features to grid
    AssignFeaturesToGrid();
}

WAIKeyFrame() [2/2]

WAIKeyFrame::WAIKeyFrame	(	WAIFrame &	F,
		bool	retainImg = true
	)

keyframe generation from frame

Definition at line 121 of file WAIKeyFrame.cpp.

  : mnFrameId(F.mnId),
    mTimeStamp(F.mTimeStamp),
    mnGridCols(FRAME_GRID_COLS),
    mnGridRows(FRAME_GRID_ROWS),
    mfGridElementWidthInv(F.mfGridElementWidthInv),
    mfGridElementHeightInv(F.mfGridElementHeightInv),
    _fixed(false),
    mnLoopQuery(0),
    mnLoopWords(0),
    mnRelocQuery(0),
    mnRelocWords(0),
    fx(F.fx),
    fy(F.fy),
    cx(F.cx),
    cy(F.cy),
    invfx(F.invfx),
    invfy(F.invfy),
    /* mbf(F.mbf), mb(F.mb), mThDepth(F.mThDepth),*/ N(F.N),
    /*mvKeys(F.mvKeys),*/ mvKeysUn(F.mvKeysUn),
    /* mvuRight(F.mvuRight), mvDepth(F.mvDepth),*/ mDescriptors(F.mDescriptors.clone()),
    mBowVec(F.mBowVec),
    mFeatVec(F.mFeatVec),
    mnScaleLevels(F.mnScaleLevels),
    mfScaleFactor(F.mfScaleFactor),
    mfLogScaleFactor(F.mfLogScaleFactor),
    mvScaleFactors(F.mvScaleFactors),
    mvLevelSigma2(F.mvLevelSigma2),
    mvInvLevelSigma2(F.mvInvLevelSigma2),
    mnMinX((int)F.mnMinX),
    mnMinY((int)F.mnMinY),
    mnMaxX((int)F.mnMaxX),
    mnMaxY((int)F.mnMaxY),
    mK(F.mK),
    mvpMapPoints(F.mvpMapPoints),
    /*mpORBvocabulary(F.mpORBvocabulary),*/ mbFirstConnection(true),
    mpParent(NULL),
    mbNotErase(false),
    mbToBeErased(false),
    mbBad(false) /*, mHalfBaseline(F.mb / 2)*/
{
    mnMarker[0] = 0;
    mnMarker[1] = 0;
    mnMarker[2] = 0;
    mnMarker[3] = 0;
    mnMarker[4] = 0;
    mnMarker[5] = 0;
    mnMarker[6] = 0;
    mnId        = nNextId++;
 
    for (int i = 0; i < FRAME_GRID_COLS; i++)
        for (int j = 0; j < FRAME_GRID_ROWS; j++)
            mGrid[i][j] = F.mGrid[i][j];
 
    //mGrid.resize(mnGridCols);
    //for (int i = 0; i<mnGridCols; i++)
    //{
    //    mGrid[i].resize(mnGridRows);
    //    for (int j = 0; j<mnGridRows; j++)
    //        mGrid[i][j] = F.mGrid[i][j];
    //}
 
    SetPose(F.mTcw);
 
    if (retainImg && !F.imgGray.empty())
        imgGray = F.imgGray;
}

Member Function Documentation

AddChild()

void WAIKeyFrame::AddChild

(

WAIKeyFrame *

pKF

)

Definition at line 538 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    mspChildrens.insert(pKF);
}

AddConnection()

void WAIKeyFrame::AddConnection	(	WAIKeyFrame *	pKF,
		int	weight
	)

Definition at line 265 of file WAIKeyFrame.cpp.

{
    {
        unique_lock<mutex> lock(mMutexConnections);
        if (!mConnectedKeyFrameWeights.count(pKF))
            mConnectedKeyFrameWeights[pKF] = weight;
        else if (mConnectedKeyFrameWeights[pKF] != weight)
            mConnectedKeyFrameWeights[pKF] = weight;
        else
            return;
    }
 
    UpdateBestCovisibles();
}

AddLoopEdge()

void WAIKeyFrame::AddLoopEdge

(

WAIKeyFrame *

pKF

)

Definition at line 575 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    mbNotErase = true;
    mspLoopEdges.insert(pKF);
}

AddMapPoint()

void WAIKeyFrame::AddMapPoint	(	WAIMapPoint *	pMP,
		size_t	idx
	)

Definition at line 357 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
 
    mvpMapPoints[idx] = pMP;
}

AssignFeaturesToGrid()

void WAIKeyFrame::AssignFeaturesToGrid ( )

private

this is a function from Frame, but we need it here for map loading

Definition at line 857 of file WAIKeyFrame.cpp.

{
    PROFILE_SCOPE("WAI::WAIKeyFrame::AssignFeaturesToGrid");
 
    int nReserve = (int)(0.5f * N / (FRAME_GRID_COLS * FRAME_GRID_ROWS));
    for (unsigned int i = 0; i < FRAME_GRID_COLS; i++)
        for (unsigned int j = 0; j < FRAME_GRID_ROWS; j++)
            mGrid[i][j].reserve(nReserve);
 
    for (int i = 0; i < N; i++)
    {
        const cv::KeyPoint& kp = mvKeysUn[i];
 
        int nGridPosX, nGridPosY;
        if (PosInGrid(kp, nGridPosX, nGridPosY))
            mGrid[nGridPosX][nGridPosY].push_back(i);
    }
}

ChangeParent()

void WAIKeyFrame::ChangeParent

(

WAIKeyFrame *

pKF

)

Definition at line 550 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    mpParent = pKF;
    pKF->AddChild(this);
}

ComputeBoW()

void WAIKeyFrame::ComputeBoW

(

WAIOrbVocabulary *

vocabulary

)

Definition at line 196 of file WAIKeyFrame.cpp.

{
    PROFILE_SCOPE("WAI::WAIKeyFrame::ComputeBoW");
 
    if (mBowVec.data.empty() || mFeatVec.data.empty())
    {
        //vector<cv::Mat> vCurrentDesc = ORB_SLAM2::Converter::toDescriptorVector(mDescriptors);
        // Feature vector associate features with nodes in the 4th level (from leaves up)
        // We assume the vocabulary tree has 6 levels, change the 4 otherwise
 
        // Luc: In a 6 levels and 10 branch per level voc, 4 levelup mean the 2nd level from the top
        // that make a total of 100 words. More words means more variance between keyframe and less
        // preselected keyframe but that will make also the relocalization less invariant to changes
        //vCurrentDesc, mBowVec, mFeatVec, orbVocabulary->getDepthLevels() - 2
 
        //TODO ensure level is now from the top
        vocabulary->transform(mDescriptors, mBowVec, mFeatVec);
    }
}

ComputeSceneMedianDepth()

float WAIKeyFrame::ComputeSceneMedianDepth

(

const int

q

)

Definition at line 817 of file WAIKeyFrame.cpp.

{
    vector<WAIMapPoint*> vpMapPoints;
    cv::Mat              Tcw_;
    {
        unique_lock<mutex> lock(mMutexFeatures);
        unique_lock<mutex> lock2(mMutexPose);
        vpMapPoints = mvpMapPoints;
        Tcw_        = _Tcw.clone();
    }
 
    vector<float> vDepths;
    vDepths.reserve(N);
    cv::Mat Rcw2 = Tcw_.row(2).colRange(0, 3);
    Rcw2         = Rcw2.t();
    float zcw    = Tcw_.at<float>(2, 3);
    for (int i = 0; i < N; i++)
    {
        if (mvpMapPoints[i])
        {
            WAIMapPoint* pMP  = mvpMapPoints[i];
            cv::Mat      x3Dw = pMP->GetWorldPos();
            float        z    = (float)Rcw2.dot(x3Dw) + zcw;
            vDepths.push_back(z);
        }
    }
 
    sort(vDepths.begin(), vDepths.end());
 
    return vDepths[(vDepths.size() - 1) / q];
}

EraseChild()

void WAIKeyFrame::EraseChild

(

WAIKeyFrame *

pKF

)

Definition at line 544 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    mspChildrens.erase(pKF);
}

EraseConnection()

void WAIKeyFrame::EraseConnection

(

WAIKeyFrame *

pKF

)

Definition at line 754 of file WAIKeyFrame.cpp.

{
    bool bUpdate = false;
    {
        unique_lock<mutex> lock(mMutexConnections);
        if (mConnectedKeyFrameWeights.count(pKF))
        {
            mConnectedKeyFrameWeights.erase(pKF);
            bUpdate = true;
        }
    }
 
    if (bUpdate)
        UpdateBestCovisibles();
}

EraseMapPointMatch() [1/2]

void WAIKeyFrame::EraseMapPointMatch

(

const size_t &

idx

)

Definition at line 364 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    mvpMapPoints[idx] = static_cast<WAIMapPoint*>(NULL);
}

EraseMapPointMatch() [2/2]

void WAIKeyFrame::EraseMapPointMatch

(

WAIMapPoint *

pMP

)

Definition at line 370 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    int                idx = pMP->GetIndexInKeyFrame(this);
    if (idx >= 0)
        mvpMapPoints[idx] = static_cast<WAIMapPoint*>(NULL);
}

FindAndUpdateConnections()

void WAIKeyFrame::FindAndUpdateConnections

(

bool

buildSpanningTree = true

)

Definition at line 437 of file WAIKeyFrame.cpp.

{
    //ghm1: a covisibility graph between keyframes (nodes) is maintained:
    //if two keyframes share more than 15 observations of the same map points an edge is added. The number of the common observations is the edge weight.
    map<WAIKeyFrame*, int> KFcounter;
 
    vector<WAIMapPoint*> vpMP;
 
    {
        unique_lock<mutex> lockMPs(mMutexFeatures);
        vpMP = mvpMapPoints;
    }
 
    //For all map points in keyframe check in which other keyframes are they seen
    //Increase counter for those keyframes
    for (vector<WAIMapPoint*>::iterator vit = vpMP.begin(), vend = vpMP.end(); vit != vend; vit++)
    {
        WAIMapPoint* pMP = *vit;
 
        if (!pMP)
            continue;
 
        if (pMP->isBad())
            continue;
 
        map<WAIKeyFrame*, size_t> observations = pMP->GetObservations();
 
        for (map<WAIKeyFrame*, size_t>::iterator mit = observations.begin(), mend = observations.end(); mit != mend; mit++)
        {
            if (mit->first->mnId == mnId)
                continue;
            KFcounter[mit->first]++;
        }
    }
 
    UpdateConnections(KFcounter, buildSpanningTree);
}

findChildRecursive()

bool WAIKeyFrame::findChildRecursive

(

WAIKeyFrame *

kf

)

Definition at line 730 of file WAIKeyFrame.cpp.

{
    for (auto it = mspChildrens.begin(); it != mspChildrens.end(); ++it)
    {
        if (*it != kf)
        {
            return (*it)->findChildRecursive(kf);
        }
        else
        {
            std::cout << "findChildRecursive found among children of id: " << (*it)->mnId << std::endl;
            return true;
        }
    }
 
    return false;
}

GetBestCovisibilityKeyFrames()

vector< WAIKeyFrame * > WAIKeyFrame::GetBestCovisibilityKeyFrames

(

const int &

N

)

Definition at line 316 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
    if ((int)mvpOrderedConnectedKeyFrames.size() < N)
        return mvpOrderedConnectedKeyFrames;
    else
        return vector<WAIKeyFrame*>(mvpOrderedConnectedKeyFrames.begin(), mvpOrderedConnectedKeyFrames.begin() + N);
}

GetCameraCenter()

cv::Mat WAIKeyFrame::GetCameraCenter

(

)

Definition at line 247 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexPose);
    return Ow.clone();
}

GetChilds()

std::set< WAIKeyFrame * > WAIKeyFrame::GetChilds

(

)

Definition at line 557 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    return mspChildrens;
}

GetConnectedKeyFrames()

set< WAIKeyFrame * > WAIKeyFrame::GetConnectedKeyFrames

(

)

Definition at line 301 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
    set<WAIKeyFrame*>  s;
    for (map<WAIKeyFrame*, int>::iterator mit = mConnectedKeyFrameWeights.begin(); mit != mConnectedKeyFrameWeights.end(); mit++)
        s.insert(mit->first);
    return s;
}

GetConnectedKfWeights()

const std::map< WAIKeyFrame *, int > & WAIKeyFrame::GetConnectedKfWeights

(

)

Definition at line 351 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
    return mConnectedKeyFrameWeights;
}

GetCovisiblesByWeight()

vector< WAIKeyFrame * > WAIKeyFrame::GetCovisiblesByWeight

(

const int &

w

)

Definition at line 325 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
 
    if (mvpOrderedConnectedKeyFrames.empty())
        return vector<WAIKeyFrame*>();
 
    vector<int>::iterator it = upper_bound(mvOrderedWeights.begin(), mvOrderedWeights.end(), w, WAIKeyFrame::weightComp);
    if (it == mvOrderedWeights.end())
        return vector<WAIKeyFrame*>();
    else
    {
        int n = (int)(it - mvOrderedWeights.begin());
        return vector<WAIKeyFrame*>(mvpOrderedConnectedKeyFrames.begin(), mvpOrderedConnectedKeyFrames.begin() + n);
    }
}

GetFeaturesInArea()

vector< size_t > WAIKeyFrame::GetFeaturesInArea	(	const float &	x,
		const float &	y,
		const float &	r
	)		const

Definition at line 770 of file WAIKeyFrame.cpp.

{
    vector<size_t> vIndices;
    vIndices.reserve(N);
 
    const int nMinCellX = max(0, (int)floor((x - mnMinX - r) * mfGridElementWidthInv));
    if (nMinCellX >= mnGridCols)
        return vIndices;
 
    const int nMaxCellX = min(mnGridCols - 1, (int)ceil((x - mnMinX + r) * mfGridElementWidthInv));
    if (nMaxCellX < 0)
        return vIndices;
 
    const int nMinCellY = max(0, (int)floor((y - mnMinY - r) * mfGridElementHeightInv));
    if (nMinCellY >= mnGridRows)
        return vIndices;
 
    const int nMaxCellY = min(mnGridRows - 1, (int)ceil((y - mnMinY + r) * mfGridElementHeightInv));
    if (nMaxCellY < 0)
        return vIndices;
 
    for (int ix = nMinCellX; ix <= nMaxCellX; ix++)
    {
        for (int iy = nMinCellY; iy <= nMaxCellY; iy++)
        {
            const vector<size_t> vCell = mGrid[ix][iy];
            for (size_t j = 0, jend = vCell.size(); j < jend; j++)
            {
                const cv::KeyPoint& kpUn  = mvKeysUn[vCell[j]];
                const float         distx = kpUn.pt.x - x;
                const float         disty = kpUn.pt.y - y;
 
                if (fabs(distx) < r && fabs(disty) < r)
                    vIndices.push_back(vCell[j]);
            }
        }
    }
 
    return vIndices;
}

GetLoopEdges()

set< WAIKeyFrame * > WAIKeyFrame::GetLoopEdges

(

)

Definition at line 582 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    return mspLoopEdges;
}

GetMapPoint()

WAIMapPoint * WAIKeyFrame::GetMapPoint

(

const size_t &

idx

)

Definition at line 431 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    return mvpMapPoints[idx];
}

GetMapPointMatches()

vector< WAIMapPoint * > WAIKeyFrame::GetMapPointMatches

(

)

Definition at line 425 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    return mvpMapPoints;
}

GetMapPoints()

set< WAIMapPoint * > WAIKeyFrame::GetMapPoints

(

)

Definition at line 383 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    set<WAIMapPoint*>  s;
    for (size_t i = 0, iend = mvpMapPoints.size(); i < iend; i++)
    {
        if (!mvpMapPoints[i])
            continue;
        WAIMapPoint* pMP = mvpMapPoints[i];
        if (!pMP->isBad())
            s.insert(pMP);
    }
    return s;
}

getObjectMatrix()

cv::Mat WAIKeyFrame::getObjectMatrix

(

)

get visual representation as SLPoints

Definition at line 849 of file WAIKeyFrame.cpp.

{
    cv::Mat result = _Twc.clone();
 
    return result;
}

GetParent()

WAIKeyFrame * WAIKeyFrame::GetParent

(

)

Definition at line 563 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    return mpParent;
}

GetPose()

cv::Mat WAIKeyFrame::GetPose

(

)

Definition at line 235 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexPose);
    return _Tcw.clone();
}

GetPoseInverse()

cv::Mat WAIKeyFrame::GetPoseInverse

(

)

Definition at line 241 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexPose);
    return _Twc.clone();
}

GetRotation()

cv::Mat WAIKeyFrame::GetRotation

(

)

Definition at line 253 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexPose);
    return _Tcw.rowRange(0, 3).colRange(0, 3).clone();
}

getSizeOf()

size_t WAIKeyFrame::getSizeOf

(

)

Definition at line 902 of file WAIKeyFrame.cpp.

{
    size_t size = 0;
 
    size += sizeof(*this);
 
    //size_t testImg = sizeof(imgGray);
    //size_t testImg2 = getSizeOfCvMat(imgGray);
 
    //size_t test1 = sizeof(mDescriptors);
    //size_t test2 = getSizeOfCvMat(mDescriptors);
    //add space for cv mats:
    size += getSizeOfCvMat(mTcwGBA);
    size += getSizeOfCvMat(mTcwRefGBA);
    size += getSizeOfCvMat(mDescriptors);
    size += getSizeOfCvMat(mTcp);
    size += getSizeOfCvMat(imgGray);
    size += getSizeOfCvMat(_Twc);
    size += getSizeOfCvMat(Ow);
 
    return size;
}

getSizeOfCvMat()

size_t WAIKeyFrame::getSizeOfCvMat

(

const cv::Mat &

mat

)

Definition at line 889 of file WAIKeyFrame.cpp.

{
    size_t size = 0;
    if (mat.isContinuous())
        size = mat.total() * mat.elemSize();
    else
    {
        size = mat.step[0] * mat.rows;
    }
    return size;
}

getTexturePath()

const std::string& WAIKeyFrame::getTexturePath ( )

inline

Definition at line 292 of file WAIKeyFrame.h.

{ return _pathToTexture; }

GetTranslation()

cv::Mat WAIKeyFrame::GetTranslation

(

)

Definition at line 259 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexPose);
    return _Tcw.rowRange(0, 3).col(3).clone();
}

GetVectorCovisibleKeyFrames()

vector< WAIKeyFrame * > WAIKeyFrame::GetVectorCovisibleKeyFrames

(

)

Definition at line 310 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
    return mvpOrderedConnectedKeyFrames;
}

GetWeight()

int WAIKeyFrame::GetWeight

(

WAIKeyFrame *

pKF

)

Definition at line 342 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
    if (mConnectedKeyFrameWeights.count(pKF))
        return mConnectedKeyFrameWeights[pKF];
    else
        return 0;
}

hasChild()

bool WAIKeyFrame::hasChild

(

WAIKeyFrame *

pKF

)

Definition at line 569 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lockCon(mMutexConnections);
    return mspChildrens.count(pKF);
}

hasMapPoint()

bool WAIKeyFrame::hasMapPoint

(

WAIMapPoint *

mp

)

Definition at line 925 of file WAIKeyFrame.cpp.

{
    bool result = false;
 
    for (WAIMapPoint* mmp : mvpMapPoints)
    {
        if (mmp == mp)
        {
            result = true;
            break;
        }
    }
 
    return result;
}

isBad()

bool WAIKeyFrame::isBad

(

)

Definition at line 748 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
    return mbBad;
}

isFixed()

bool WAIKeyFrame::isFixed

(

)

const

Definition at line 941 of file WAIKeyFrame.cpp.

{
    return _fixed;
}

IsInImage()

bool WAIKeyFrame::IsInImage	(	const float &	x,
		const float &	y
	)		const

Definition at line 811 of file WAIKeyFrame.cpp.

{
    return (x >= mnMinX && x < mnMaxX && y >= mnMinY && y < mnMaxY);
}

lId()

static bool WAIKeyFrame::lId ( WAIKeyFrame *  pKF1, WAIKeyFrame *  pKF2  )

inlinestatic

Definition at line 163 of file WAIKeyFrame.h.

    {
        return pKF1->mnId < pKF2->mnId;
    }

PosInGrid()

bool WAIKeyFrame::PosInGrid ( const cv::KeyPoint &  kp, int &  posX, int &  posY  )

private

this is a function from Frame, but we need it here for map loading

Definition at line 877 of file WAIKeyFrame.cpp.

{
    posX = (int)round((kp.pt.x - mnMinX) * mfGridElementWidthInv);
    posY = (int)round((kp.pt.y - mnMinY) * mfGridElementHeightInv);
 
    //Keypoint's coordinates are undistorted, which could cause to go out of the image
    if (posX < 0 || posX >= FRAME_GRID_COLS || posY < 0 || posY >= FRAME_GRID_ROWS)
        return false;
 
    return true;
}

ReplaceMapPointMatch()

void WAIKeyFrame::ReplaceMapPointMatch	(	const size_t &	idx,
		WAIMapPoint *	pMP
	)

Definition at line 378 of file WAIKeyFrame.cpp.

{
    mvpMapPoints[idx] = pMP;
}

SetBadFlag()

void WAIKeyFrame::SetBadFlag

(

)

Definition at line 610 of file WAIKeyFrame.cpp.

{
    {
        unique_lock<mutex> lock(mMutexConnections);
        if (mnId == 0)
        {
            //never delete first keyframe
            return;
        }
        else if (mbNotErase)
        {
            //never delete keyframes with this flag
            mbToBeErased = true;
            return;
        }
    }
 
    //for all connected keyframes remove this as a neighbour
    for (map<WAIKeyFrame*, int>::iterator mit = mConnectedKeyFrameWeights.begin(), mend = mConnectedKeyFrameWeights.end(); mit != mend; mit++)
    {
        mit->first->EraseConnection(this);
    }
 
    //erase observation from keypoints observed by this keyframe
    for (size_t i = 0; i < mvpMapPoints.size(); i++)
    {
        if (mvpMapPoints[i])
        {
            mvpMapPoints[i]->EraseObservation(this);
        }
    }
 
    {
        unique_lock<mutex> lock(mMutexConnections);
        unique_lock<mutex> lock1(mMutexFeatures);
 
        mConnectedKeyFrameWeights.clear();
        mvpOrderedConnectedKeyFrames.clear();
 
        // ghm1: Update Spanning Tree: As we try to cull a keyframe we have to update the parent keyframe from all his children.
        // A parent keyframe is the one that has the best covisibility with his potential child. So it is not necessaryly the parent of the culled keyframe.
        // Rather we search all connected keyframes in covisibilty graph (see GetWeight) for every child to find the best parent
        set<WAIKeyFrame*> sParentCandidates;
        sParentCandidates.insert(mpParent);
 
        // Assign at each iteration one child with a parent (the pair with highest covisibility weight)
        // Include that child as new parent candidate for the rest
        while (!mspChildrens.empty())
        {
            bool bContinue = false;
 
            int          max = -1;
            WAIKeyFrame* pC;
            WAIKeyFrame* pP;
 
            for (set<WAIKeyFrame*>::iterator sit = mspChildrens.begin(), send = mspChildrens.end(); sit != send;)
            {
                WAIKeyFrame* pKF = *sit;
                if (pKF->isBad())
                {
                    sit = mspChildrens.erase(sit);
                    continue;
                }
 
                // Check if a parent candidate is connected to the keyframe
                vector<WAIKeyFrame*> vpConnected = pKF->GetVectorCovisibleKeyFrames();
                for (size_t i = 0, iend = vpConnected.size(); i < iend; i++)
                {
                    if (vpConnected[i]->mnId == this->mnId || vpConnected[i]->isBad()) { continue; }
 
                    for (set<WAIKeyFrame*>::iterator spcit = sParentCandidates.begin(), spcend = sParentCandidates.end(); spcit != spcend; spcit++)
                    {
                        if (vpConnected[i]->mnId == (*spcit)->mnId)
                        {
                            int w = pKF->GetWeight(vpConnected[i]);
                            if (w > max)
                            {
                                pC        = pKF;
                                pP        = vpConnected[i];
                                max       = w;
                                bContinue = true;
                            }
                        }
                    }
                }
 
                sit++;
            }
 
            if (bContinue)
            {
                pC->ChangeParent(pP);
                sParentCandidates.insert(pC);
                mspChildrens.erase(pC);
            }
            else
            {
                break;
            }
        }
 
        // If a children has no covisibility links with any parent candidate, assign to the original parent of this KF
        //ghm1: (change because of exception in ChangeParent) check that the parent is not the child itself. If this is
        //the case, remove itself from covisibles and use the second best covisible as parent.
        if (!mspChildrens.empty())
        {
            for (set<WAIKeyFrame*>::iterator sit = mspChildrens.begin(); sit != mspChildrens.end(); sit++)
            {
                (*sit)->ChangeParent(mpParent);
            }
        }
 
        mpParent->EraseChild(this);
        mTcp  = _Tcw * mpParent->GetPoseInverse();
        mbBad = true;
    }
 
    //_kfDb->erase(this);
}

SetBowVector()

void WAIKeyFrame::SetBowVector

(

WAIBowVector &

bow

)

Definition at line 190 of file WAIKeyFrame.cpp.

{
    mBowVec = bow;
}

SetErase()

void WAIKeyFrame::SetErase

(

)

Definition at line 594 of file WAIKeyFrame.cpp.

{
    {
        unique_lock<mutex> lock(mMutexConnections);
        if (mspLoopEdges.empty())
        {
            mbNotErase = false;
        }
    }
 
    if (mbToBeErased)
    {
        SetBadFlag();
    }
}

SetNotErase()

void WAIKeyFrame::SetNotErase

(

)

Definition at line 588 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexConnections);
    mbNotErase = true;
}

SetPose()

void WAIKeyFrame::SetPose

(

const cv::Mat &

Tcw

)

Definition at line 216 of file WAIKeyFrame.cpp.

{
    PROFILE_SCOPE("WAI::WAIKeyFrame::SetPose");
 
    unique_lock<mutex> lock(mMutexPose);
    Tcw.copyTo(_Tcw);
    cv::Mat Rcw = _Tcw.rowRange(0, 3).colRange(0, 3);
    cv::Mat tcw = _Tcw.rowRange(0, 3).col(3);
    cv::Mat Rwc = Rcw.t();
    Ow          = -Rwc * tcw;
 
    _Twc = cv::Mat::eye(4, 4, Tcw.type());
    Rwc.copyTo(_Twc.rowRange(0, 3).colRange(0, 3));
    Ow.copyTo(_Twc.rowRange(0, 3).col(3));
    //ghm1: unused code fragments because of monocular usage
    //cv::Mat center = (cv::Mat_<float>(4, 1) << mHalfBaseline, 0, 0, 1);
    //Cw = Twc*center;
}

setTexturePath()

void WAIKeyFrame::setTexturePath ( const std::string &  path )

inline

Definition at line 291 of file WAIKeyFrame.h.

{ _pathToTexture = path; }

TrackedMapPoints()

int WAIKeyFrame::TrackedMapPoints

(

const int &

minObs

)

Definition at line 398 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
 
    int        nPoints   = 0;
    const bool bCheckObs = minObs > 0;
    for (int i = 0; i < N; i++)
    {
        WAIMapPoint* pMP = mvpMapPoints[i];
        if (pMP)
        {
            if (!pMP->isBad())
            {
                if (bCheckObs)
                {
                    if (mvpMapPoints[i]->Observations() >= minObs)
                        nPoints++;
                }
                else
                    nPoints++;
            }
        }
    }
 
    return nPoints;
}

UpdateBestCovisibles()

void WAIKeyFrame::UpdateBestCovisibles

(

)

Definition at line 280 of file WAIKeyFrame.cpp.

{
    unique_lock<mutex>              lock(mMutexConnections);
    vector<pair<int, WAIKeyFrame*>> vPairs;
    vPairs.reserve(mConnectedKeyFrameWeights.size());
    for (map<WAIKeyFrame*, int>::iterator mit = mConnectedKeyFrameWeights.begin(), mend = mConnectedKeyFrameWeights.end(); mit != mend; mit++)
        vPairs.push_back(make_pair(mit->second, mit->first));
 
    sort(vPairs.begin(), vPairs.end());
    list<WAIKeyFrame*> lKFs;
    list<int>          lWs;
    for (size_t i = 0, iend = vPairs.size(); i < iend; i++)
    {
        lKFs.push_front(vPairs[i].second);
        lWs.push_front(vPairs[i].first);
    }
 
    mvpOrderedConnectedKeyFrames = vector<WAIKeyFrame*>(lKFs.begin(), lKFs.end());
    mvOrderedWeights             = vector<int>(lWs.begin(), lWs.end());
}

UpdateConnections()

void WAIKeyFrame::UpdateConnections	(	std::map< WAIKeyFrame *, int >	KFcounter,
		bool	buildSpanningTree
	)

Definition at line 475 of file WAIKeyFrame.cpp.

{
    // This should not happen
    if (KFcounter.empty())
        return;
 
    //If the counter is greater than threshold add connection
    //In case no keyframe counter is over threshold add the one with maximum counter
    int          nmax   = 0;
    WAIKeyFrame* pKFmax = NULL;
    int          th     = 15;
 
    vector<pair<int, WAIKeyFrame*>> vPairs;
    vPairs.reserve(KFcounter.size());
    for (map<WAIKeyFrame*, int>::iterator mit = KFcounter.begin(), mend = KFcounter.end(); mit != mend; mit++)
    {
        if (mit->second > nmax)
        {
            nmax   = mit->second;
            pKFmax = mit->first;
        }
        if (mit->second >= th)
        {
            vPairs.push_back(make_pair(mit->second, mit->first));
            (mit->first)->AddConnection(this, mit->second);
        }
    }
 
    if (vPairs.empty())
    {
        vPairs.push_back(make_pair(nmax, pKFmax));
        pKFmax->AddConnection(this, nmax);
    }
 
    sort(vPairs.begin(), vPairs.end());
    list<WAIKeyFrame*> lKFs;
    list<int>          lWs;
    for (size_t i = 0; i < vPairs.size(); i++)
    {
        lKFs.push_front(vPairs[i].second);
        lWs.push_front(vPairs[i].first);
    }
 
    {
        unique_lock<mutex> lockCon(mMutexConnections);
 
        // mspConnectedKeyFrames = spConnectedKeyFrames;
        mConnectedKeyFrameWeights    = KFcounter;
        mvpOrderedConnectedKeyFrames = vector<WAIKeyFrame*>(lKFs.begin(), lKFs.end());
        mvOrderedWeights             = vector<int>(lWs.begin(), lWs.end());
 
        if (mbFirstConnection && mnId != 0)
        {
            if (buildSpanningTree)
            {
                mpParent = mvpOrderedConnectedKeyFrames.front();
                mpParent->AddChild(this);
            }
            mbFirstConnection = false;
        }
    }
}

weightComp()

static bool WAIKeyFrame::weightComp ( int  a, int  b  )

inlinestatic

Definition at line 158 of file WAIKeyFrame.h.

    {
        return a > b;
    }

Member Data Documentation

_fixed

const bool WAIKeyFrame::_fixed = false

Definition at line 181 of file WAIKeyFrame.h.

_pathToTexture

std::string WAIKeyFrame::_pathToTexture

private

Definition at line 308 of file WAIKeyFrame.h.

_Tcw

cv::Mat WAIKeyFrame::_Tcw

protected

Definition at line 257 of file WAIKeyFrame.h.

_Twc

cv::Mat WAIKeyFrame::_Twc

protected

opencv coordinate representation: z-axis points to principlal point, x-axis to the right and y-axis down Infos about the pose: https://github.com/raulmur/ORB_SLAM2/issues/249

Definition at line 256 of file WAIKeyFrame.h.

cx

const float WAIKeyFrame::cx

Definition at line 214 of file WAIKeyFrame.h.

cy

const float WAIKeyFrame::cy

Definition at line 214 of file WAIKeyFrame.h.

fx

const float WAIKeyFrame::fx

Definition at line 214 of file WAIKeyFrame.h.

fy

const float WAIKeyFrame::fy

Definition at line 214 of file WAIKeyFrame.h.

imgGray

cv::Mat WAIKeyFrame::imgGray

Definition at line 248 of file WAIKeyFrame.h.

invfx

const float WAIKeyFrame::invfx

Definition at line 214 of file WAIKeyFrame.h.

invfy

const float WAIKeyFrame::invfy

Definition at line 214 of file WAIKeyFrame.h.

mbBad

bool WAIKeyFrame::mbBad

protected

Definition at line 283 of file WAIKeyFrame.h.

mbFirstConnection

bool WAIKeyFrame::mbFirstConnection = true

protected

Definition at line 275 of file WAIKeyFrame.h.

mbNotErase

bool WAIKeyFrame::mbNotErase

protected

Definition at line 281 of file WAIKeyFrame.h.

mBowVec

WAIBowVector WAIKeyFrame::mBowVec

Definition at line 226 of file WAIKeyFrame.h.

mbToBeErased

bool WAIKeyFrame::mbToBeErased

protected

Definition at line 282 of file WAIKeyFrame.h.

mConnectedKeyFrameWeights

std::map<WAIKeyFrame*, int> WAIKeyFrame::mConnectedKeyFrameWeights

protected

Definition at line 269 of file WAIKeyFrame.h.

mDescriptors

const cv::Mat WAIKeyFrame::mDescriptors

Definition at line 223 of file WAIKeyFrame.h.

mFeatVec

WAIFeatVector WAIKeyFrame::mFeatVec

Definition at line 227 of file WAIKeyFrame.h.

mfGridElementHeightInv

const float WAIKeyFrame::mfGridElementHeightInv

Definition at line 187 of file WAIKeyFrame.h.

mfGridElementWidthInv

const float WAIKeyFrame::mfGridElementWidthInv

Definition at line 186 of file WAIKeyFrame.h.

mfLogScaleFactor

const float WAIKeyFrame::mfLogScaleFactor

Definition at line 235 of file WAIKeyFrame.h.

mfScaleFactor

const float WAIKeyFrame::mfScaleFactor

Definition at line 234 of file WAIKeyFrame.h.

mGrid

std::vector<std::size_t> WAIKeyFrame::mGrid[FRAME_GRID_COLS][FRAME_GRID_ROWS]

protected

Definition at line 266 of file WAIKeyFrame.h.

mK

const cv::Mat WAIKeyFrame::mK

Definition at line 245 of file WAIKeyFrame.h.

mLoopScore

float WAIKeyFrame::mLoopScore = -1.0

Definition at line 204 of file WAIKeyFrame.h.

mMutexConnections

std::mutex WAIKeyFrame::mMutexConnections

Definition at line 287 of file WAIKeyFrame.h.

mMutexFeatures

std::mutex WAIKeyFrame::mMutexFeatures

Definition at line 288 of file WAIKeyFrame.h.

mMutexPose

std::mutex WAIKeyFrame::mMutexPose

Definition at line 286 of file WAIKeyFrame.h.

mnFrameId

const long unsigned int WAIKeyFrame::mnFrameId

Definition at line 176 of file WAIKeyFrame.h.

mnGridCols

const int WAIKeyFrame::mnGridCols

Definition at line 184 of file WAIKeyFrame.h.

mnGridRows

const int WAIKeyFrame::mnGridRows

Definition at line 185 of file WAIKeyFrame.h.

mnId

long unsigned int WAIKeyFrame::mnId

Definition at line 175 of file WAIKeyFrame.h.

mnLoopQuery

long unsigned int WAIKeyFrame::mnLoopQuery = 0

Definition at line 202 of file WAIKeyFrame.h.

mnLoopWords

int WAIKeyFrame::mnLoopWords = 0

Definition at line 203 of file WAIKeyFrame.h.

mnMarker

long unsigned int WAIKeyFrame::mnMarker[7]

Definition at line 199 of file WAIKeyFrame.h.

mnMaxX

const int WAIKeyFrame::mnMaxX

Definition at line 243 of file WAIKeyFrame.h.

mnMaxY

const int WAIKeyFrame::mnMaxY

Definition at line 244 of file WAIKeyFrame.h.

mnMinX

const int WAIKeyFrame::mnMinX

Definition at line 241 of file WAIKeyFrame.h.

mnMinY

const int WAIKeyFrame::mnMinY

Definition at line 242 of file WAIKeyFrame.h.

mnRelocQuery

long unsigned int WAIKeyFrame::mnRelocQuery = 0

Definition at line 205 of file WAIKeyFrame.h.

mnRelocWords

int WAIKeyFrame::mnRelocWords = 0

Definition at line 206 of file WAIKeyFrame.h.

mnScaleLevels

const int WAIKeyFrame::mnScaleLevels

Definition at line 233 of file WAIKeyFrame.h.

mpParent

WAIKeyFrame* WAIKeyFrame::mpParent = NULL

protected

Definition at line 276 of file WAIKeyFrame.h.

mRelocScore

float WAIKeyFrame::mRelocScore = -1.0f

Definition at line 207 of file WAIKeyFrame.h.

mspChildrens

std::set<WAIKeyFrame*> WAIKeyFrame::mspChildrens

protected

Definition at line 277 of file WAIKeyFrame.h.

mspLoopEdges

std::set<WAIKeyFrame*> WAIKeyFrame::mspLoopEdges

protected

Definition at line 278 of file WAIKeyFrame.h.

mTcp

cv::Mat WAIKeyFrame::mTcp

Definition at line 230 of file WAIKeyFrame.h.

mTcwGBA

cv::Mat WAIKeyFrame::mTcwGBA

Definition at line 210 of file WAIKeyFrame.h.

mTcwRefGBA

cv::Mat WAIKeyFrame::mTcwRefGBA

Definition at line 211 of file WAIKeyFrame.h.

mTimeStamp

const double WAIKeyFrame::mTimeStamp

Definition at line 178 of file WAIKeyFrame.h.

mvInvLevelSigma2

const std::vector<float> WAIKeyFrame::mvInvLevelSigma2

Definition at line 238 of file WAIKeyFrame.h.

mvKeysUn

const std::vector<cv::KeyPoint> WAIKeyFrame::mvKeysUn

Definition at line 220 of file WAIKeyFrame.h.

mvLevelSigma2

const std::vector<float> WAIKeyFrame::mvLevelSigma2

Definition at line 237 of file WAIKeyFrame.h.

mvOrderedWeights

std::vector<int> WAIKeyFrame::mvOrderedWeights

protected

Definition at line 272 of file WAIKeyFrame.h.

mvpMapPoints

std::vector<WAIMapPoint*> WAIKeyFrame::mvpMapPoints

protected

Definition at line 263 of file WAIKeyFrame.h.

mvpOrderedConnectedKeyFrames

std::vector<WAIKeyFrame*> WAIKeyFrame::mvpOrderedConnectedKeyFrames

protected

Definition at line 271 of file WAIKeyFrame.h.

mvScaleFactors

const std::vector<float> WAIKeyFrame::mvScaleFactors

Definition at line 236 of file WAIKeyFrame.h.

N

const int WAIKeyFrame::N = 0

Definition at line 217 of file WAIKeyFrame.h.

nNextId

long unsigned int WAIKeyFrame::nNextId = 0

static

This file is part of ORB-SLAM2.

Copyright (C) 2014-2016 Ra�l Mur-Artal <raulmur at unizar dot es> (University of Zaragoza) For more information see https://github.com/raulmur/ORB_SLAM2

ORB-SLAM2 is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ORB-SLAM2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ORB-SLAM2. If not, see http://www.gnu.org/licenses/.

Definition at line 174 of file WAIKeyFrame.h.

Ow

cv::Mat WAIKeyFrame::Ow

protected

camera center

Definition at line 259 of file WAIKeyFrame.h.

---

The documentation for this class was generated from the following files:

• WAIKeyFrame.h
• WAIKeyFrame.cpp