2011-02-22 21:43:26 +01:00
Common Interfaces of Feature Detectors
======================================
2011-04-19 13:41:12 +02:00
.. highlight :: cpp
2011-05-04 21:22:51 +02:00
Feature detectors in OpenCV have wrappers with a common interface that enables you to easily switch
2011-02-26 12:05:10 +01:00
between different algorithms solving the same problem. All objects that implement keypoint detectors
2011-05-04 21:22:51 +02:00
inherit the
:ref: `FeatureDetector` interface.
2011-02-22 21:43:26 +01:00
.. index :: KeyPoint
2011-03-03 08:29:55 +01:00
.. KeyPoint:
2011-02-22 21:43:26 +01:00
KeyPoint
--------
2011-06-16 14:48:23 +02:00
.. ocv:class :: KeyPoint
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Data structure for salient point detectors ::
2011-02-22 21:43:26 +01:00
class KeyPoint
{
public:
// the default constructor
2011-02-26 12:05:10 +01:00
KeyPoint() : pt(0,0), size(0), angle(-1), response(0), octave(0),
2011-02-22 21:43:26 +01:00
class_id(-1) {}
// the full constructor
KeyPoint(Point2f _pt, float _size, float _angle=-1,
float _response=0, int _octave=0, int _class_id=-1)
2011-02-26 12:05:10 +01:00
: pt(_pt), size(_size), angle(_angle), response(_response),
2011-02-22 21:43:26 +01:00
octave(_octave), class_id(_class_id) {}
// another form of the full constructor
KeyPoint(float x, float y, float _size, float _angle=-1,
float _response=0, int _octave=0, int _class_id=-1)
2011-02-26 12:05:10 +01:00
: pt(x, y), size(_size), angle(_angle), response(_response),
2011-02-22 21:43:26 +01:00
octave(_octave), class_id(_class_id) {}
// converts vector of keypoints to vector of points
static void convert(const std::vector<KeyPoint>& keypoints,
std::vector<Point2f>& points2f,
const std::vector<int>& keypointIndexes=std::vector<int>());
2011-02-26 12:05:10 +01:00
// converts vector of points to the vector of keypoints, where each
2011-05-04 21:22:51 +02:00
// keypoint is assigned to the same size and the same orientation
2011-02-22 21:43:26 +01:00
static void convert(const std::vector<Point2f>& points2f,
std::vector<KeyPoint>& keypoints,
2011-02-26 12:05:10 +01:00
float size=1, float response=1, int octave=0,
2011-02-22 21:43:26 +01:00
int class_id=-1);
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
// computes overlap for pair of keypoints;
// overlap is a ratio between area of keypoint regions intersection and
2011-05-04 21:22:51 +02:00
// area of keypoint regions union (now keypoint region is a circle)
2011-02-22 21:43:26 +01:00
static float overlap(const KeyPoint& kp1, const KeyPoint& kp2);
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
Point2f pt; // coordinates of the keypoints
2011-05-04 21:22:51 +02:00
float size; // diameter of the meaningful keypoint neighborhood
2011-02-22 21:43:26 +01:00
float angle; // computed orientation of the keypoint (-1 if not applicable)
2011-02-26 12:05:10 +01:00
float response; // the response by which the most strong keypoints
2011-05-04 21:22:51 +02:00
// have been selected. Can be used for further sorting
2011-02-22 21:43:26 +01:00
// or subsampling
int octave; // octave (pyramid layer) from which the keypoint has been extracted
2011-02-26 12:05:10 +01:00
int class_id; // object class (if the keypoints need to be clustered by
// an object they belong to)
2011-02-22 21:43:26 +01:00
};
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
// writes vector of keypoints to the file storage
void write(FileStorage& fs, const string& name, const vector<KeyPoint>& keypoints);
// reads vector of keypoints from the specified file storage node
2011-02-26 12:05:10 +01:00
void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);
2011-03-03 08:29:55 +01:00
2011-04-19 13:41:12 +02:00
..
2011-02-22 21:43:26 +01:00
.. index :: FeatureDetector
.. _FeatureDetector:
FeatureDetector
---------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: FeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Abstract base class for 2D image feature detectors ::
2011-02-22 21:43:26 +01:00
class CV_EXPORTS FeatureDetector
{
public:
virtual ~FeatureDetector();
2011-02-26 12:05:10 +01:00
void detect( const Mat& image, vector<KeyPoint>& keypoints,
2011-02-22 21:43:26 +01:00
const Mat& mask=Mat() ) const;
2011-02-26 12:05:10 +01:00
void detect( const vector<Mat>& images,
vector<vector<KeyPoint> >& keypoints,
2011-02-22 21:43:26 +01:00
const vector<Mat>& masks=vector<Mat>() ) const;
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
virtual void read(const FileNode&);
virtual void write(FileStorage&) const;
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
static Ptr<FeatureDetector> create( const string& detectorType );
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
.. index :: FeatureDetector::detect
2011-02-28 22:26:43 +01:00
FeatureDetector::detect
2011-02-22 21:43:26 +01:00
---------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: void FeatureDetector::detect( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Detects keypoints in an image (first variant) or image set (second variant).
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param image: Image.
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param keypoints: Detected keypoints.
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param mask: Mask specifying where to look for keypoints (optional). It must be a char matrix with non-zero values in the region of interest.
2011-02-22 21:43:26 +01:00
2011-06-16 14:48:23 +02:00
.. ocv:function :: void FeatureDetector::detect( const vector<Mat>& images, vector<vector<KeyPoint> >& keypoints, const vector<Mat>& masks=vector<Mat>() ) const
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param images: Image set.
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param keypoints: Collection of keypoints detected in input images. ``keypoints[i]`` is a set of keypoints detected in ``images[i]`` .
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param masks: Masks for each input image specifying where to look for keypoints (optional). ``masks[i]`` is a mask for ``images[i]`` . Each element of the ``masks`` vector must be a char matrix with non-zero values in the region of interest.
2011-02-22 21:43:26 +01:00
.. index :: FeatureDetector::read
2011-02-28 22:26:43 +01:00
FeatureDetector::read
2011-02-22 21:43:26 +01:00
-------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: void FeatureDetector::read( const FileNode& fn )
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Reads a feature detector object from a file node.
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param fn: File node from which the detector is read.
2011-02-22 21:43:26 +01:00
.. index :: FeatureDetector::write
2011-02-28 22:26:43 +01:00
FeatureDetector::write
2011-02-22 21:43:26 +01:00
--------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: void FeatureDetector::write( FileStorage& fs ) const
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Writes a feature detector object to a file storage.
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
:param fs: File storage where the detector is written.
2011-02-22 21:43:26 +01:00
.. index :: FeatureDetector::create
2011-02-28 22:26:43 +01:00
FeatureDetector::create
2011-02-22 21:43:26 +01:00
---------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: Ptr<FeatureDetector> FeatureDetector::create( const string& detectorType )
2011-02-22 21:43:26 +01:00
2011-05-12 01:31:50 +02:00
Creates a feature detector by its name.
2011-02-22 21:43:26 +01:00
2011-02-26 12:05:10 +01:00
:param detectorType: Feature detector type.
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
The following detector types are supported:
2011-05-08 17:30:00 +02:00
* `` "FAST" `` -- :ref: `FastFeatureDetector`
* `` "STAR" `` -- :ref: `StarFeatureDetector`
* `` "SIFT" `` -- :ref: `SiftFeatureDetector`
* `` "SURF" `` -- :ref: `SurfFeatureDetector`
2011-05-21 00:25:53 +02:00
* `` "ORB" `` -- :ref: `OrbFeatureDetector`
2011-05-08 17:30:00 +02:00
* `` "MSER" `` -- :ref: `MserFeatureDetector`
* `` "GFTT" `` -- :ref: `GfttFeatureDetector`
* `` "HARRIS" `` -- :ref: `HarrisFeatureDetector`
2011-05-04 21:22:51 +02:00
Also a combined format is supported: feature detector adapter name ( `` "Grid" `` --
2011-05-08 17:30:00 +02:00
:ref: `GridAdaptedFeatureDetector` , `` "Pyramid" `` --
:ref: `PyramidAdaptedFeatureDetector` ) + feature detector name (see above),
for example: `` "GridFAST" `` , `` "PyramidSTAR" `` .
2011-02-22 21:43:26 +01:00
.. index :: FastFeatureDetector
.. _FastFeatureDetector:
FastFeatureDetector
-------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: FastFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Wrapping class for feature detection using the
2011-05-08 17:30:00 +02:00
:ref: `FAST` method ::
2011-02-22 21:43:26 +01:00
class FastFeatureDetector : public FeatureDetector
{
public:
FastFeatureDetector( int threshold=1, bool nonmaxSuppression=true );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
.. index :: GoodFeaturesToTrackDetector
.. _GoodFeaturesToTrackDetector:
GoodFeaturesToTrackDetector
---------------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: GoodFeaturesToTrackDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Wrapping class for feature detection using the
2011-05-08 17:30:00 +02:00
:ref: `goodFeaturesToTrack` function ::
2011-02-22 21:43:26 +01:00
class GoodFeaturesToTrackDetector : public FeatureDetector
{
public:
class Params
{
public:
2011-02-26 12:05:10 +01:00
Params( int maxCorners=1000, double qualityLevel=0.01,
double minDistance=1., int blockSize=3,
2011-02-22 21:43:26 +01:00
bool useHarrisDetector=false, double k=0.04 );
void read( const FileNode& fn );
void write( FileStorage& fs ) const;
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
int maxCorners;
double qualityLevel;
double minDistance;
int blockSize;
bool useHarrisDetector;
double k;
};
2011-02-26 12:05:10 +01:00
2011-02-22 21:43:26 +01:00
GoodFeaturesToTrackDetector( const GoodFeaturesToTrackDetector::Params& params=
GoodFeaturesToTrackDetector::Params() );
2011-02-26 12:05:10 +01:00
GoodFeaturesToTrackDetector( int maxCorners, double qualityLevel,
double minDistance, int blockSize=3,
2011-02-22 21:43:26 +01:00
bool useHarrisDetector=false, double k=0.04 );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
.. index :: MserFeatureDetector
.. _MserFeatureDetector:
MserFeatureDetector
-------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: MserFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Wrapping class for feature detection using the
2011-05-08 17:30:00 +02:00
:ref: `MSER` class ::
2011-02-22 21:43:26 +01:00
class MserFeatureDetector : public FeatureDetector
{
public:
MserFeatureDetector( CvMSERParams params=cvMSERParams() );
2011-02-26 12:05:10 +01:00
MserFeatureDetector( int delta, int minArea, int maxArea,
2011-02-22 21:43:26 +01:00
double maxVariation, double minDiversity,
2011-02-26 12:05:10 +01:00
int maxEvolution, double areaThreshold,
2011-02-22 21:43:26 +01:00
double minMargin, int edgeBlurSize );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
.. index :: StarFeatureDetector
.. _StarFeatureDetector:
StarFeatureDetector
-------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: StarFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Wrapping class for feature detection using the
2011-05-08 17:30:00 +02:00
:ref: `StarDetector` class ::
2011-02-22 21:43:26 +01:00
class StarFeatureDetector : public FeatureDetector
{
public:
2011-02-26 12:05:10 +01:00
StarFeatureDetector( int maxSize=16, int responseThreshold=30,
2011-02-22 21:43:26 +01:00
int lineThresholdProjected = 10,
int lineThresholdBinarized=8, int suppressNonmaxSize=5 );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
.. index :: SiftFeatureDetector
.. _SiftFeatureDetector:
SiftFeatureDetector
-------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: SiftFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Wrapping class for feature detection using the
2011-05-08 17:30:00 +02:00
:ref: `SIFT` class ::
2011-02-22 21:43:26 +01:00
class SiftFeatureDetector : public FeatureDetector
{
public:
2011-02-26 12:05:10 +01:00
SiftFeatureDetector(
2011-02-22 21:43:26 +01:00
const SIFT::DetectorParams& detectorParams=SIFT::DetectorParams(),
const SIFT::CommonParams& commonParams=SIFT::CommonParams() );
SiftFeatureDetector( double threshold, double edgeThreshold,
int nOctaves=SIFT::CommonParams::DEFAULT_NOCTAVES,
int nOctaveLayers=SIFT::CommonParams::DEFAULT_NOCTAVE_LAYERS,
int firstOctave=SIFT::CommonParams::DEFAULT_FIRST_OCTAVE,
int angleMode=SIFT::CommonParams::FIRST_ANGLE );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
.. index :: SurfFeatureDetector
.. _SurfFeatureDetector:
SurfFeatureDetector
-------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: SurfFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Wrapping class for feature detection using the
2011-05-08 17:30:00 +02:00
:ref: `SURF` class ::
2011-02-22 21:43:26 +01:00
class SurfFeatureDetector : public FeatureDetector
{
public:
SurfFeatureDetector( double hessianThreshold = 400., int octaves = 3,
int octaveLayers = 4 );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
2011-05-21 00:25:53 +02:00
.. index :: OrbFeatureDetector
.. _OrbFeatureDetector:
OrbFeatureDetector
-------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: OrbFeatureDetector
2011-05-21 00:25:53 +02:00
Wrapping class for feature detection using the
:ref: `ORB` class ::
class OrbFeatureDetector : public FeatureDetector
{
public:
OrbFeatureDetector( size_t n_features );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-06-09 17:20:55 +02:00
.. index :: SimpleBlobDetector
.. _SimpleBlobDetector:
SimpleBlobDetector
-------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: SimpleBlobDetector
2011-06-09 17:20:55 +02:00
Class for extracting blobs from an image ::
class SimpleBlobDetector : public FeatureDetector
{
public:
struct Params
{
Params();
float thresholdStep;
float minThreshold;
float maxThreshold;
size_t minRepeatability;
float minDistBetweenBlobs;
bool filterByColor;
uchar blobColor;
bool filterByArea;
float minArea, maxArea;
bool filterByCircularity;
float minCircularity, maxCircularity;
bool filterByInertia;
float minInertiaRatio, maxInertiaRatio;
bool filterByConvexity;
float minConvexity, maxConvexity;
};
SimpleBlobDetector(const SimpleBlobDetector::Params ¶meters = SimpleBlobDetector::Params());
protected:
...
};
2011-06-16 14:48:23 +02:00
The class implements a simple algorithm for extracting blobs from an image. It converts the source image to binary images by applying thresholding with several thresholds from `` minThreshold `` (inclusive) to `` maxThreshold `` (exclusive) with distance `` thresholdStep `` between neighboring thresholds. Then connected components are extracted from every binary image by :ocv:func: `findContours` and their centers are calculated. Centers from several binary images are grouped by their coordinates. Close centers form one group that corresponds to one blob and this is controled by the `` minDistBetweenBlobs `` parameter. Then final centers of blobs and their radiuses are estimated from these groups and returned as locations and sizes of keypoints.
2011-06-09 17:20:55 +02:00
This class performs several filtrations of returned blobs. You should set `` filterBy* `` to true/false to turn on/off corresponding filtration. Available filtrations:
* By color. This filter compares the intensity of a binary image at the center of a blob to `` blobColor `` . If they differ then the blob is filtered out. Use `` blobColor = 0 `` to extract dark blobs and `` blobColor = 255 `` to extract light blobs.
* By area. Extracted blobs will have area between `` minArea `` (inclusive) and `` maxArea `` (exclusive).
* By circularity. Extracted blobs will have circularity (:math: `\frac{4*\pi*Area}{perimeter * perimeter}` ) between `` minCircularity `` (inclusive) and `` maxCircularity `` (exclusive).
* By ratio of the minimum inertia to maximum inertia. Extracted blobs will have this ratio between `` minInertiaRatio `` (inclusive) and `` maxInertiaRatio `` (exclusive).
* By convexity. Extracted blobs will have convexity (area / area of blob convex hull) between `` minConvexity `` (inclusive) and `` maxConvexity `` (exclusive).
Default values of parameters are tuned to extract dark circular blobs.
2011-02-22 21:43:26 +01:00
.. index :: GridAdaptedFeatureDetector
.. _GridAdaptedFeatureDetector:
GridAdaptedFeatureDetector
--------------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: GridAdaptedFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Class adapting a detector to partition the source image into a grid and detect points in each cell ::
2011-02-22 21:43:26 +01:00
class GridAdaptedFeatureDetector : public FeatureDetector
{
public:
/*
* detector Detector that will be adapted.
2011-02-26 12:05:10 +01:00
* maxTotalKeypoints Maximum count of keypoints detected on the image.
2011-05-04 21:22:51 +02:00
* Only the strongest keypoints will be kept.
* gridRows Grid row count.
2011-02-22 21:43:26 +01:00
* gridCols Grid column count.
*/
2011-02-26 12:05:10 +01:00
GridAdaptedFeatureDetector( const Ptr<FeatureDetector>& detector,
int maxTotalKeypoints, int gridRows=4,
2011-02-22 21:43:26 +01:00
int gridCols=4 );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
2011-02-22 21:43:26 +01:00
.. index :: PyramidAdaptedFeatureDetector
.. _PyramidAdaptedFeatureDetector:
PyramidAdaptedFeatureDetector
-----------------------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: PyramidAdaptedFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Class adapting a detector to detect points over multiple levels of a Gaussian pyramid. Consider using this class for detectors that are not inherently scaled. ::
2011-02-22 21:43:26 +01:00
class PyramidAdaptedFeatureDetector : public FeatureDetector
{
public:
2011-02-26 12:05:10 +01:00
PyramidAdaptedFeatureDetector( const Ptr<FeatureDetector>& detector,
2011-02-22 21:43:26 +01:00
int levels=2 );
virtual void read( const FileNode& fn );
virtual void write( FileStorage& fs ) const;
protected:
...
};
2011-03-03 08:29:55 +01:00
.. index :: DynamicAdaptedFeatureDetector
2011-02-22 21:43:26 +01:00
DynamicAdaptedFeatureDetector
-----------------------------
2011-03-03 08:29:55 +01:00
2011-06-16 14:48:23 +02:00
.. ocv:class :: DynamicAdaptedFeatureDetector
2011-02-22 21:43:26 +01:00
2011-05-04 21:22:51 +02:00
Adaptively adjusting detector that iteratively detects features until the desired number is found ::
2011-03-03 08:29:55 +01:00
class DynamicAdaptedFeatureDetector: public FeatureDetector
{
public:
2011-05-12 01:31:50 +02:00
DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>& adjuster,
2011-03-03 08:29:55 +01:00
int min_features=400, int max_features=500, int max_iters=5 );
...
};
2011-02-22 21:43:26 +01:00
2011-05-08 17:30:00 +02:00
If the detector is persisted, it "remembers" the parameters
2011-05-04 21:22:51 +02:00
used for the last detection. In this case, the detector may be used for consistent numbers
of keypoints in a set of temporally related images, such as video streams or
2011-02-22 21:43:26 +01:00
panorama series.
2011-05-04 21:22:51 +02:00
`` DynamicAdaptedFeatureDetector `` uses another detector such as FAST or SURF to do the dirty work,
with the help of `` AdjusterAdapter `` .
2011-05-12 01:31:50 +02:00
If the detected number of features is not large enough,
2011-05-04 21:22:51 +02:00
`` AdjusterAdapter `` adjusts the detection parameters so that the next detection
2011-05-15 22:56:53 +02:00
results in a bigger or smaller number of features. This is repeated until either the number of desired features are found
2011-02-22 21:43:26 +01:00
or the parameters are maxed out.
2011-05-04 21:22:51 +02:00
Adapters can be easily implemented for any detector via the
`` AdjusterAdapter `` interface.
2011-02-22 21:43:26 +01:00
2011-05-12 01:31:50 +02:00
Beware that this is not thread-safe since the adjustment of parameters requires modification of the feature detector class instance.
2011-02-22 21:43:26 +01:00
2011-05-08 17:30:00 +02:00
Example of creating `` DynamicAdaptedFeatureDetector `` : ::
2011-02-22 21:43:26 +01:00
//sample usage:
2011-02-26 12:05:10 +01:00
//will create a detector that attempts to find
2011-02-22 21:43:26 +01:00
//100 - 110 FAST Keypoints, and will at most run
2011-02-26 12:05:10 +01:00
//FAST feature detection 10 times until that
2011-02-22 21:43:26 +01:00
//number of keypoints are found
Ptr<FeatureDetector> detector(new DynamicAdaptedFeatureDetector (100, 110, 10,
new FastAdjuster(20,true)));
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
2011-03-03 08:29:55 +01:00
.. index :: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector
DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector
----------------------------------------------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>& adjuster, int min_features, int max_features, int max_iters )
2011-03-03 08:29:55 +01:00
2011-05-15 22:56:53 +02:00
Constructs the class.
2011-03-03 08:29:55 +01:00
2011-05-12 01:31:50 +02:00
:param adjuster: :ref:`AdjusterAdapter` that detects features and adjusts parameters.
2011-03-03 08:29:55 +01:00
2011-05-08 17:30:00 +02:00
:param min_features: Minimum desired number of features.
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
:param max_features: Maximum desired number of features.
2011-03-03 08:29:55 +01:00
2011-05-08 17:30:00 +02:00
:param max_iters: Maximum number of times to try adjusting the feature detector parameters. For :ref:`FastAdjuster` , this number can be high, but with ``Star`` or ``Surf`` many iterations can be time-comsuming. At each iteration the detector is rerun.
2011-03-03 08:29:55 +01:00
.. index :: AdjusterAdapter
AdjusterAdapter
---------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: AdjusterAdapter
2011-03-03 08:29:55 +01:00
2011-05-12 01:31:50 +02:00
Class providing an interface for adjusting parameters of a feature detector. This interface is used by :ref: `DynamicAdaptedFeatureDetector` . It is a wrapper for :ref: `FeatureDetector` that enables adjusting parameters after feature detection. ::
2011-03-03 08:29:55 +01:00
class AdjusterAdapter: public FeatureDetector
{
public:
virtual ~AdjusterAdapter() {}
virtual void tooFew(int min, int n_detected) = 0;
virtual void tooMany(int max, int n_detected) = 0;
virtual bool good() const = 0;
};
See
2011-05-08 17:30:00 +02:00
:ref: `FastAdjuster` ,
:ref: `StarAdjuster` ,
:ref: `SurfAdjuster` for concrete implementations.
2011-03-03 08:29:55 +01:00
.. index :: AdjusterAdapter::tooFew
AdjusterAdapter::tooFew
---------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: void AdjusterAdapter::tooFew(int min, int n_detected)
2011-03-03 08:29:55 +01:00
2011-05-12 01:31:50 +02:00
Adjusts the detector parameters to detect more features.
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
:param min: Minimum desired number of features.
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
:param n_detected: Number of features detected during the latest run.
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
Example: ::
2011-03-03 08:29:55 +01:00
void FastAdjuster::tooFew(int min, int n_detected)
{
thresh_--;
}
.. index :: AdjusterAdapter::tooMany
AdjusterAdapter::tooMany
----------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: void AdjusterAdapter::tooMany(int max, int n_detected)
2011-03-03 08:29:55 +01:00
2011-05-08 17:30:00 +02:00
Adjusts the detector parameters to detect less features.
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
:param max: Maximum desired number of features.
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
:param n_detected: Number of features detected during the latest run.
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
Example: ::
2011-03-03 08:29:55 +01:00
void FastAdjuster::tooMany(int min, int n_detected)
{
thresh_++;
}
.. index :: AdjusterAdapter::good
AdjusterAdapter::good
-------------------------
2011-06-16 14:48:23 +02:00
.. ocv:function :: bool AdjusterAdapter::good() const
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
Returns false if the detector parameters cannot be adjusted any more.
Example: ::
2011-03-03 08:29:55 +01:00
bool FastAdjuster::good() const
{
return (thresh_ > 1) && (thresh_ < 200);
}
.. index :: FastAdjuster
FastAdjuster
------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: FastAdjuster
2011-03-03 08:29:55 +01:00
2011-05-15 22:56:53 +02:00
:ref: `AdjusterAdapter` for :ref: `FastFeatureDetector` . This class decreases or increases the threshold value by 1. ::
2011-03-03 08:29:55 +01:00
class FastAdjuster FastAdjuster: public AdjusterAdapter
{
public:
FastAdjuster(int init_thresh = 20, bool nonmax = true);
...
};
.. index :: StarAdjuster
StarAdjuster
------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: StarAdjuster
2011-03-03 08:29:55 +01:00
2011-05-15 22:56:53 +02:00
:ref: `AdjusterAdapter` for :ref: `StarFeatureDetector` . This class adjusts the `` responseThreshhold `` of `` StarFeatureDetector `` . ::
2011-03-03 08:29:55 +01:00
class StarAdjuster: public AdjusterAdapter
{
StarAdjuster(double initial_thresh = 30.0);
...
};
.. index :: SurfAdjuster
SurfAdjuster
------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: SurfAdjuster
2011-03-03 08:29:55 +01:00
2011-05-15 22:56:53 +02:00
:ref: `AdjusterAdapter` for :ref: `SurfFeatureDetector` . This class adjusts the `` hessianThreshold `` of `` SurfFeatureDetector `` . ::
2011-03-03 08:29:55 +01:00
class SurfAdjuster: public SurfAdjuster
{
SurfAdjuster();
...
};
.. index :: FeatureDetector
FeatureDetector
---------------
2011-06-16 14:48:23 +02:00
.. ocv:class :: FeatureDetector
2011-03-03 08:29:55 +01:00
2011-05-04 21:22:51 +02:00
Abstract base class for 2D image feature detectors ::
2011-03-03 08:29:55 +01:00
class CV_EXPORTS FeatureDetector
{
public:
virtual ~FeatureDetector();
void detect( const Mat& image, vector<KeyPoint>& keypoints,
const Mat& mask=Mat() ) const;
void detect( const vector<Mat>& images,
vector<vector<KeyPoint> >& keypoints,
const vector<Mat>& masks=vector<Mat>() ) const;
virtual void read(const FileNode&);
virtual void write(FileStorage&) const;
static Ptr<FeatureDetector> create( const string& detectorType );
protected:
...
};