WAIMapPoint Class Reference

#include <WAIMapPoint.h>

Public Types
enum	RefKfSource { RefKfSource_None = 0 , RefKfSource_Constructor = 1 , RefKfSource_EraseObservation = 2 }

Public Member Functions
	WAIMapPoint (int id, const cv::Mat &Pos, bool fixMp)
	constructor used during map loading More...
	WAIMapPoint (const cv::Mat &Pos, WAIKeyFrame *pRefKF)
WAI::V3	worldPosVec ()
WAI::V3	normalVec ()
void	worldPosVec (WAI::V3)
void	SetWorldPos (const cv::Mat &Pos)
cv::Mat	GetWorldPos ()
cv::Mat	GetNormal ()
void	SetNormal (const cv::Mat &normal)
WAIKeyFrame *	GetReferenceKeyFrame ()
std::map< WAIKeyFrame *, size_t >	GetObservations ()
int	Observations ()
void	AddObservation (WAIKeyFrame *pKF, size_t idx)
void	EraseObservation (WAIKeyFrame *pKF)
int	GetIndexInKeyFrame (WAIKeyFrame *pKF)
bool	IsInKeyFrame (WAIKeyFrame *pKF)
void	SetBadFlag ()
bool	isBad ()
void	Replace (WAIMapPoint *pMP)
WAIMapPoint *	GetReplaced ()
void	IncreaseVisible (int n=1)
void	IncreaseFound (int n=1)
float	GetFoundRatio ()
void	ComputeDistinctiveDescriptors ()
cv::Mat	GetDescriptor ()
void	SetDescriptor (const cv::Mat &descriptor)
void	UpdateNormalAndDepth ()
float	GetMinDistanceInvariance ()
float	GetMaxDistanceInvariance ()
int	PredictScale (const float &currentDist, WAIKeyFrame *pF)
int	PredictScale (const float &currentDist, WAIFrame *pF)
WAIKeyFrame *	refKf () const
void	refKf (WAIKeyFrame *refKf)
size_t	getSizeOfCvMat (const cv::Mat &mat)
size_t	getSizeOf ()
bool	isFixed () const
bool	loadedFromMap ()
float	GetMaxDistance ()
float	GetMinDistance ()
void	SetMaxDistance (float maxDist)
void	SetMinDistance (float minDist)

Public Attributes
RefKfSource	refKfSource = RefKfSource_None
long unsigned int	mnId = -1
long int	mnFirstKFid
int	nObs = 0
float	mTrackProjX = 0.0f
float	mTrackProjY = 0.0f
bool	mbTrackInView = false
int	mnTrackScaleLevel = 0
float	mTrackViewCos = 0.0f
long unsigned int	mnLastFrameSeen = 0
int	mnMarker [7]
long unsigned int	mnCorrectedByKF
long unsigned int	mnCorrectedReference
cv::Mat	mPosGBA

Static Public Attributes
static long unsigned int	nNextId = 0
static std::mutex	mGlobalMutex
static std::mutex	mMutexMapPointCreation

Protected Attributes
bool	_fixed = false
bool	_loadedFromMap = false
cv::Mat	mWorldPos
std::map< WAIKeyFrame *, size_t >	mObservations
cv::Mat	mNormalVector
cv::Mat	mDescriptor
WAIKeyFrame *	mpRefKF = NULL
int	mnVisible = 0
int	mnFound = 0
bool	mbBad = false
WAIMapPoint *	mpReplaced
float	mfMinDistance = 0.f
float	mfMaxDistance = 0.f
std::mutex	mMutexPos
std::mutex	mMutexFeatures

Detailed Description

Definition at line 39 of file WAIMapPoint.h.

Member Enumeration Documentation

RefKfSource

enum WAIMapPoint::RefKfSource

Enumerator
RefKfSource_None
RefKfSource_Constructor
RefKfSource_EraseObservation

Definition at line 93 of file WAIMapPoint.h.

    {
        RefKfSource_None             = 0,
        RefKfSource_Constructor      = 1,
        RefKfSource_EraseObservation = 2
    };

Constructor & Destructor Documentation

WAIMapPoint() [1/2]

WAIMapPoint::WAIMapPoint	(	int	id,
		const cv::Mat &	Pos,
		bool	fixMp
	)

constructor used during map loading

Definition at line 22 of file WAIMapPoint.cpp.

  : mnId(id),
    mnFirstKFid(-1),
    /* mnFirstFrame(pRefKF->mnFrameId), */ nObs(0),
    mnLastFrameSeen(0),
    mnCorrectedByKF(0),
    mnCorrectedReference(0),
    mpRefKF(NULL),
    mnVisible(1),
    mnFound(1),
    mbBad(false),
    mpReplaced(static_cast<WAIMapPoint*>(NULL)),
    mfMinDistance(0),
    mfMaxDistance(0),
    _fixed(fixMp),
    _loadedFromMap(true)
{
 
    mnMarker[0] = 0;
    mnMarker[1] = 0;
    mnMarker[2] = 0;
    mnMarker[3] = 0;
    mnMarker[4] = 0;
    mnMarker[5] = 0;
    mnMarker[6] = 0;
 
    SetWorldPos(Pos);
    mNormalVector = cv::Mat::zeros(3, 1, CV_32F);
 
    //update highest used id for new map point generation
    if (id >= (int)nNextId)
        nNextId = id + 1;
}

WAIMapPoint() [2/2]

WAIMapPoint::WAIMapPoint	(	const cv::Mat &	Pos,
		WAIKeyFrame *	pRefKF
	)

Definition at line 56 of file WAIMapPoint.cpp.

  : mnFirstKFid(pRefKF->mnId),
    /* mnFirstFrame(pRefKF->mnFrameId), */
    nObs(0),
    mnLastFrameSeen(0),
    mnCorrectedByKF(0),
    mnCorrectedReference(0),
    mpRefKF(pRefKF),
    mnVisible(1),
    mnFound(1),
    mbBad(false),
    mpReplaced(static_cast<WAIMapPoint*>(NULL)),
    mfMinDistance(0),
    mfMaxDistance(0),
    _fixed(false),
    _loadedFromMap(false)
{
    mnMarker[0] = 0;
    mnMarker[1] = 0;
    mnMarker[2] = 0;
    mnMarker[3] = 0;
    mnMarker[4] = 0;
    mnMarker[5] = 0;
    mnMarker[6] = 0;
 
    SetWorldPos(Pos);
    //Pos.copyTo(mWorldPos);
    mNormalVector = cv::Mat::zeros(3, 1, CV_32F);
 
    //TODO(Luluc) remove mMutexPointCreaton on WAIMap
    // MapPoints can be created from Tracking and Local Mapping. This mutex avoid conflicts with id.
    unique_lock<mutex> lock(mMutexMapPointCreation);
    mnId = nNextId++;
 
    refKfSource = RefKfSource_Constructor;
}

Member Function Documentation

AddObservation()

void WAIMapPoint::AddObservation	(	WAIKeyFrame *	pKF,
		size_t	idx
	)

Definition at line 157 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    if (mObservations.count(pKF))
        return;
    mObservations[pKF] = idx;
    nObs++;
}

ComputeDistinctiveDescriptors()

void WAIMapPoint::ComputeDistinctiveDescriptors

(

)

Definition at line 313 of file WAIMapPoint.cpp.

{
    // Retrieve all observed descriptors
    vector<cv::Mat> vDescriptors;
 
    map<WAIKeyFrame*, size_t> observations;
 
    {
        unique_lock<mutex> lock1(mMutexFeatures);
        if (mbBad)
            return;
        observations = mObservations;
    }
 
    if (observations.empty())
        return;
 
    vDescriptors.reserve(observations.size());
 
    for (map<WAIKeyFrame*, size_t>::iterator mit = observations.begin(), mend = observations.end(); mit != mend; mit++)
    {
        WAIKeyFrame* pKF = mit->first;
 
        if (pKF && !pKF->isBad())
            vDescriptors.push_back(pKF->mDescriptors.row((int)mit->second));
    }
 
    if (vDescriptors.empty())
        return;
 
        // Compute distances between them
#ifdef _WINDOWS
    size_t N = vDescriptors.size();
 
    float** Distances = new float*[N];
    for (size_t i = 0; i < N; ++i)
        Distances[i] = new float[N];
 
    for (size_t i = 0; i < N; i++)
    {
        Distances[i][i] = 0;
        for (size_t j = i + 1; j < N; j++)
        {
            int distij      = ORBmatcher::DescriptorDistance(vDescriptors[i], vDescriptors[j]);
            Distances[i][j] = (float)distij;
            Distances[j][i] = (float)distij;
        }
    }
#else
    const size_t N = vDescriptors.size();
 
    float Distances[N][N];
    for (size_t i = 0; i < N; i++)
    {
        Distances[i][i] = 0;
        for (size_t j = i + 1; j < N; j++)
        {
            int distij      = ORBmatcher::DescriptorDistance(vDescriptors[i], vDescriptors[j]);
            Distances[i][j] = distij;
            Distances[j][i] = distij;
        }
    }
#endif
    // Take the descriptor with least median distance to the rest
    int BestMedian = INT_MAX;
    int BestIdx    = 0;
    for (size_t i = 0; i < N; i++)
    {
        vector<int> vDists(Distances[i], Distances[i] + N);
        sort(vDists.begin(), vDists.end());
        int median = vDists[(uint64_t)(0.5 * (N - 1))];
 
        if (median < BestMedian)
        {
            BestMedian = median;
            BestIdx    = (int)i;
        }
    }
 
    //free Distances
#ifdef _WINDOWS
    for (size_t i = 0; i < N; ++i)
        delete Distances[i];
    delete[] Distances;
#endif
 
    {
        unique_lock<mutex> lock(mMutexFeatures);
        mDescriptor = vDescriptors[BestIdx].clone();
    }
}

EraseObservation()

void WAIMapPoint::EraseObservation

(

WAIKeyFrame *

pKF

)

Definition at line 166 of file WAIMapPoint.cpp.

{
    bool bBad = false;
    {
        unique_lock<mutex> lock(mMutexFeatures);
        if (mObservations.count(pKF))
        {
            //int idx = mObservations[pKF];
            //if (pKF->mvuRight[idx] >= 0)
            //    nObs -= 2;
            //else
            //    nObs--;
            nObs--;
 
            mObservations.erase(pKF);
 
            if (mpRefKF == pKF)
            {
                for (auto it = mObservations.begin(); it != mObservations.end(); it++)
                {
                    WAIKeyFrame* kf = it->first;
                    if (!kf->isBad())
                    {
                        mpRefKF = kf;
                        break;
                    }
                    else
                    {
                        continue;
                    }
                }
                if (mpRefKF == pKF)
                {
                    bBad = true;
                }
                refKfSource = RefKfSource_EraseObservation;
            }
 
            // If only 2 observations or less, discard point
            if (nObs <= 2)
                bBad = true;
        }
    }
 
    if (bBad)
        SetBadFlag();
}

GetDescriptor()

cv::Mat WAIMapPoint::GetDescriptor

(

)

Definition at line 405 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    return mDescriptor.clone();
}

GetFoundRatio()

float WAIMapPoint::GetFoundRatio

(

)

Definition at line 307 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    return static_cast<float>(mnFound) / mnVisible;
}

GetIndexInKeyFrame()

int WAIMapPoint::GetIndexInKeyFrame

(

WAIKeyFrame *

pKF

)

Definition at line 417 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    if (mObservations.count(pKF))
        return (int)mObservations[pKF];
    else
        return -1;
}

GetMaxDistance()

float WAIMapPoint::GetMaxDistance

(

)

Definition at line 493 of file WAIMapPoint.cpp.

{
    return mfMaxDistance;
}

GetMaxDistanceInvariance()

float WAIMapPoint::GetMaxDistanceInvariance

(

)

Definition at line 482 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexPos);
    return 1.2f * mfMaxDistance;
}

GetMinDistance()

float WAIMapPoint::GetMinDistance

(

)

Definition at line 488 of file WAIMapPoint.cpp.

{
    return mfMinDistance;
}

GetMinDistanceInvariance()

float WAIMapPoint::GetMinDistanceInvariance

(

)

Definition at line 476 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexPos);
    return 0.8f * mfMinDistance;
}

GetNormal()

cv::Mat WAIMapPoint::GetNormal

(

)

Definition at line 139 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexPos);
    return mNormalVector.clone();
}

GetObservations()

std::map< WAIKeyFrame *, size_t > WAIMapPoint::GetObservations

(

)

Definition at line 214 of file WAIMapPoint.cpp.

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

GetReferenceKeyFrame()

WAIKeyFrame * WAIMapPoint::GetReferenceKeyFrame

(

)

Definition at line 151 of file WAIMapPoint.cpp.

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

GetReplaced()

WAIMapPoint * WAIMapPoint::GetReplaced

(

)

Definition at line 243 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock1(mMutexFeatures);
    unique_lock<mutex> lock2(mMutexPos);
    return mpReplaced;
}

getSizeOf()

size_t WAIMapPoint::getSizeOf

(

)

Definition at line 554 of file WAIMapPoint.cpp.

{
    size_t size = 0;
 
    size += sizeof(*this);
    size += getSizeOfCvMat(mWorldPos);
    size += getSizeOfCvMat(mNormalVector);
    size += getSizeOfCvMat(mDescriptor);
    size += getSizeOfCvMat(mPosGBA);
 
    return size;
}

getSizeOfCvMat()

size_t WAIMapPoint::getSizeOfCvMat

(

const cv::Mat &

mat

)

Definition at line 542 of file WAIMapPoint.cpp.

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

GetWorldPos()

cv::Mat WAIMapPoint::GetWorldPos

(

)

Definition at line 133 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexPos);
    return mWorldPos.clone();
}

IncreaseFound()

void WAIMapPoint::IncreaseFound

(

int

n = 1

)

Definition at line 301 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    mnFound += n;
}

IncreaseVisible()

void WAIMapPoint::IncreaseVisible

(

int

n = 1

)

Definition at line 295 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    mnVisible += n;
}

isBad()

bool WAIMapPoint::isBad

(

)

Definition at line 288 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    unique_lock<mutex> lock2(mMutexPos);
    return mbBad;
}

isFixed()

bool WAIMapPoint::isFixed ( ) const

inline

Definition at line 105 of file WAIMapPoint.h.

{ return _fixed; }

IsInKeyFrame()

bool WAIMapPoint::IsInKeyFrame

(

WAIKeyFrame *

pKF

)

Definition at line 426 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    return (mObservations.count(pKF));
}

loadedFromMap()

bool WAIMapPoint::loadedFromMap ( )

inline

Definition at line 106 of file WAIMapPoint.h.

{ return _loadedFromMap; }

normalVec()

WAI::V3 WAIMapPoint::normalVec

(

)

Definition at line 113 of file WAIMapPoint.cpp.

{
    WAI::V3 vec = {};
 
    if (!mNormalVector.empty())
    {
        vec.x = mNormalVector.at<float>(0, 0);
        vec.y = mNormalVector.at<float>(1, 0);
        vec.z = mNormalVector.at<float>(2, 0);
    }
    return vec;
}

Observations()

int WAIMapPoint::Observations

(

)

Definition at line 220 of file WAIMapPoint.cpp.

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

PredictScale() [1/2]

int WAIMapPoint::PredictScale	(	const float &	currentDist,
		WAIFrame *	pF
	)

Definition at line 525 of file WAIMapPoint.cpp.

{
    float ratio;
    {
        unique_lock<mutex> lock(mMutexPos);
        ratio = mfMaxDistance / currentDist;
    }
 
    int nScale = (int)ceil(log(ratio) / pF->mfLogScaleFactor);
    if (nScale < 0)
        nScale = 0;
    else if (nScale >= pF->mnScaleLevels)
        nScale = pF->mnScaleLevels - 1;
 
    return nScale;
}

PredictScale() [2/2]

int WAIMapPoint::PredictScale	(	const float &	currentDist,
		WAIKeyFrame *	pF
	)

Definition at line 508 of file WAIMapPoint.cpp.

{
    float ratio;
    {
        unique_lock<mutex> lock(mMutexPos);
        ratio = mfMaxDistance / currentDist;
    }
 
    int nScale = (int)ceil(log(ratio) / pKF->mfLogScaleFactor);
    if (nScale < 0)
        nScale = 0;
    else if (nScale >= pKF->mnScaleLevels)
        nScale = pKF->mnScaleLevels - 1;
 
    return nScale;
}

refKf() [1/2]

WAIKeyFrame* WAIMapPoint::refKf ( ) const

inline

Definition at line 90 of file WAIMapPoint.h.

{ return mpRefKF; }

refKf() [2/2]

void WAIMapPoint::refKf ( WAIKeyFrame *  refKf )

inline

Definition at line 91 of file WAIMapPoint.h.

{ mpRefKF = refKf; }

Replace()

void WAIMapPoint::Replace

(

WAIMapPoint *

pMP

)

Definition at line 250 of file WAIMapPoint.cpp.

{
    if (pMP->mnId == this->mnId)
        return;
 
    int                       nvisible, nfound;
    map<WAIKeyFrame*, size_t> obs;
    {
        unique_lock<mutex> lock1(mMutexFeatures);
        unique_lock<mutex> lock2(mMutexPos);
        obs = mObservations;
        mObservations.clear();
        mbBad      = true;
        nvisible   = mnVisible;
        nfound     = mnFound;
        mpReplaced = pMP;
    }
 
    for (map<WAIKeyFrame*, size_t>::iterator mit = obs.begin(), mend = obs.end(); mit != mend; mit++)
    {
        // Replace measurement in keyframe
        WAIKeyFrame* pKF = mit->first;
 
        if (!pMP->IsInKeyFrame(pKF))
        {
            pKF->ReplaceMapPointMatch(mit->second, pMP);
            pMP->AddObservation(pKF, mit->second);
        }
        else
        {
            pKF->EraseMapPointMatch(mit->second);
        }
    }
    pMP->IncreaseFound(nfound);
    pMP->IncreaseVisible(nvisible);
    pMP->ComputeDistinctiveDescriptors();
}

SetBadFlag()

void WAIMapPoint::SetBadFlag

(

)

Definition at line 226 of file WAIMapPoint.cpp.

{
    map<WAIKeyFrame*, size_t> obs;
    {
        unique_lock<mutex> lock1(mMutexFeatures);
        unique_lock<mutex> lock2(mMutexPos);
        mbBad = true;
        obs   = mObservations;
        mObservations.clear();
    }
    for (map<WAIKeyFrame*, size_t>::iterator mit = obs.begin(), mend = obs.end(); mit != mend; mit++)
    {
        WAIKeyFrame* pKF = mit->first;
        pKF->EraseMapPointMatch(mit->second);
    }
}

SetDescriptor()

void WAIMapPoint::SetDescriptor

(

const cv::Mat &

descriptor

)

Definition at line 411 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexFeatures);
    descriptor.copyTo(mDescriptor);
}

SetMaxDistance()

void WAIMapPoint::SetMaxDistance

(

float

maxDist

)

Definition at line 498 of file WAIMapPoint.cpp.

{
    mfMaxDistance = maxDist;
}

SetMinDistance()

void WAIMapPoint::SetMinDistance

(

float

minDist

)

Definition at line 503 of file WAIMapPoint.cpp.

{
    mfMinDistance = minDist;
}

SetNormal()

void WAIMapPoint::SetNormal

(

const cv::Mat &

normal

)

Definition at line 145 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexPos);
    normal.copyTo(mNormalVector);
}

SetWorldPos()

void WAIMapPoint::SetWorldPos

(

const cv::Mat &

Pos

)

Definition at line 126 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock2(mGlobalMutex);
    unique_lock<mutex> lock(mMutexPos);
    Pos.copyTo(mWorldPos);
}

UpdateNormalAndDepth()

void WAIMapPoint::UpdateNormalAndDepth

(

)

Definition at line 433 of file WAIMapPoint.cpp.

{
    map<WAIKeyFrame*, size_t> observations;
    WAIKeyFrame*              pRefKF;
    cv::Mat                   Pos;
    {
        unique_lock<mutex> lock1(mMutexFeatures);
        unique_lock<mutex> lock2(mMutexPos);
        if (mbBad)
            return;
        observations = mObservations;
        pRefKF       = mpRefKF;
        Pos          = mWorldPos.clone();
    }
 
    if (observations.empty())
        return;
 
    cv::Mat normal = cv::Mat::zeros(3, 1, CV_32F);
    int     n      = 0;
    for (map<WAIKeyFrame*, size_t>::iterator mit = observations.begin(), mend = observations.end(); mit != mend; mit++)
    {
        WAIKeyFrame* pKF     = mit->first;
        cv::Mat      Owi     = pKF->GetCameraCenter();
        cv::Mat      normali = mWorldPos - Owi;
        normal               = normal + normali / cv::norm(normali);
        n++;
    }
 
    cv::Mat     PC               = Pos - pRefKF->GetCameraCenter();
    const float dist             = (float)cv::norm(PC);
    const int   level            = pRefKF->mvKeysUn[observations[pRefKF]].octave;
    const float levelScaleFactor = pRefKF->mvScaleFactors[level];
    const int   nLevels          = pRefKF->mnScaleLevels;
 
    {
        unique_lock<mutex> lock3(mMutexPos);
        mfMaxDistance = dist * levelScaleFactor;
        mfMinDistance = mfMaxDistance / pRefKF->mvScaleFactors[nLevels - 1];
        mNormalVector = normal / n;
    }
}

worldPosVec() [1/2]

WAI::V3 WAIMapPoint::worldPosVec

(

)

Definition at line 95 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexPos);
    WAI::V3            vec;
    vec.x = mWorldPos.at<float>(0, 0);
    vec.y = mWorldPos.at<float>(1, 0);
    vec.z = mWorldPos.at<float>(2, 0);
    return vec;
}

worldPosVec() [2/2]

void WAIMapPoint::worldPosVec

(

WAI::V3

vec

)

Definition at line 105 of file WAIMapPoint.cpp.

{
    unique_lock<mutex> lock(mMutexPos);
    mWorldPos.at<float>(0, 0) = vec.x;
    mWorldPos.at<float>(1, 0) = vec.y;
    mWorldPos.at<float>(2, 0) = vec.z;
}

Member Data Documentation

_fixed

bool WAIMapPoint::_fixed = false

protected

Definition at line 148 of file WAIMapPoint.h.

_loadedFromMap

bool WAIMapPoint::_loadedFromMap = false

protected

Definition at line 150 of file WAIMapPoint.h.

mbBad

bool WAIMapPoint::mbBad = false

protected

Definition at line 173 of file WAIMapPoint.h.

mbTrackInView

bool WAIMapPoint::mbTrackInView = false

Definition at line 120 of file WAIMapPoint.h.

mDescriptor

cv::Mat WAIMapPoint::mDescriptor

protected

Definition at line 163 of file WAIMapPoint.h.

mfMaxDistance

float WAIMapPoint::mfMaxDistance = 0.f

protected

Definition at line 178 of file WAIMapPoint.h.

mfMinDistance

float WAIMapPoint::mfMinDistance = 0.f

protected

Definition at line 177 of file WAIMapPoint.h.

mGlobalMutex

mutex WAIMapPoint::mGlobalMutex

static

Definition at line 137 of file WAIMapPoint.h.

mMutexFeatures

std::mutex WAIMapPoint::mMutexFeatures

protected

Definition at line 181 of file WAIMapPoint.h.

mMutexMapPointCreation

mutex WAIMapPoint::mMutexMapPointCreation

static

Definition at line 138 of file WAIMapPoint.h.

mMutexPos

std::mutex WAIMapPoint::mMutexPos

protected

Definition at line 180 of file WAIMapPoint.h.

mnCorrectedByKF

long unsigned int WAIMapPoint::mnCorrectedByKF

Definition at line 132 of file WAIMapPoint.h.

mnCorrectedReference

long unsigned int WAIMapPoint::mnCorrectedReference

Definition at line 133 of file WAIMapPoint.h.

mnFirstKFid

long int WAIMapPoint::mnFirstKFid

Definition at line 111 of file WAIMapPoint.h.

mnFound

int WAIMapPoint::mnFound = 0

protected

Definition at line 170 of file WAIMapPoint.h.

mnId

long unsigned int WAIMapPoint::mnId = -1

Definition at line 108 of file WAIMapPoint.h.

mnLastFrameSeen

long unsigned int WAIMapPoint::mnLastFrameSeen = 0

Definition at line 124 of file WAIMapPoint.h.

mnMarker

int WAIMapPoint::mnMarker[7]

Definition at line 128 of file WAIMapPoint.h.

mNormalVector

cv::Mat WAIMapPoint::mNormalVector

protected

Definition at line 160 of file WAIMapPoint.h.

mnTrackScaleLevel

int WAIMapPoint::mnTrackScaleLevel = 0

Definition at line 121 of file WAIMapPoint.h.

mnVisible

int WAIMapPoint::mnVisible = 0

protected

Definition at line 169 of file WAIMapPoint.h.

mObservations

std::map<WAIKeyFrame*, size_t> WAIMapPoint::mObservations

protected

Definition at line 157 of file WAIMapPoint.h.

mPosGBA

cv::Mat WAIMapPoint::mPosGBA

Definition at line 134 of file WAIMapPoint.h.

mpRefKF

WAIKeyFrame* WAIMapPoint::mpRefKF = NULL

protected

Definition at line 166 of file WAIMapPoint.h.

mpReplaced

WAIMapPoint* WAIMapPoint::mpReplaced

protected

Definition at line 174 of file WAIMapPoint.h.

mTrackProjX

float WAIMapPoint::mTrackProjX = 0.0f

Definition at line 116 of file WAIMapPoint.h.

mTrackProjY

float WAIMapPoint::mTrackProjY = 0.0f

Definition at line 117 of file WAIMapPoint.h.

mTrackViewCos

float WAIMapPoint::mTrackViewCos = 0.0f

Definition at line 122 of file WAIMapPoint.h.

mWorldPos

cv::Mat WAIMapPoint::mWorldPos

protected

Definition at line 154 of file WAIMapPoint.h.

nNextId

long unsigned int WAIMapPoint::nNextId = 0

static

Definition at line 110 of file WAIMapPoint.h.

nObs

int WAIMapPoint::nObs = 0

Definition at line 112 of file WAIMapPoint.h.

refKfSource

RefKfSource WAIMapPoint::refKfSource = RefKfSource_None

Definition at line 100 of file WAIMapPoint.h.

---

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

• WAIMapPoint.h
• WAIMapPoint.cpp