mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-28 21:20:18 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

update features2d documentation after changes create functions and DynamicAdaptedFeatureDetector

Browse Source
This commit is contained in:
Maria Dimashova 2010-11-25 17:44:16 +00:00
parent 1286c1db45
commit 362df22fac
2 changed files with 100 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
doc/features2d_common_detection_description.tex
View File

@ -75,6 +75,8 @@ public:
virtual void read(const FileNode&);
virtual void write(FileStorage&) const;
static Ptr<FeatureDetector> create( const string& detectorType );
protected:
...
@ -132,6 +134,31 @@ void FeatureDetector::write( FileStorage\& fs ) const;
\cvarg{fs}{File storage in which detector will be written.}
\end{description}
\cvCppFunc{FeatureDetector::create}
Feature detector factory that creates \cvCppCross{FeatureDetector} of given type with
default parameters (rather using default constructor).
\begin{lstlisting}
Ptr<FeatureDetector> FeatureDetector::create( const string& detectorType );
\end{lstlisting}
\begin{description}
\cvarg{detectorType}{Feature detector type.}
\end{description}
Now the following detector types are supported:\\
\texttt{"FAST"} -- \cvCppCross{FastFeatureDetector},\\
\texttt{"STAR"} -- \cvCppCross{StarFeatureDetector},\\
\texttt{"SIFT"} -- \cvCppCross{SiftFeatureDetector}, \\
\texttt{"SURF"} -- \cvCppCross{SurfFeatureDetector}, \\
\texttt{"MSER"} -- \cvCppCross{MserFeatureDetector}, \\
\texttt{"GFTT"} -- \cvCppCross{GfttFeatureDetector}, \\
\texttt{"HARRIS"} -- \cvCppCross{HarrisFeatureDetector}. \\
Also combined format is supported: feature detector adapter name (\texttt{"Grid"} --
\cvCppCross{GridAdaptedFeatureDetector}, \texttt{"Pyramid"} --
\cvCppCross{PyramidAdaptedFeatureDetector}) + feature detector name (see above),
e.g. \texttt{"GridFAST"}, \texttt{"PyramidSTAR"}, etc.
\cvclass{FastFeatureDetector}
Wrapping class for feature detection using \cvCppCross{FAST} method.
@ -302,21 +329,6 @@ protected:
%dynamic detectors doc
\input{features2d_dynamic_detectors}
\cvCppFunc{createFeatureDetector}
Feature detector factory that creates \cvCppCross{FeatureDetector} of given type with
default parameters (rather using default constructor).
\begin{lstlisting}
Ptr<FeatureDetector> createFeatureDetector( const string& detectorType );
\end{lstlisting}
\begin{description}
\cvarg{detectorType}{Feature detector type.}
\end{description}
Now the following detector types are supported ''FAST'', ''STAR'', ''SIFT'',
''SURF'', ''MSER'', ''GFTT'', ''HARRIS''.
\section{Common Interfaces of Descriptor Extractors}
Extractors of keypoint descriptors in OpenCV have wrappers with common interface that enables to switch easily
between different algorithms solving the same problem. This section is devoted to computing descriptors
@ -342,6 +354,8 @@ public:
virtual int descriptorSize() const = 0;
virtual int descriptorType() const = 0;
static Ptr<DescriptorExtractor> create( const string& descriptorExtractorType );
protected:
...
@ -407,6 +421,27 @@ void DescriptorExtractor::write( FileStorage\& fs ) const;
\cvarg{fs}{File storage in which detector will be written.}
\end{description}
\cvCppFunc{DescriptorExtractor::create}
Descriptor extractor factory that creates \cvCppCross{DescriptorExtractor} of given type with
default parameters (rather using default constructor).
\begin{lstlisting}
Ptr<DescriptorExtractor>
DescriptorExtractor::create( const string& descriptorExtractorType );
\end{lstlisting}
\begin{description}
\cvarg{descriptorExtractorType}{Descriptor extractor type.}
\end{description}
Now the following descriptor extractor types are supported:\\
\texttt{"SIFT"} -- \cvCppCross{SiftFeatureDetector},\\
\texttt{"SURF"} -- \cvCppCross{SurfFeatureDetector},\\
\texttt{"BRIEF"} -- \cvCppCross{BriefFeatureDetector}.\\
Also combined format is supported: descriptor extractor adapter name (\texttt{"Opponent"} --
\cvCppCross{OpponentColorDescriptorExtractor}) + descriptor extractor name (see above),
e.g. \texttt{"OpponentSIFT"}, etc.
\cvclass{SiftDescriptorExtractor}
Wrapping class for descriptors computing using \cvCppCross{SIFT} class.
@ -516,22 +551,6 @@ protected:
};
\end{lstlisting}
\cvCppFunc{createDescriptorExtractor}
Descriptor extractor factory that creates \cvCppCross{DescriptorExtractor} of given type with
default parameters (rather using default constructor).
\begin{lstlisting}
Ptr<DescriptorExtractor>
createDescriptorExtractor( const string& descriptorExtractorType );
\end{lstlisting}
\begin{description}
\cvarg{descriptorExtractorType}{Descriptor extractor type.}
\end{description}
Now the following descriptor extractor types are supported ''SIFT'', ''SURF'',
''OpponentSIFT'', ''OpponentSURF'', ''BRIEF''.
\section{Common Interfaces of Descriptor Matchers}
Matchers of keypoint descriptors in OpenCV have wrappers with common interface that enables to switch easily
between different algorithms solving the same problem. This section is devoted to matching descriptors
@ -612,6 +631,8 @@ public:
virtual void write( FileStorage& ) const;
virtual Ptr<DescriptorMatcher> clone( bool emptyTrainData=false ) const = 0;
static Ptr<DescriptorMatcher> create( const string& descriptorMatcherType );
protected:
vector<Mat> trainDescCollection;
@ -769,6 +790,21 @@ DescriptorMatcher::clone( bool emptyTrainData ) const;
but with empty train data..}
\end{description}
\cvCppFunc{DescriptorMatcher::create}
Descriptor matcher factory that creates \cvCppCross{DescriptorMatcher} of
given type with default parameters (rather using default constructor).
\begin{lstlisting}
Ptr<DescriptorMatcher>
DescriptorMatcher::create( const string& descriptorMatcherType );
\end{lstlisting}
\begin{description}
\cvarg{descriptorMatcherType}{Descriptor matcher type.}
\end{description}
Now the following matcher types are supported: \texttt{"BruteForce"} (it uses \texttt{L2}), \texttt{"BruteForce-L1"},
\texttt{"BruteForce-Hamming"}, \texttt{"BruteForce-HammingLUT"}, \texttt{"FlannBased"}.
\cvclass{BruteForceMatcher}
Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest
descriptor in the second set by trying each one. This descriptor matcher supports masking
@ -881,20 +917,6 @@ protected:
};
\end{lstlisting}
\cvCppFunc{createDescriptorMatcher}
Descriptor matcher factory that creates \cvCppCross{DescriptorMatcher} of
given type with default parameters (rather using default constructor).
\begin{lstlisting}
Ptr<DescriptorMatcher> createDescriptorMatcher( const string& descriptorMatcherType );
\end{lstlisting}
\begin{description}
\cvarg{descriptorMatcherType}{Descriptor matcher type.}
\end{description}
Now the following matcher types are supported: ''BruteForce'' (it uses L2), ''BruteForce-L1'',
''BruteForce-Hamming'', ''BruteForce-HammingLUT''.
\section{Common Interfaces of Generic Descriptor Matchers}
Matchers of keypoint descriptors in OpenCV have wrappers with common interface that enables to switch easily
between different algorithms solving the same problem. This section is devoted to matching descriptors

58
doc/features2d_dynamic_detectors.tex
View File

@ -1,4 +1,4 @@
\cvclass{DynamicDetector}
\cvclass{DynamicAdaptedFeatureDetector}
An adaptively adjusting detector that iteratively detects until the desired number
of features are found.
@ -7,7 +7,7 @@ used on the last detection. In this way, the detector may be used for consistent
of keypoints in a sets of images that are temporally related such as video streams or
panorama series.
The DynamicDetector uses another detector such as FAST or SURF to do the dirty work,
The DynamicAdaptedFeatureDetector uses another detector such as FAST or SURF to do the dirty work,
with the help of an AdjusterAdapter.
After a detection, and an unsatisfactory number of features are detected,
the AdjusterAdapter will adjust the detection parameters so that the next detection will
@ -20,52 +20,54 @@ AdjusterAdapter interface.
Beware that this is not thread safe - as the adjustment of parameters breaks the const
of the detection routine...
Here is a sample of how to create a DynamicDetector.
Here is a sample of how to create a DynamicAdaptedFeatureDetector.
\begin{lstlisting}
//sample usage:
//will create a detector that attempts to find
//100 - 110 FAST Keypoints, and will at most run
//FAST feature detection 10 times until that
//number of keypoints are found
Ptr<FeatureDetector> detector(new DynamicDetector (100, 110, 10,
Ptr<FeatureDetector> detector(new DynamicAdaptedFeatureDetector (100, 110, 10,
new FastAdjuster(20,true)));
\end{lstlisting}
\begin{lstlisting}
class DynamicDetector: public FeatureDetector {
class DynamicAdaptedFeatureDetector: public FeatureDetector
{
public:
DynamicDetector(int min_features, int max_features, int max_iters,
const Ptr<AdjusterAdapter>& a);
...
DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>& adjaster,
int min_features=400, int max_features=500, int max_iters=5 );
...
};
\end{lstlisting}
\cvCppFunc{DynamicDetector::DynamicDetector}
DynamicDetector constructor.
\cvCppFunc{DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector}
DynamicAdaptedFeatureDetector constructor.
\cvdefCpp{
DynamicDetector::DynamicDetector( \par int min\_features, \par int max\_features, \par int max\_iters,
\par const Ptr<AdjusterAdapter>\& a);
DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector(
\par const Ptr<AdjusterAdapter>\& adjaster,
\par int min\_features, \par int max\_features, \par int max\_iters );
}
\begin{description}
\cvarg{adjaster}{ An \cvCppCross{AdjusterAdapter} that will do the detection and parameter
adjustment}
\cvarg{min\_features}{This minimum desired number features.}
\cvarg{max\_features}{The maximum desired number of features.}
\cvarg{max\_iters}{The maximum number of times to try to adjust the feature detector parameters. For the \cvCppCross{FastAdjuster} this number can be high,
but with Star or Surf, many iterations can get time consuming. At each iteration the detector is rerun, so keep this in mind when choosing this value.}
\cvarg{a}{ An \cvCppCross{AdjusterAdapter} that will do the detection and parameter
adjustment}
\end{description}
\cvclass{AdjusterAdapter}
A feature detector parameter adjuster interface, this is used by the \cvCppCross{DynamicDetector}
A feature detector parameter adjuster interface, this is used by the \cvCppCross{DynamicAdaptedFeatureDetector}
and is a wrapper for \cvCppCross{FeatureDetecto}r that allow them to be adjusted after a detection.
See \cvCppCross{FastAdjuster}, \cvCppCross{StarAdjuster}, \cvCppCross{SurfAdjuster} for concrete implementations.
\begin{lstlisting}
class AdjusterAdapter: public FeatureDetector {
class AdjusterAdapter: public FeatureDetector
{
public:
virtual ~AdjusterAdapter() {
}
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;
@ -73,7 +75,7 @@ public:
\end{lstlisting}
\cvCppFunc{AdjusterAdapter::tooFew}
\cvdefCpp{
virtual void tooFew(\par int min, int n\_detected) = 0;
virtual void tooFew(int min, int n\_detected) = 0;
}
Too few features were detected so, adjust the detector parameters accordingly - so that the next
detection detects more features.
@ -83,7 +85,8 @@ detection detects more features.
\end{description}
An example implementation of this is
\begin{lstlisting}
void FastAdjuster::tooFew(int min, int n_detected) {
void FastAdjuster::tooFew(int min, int n_detected)
{
thresh_--;
}
\end{lstlisting}
@ -100,7 +103,8 @@ virtual void tooMany(int max, int n\_detected) = 0;
\end{description}
An example implementation of this is
\begin{lstlisting}
void FastAdjuster::tooMany(int min, int n_detected) {
void FastAdjuster::tooMany(int min, int n_detected)
{
thresh_++;
}
\end{lstlisting}
@ -112,7 +116,8 @@ virtual bool good() const = 0;
}
An example implementation of this is
\begin{lstlisting}
bool FastAdjuster::good() const {
bool FastAdjuster::good() const
{
return (thresh_ > 1) && (thresh_ < 200);
}
\end{lstlisting}
@ -122,7 +127,8 @@ An \cvCppCross{AdjusterAdapter} for the \cvCppCross{FastFeatureDetector}. This w
threshhold by 1
\begin{lstlisting}
class FastAdjuster FastAdjuster: public AdjusterAdapter {
class FastAdjuster FastAdjuster: public AdjusterAdapter
{
public:
FastAdjuster(int init_thresh = 20, bool nonmax = true);
...
@ -133,7 +139,8 @@ public:
An \cvCppCross{AdjusterAdapter} for the \cvCppCross{StarFeatureDetector}. This adjusts the responseThreshhold of
StarFeatureDetector.
\begin{lstlisting}
class StarAdjuster: public AdjusterAdapter {
class StarAdjuster: public AdjusterAdapter
{
StarAdjuster(double initial_thresh = 30.0);
...
};
@ -144,7 +151,8 @@ class StarAdjuster: public AdjusterAdapter {
An \cvCppCross{AdjusterAdapter} for the \cvCppCross{SurfFeatureDetector}. This adjusts the hessianThreshold of
SurfFeatureDetector.
\begin{lstlisting}
class SurfAdjuster: public SurfAdjuster {
class SurfAdjuster: public SurfAdjuster
{
SurfAdjuster();
...
};