Main MRPT website > C++ reference
MRPT logo
CFeatureExtraction.h
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2014, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 #ifndef CFeatureExtraction_H
10 #define CFeatureExtraction_H
11 
12 #include <mrpt/utils/CImage.h>
13 #include <mrpt/utils/CTicTac.h>
14 #include <mrpt/vision/utils.h>
15 #include <mrpt/vision/CFeature.h>
16 #include <mrpt/vision/TSimpleFeature.h>
17 
18 namespace mrpt
19 {
20  namespace vision
21  {
22  /** The central class from which images can be analyzed in search of different kinds of interest points and descriptors computed for them.
23  * To extract features from an image, create an instance of CFeatureExtraction,
24  * fill out its CFeatureExtraction::options field, including the algorithm to use (see
25  * CFeatureExtraction::TOptions::featsType), and call CFeatureExtraction::detectFeatures.
26  * This will return a set of features of the class mrpt::vision::CFeature, which include
27  * details for each interest point as well as the desired descriptors and/or patches.
28  *
29  * By default, a 21x21 patch is extracted for each detected feature. If the patch is not needed,
30  * set patchSize to 0 in CFeatureExtraction::options
31  *
32  * The implemented <b>detection</b> algorithms are (see CFeatureExtraction::TOptions::featsType):
33  * - KLT (Kanade-Lucas-Tomasi): A detector (no descriptor vector).
34  * - Harris: A detector (no descriptor vector).
35  * - BCD (Binary Corner Detector): A detector (no descriptor vector) (Not implemented yet).
36  * - SIFT: An implementation of the SIFT detector and descriptor. The implemention may be selected with CFeatureExtraction::TOptions::SIFTOptions::implementation.
37  * - SURF: OpenCV's implementation of SURF detector and descriptor.
38  * - The FAST feature detector (OpenCV's implementation)
39  * - The FASTER (9,10,12) detectors (Edward Rosten's libcvd implementation optimized for SSE2).
40  *
41  * Additionally, given a list of interest points onto an image, the following
42  * <b>descriptors</b> can be computed for each point by calling CFeatureExtraction::computeDescriptors :
43  * - SIFT descriptor (Lowe's descriptors).
44  * - SURF descriptor (OpenCV's implementation - Requires OpenCV 1.1.0 from SVN or later).
45  * - Intensity-domain spin images (SpinImage): Creates a vector descriptor with the 2D histogram as a single row.
46  * - A circular patch in polar coordinates (Polar images): The matrix descriptor is a 2D polar image centered at the interest point.
47  * - A log-polar image patch (Log-polar images): The matrix descriptor is the 2D log-polar image centered at the interest point.
48  *
49  *
50  * Apart from the normal entry point \a detectFeatures(), these other low-level static methods are provided for convenience:
51  * - CFeatureExtraction::detectFeatures_SSE2_FASTER9()
52  * - CFeatureExtraction::detectFeatures_SSE2_FASTER10()
53  * - CFeatureExtraction::detectFeatures_SSE2_FASTER12()
54  *
55  * \note The descriptor "Intensity-domain spin images" is described in "A sparse texture representation using affine-invariant regions", S Lazebnik, C Schmid, J Ponce, 2003 IEEE Computer Society Conference on Computer Vision.
56  * \sa mrpt::vision::CFeature
57  * \ingroup mrptvision_features
58  */
59  class VISION_IMPEXP CFeatureExtraction
60  {
61  public:
62  enum TSIFTImplementation
63  {
64  LoweBinary = 0,
65  CSBinary,
66  VedaldiBinary,
67  Hess,
68  OpenCV
69  };
70 
71  /** The set of parameters for all the detectors & descriptor algorithms */
72  struct VISION_IMPEXP TOptions : public utils::CLoadableOptions
73  {
74  /** Initalizer
75  */
76  TOptions(const TFeatureType featsType = featKLT);
77 
78  /** See utils::CLoadableOptions
79  */
80  void loadFromConfigFile(
81  const mrpt::utils::CConfigFileBase &source,
82  const std::string &section);
83 
84  /** See utils::CLoadableOptions
85  */
86  void dumpToTextStream(CStream &out) const;
87 
88  /** Type of the extracted features
89  */
90  TFeatureType featsType;
91 
92  /** Size of the patch to extract, or 0 if no patch is desired (default=21).
93  */
94  unsigned int patchSize;
95 
96  /** Whether to use a mask for determining the regions where not to look for keypoints (default=false).
97  */
98  bool useMask;
99 
100  /** Whether to add the found features to the input feature list or clear it before adding them (default=false).
101  */
102  bool addNewFeatures;
103 
104  /** Indicates if subpixel accuracy is desired for the extracted points (only applicable to KLT and Harris features)
105  */
106  bool FIND_SUBPIXEL;
107 
108  /** KLT Options */
109  struct VISION_IMPEXP TKLTOptions
110  {
111  int radius; // size of the block of pixels used
112  float threshold; // (default=0.1) for rejecting weak local maxima (with min_eig < threshold*max(eig_image))
113  float min_distance; // minimum distance between features
114  bool tile_image; // splits the image into 8 tiles and search for the best points in all of them (distribute the features over all the image)
115  } KLTOptions;
116 
117  /** Harris Options */
118  struct VISION_IMPEXP THarrisOptions
119  {
120  float threshold; // (default=0.005) for rejecting weak local maxima (with min_eig < threshold*max(eig_image))
121  float k; // k factor for the Harris algorithm
122  float sigma; // standard deviation for the gaussian smoothing function
123  int radius; // size of the block of pixels used
124  float min_distance; // minimum distance between features
125  bool tile_image; // splits the image into 8 tiles and search for the best points in all of them (distribute the features over all the image)
126  } harrisOptions;
127 
128  /** BCD Options */
129  struct VISION_IMPEXP TBCDOptions
130  {
131  } BCDOptions;
132 
133  /** FAST and FASTER Options */
134  struct VISION_IMPEXP TFASTOptions
135  {
136  int threshold; //!< default= 20
137  bool nonmax_suppression; //!< Default = true
138  float min_distance; //!< (default=5) minimum distance between features (in pixels)
139  bool use_KLT_response; //!< (default=false) If true, use CImage::KLT_response to compute the response at each point instead of the FAST "standard response".
140  } FASTOptions;
141 
142  /** ORB Options */
143  struct VISION_IMPEXP TORBOptions
144  {
145  TORBOptions() : scale_factor(1.2), n_levels(8), extract_patch(false), min_distance(0) {}
146 
147  float scale_factor;
148  size_t n_levels;
149  bool extract_patch;
150  size_t min_distance;
151 
152  } ORBOptions;
153 
154  /** SIFT Options */
155  struct VISION_IMPEXP TSIFTOptions
156  {
157  TSIFTOptions() : threshold(0.04), edgeThreshold(10) { }
158 
159  TSIFTImplementation implementation;
160  double threshold; //!< default= 0.04
161  double edgeThreshold; //!< default= 10
162  } SIFTOptions;
163 
164  struct VISION_IMPEXP TSURFOptions
165  {
166  TSURFOptions() : rotation_invariant(true),hessianThreshold(600), nOctaves(2), nLayersPerOctave(4) { }
167 
168  /** SURF Options
169  */
170  bool rotation_invariant; //!< Compute the rotation invariant SURF (dim=128) if set to true (default), or the smaller uSURF otherwise (dim=64)
171  int hessianThreshold; //!< Default: 600
172  int nOctaves; //!< Default: 2
173  int nLayersPerOctave; //!< Default: 4
174  } SURFOptions;
175 
176  struct VISION_IMPEXP TSpinImagesOptions
177  {
178  /** SpinImages Options
179  */
180  unsigned int hist_size_intensity; //!< Number of bins in the "intensity" axis of the 2D histogram (default=10).
181  unsigned int hist_size_distance; //!< Number of bins in the "distance" axis of the 2D histogram (default=10).
182  float std_dist; //!< Standard deviation in "distance", used for the "soft histogram" (default=0.4 pixels)
183  float std_intensity; //!< Standard deviation in "intensity", used for the "soft histogram" (default=20 units [0,255])
184  unsigned int radius; //!< Maximum radius of the area of which the histogram is built, in pixel units (default=20 pixels)
185  } SpinImagesOptions;
186 
187  /** PolarImagesOptions Options
188  */
189  struct VISION_IMPEXP TPolarImagesOptions
190  {
191  unsigned int bins_angle; //!< Number of bins in the "angular" axis of the polar image (default=8).
192  unsigned int bins_distance; //!< Number of bins in the "distance" axis of the polar image (default=6).
193  unsigned int radius; //!< Maximum radius of the area of which the polar image is built, in pixel units (default=20 pixels)
194  } PolarImagesOptions;
195 
196  /** LogPolarImagesOptions Options
197  */
198  struct VISION_IMPEXP TLogPolarImagesOptions
199  {
200  unsigned int radius; //!< Maximum radius of the area of which the log polar image is built, in pixel units (default=30 pixels)
201  unsigned int num_angles; //!< (default=16) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(radius)
202  double rho_scale; //!< (default=5) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(radius)
203  } LogPolarImagesOptions;
204 
205  };
206 
207  TOptions options; //!< Set all the parameters of the desired method here before calling "detectFeatures"
208 
209  /** Constructor
210  */
211  CFeatureExtraction();
212 
213  /** Virtual destructor.
214  */
215  virtual ~CFeatureExtraction();
216 
217  /** Extract features from the image based on the method defined in TOptions.
218  * \param img (input) The image from where to extract the images.
219  * \param feats (output) A complete list of features (containing a patch for each one of them if options.patchsize > 0).
220  * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
221  * \param ROI (op. input) Region of Interest. Default: The whole image.
222  *
223  * \sa computeDescriptors
224  */
225  void detectFeatures( const CImage & img,
226  CFeatureList & feats,
227  const unsigned int init_ID = 0,
228  const unsigned int nDesiredFeatures = 0,
229  const TImageROI & ROI = TImageROI(),
230  const CMatrixBool * mask = NULL ) const; // Important: This was a const ref. in mrpt <0.9.4, but the instantiation of a default value
231  // for CMatrixBool being a template generated duplicated linking errors for MSVC, thus it was changed to a pointer.
232 
233  /** Compute one (or more) descriptors for the given set of interest points onto the image, which may have been filled out manually or from \a detectFeatures
234  * \param in_img (input) The image from where to compute the descriptors.
235  * \param inout_features (input/output) The list of features whose descriptors are going to be computed.
236  * \param in_descriptor_list (input) The bitwise OR of one or several descriptors defined in TDescriptorType.
237  *
238  * Each value in "in_descriptor_list" represents one descriptor to be computed, for example:
239  * \code
240  * // This call will compute both, SIFT and Spin-Image descriptors for a list of feature points lstFeats.
241  * fext.computeDescriptors(img, lstFeats, descSIFT | descSpinImages );
242  * \endcode
243  *
244  * \note The SIFT descriptors for already located features can only be computed through the Hess and
245  * CSBinary implementations which may be specified in CFeatureExtraction::TOptions::SIFTOptions.
246  *
247  * \note This call will also use additional parameters from \a options
248  */
249  void computeDescriptors(
250  const CImage &in_img,
251  CFeatureList &inout_features,
252  TDescriptorType in_descriptor_list) const;
253 
254  /** Extract more features from the image (apart from the provided ones) based on the method defined in TOptions.
255  * \param img (input) The image from where to extract the images.
256  * \param inList (input) The actual features in the image.
257  * \param outList (output) The list of new features (containing a patch for each one of them if options.patchsize > 0).
258  * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
259  *
260  * \sa The more powerful class: mrpt::vision::CGenericFeatureTracker
261  */
262  void findMoreFeatures( const CImage &img,
263  const CFeatureList &inList,
264  CFeatureList &outList,
265  unsigned int nDesiredFeats = 0) const;
266 
267 
268  /** @name Static methods with low-level detector functionality
269  @{ */
270 
271  /** A SSE2-optimized implementation of FASTER-9 (requires img to be grayscale). If SSE2 is not available, it gratefully falls back to a non-optimized version.
272  *
273  * Only the pt.{x,y} fields are filled out for each feature: the rest of fields are left <b>uninitialized</b> and their content is <b>undefined</b>.
274  * Note that (x,y) are already scaled to the 0-level image coordinates if octave>0, by means of:
275  *
276  * \code
277  * pt.x = detected.x << octave;
278  * pt.y = detected.y << octave;
279  * \endcode
280  *
281  * If \a append_to_list is true, the \a corners list is not cleared before adding the newly detected feats.
282  *
283  * If a valid pointer is provided for \a out_feats_index_by_row, upon return you will find a vector with
284  * as many entries as rows in the image (the real number of rows, disregarding the value of \a octave).
285  * The number in each entry is the 0-based index (in \a corners) of
286  * the first feature that falls in that line of the image. This index can be used to fasten looking for correspondences.
287  *
288  * \ingroup mrptvision_features
289  */
290  static void detectFeatures_SSE2_FASTER9(
291  const CImage &img,
292  TSimpleFeatureList & corners,
293  const int threshold = 20,
294  bool append_to_list = false,
295  uint8_t octave = 0,
296  std::vector<size_t> * out_feats_index_by_row = NULL );
297 
298  /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the detector.
299  * \ingroup mrptvision_features */
300  static void detectFeatures_SSE2_FASTER10(
301  const CImage &img,
302  TSimpleFeatureList & corners,
303  const int threshold = 20,
304  bool append_to_list = false,
305  uint8_t octave = 0,
306  std::vector<size_t> * out_feats_index_by_row = NULL );
307 
308  /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the detector.
309  * \ingroup mrptvision_features */
310  static void detectFeatures_SSE2_FASTER12(
311  const CImage &img,
312  TSimpleFeatureList & corners,
313  const int threshold = 20,
314  bool append_to_list = false,
315  uint8_t octave = 0,
316  std::vector<size_t> * out_feats_index_by_row = NULL );
317 
318  /** @} */
319 
320  private:
321  /** Compute the SIFT descriptor of the provided features into the input image
322  * \param in_img (input) The image from where to compute the descriptors.
323  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
324  *
325  * \note The SIFT descriptors for already located features can only be computed through the Hess and
326  CSBinary implementations which may be specified in CFeatureExtraction::TOptions::SIFTOptions.
327  */
328  void internal_computeSiftDescriptors( const CImage &in_img,
329  CFeatureList &in_features) const;
330 
331 
332  /** Compute the SURF descriptor of the provided features into the input image
333  * \param in_img (input) The image from where to compute the descriptors.
334  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
335  */
336  void internal_computeSurfDescriptors( const CImage &in_img,
337  CFeatureList &in_features) const;
338 
339  /** Compute the ORB descriptor of the provided features into the input image
340  * \param in_img (input) The image from where to compute the descriptors.
341  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
342  */
343  void internal_computeORBDescriptors( const CImage &in_img,
344  CFeatureList &in_features) const;
345 
346  /** Compute the intensity-domain spin images descriptor of the provided features into the input image
347  * \param in_img (input) The image from where to compute the descriptors.
348  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
349  *
350  * \note Additional parameters from CFeatureExtraction::TOptions::SpinImagesOptions are used in this method.
351  */
352  void internal_computeSpinImageDescriptors( const CImage &in_img,
353  CFeatureList &in_features) const;
354 
355  /** Compute a polar-image descriptor of the provided features into the input image
356  * \param in_img (input) The image from where to compute the descriptors.
357  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
358  *
359  * \note Additional parameters from CFeatureExtraction::TOptions::PolarImagesOptions are used in this method.
360  */
361  void internal_computePolarImageDescriptors( const CImage &in_img,
362  CFeatureList &in_features) const;
363 
364  /** Compute a log-polar image descriptor of the provided features into the input image
365  * \param in_img (input) The image from where to compute the descriptors.
366  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
367  *
368  * \note Additional parameters from CFeatureExtraction::TOptions::LogPolarImagesOptions are used in this method.
369  */
370  void internal_computeLogPolarImageDescriptors( const CImage &in_img,
371  CFeatureList &in_features) const;
372 
373  /** Select good features using the openCV implementation of the KLT method.
374  * \param img (input) The image from where to select extract the images.
375  * \param feats (output) A complete list of features (containing a patch for each one of them if options.patchsize > 0).
376  * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
377  * \param omitPixels (op. input) A mask for determining the ROI. (0: do not omit this pixel, 1: omit this pixel)
378  */
379  void selectGoodFeaturesKLT(
380  const CImage &inImg,
381  CFeatureList &feats,
382  unsigned int init_ID = 0,
383  unsigned int nDesiredFeatures = 0,
384  void *mask_ = NULL) const;
385 
386  /** Extract features from the image based on the KLT method.
387  * \param img The image from where to extract the images.
388  * \param feats The list of extracted features.
389  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
390  * \param ROI (op. input) Region of Interest. Default: All the image.
391  */
392  void extractFeaturesKLT(
393  const CImage &img,
394  CFeatureList &feats,
395  unsigned int init_ID = 0,
396  unsigned int nDesiredFeatures = 0,
397  const TImageROI &ROI = TImageROI()) const;
398 
399  // ------------------------------------------------------------------------------------
400  // BCD
401  // ------------------------------------------------------------------------------------
402  /** Extract features from the image based on the BCD method.
403  * \param img The image from where to extract the images.
404  * \param feats The list of extracted features.
405  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
406  * \param ROI (op. input) Region of Interest. Default: All the image.
407  */
408  void extractFeaturesBCD(
409  const CImage &img,
410  CFeatureList &feats,
411  unsigned int init_ID = 0,
412  unsigned int nDesiredFeatures = 0,
413  const TImageROI &ROI = TImageROI()) const;
414 
415  // ------------------------------------------------------------------------------------
416  // SIFT
417  // ------------------------------------------------------------------------------------
418  /** Extract features from the image based on the SIFT method.
419  * \param img The image from where to extract the images.
420  * \param feats The list of extracted features.
421  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
422  * \param ROI (op. input) Region of Interest. Default: All the image.
423  */
424  void extractFeaturesSIFT(
425  const CImage &img,
426  CFeatureList &feats,
427  unsigned int init_ID = 0,
428  unsigned int nDesiredFeatures = 0,
429  const TImageROI &ROI = TImageROI()) const;
430 
431  // ------------------------------------------------------------------------------------
432  // ORB
433  // ------------------------------------------------------------------------------------
434  /** Extract features from the image based on the ORB method.
435  * \param img The image from where to extract the images.
436  * \param feats The list of extracted features.
437  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
438  * \param ROI (op. input) Region of Interest. Default: All the image.
439  */
440  void extractFeaturesORB(
441  const CImage &img,
442  CFeatureList &feats,
443  const unsigned int init_ID = 0,
444  const unsigned int nDesiredFeatures = 0,
445  const TImageROI &ROI = TImageROI(),
446  const CMatrixBool * mask = NULL ) const; // Important: This was a const ref. in mrpt <0.9.4, but the instantiation of a default value
447  // for CMatrixBool being a template generated duplicated linking errors for MSVC, thus it was changed to a pointer.
448 
449 
450  // ------------------------------------------------------------------------------------
451  // SURF
452  // ------------------------------------------------------------------------------------
453  /** Extract features from the image based on the SURF method.
454  * \param img The image from where to extract the images.
455  * \param feats The list of extracted features.
456  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
457  * \param ROI (op. input) Region of Interest. Default: All the image.
458  */
459  void extractFeaturesSURF(
460  const CImage &img,
461  CFeatureList &feats,
462  unsigned int init_ID = 0,
463  unsigned int nDesiredFeatures = 0,
464  const TImageROI &ROI = TImageROI()) const;
465 
466  // ------------------------------------------------------------------------------------
467  // FAST
468  // ------------------------------------------------------------------------------------
469  /** Extract features from the image based on the FAST method.
470  * \param img The image from where to extract the images.
471  * \param feats The list of extracted features.
472  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
473  * \param ROI (op. input) Region of Interest. Default: All the image.
474  */
475  void extractFeaturesFAST(
476  const CImage &img,
477  CFeatureList &feats,
478  unsigned int init_ID = 0,
479  unsigned int nDesiredFeatures = 0,
480  const TImageROI &ROI = TImageROI(),
481  const CMatrixBool * mask = NULL ) const; // Important: This was a const ref. in mrpt <0.9.4, but the instantiation of a default value
482  // for CMatrixBool being a template generated duplicated linking errors for MSVC, thus it was changed to a pointer.
483 
484  /** Edward's "FASTER & Better" detector, N=9,10,12 */
485  void extractFeaturesFASTER_N(
486  const int N,
487  const CImage &img,
488  CFeatureList &feats,
489  unsigned int init_ID = 0,
490  unsigned int nDesiredFeatures = 0,
491  const TImageROI &ROI = TImageROI()) const;
492 
493 
494  // ------------------------------------------------------------------------------------
495  // my_scale_space_extrema
496  // ------------------------------------------------------------------------------------
497  /** Computes extrema in the scale space.
498  * \param dog_pyr Pyramid of images.
499  * \param octvs Number of considered octaves.
500  * \param intvls Number of intervales in octaves.
501  */
502  void* my_scale_space_extrema(
503  CFeatureList &featList, void* dog_pyr,
504  int octvs, int intvls, double contr_thr, int curv_thr,
505  void* storage ) const;
506 
507  /** Adjust scale if the image was initially doubled.
508  * \param features The sequence of features.
509  */
510  void my_adjust_for_img_dbl( void* features ) const;
511 
512  /** Gets the number of times that a point in the image is higher or lower than the surroundings in the image-scale space
513  * \param dog_pyr Pyramid of images.
514  * \param octvs Number of considered octaves.
515  * \param intvls Number of intervales in octaves.
516  * \param row The row of the feature in the original image.
517  * \param col The column of the feature in the original image.
518  * \param nMin [out]: Times that the feature is lower than the surroundings.
519  * \param nMax [out]: Times that the feature is higher than the surroundings.
520  */
521  void getTimesExtrema( void* dog_pyr, int octvs, int intvls, float row, float col, unsigned int &nMin, unsigned int &nMax ) const;
522 
523  /** Computes the Laplacian value of the feature in the corresponing image in the pyramid.
524  * \param dog_pyr Pyramid of images.
525  * \param octvs Number of considered octaves.
526  * \param intvls Number of intervales in octaves.
527  * \param row The row of the feature in the original image.
528  * \param col The column of the feature in the original image.
529  */
530  double getLaplacianValue( void* dog_pyr, int octvs, int intvls, float row, float col ) const;
531 
532  /** Append a sequence of openCV features into an MRPT feature list.
533  * \param features The sequence of features.
534  * \param list [in-out] The list of MRPT features.
535  * \param init_ID [in] The initial ID for the new features.
536  */
537  void insertCvSeqInCFeatureList( void* features, CFeatureList &list, unsigned int init_ID = 0 ) const;
538 
539  /** Converts a sequence of openCV features into an MRPT feature list.
540  * \param features The sequence of features.
541  * \param list [in-out] The list of MRPT features.
542  * \param init_ID [in][optional] The initial ID for the features (default = 0).
543  * \param ROI [in][optional] The initial ID for the features (default = empty ROI -> not used).
544  */
545  void convertCvSeqInCFeatureList( void* features, CFeatureList &list, unsigned int init_ID = 0, const TImageROI &ROI = TImageROI() ) const;
546 
547  }; // end of class
548  } // end of namespace
549 } // end of namespace
550 #endif
mrpt::vision::CFeatureExtraction::CSBinary
Definition: CFeatureExtraction.h:65
mrpt::vision::CFeatureExtraction::TOptions::useMask
bool useMask
Whether to use a mask for determining the regions where not to look for keypoints (default=false)...
Definition: CFeatureExtraction.h:98
mrpt::utils::CImage
A class for storing images as grayscale or RGB bitmaps.
Definition: CImage.h:97
mrpt::vision::CFeatureExtraction::TOptions::TSpinImagesOptions::radius
unsigned int radius
Maximum radius of the area of which the histogram is built, in pixel units (default=20 pixels) ...
Definition: CFeatureExtraction.h:184
mrpt::vision::CFeatureExtraction::Hess
Definition: CFeatureExtraction.h:67
mrpt::vision::CFeatureExtraction::TOptions::featsType
TFeatureType featsType
Type of the extracted features.
Definition: CFeatureExtraction.h:90
mrpt::vision::CFeatureExtraction::TOptions::TLogPolarImagesOptions::rho_scale
double rho_scale
(default=5) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(ra...
Definition: CFeatureExtraction.h:202
mrpt::vision::CFeatureExtraction::TOptions::TLogPolarImagesOptions::num_angles
unsigned int num_angles
(default=16) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(r...
Definition: CFeatureExtraction.h:201
mrpt::vision::CFeatureExtraction::options
TOptions options
Set all the parameters of the desired method here before calling "detectFeatures".
Definition: CFeatureExtraction.h:207
mrpt::utils::CStream
class BASE_IMPEXP CStream
Definition: math_frwds.h:26
mrpt::vision::CFeatureExtraction::TOptions::FIND_SUBPIXEL
bool FIND_SUBPIXEL
Indicates if subpixel accuracy is desired for the extracted points (only applicable to KLT and Harris...
Definition: CFeatureExtraction.h:106
mrpt::vision::CFeatureExtraction::TOptions
The set of parameters for all the detectors & descriptor algorithms.
Definition: CFeatureExtraction.h:72
VISION_IMPEXP
#define VISION_IMPEXP
Definition: vision/include/mrpt/vision/link_pragmas.h:90
mrpt::vision::CFeatureExtraction::VedaldiBinary
Definition: CFeatureExtraction.h:66
mrpt::vision::CFeatureExtraction::TOptions::TFASTOptions::use_KLT_response
bool use_KLT_response
(default=false) If true, use CImage::KLT_response to compute the response at each point instead of th...
Definition: CFeatureExtraction.h:139
CFeature.h
mrpt::utils::CConfigFileBase
This class allows loading and storing values and vectors of different types from a configuration text...
Definition: CConfigFileBase.h:30
mrpt::vision::CFeatureExtraction::TOptions::TSpinImagesOptions::std_dist
float std_dist
Standard deviation in "distance", used for the "soft histogram" (default=0.4 pixels) ...
Definition: CFeatureExtraction.h:182
mrpt::vision::TImageROI
A structure for defining a ROI within an image.
Definition: vision/include/mrpt/vision/types.h:261
mrpt::math::CMatrixBool
CMatrixTemplate< bool > CMatrixBool
Declares a matrix of booleans (non serializable).
Definition: CMatrixTemplate.h:556
mrpt::vision::CFeatureExtraction::TOptions::TSpinImagesOptions::std_intensity
float std_intensity
Standard deviation in "intensity", used for the "soft histogram" (default=20 units [0...
Definition: CFeatureExtraction.h:183
TSimpleFeature.h
mrpt::vision::CFeatureExtraction::TOptions::TFASTOptions::min_distance
float min_distance
(default=5) minimum distance between features (in pixels)
Definition: CFeatureExtraction.h:138
mrpt::vision::CFeatureExtraction::TOptions::TPolarImagesOptions::bins_distance
unsigned int bins_distance
Number of bins in the "distance" axis of the polar image (default=6).
Definition: CFeatureExtraction.h:192
mrpt::vision::CFeatureExtraction::TSIFTImplementation
TSIFTImplementation
Definition: CFeatureExtraction.h:62
mrpt::vision::CFeatureList
A list of visual features, to be used as output by detectors, as input/output by trackers, etc.
Definition: CFeature.h:215
mrpt::vision::TDescriptorType
TDescriptorType
The bitwise OR combination of values of TDescriptorType are used in CFeatureExtraction::computeDescri...
Definition: vision/include/mrpt/vision/types.h:61
mrpt::vision::TFeatureType
TFeatureType
Types of features - This means that the point has been detected with this algorithm, which is independent of additional descriptors a feature may also have.
Definition: vision/include/mrpt/vision/types.h:43
CTicTac.h
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: CParticleFilter.h:16
mrpt::vision::CFeatureExtraction::TOptions::TPolarImagesOptions::radius
unsigned int radius
Maximum radius of the area of which the polar image is built, in pixel units (default=20 pixels) ...
Definition: CFeatureExtraction.h:193
mrpt::vision::CFeatureExtraction::TOptions::TPolarImagesOptions::bins_angle
unsigned int bins_angle
Number of bins in the "angular" axis of the polar image (default=8).
Definition: CFeatureExtraction.h:191
mrpt::vision::TSimpleFeatureList_templ< TSimpleFeature >
mrpt::vision::CFeatureExtraction::TOptions::patchSize
unsigned int patchSize
Size of the patch to extract, or 0 if no patch is desired (default=21).
Definition: CFeatureExtraction.h:94
mrpt::vision::CFeatureExtraction::TOptions::TLogPolarImagesOptions::radius
unsigned int radius
Maximum radius of the area of which the log polar image is built, in pixel units (default=30 pixels) ...
Definition: CFeatureExtraction.h:200
mrpt::vision::CFeatureExtraction::TOptions::addNewFeatures
bool addNewFeatures
Whether to add the found features to the input feature list or clear it before adding them (default=f...
Definition: CFeatureExtraction.h:102
CImage.h
mrpt::vision::CFeatureExtraction::TOptions::TSpinImagesOptions::hist_size_distance
unsigned int hist_size_distance
Number of bins in the "distance" axis of the 2D histogram (default=10).
Definition: CFeatureExtraction.h:181
mrpt::vision::featKLT
Kanade-Lucas-Tomasi feature [SHI'94].
Definition: vision/include/mrpt/vision/types.h:46
mrpt::utils::CLoadableOptions
This is a virtual base class for sets of options than can be loaded from and/or saved to configuratio...
Definition: CLoadableOptions.h:31
mrpt::vision::CFeatureExtraction
The central class from which images can be analyzed in search of different kinds of interest points a...
Definition: CFeatureExtraction.h:59


Page generated by Doxygen 1.8.8 for MRPT 1.2.2 SVN:Unversioned directory at Tue Oct 14 02:14:08 UTC 2014