Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor.
More...
#include <opencv2/features2d.hpp>
|
| virtual String | getDefaultName () const CV_OVERRIDE |
| virtual int | getEdgeThreshold () const =0 |
| virtual int | getFastThreshold () const =0 |
| virtual int | getFirstLevel () const =0 |
| virtual int | getMaxFeatures () const =0 |
| virtual int | getNLevels () const =0 |
| virtual int | getPatchSize () const =0 |
| virtual double | getScaleFactor () const =0 |
| virtual ORB::ScoreType | getScoreType () const =0 |
| virtual int | getWTA_K () const =0 |
| virtual void | setEdgeThreshold (int edgeThreshold)=0 |
| virtual void | setFastThreshold (int fastThreshold)=0 |
| virtual void | setFirstLevel (int firstLevel)=0 |
| virtual void | setMaxFeatures (int maxFeatures)=0 |
| virtual void | setNLevels (int nlevels)=0 |
| virtual void | setPatchSize (int patchSize)=0 |
| virtual void | setScaleFactor (double scaleFactor)=0 |
| virtual void | setScoreType (ORB::ScoreType scoreType)=0 |
| virtual void | setWTA_K (int wta_k)=0 |
| virtual | ~Feature2D () |
| virtual void | compute (InputArray image, std::vector< KeyPoint > &keypoints, OutputArray descriptors) |
| | Computes the descriptors for a set of keypoints detected in an image (first variant) or image set (second variant).
|
| virtual void | compute (InputArrayOfArrays images, std::vector< std::vector< KeyPoint > > &keypoints, OutputArrayOfArrays descriptors) |
| virtual int | defaultNorm () const |
| virtual int | descriptorSize () const |
| virtual int | descriptorType () const |
| virtual void | detect (InputArray image, std::vector< KeyPoint > &keypoints, InputArray mask=noArray()) |
| | Detects keypoints in an image (first variant) or image set (second variant).
|
| virtual void | detect (InputArrayOfArrays images, std::vector< std::vector< KeyPoint > > &keypoints, InputArrayOfArrays masks=noArray()) |
| virtual void | detectAndCompute (InputArray image, InputArray mask, std::vector< KeyPoint > &keypoints, OutputArray descriptors, bool useProvidedKeypoints=false) |
| virtual bool | empty () const CV_OVERRIDE |
| | Return true if detector object is empty.
|
| virtual void | read (const FileNode &) CV_OVERRIDE |
| | Reads algorithm parameters from a file storage.
|
| void | read (const String &fileName) |
| void | write (const Ptr< FileStorage > &fs, const String &name) const |
| void | write (const String &fileName) const |
| virtual void | write (FileStorage &) const CV_OVERRIDE |
| | Stores algorithm parameters in a file storage.
|
| void | write (FileStorage &fs, const String &name) const |
| | Algorithm () |
| virtual | ~Algorithm () |
| virtual void | clear () |
| | Clears the algorithm state.
|
| virtual void | save (const String &filename) const |
| void | write (const Ptr< FileStorage > &fs, const String &name=String()) const |
| void | write (FileStorage &fs, const String &name) const |
|
| static Ptr< ORB > | create (int nfeatures=500, float scaleFactor=1.2f, int nlevels=8, int edgeThreshold=31, int firstLevel=0, int WTA_K=2, ORB::ScoreType scoreType=ORB::HARRIS_SCORE, int patchSize=31, int fastThreshold=20) |
| | The ORB constructor.
|
| template<typename _Tp> |
| static Ptr< _Tp > | load (const String &filename, const String &objname=String()) |
| | Loads algorithm from the file.
|
| template<typename _Tp> |
| static Ptr< _Tp > | loadFromString (const String &strModel, const String &objname=String()) |
| | Loads algorithm from a String.
|
| template<typename _Tp> |
| static Ptr< _Tp > | read (const FileNode &fn) |
| | Reads algorithm from the file node.
|
Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor.
described in [232] . The algorithm uses FAST in pyramids to detect stable keypoints, selects the strongest features using FAST or Harris response, finds their orientation using first-order moments and computes the descriptors using BRIEF (where the coordinates of random point pairs (or k-tuples) are rotated according to the measured orientation).
◆ ScoreType
| Enumerator |
|---|
| HARRIS_SCORE | |
| FAST_SCORE | |
◆ create()
| Ptr< ORB > cv::ORB::create |
( |
int | nfeatures = 500, |
|
|
float | scaleFactor = 1.2f, |
|
|
int | nlevels = 8, |
|
|
int | edgeThreshold = 31, |
|
|
int | firstLevel = 0, |
|
|
int | WTA_K = 2, |
|
|
ORB::ScoreType | scoreType = ORB::HARRIS_SCORE, |
|
|
int | patchSize = 31, |
|
|
int | fastThreshold = 20 ) |
|
static |
| Python: |
|---|
| cv.ORB.create( | [, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize[, fastThreshold]]]]]]]]] | ) -> | retval |
| cv.ORB_create( | [, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize[, fastThreshold]]]]]]]]] | ) -> | retval |
The ORB constructor.
- Parameters
-
| nfeatures | The maximum number of features to retain. |
| scaleFactor | Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer. |
| nlevels | The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). |
| edgeThreshold | This is size of the border where the features are not detected. It should roughly match the patchSize parameter. |
| firstLevel | The level of pyramid to put source image to. Previous layers are filled with upscaled source image. |
| WTA_K | The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). |
| scoreType | The default HARRIS_SCORE means that Harris algorithm is used to rank features (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. |
| patchSize | size of the patch used by the oriented BRIEF descriptor. Of course, on smaller pyramid layers the perceived image area covered by a feature will be larger. |
| fastThreshold | the fast threshold |
- Examples
- samples/cpp/stitching_detailed.cpp.
◆ getDefaultName()
| virtual String cv::ORB::getDefaultName |
( |
| ) |
const |
|
virtual |
| Python: |
|---|
| cv.ORB.getDefaultName( | | ) -> | retval |
Returns the algorithm string identifier. This string is used as top level xml/yml node tag when the object is saved to a file or string.
Reimplemented from cv::Feature2D.
◆ getEdgeThreshold()
| virtual int cv::ORB::getEdgeThreshold |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getEdgeThreshold( | | ) -> | retval |
◆ getFastThreshold()
| virtual int cv::ORB::getFastThreshold |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getFastThreshold( | | ) -> | retval |
◆ getFirstLevel()
| virtual int cv::ORB::getFirstLevel |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getFirstLevel( | | ) -> | retval |
◆ getMaxFeatures()
| virtual int cv::ORB::getMaxFeatures |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getMaxFeatures( | | ) -> | retval |
◆ getNLevels()
| virtual int cv::ORB::getNLevels |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getNLevels( | | ) -> | retval |
◆ getPatchSize()
| virtual int cv::ORB::getPatchSize |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getPatchSize( | | ) -> | retval |
◆ getScaleFactor()
| virtual double cv::ORB::getScaleFactor |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getScaleFactor( | | ) -> | retval |
◆ getScoreType()
| Python: |
|---|
| cv.ORB.getScoreType( | | ) -> | retval |
◆ getWTA_K()
| virtual int cv::ORB::getWTA_K |
( |
| ) |
const |
|
pure virtual |
| Python: |
|---|
| cv.ORB.getWTA_K( | | ) -> | retval |
◆ setEdgeThreshold()
| virtual void cv::ORB::setEdgeThreshold |
( |
int | edgeThreshold | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setEdgeThreshold( | edgeThreshold | ) -> | None |
◆ setFastThreshold()
| virtual void cv::ORB::setFastThreshold |
( |
int | fastThreshold | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setFastThreshold( | fastThreshold | ) -> | None |
◆ setFirstLevel()
| virtual void cv::ORB::setFirstLevel |
( |
int | firstLevel | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setFirstLevel( | firstLevel | ) -> | None |
◆ setMaxFeatures()
| virtual void cv::ORB::setMaxFeatures |
( |
int | maxFeatures | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setMaxFeatures( | maxFeatures | ) -> | None |
◆ setNLevels()
| virtual void cv::ORB::setNLevels |
( |
int | nlevels | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setNLevels( | nlevels | ) -> | None |
◆ setPatchSize()
| virtual void cv::ORB::setPatchSize |
( |
int | patchSize | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setPatchSize( | patchSize | ) -> | None |
◆ setScaleFactor()
| virtual void cv::ORB::setScaleFactor |
( |
double | scaleFactor | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setScaleFactor( | scaleFactor | ) -> | None |
◆ setScoreType()
| Python: |
|---|
| cv.ORB.setScoreType( | scoreType | ) -> | None |
◆ setWTA_K()
| virtual void cv::ORB::setWTA_K |
( |
int | wta_k | ) |
|
|
pure virtual |
| Python: |
|---|
| cv.ORB.setWTA_K( | wta_k | ) -> | None |
◆ kBytes
| const int cv::ORB::kBytes = 32 |
|
static |
The documentation for this class was generated from the following file: