FeatureExtractorFactory Class Reference

#include <FeatureExtractorFactory.h>

Public Member Functions
	FeatureExtractorFactory ()
std::unique_ptr< ORB_SLAM2::KPextractor >	make (ExtractorType id, const cv::Size &videoFrameSize, int nLevels)
std::unique_ptr< ORB_SLAM2::KPextractor >	make (std::string extractorType, const cv::Size &videoFrameSize, int nLevels)
const std::vector< std::string > &	getExtractorIdToNames () const

Private Member Functions
std::unique_ptr< ORB_SLAM2::KPextractor >	orbExtractor (int nf, int nLevels)
std::unique_ptr< ORB_SLAM2::KPextractor >	briefExtractor (int nf, int nLevels)
std::unique_ptr< ORB_SLAM2::KPextractor >	glslExtractor (const cv::Size &videoFrameSize, int nbKeypointsBigSigma, int nbKeypointsSmallSigma, float highThrs, float lowThrs, float bigSigma, float smallSigma)

Private Attributes
std::vector< std::string >	_extractorIdToNames

Detailed Description

Definition at line 23 of file FeatureExtractorFactory.h.

Constructor & Destructor Documentation

FeatureExtractorFactory()

FeatureExtractorFactory::FeatureExtractorFactory

(

)

Definition at line 9 of file FeatureExtractorFactory.cpp.

{
    _extractorIdToNames.resize(ExtractorType_Last);
    _extractorIdToNames[ExtractorType_FAST_ORBS_1000]  = "FAST-ORBS-1000";
    _extractorIdToNames[ExtractorType_FAST_ORBS_2000]  = "FAST-ORBS-2000";
    _extractorIdToNames[ExtractorType_FAST_ORBS_3000]  = "FAST-ORBS-3000";
    _extractorIdToNames[ExtractorType_FAST_ORBS_4000]  = "FAST-ORBS-4000";
    _extractorIdToNames[ExtractorType_FAST_BRIEF_1000] = "FAST-BRIEF-1000";
    _extractorIdToNames[ExtractorType_FAST_BRIEF_2000] = "FAST-BRIEF-2000";
    _extractorIdToNames[ExtractorType_FAST_BRIEF_3000] = "FAST-BRIEF-3000";
    _extractorIdToNames[ExtractorType_FAST_BRIEF_4000] = "FAST-BRIEF-4000";
}

Member Function Documentation

briefExtractor()

std::unique_ptr< KPextractor > FeatureExtractorFactory::briefExtractor ( int  nf, int  nLevels  )

private

Definition at line 87 of file FeatureExtractorFactory.cpp.

{
    float fScaleFactor = 1.2f;
    int   fIniThFAST   = 20;
    int   fMinThFAST   = 7;
    return std::make_unique<ORB_SLAM2::BRIEFextractor>(nf,
                                                       fScaleFactor,
                                                       nLevels,
                                                       fIniThFAST,
                                                       fMinThFAST);
}

getExtractorIdToNames()

const std::vector<std::string>& FeatureExtractorFactory::getExtractorIdToNames ( ) const

inline

Definition at line 30 of file FeatureExtractorFactory.h.

    {
        return _extractorIdToNames;
    }

glslExtractor()

std::unique_ptr< KPextractor > FeatureExtractorFactory::glslExtractor ( const cv::Size &  videoFrameSize, int  nbKeypointsBigSigma, int  nbKeypointsSmallSigma, float  highThrs, float  lowThrs, float  bigSigma, float  smallSigma  )

private

Definition at line 101 of file FeatureExtractorFactory.cpp.

{
    // int nbKeypointsBigSigma, int nbKeypointsSmallSigma, float highThrs, float lowThrs, float bigSigma, float smallSigma
    return std::make_unique<GLSLextractor>(videoFrameSize.width,
                                           videoFrameSize.height,
                                           nbKeypointsBigSigma,
                                           nbKeypointsSmallSigma,
                                           highThrs,
                                           lowThrs,
                                           bigSigma,
                                           smallSigma);
}

make() [1/2]

std::unique_ptr< KPextractor > FeatureExtractorFactory::make	(	ExtractorType	id,
		const cv::Size &	videoFrameSize,
		int	nLevels
	)

Definition at line 22 of file FeatureExtractorFactory.cpp.

{
    switch (id)
    {
        case ExtractorType_FAST_ORBS_1000:
            return orbExtractor(1000, nLevels);
        case ExtractorType_FAST_ORBS_2000:
            return orbExtractor(2000, nLevels);
        case ExtractorType_FAST_ORBS_3000:
            return orbExtractor(3000, nLevels);
        case ExtractorType_FAST_ORBS_4000:
            return orbExtractor(4000, nLevels);
        case ExtractorType_FAST_BRIEF_1000:
            return briefExtractor(1000, nLevels);
        case ExtractorType_FAST_BRIEF_2000:
            return briefExtractor(2000, nLevels);
        case ExtractorType_FAST_BRIEF_3000:
            return briefExtractor(3000, nLevels);
        case ExtractorType_FAST_BRIEF_4000:
            return briefExtractor(4000, nLevels);
            /*
            #ifndef TARGET_OS_IOS
                    case ExtractorType_GLSL_1:
                        return glslExtractor(videoFrameSize, 16, 16, 0.5f, 0.10f, 1.9f, 1.3f);
                    case ExtractorType_GLSL:
                        return glslExtractor(videoFrameSize, 16, 16, 0.5f, 0.10f, 1.9f, 1.4f);
            #endif
            */
        default:
            return orbExtractor(1000, nLevels);
    }
}

make() [2/2]

std::unique_ptr< KPextractor > FeatureExtractorFactory::make	(	std::string	extractorType,
		const cv::Size &	videoFrameSize,
		int	nLevels
	)

Definition at line 57 of file FeatureExtractorFactory.cpp.

{
    std::unique_ptr<KPextractor> result = nullptr;
 
    for (int i = 0; i < _extractorIdToNames.size(); i++)
    {
        if (_extractorIdToNames[i] == extractorType)
        {
            result = make((ExtractorType)i, videoFrameSize, nLevels);
            break;
        }
    }
 
    return result;
}

orbExtractor()

std::unique_ptr< KPextractor > FeatureExtractorFactory::orbExtractor ( int  nf, int  nLevels  )

private

Definition at line 75 of file FeatureExtractorFactory.cpp.

{
    float fScaleFactor = 1.2f;
    int   fIniThFAST   = 20;
    int   fMinThFAST   = 7;
    return std::make_unique<ORB_SLAM2::ORBextractor>(nf,
                                                     fScaleFactor,
                                                     nLevels,
                                                     fIniThFAST,
                                                     fMinThFAST);
}

Member Data Documentation

_extractorIdToNames

std::vector<std::string> FeatureExtractorFactory::_extractorIdToNames

private

Definition at line 49 of file FeatureExtractorFactory.h.

---

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

• FeatureExtractorFactory.h
• FeatureExtractorFactory.cpp