CVRaulMurOrb Class Reference

Orb detector and descriptor with distribution. More...

#include <CVRaulMurOrb.h>

Inherits CVFeature2D.

Public Types
enum	{ HARRIS_SCORE = 0 , FAST_SCORE = 1 }

Public Member Functions
	CVRaulMurOrb (int nfeatures, float scaleFactor, int nlevels, int iniThFAST, int minThFAST)
void	detectAndCompute (CVInputArray image, CVInputArray mask, CVVKeyPoint &keypoints, CVOutputArray descriptors, bool useProvidedKeypoints)
uint	GetLevels ()
float	GetScaleFactor ()
vector< float >	GetScaleFactors ()
vector< float >	GetInverseScaleFactors ()
vector< float >	GetScaleSigmaSquares ()
vector< float >	GetInverseScaleSigmaSquares ()

Public Attributes
CVVMat	mvImagePyramid

Protected Member Functions
void	ComputePyramid (CVMat image)
void	ComputeKeyPointsOctTree (CVVVKeyPoint &allKeypoints)
	Get the Keypoints and distribute them. More...
CVVKeyPoint	DistributeOctTree (const CVVKeyPoint &vToDistributeKeys, const int &minX, const int &maxX, const int &minY, const int &maxY, const int &nFeatures, const int &level)
	Create The tree and distribute it. More...

Protected Attributes
CVVPoint	pattern
int	nfeatures
double	scaleFactor
uint	nlevels
int	iniThFAST
int	minThFAST
vector< int >	mnFeaturesPerLevel
vector< int >	umax
vector< float >	mvScaleFactor
vector< float >	mvInvScaleFactor
vector< float >	mvLevelSigma2
vector< float >	mvInvLevelSigma2

Detailed Description

Orb detector and descriptor with distribution.

Definition at line 20 of file CVRaulMurOrb.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
HARRIS_SCORE
FAST_SCORE

Definition at line 23 of file CVRaulMurOrb.h.

    {
        HARRIS_SCORE = 0,
        FAST_SCORE   = 1
    };

Constructor & Destructor Documentation

CVRaulMurOrb()

CVRaulMurOrb::CVRaulMurOrb	(	int	nfeatures,
		float	scaleFactor,
		int	nlevels,
		int	iniThFAST,
		int	minThFAST
	)

Definition at line 365 of file CVRaulMurOrb.cpp.

  : nfeatures(_nfeatures),
    scaleFactor(_scaleFactor),
    nlevels((uint)_nlevels),
    iniThFAST(_iniThFAST),
    minThFAST(_minThFAST)
 
{
    mvScaleFactor.resize(nlevels);
    mvLevelSigma2.resize(nlevels);
    mvScaleFactor[0] = 1.0f;
    mvLevelSigma2[0] = 1.0f;
    for (uint i = 1; i < nlevels; i++)
    {
        mvScaleFactor[i] = mvScaleFactor[i - 1] * (float)scaleFactor;
        mvLevelSigma2[i] = mvScaleFactor[i] * mvScaleFactor[i];
    }
 
    mvInvScaleFactor.resize(nlevels);
    mvInvLevelSigma2.resize(nlevels);
    for (uint i = 0; i < nlevels; i++)
    {
        mvInvScaleFactor[i] = 1.0f / mvScaleFactor[i];
        mvInvLevelSigma2[i] = 1.0f / mvLevelSigma2[i];
    }
 
    mvImagePyramid.resize(nlevels);
 
    mnFeaturesPerLevel.resize(nlevels);
    float factor                   = 1.0f / (float)scaleFactor;
    float nDesiredFeaturesPerScale = nfeatures * (1 - factor) / (1 - (float)pow((double)factor, (double)nlevels));
 
    int sumFeatures = 0;
    for (uint level = 0; level < nlevels - 1; level++)
    {
        mnFeaturesPerLevel[level] = cvRound(nDesiredFeaturesPerScale);
        sumFeatures += mnFeaturesPerLevel[level];
        nDesiredFeaturesPerScale *= factor;
    }
    mnFeaturesPerLevel[nlevels - 1] = std::max(nfeatures - sumFeatures, 0);
 
    const int      npoints  = 512;
    const CVPoint* pattern0 = (const CVPoint*)bit_pattern_31_;
    std::copy(pattern0, pattern0 + npoints, std::back_inserter(pattern));
 
    // This is for orientation
    //  pre-compute the end of a row in a circular patch
    umax.resize(HALF_PATCH_SIZE + 1);
 
    int          v, v0, vmax = cvFloor(HALF_PATCH_SIZE * sqrt(2.f) / 2 + 1);
    int          vmin = cvCeil(HALF_PATCH_SIZE * sqrt(2.f) / 2);
    const double hp2  = HALF_PATCH_SIZE * HALF_PATCH_SIZE;
 
    for (v = 0; v <= vmax; ++v)
        umax[(uint)v] = cvRound(sqrt(hp2 - v * v));
 
    // Make sure we are symmetric
    for (v = HALF_PATCH_SIZE, v0 = 0; v >= vmin; --v)
    {
        while (umax[(uint)v0] == umax[(uint)v0 + 1])
            ++v0;
        umax[(uint)v] = v0;
        ++v0;
    }
}

Member Function Documentation

ComputeKeyPointsOctTree()

void CVRaulMurOrb::ComputeKeyPointsOctTree ( CVVVKeyPoint &  allKeypoints )

protected

Get the Keypoints and distribute them.

Definition at line 682 of file CVRaulMurOrb.cpp.

{
    const float W = 30;
 
    for (uint level = 0; level < nlevels; ++level)
    {
        const int minBorderX = EDGE_THRESHOLD - 3;
        const int minBorderY = minBorderX;
        const int maxBorderX = mvImagePyramid[level].cols - EDGE_THRESHOLD + 3;
        const int maxBorderY = mvImagePyramid[level].rows - EDGE_THRESHOLD + 3;
 
        CVVKeyPoint vToDistributeKeys;
        vToDistributeKeys.reserve((uint)nfeatures * 10);
 
        const float width  = (float)(maxBorderX - minBorderX);
        const float height = (float)(maxBorderY - minBorderY);
 
        // generate the Cells to look for features in
        const int nCols = (int)(width / W);
        const int nRows = (int)(height / W);
        const int wCell = (int)(ceil(width / nCols));
        const int hCell = (int)(ceil(height / nRows));
 
        for (int i = 0; i < nRows; i++)
        {
            const float iniY = (float)(minBorderY + i * hCell);
            float       maxY = iniY + hCell + 6;
 
            if (iniY >= maxBorderY - 3)
                continue;
            if (maxY > maxBorderY)
                maxY = (float)maxBorderY;
 
            for (int j = 0; j < nCols; j++)
            {
                const float iniX = (float)(minBorderX + j * wCell);
                float       maxX = iniX + wCell + 6;
                if (iniX >= maxBorderX - 6)
                    continue;
                if (maxX > maxBorderX)
                    maxX = (float)maxBorderX;
 
                CVVKeyPoint vKeysCell;
 
                // Try to get Keypoints with initial Threshold
 
                FAST(mvImagePyramid[level]
                       .rowRange((int)iniY, (int)maxY)
                       .colRange((int)iniX, (int)maxX),
                     vKeysCell,
                     iniThFAST,
                     true);
 
                // If no Keypoints are found try again with a lower Threshold
                if (vKeysCell.empty())
                {
                    FAST(mvImagePyramid[level]
                           .rowRange((int)iniY, (int)maxY)
                           .colRange((int)iniX, (int)maxX),
                         vKeysCell,
                         minThFAST,
                         true);
                }
 
                if (!vKeysCell.empty())
                {
                    for (CVVKeyPoint::iterator vit = vKeysCell.begin(); vit != vKeysCell.end(); vit++)
                    {
                        (*vit).pt.x += j * wCell;
                        (*vit).pt.y += i * hCell;
                        vToDistributeKeys.push_back(*vit);
                    }
                }
            }
        }
 
        CVVKeyPoint& keypoints = allKeypoints[level];
        keypoints.reserve((uint)nfeatures);
 
        keypoints = DistributeOctTree(vToDistributeKeys,
                                      minBorderX,
                                      maxBorderX,
                                      minBorderY,
                                      maxBorderY,
                                      mnFeaturesPerLevel[level],
                                      (int)level);
 
        const int scaledPatchSize = (int)(PATCH_SIZE * mvScaleFactor[level]);
 
        // Add border to coordinates and scale information
        const int nkps = (int)keypoints.size();
        for (uint i = 0; i < (uint)nkps; i++)
        {
            keypoints[i].pt.x += minBorderX;
            keypoints[i].pt.y += minBorderY;
            keypoints[i].octave = (int)level;
            keypoints[i].size   = (float)scaledPatchSize;
        }
    }
 
    // compute orientations
 
    for (uint level = 0; level < nlevels; ++level)
        computeOrientation(mvImagePyramid[level], allKeypoints[level], umax);
}

ComputePyramid()

void CVRaulMurOrb::ComputePyramid ( CVMat  image )

protected

Definition at line 900 of file CVRaulMurOrb.cpp.

{
    for (uint level = 0; level < (uint)nlevels; ++level)
    {
        float  scale = mvInvScaleFactor[level];
        CVSize sz(cvRound((float)image.cols * scale),
                  cvRound((float)image.rows * scale));
        CVSize wholeSize(sz.width + EDGE_THRESHOLD * 2,
                         sz.height + EDGE_THRESHOLD * 2);
        CVMat  temp(wholeSize, image.type()), masktemp;
 
        mvImagePyramid[level] = temp(CVRect(EDGE_THRESHOLD,
                                            EDGE_THRESHOLD,
                                            sz.width,
                                            sz.height));
 
        // Compute the resized image
        if (level != 0)
        {
            resize(mvImagePyramid[level - 1],
                   mvImagePyramid[level],
                   sz,
                   0,
                   0,
                   INTER_LINEAR);
 
            copyMakeBorder(mvImagePyramid[level],
                           temp,
                           EDGE_THRESHOLD,
                           EDGE_THRESHOLD,
                           EDGE_THRESHOLD,
                           EDGE_THRESHOLD,
                           BORDER_REFLECT_101 + BORDER_ISOLATED);
        }
        else
        {
            copyMakeBorder(image, temp, EDGE_THRESHOLD, EDGE_THRESHOLD, EDGE_THRESHOLD, EDGE_THRESHOLD, BORDER_REFLECT_101);
        }
    }
 
    // save image pyriamid
    /*for (int level = 0; level < nlevels; ++level) {
        string filename = "D:/Development/SLProject/debug_ouput/imagePyriamid" + to_string(level) + ".jpg";
        cv::imwrite(filename, mvImagePyramid[level]);
    }*/
}

detectAndCompute()

void CVRaulMurOrb::detectAndCompute	(	CVInputArray	_image,
		CVInputArray	_mask,
		CVVKeyPoint &	_keypoints,
		CVOutputArray	_descriptors,
		bool	useProvidedKeypoints
	)

Main detection function. Can be seperated if predefined keypoints are given or no descriptor array is given.

Remove Points from image border. Ensures that ORB_SLAM and ORB generate the same descriptors from the same keypoints.

Definition at line 810 of file CVRaulMurOrb.cpp.

{
    if (_image.empty())
        return;
 
    CVMat image = _image.getMat();
    assert(image.type() == CV_8UC1);
 
    // Pre-compute the scale pyramid
    ComputePyramid(image);
    CVMat        descriptors;
    CVVVKeyPoint allKeypoints;
    allKeypoints.resize(nlevels);
    int nkeypoints = 0;
    if (!useProvidedKeypoints)
    {
        ComputeKeyPointsOctTree(allKeypoints);
        // ComputeKeyPointsOld(allKeypoints);
        for (uint level = 0; level < nlevels; ++level)
            nkeypoints += (int)allKeypoints[level].size();
        _keypoints.clear();
        _keypoints.reserve((uint)nkeypoints);
    }
    else
    {
        //! Remove Points from image border. Ensures that ORB_SLAM and ORB
        //! generate the same descriptors from the same keypoints.
        KeyPointsFilter::runByImageBorder(_keypoints, _image.size(), 31);
        nkeypoints     = (int)_keypoints.size();
        int last_level = 0;
        for (uint index = 0; index < _keypoints.size(); index++)
        {
            if (_keypoints[index].octave > last_level)
                last_level = _keypoints[index].octave;
 
            _keypoints[index].pt /= mvScaleFactor[(uint)_keypoints[index].octave];
            allKeypoints[(uint)_keypoints[index].octave].push_back(_keypoints[index]);
        }
    }
    if (nkeypoints == 0)
        _descriptors.release();
    else if (_descriptors.needed())
    {
        _descriptors.create(nkeypoints, 32, CV_8U);
        descriptors = _descriptors.getMat();
    }
 
    int offset = 0;
    for (uint level = 0; level < nlevels; ++level)
    {
        CVVKeyPoint& keypoints       = allKeypoints[level];
        int          nkeypointsLevel = (int)keypoints.size();
 
        if (nkeypointsLevel == 0)
            continue;
        if (_descriptors.needed())
        {
            // preprocess the resized image
            CVMat workingMat = mvImagePyramid[level].clone();
            GaussianBlur(workingMat, workingMat, cv::Size(7, 7), 2, 2, BORDER_REFLECT_101);
 
            // Compute the descriptors
            CVMat desc = descriptors.rowRange(offset, offset + nkeypointsLevel);
 
            computeDescriptors(workingMat, keypoints, desc, pattern);
        }
        offset += nkeypointsLevel;
 
        // Scale keypoint coordinates
        if (level != 0)
        {
            float scale = mvScaleFactor[level]; // getScale(level, firstLevel, scaleFactor);
            for (CVVKeyPoint::iterator keypoint    = keypoints.begin(),
                                       keypointEnd = keypoints.end();
                 keypoint != keypointEnd;
                 ++keypoint)
                keypoint->pt *= scale;
        }
        // And add the keypoints to the output
        if (!useProvidedKeypoints)
        {
            _keypoints.insert(_keypoints.end(), keypoints.begin(), keypoints.end());
        }
    }
}

DistributeOctTree()

CVVKeyPoint CVRaulMurOrb::DistributeOctTree ( const CVVKeyPoint &  vToDistributeKeys, const int &  minX, const int &  maxX, const int &  minY, const int &  maxY, const int &  nFeatures, const int &  level  )

protected

Create The tree and distribute it.

Check if the nodes are empty and erase them if not

Definition at line 450 of file CVRaulMurOrb.cpp.

{
    // Compute how many initial nodes
    const int nIni = (int)round(static_cast<float>(maxX - minX) / (maxY - minY));
 
    const float hX = static_cast<float>(maxX - minX) / nIni;
 
    list<CVRaulMurExtNode> lNodes;
 
    vector<CVRaulMurExtNode*> vpIniNodes;
    vpIniNodes.resize((uint)nIni);
 
    for (int i = 0; i < nIni; i++)
    {
        CVRaulMurExtNode ni;
        // upperleft
        ni.UL = CVPoint2i((int)(hX * (float)(i)), 0);
        // upperright
        ni.UR = CVPoint2i((int)(hX * (float)(i + 1)), 0);
        // bottomleft
        ni.BL = CVPoint2i(ni.UL.x, maxY - minY);
        // bottomright
        ni.BR = CVPoint2i(ni.UR.x, maxY - minY);
        ni.vKeys.reserve(vToDistributeKeys.size());
 
        lNodes.push_back(ni);
        vpIniNodes[(uint)i] = &lNodes.back();
    }
 
    // Associate points to childs
    for (size_t i = 0; i < vToDistributeKeys.size(); i++)
    {
        const CVKeyPoint& kp = vToDistributeKeys[i];
        vpIniNodes[(uint)(kp.pt.x / hX)]->vKeys.push_back(kp);
    }
 
    list<CVRaulMurExtNode>::iterator lit = lNodes.begin();
    //! Check if the nodes are empty and erase them if not
    while (lit != lNodes.end())
    {
        if (lit->vKeys.size() == 1)
        {
            lit->bNoMore = true;
            lit++;
        }
        else if (lit->vKeys.empty())
            lit = lNodes.erase(lit);
        else
            lit++;
    }
 
    bool bFinish = false;
 
    int iteration = 0;
 
    vector<pair<int, CVRaulMurExtNode*>> vSizeAndPointerToNode;
    vSizeAndPointerToNode.reserve(lNodes.size() * 4);
 
    while (!bFinish)
    {
        int prevSize = (int)lNodes.size();
 
        lit = lNodes.begin();
 
        int nToExpand = 0;
 
        vSizeAndPointerToNode.clear();
 
        while (lit != lNodes.end())
        {
            if (lit->bNoMore)
            {
                // If node only contains one point do not subdivide and continue
                lit++;
                continue;
            }
            else
            {
                // If more than one point, subdivide
                CVRaulMurExtNode n1, n2, n3, n4;
                lit->DivideNode(n1, n2, n3, n4);
 
                // Add children if they contain points
                if (!n1.vKeys.empty())
                {
                    lNodes.push_front(n1);
                    if (!n1.vKeys.empty())
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(std::make_pair(n1.vKeys.size(), &lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }
                if (!n2.vKeys.empty())
                {
                    lNodes.push_front(n2);
                    if (n2.vKeys.size() > 1)
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(std::make_pair(n2.vKeys.size(), &lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }
                if (!n3.vKeys.empty())
                {
                    lNodes.push_front(n3);
                    if (n3.vKeys.size() > 1)
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(std::make_pair(n3.vKeys.size(), &lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }
                if (!n4.vKeys.empty())
                {
                    lNodes.push_front(n4);
                    if (n4.vKeys.size() > 1)
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(std::make_pair(n4.vKeys.size(), &lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }
 
                lit = lNodes.erase(lit);
                continue;
            }
        }
 
        // Finish if there are more nodes than required features
        // or all nodes contain just one point
 
        if ((int)lNodes.size() >= N || (int)lNodes.size() == prevSize)
        {
            bFinish = true;
        }
        else if (((int)lNodes.size() + nToExpand * 3) > N)
        {
            while (!bFinish)
            {
                prevSize = (int)lNodes.size();
 
                vector<pair<int, CVRaulMurExtNode*>> vPrevSizeAndPointerToNode = vSizeAndPointerToNode;
                vSizeAndPointerToNode.clear();
 
                sort(vPrevSizeAndPointerToNode.begin(), vPrevSizeAndPointerToNode.end());
                for (int j = (int)vPrevSizeAndPointerToNode.size() - 1; j >= 0; j--)
                {
                    CVRaulMurExtNode n1, n2, n3, n4;
                    vPrevSizeAndPointerToNode[(uint)j].second->DivideNode(n1, n2, n3, n4);
 
                    // Add childs if they contain points
                    if (!n1.vKeys.empty())
                    {
                        lNodes.push_front(n1);
                        if (n1.vKeys.size() > 1)
                        {
                            vSizeAndPointerToNode.push_back(std::make_pair(n1.vKeys.size(), &lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }
                    if (!n2.vKeys.empty())
                    {
                        lNodes.push_front(n2);
                        if (n2.vKeys.size() > 1)
                        {
                            vSizeAndPointerToNode.push_back(std::make_pair(n2.vKeys.size(), &lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }
                    if (!n3.vKeys.empty())
                    {
                        lNodes.push_front(n3);
                        if (n3.vKeys.size() > 1)
                        {
                            vSizeAndPointerToNode.push_back(std::make_pair(n3.vKeys.size(), &lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }
                    if (!n4.vKeys.empty())
                    {
                        lNodes.push_front(n4);
                        if (n4.vKeys.size() > 1)
                        {
                            vSizeAndPointerToNode.push_back(std::make_pair(n4.vKeys.size(), &lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }
 
                    lNodes.erase(vPrevSizeAndPointerToNode[(uint)j].second->lit);
 
                    if ((int)lNodes.size() >= N)
                        break;
                }
 
                if ((int)lNodes.size() >= N || (int)lNodes.size() == prevSize)
                    bFinish = true;
            }
        }
    }
 
    // Retain the best point in each node
    CVVKeyPoint vResultKeys;
    vResultKeys.reserve((uint)nfeatures);
    for (list<CVRaulMurExtNode>::iterator lit = lNodes.begin(); lit != lNodes.end(); lit++)
    {
        CVVKeyPoint& vNodeKeys   = lit->vKeys;
        CVKeyPoint*  pKP         = &vNodeKeys[0];
        float        maxResponse = pKP->response;
 
        for (size_t k = 1; k < vNodeKeys.size(); k++)
        {
            if (vNodeKeys[k].response > maxResponse)
            {
                pKP         = &vNodeKeys[k];
                maxResponse = vNodeKeys[k].response;
            }
        }
 
        vResultKeys.push_back(*pKP);
    }
 
    return vResultKeys;
}

GetInverseScaleFactors()

vector<float> CVRaulMurOrb::GetInverseScaleFactors ( )

inline

Definition at line 47 of file CVRaulMurOrb.h.

{ return mvInvScaleFactor; }

GetInverseScaleSigmaSquares()

vector<float> CVRaulMurOrb::GetInverseScaleSigmaSquares ( )

inline

Definition at line 49 of file CVRaulMurOrb.h.

{ return mvInvLevelSigma2; }

GetLevels()

uint CVRaulMurOrb::GetLevels ( )

inline

Definition at line 44 of file CVRaulMurOrb.h.

{ return nlevels; }

GetScaleFactor()

float CVRaulMurOrb::GetScaleFactor ( )

inline

Definition at line 45 of file CVRaulMurOrb.h.

{ return (float)scaleFactor; }

GetScaleFactors()

vector<float> CVRaulMurOrb::GetScaleFactors ( )

inline

Definition at line 46 of file CVRaulMurOrb.h.

{ return mvScaleFactor; }

GetScaleSigmaSquares()

vector<float> CVRaulMurOrb::GetScaleSigmaSquares ( )

inline

Definition at line 48 of file CVRaulMurOrb.h.

{ return mvLevelSigma2; }

Member Data Documentation

iniThFAST

int CVRaulMurOrb::iniThFAST

protected

Definition at line 67 of file CVRaulMurOrb.h.

minThFAST

int CVRaulMurOrb::minThFAST

protected

Definition at line 68 of file CVRaulMurOrb.h.

mnFeaturesPerLevel

vector<int> CVRaulMurOrb::mnFeaturesPerLevel

protected

Definition at line 69 of file CVRaulMurOrb.h.

mvImagePyramid

CVVMat CVRaulMurOrb::mvImagePyramid

Definition at line 51 of file CVRaulMurOrb.h.

mvInvLevelSigma2

vector<float> CVRaulMurOrb::mvInvLevelSigma2

protected

Definition at line 74 of file CVRaulMurOrb.h.

mvInvScaleFactor

vector<float> CVRaulMurOrb::mvInvScaleFactor

protected

Definition at line 72 of file CVRaulMurOrb.h.

mvLevelSigma2

vector<float> CVRaulMurOrb::mvLevelSigma2

protected

Definition at line 73 of file CVRaulMurOrb.h.

mvScaleFactor

vector<float> CVRaulMurOrb::mvScaleFactor

protected

Definition at line 71 of file CVRaulMurOrb.h.

nfeatures

int CVRaulMurOrb::nfeatures

protected

Definition at line 64 of file CVRaulMurOrb.h.

nlevels

uint CVRaulMurOrb::nlevels

protected

Definition at line 66 of file CVRaulMurOrb.h.

pattern

CVVPoint CVRaulMurOrb::pattern

protected

Definition at line 63 of file CVRaulMurOrb.h.

scaleFactor

double CVRaulMurOrb::scaleFactor

protected

Definition at line 65 of file CVRaulMurOrb.h.

umax

vector<int> CVRaulMurOrb::umax

protected

Definition at line 70 of file CVRaulMurOrb.h.

---

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

• CVRaulMurOrb.h
• CVRaulMurOrb.cpp