Main MRPT website > C++ reference for MRPT 1.3.2
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-2015, 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>
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  */
60  {
61  public:
63  {
64  LoweBinary = 0,
68  OpenCV
69  };
70 
71  /** The set of parameters for all the detectors & descriptor algorithms */
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(mrpt::utils::CStream &out) const;
87 
88  /** Type of the extracted features
89  */
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  */
103 
104  /** Indicates if subpixel accuracy is desired for the extracted points (only applicable to KLT and Harris features)
105  */
107 
108  /** KLT Options */
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 */
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 */
130  {
131  } BCDOptions;
132 
133  /** FAST and FASTER Options */
135  {
136  int threshold; //!< default= 20
137  float min_distance; //!< (default=5) minimum distance between features (in pixels)
138  bool nonmax_suppression; //!< Default = true
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 */
144  {
145  TORBOptions() : n_levels(8), min_distance(0), scale_factor(1.2f),extract_patch(false) {}
146 
147  size_t n_levels;
148  size_t min_distance;
151  } ORBOptions;
152 
153  /** SIFT Options */
155  {
156  TSIFTOptions() : threshold(0.04), edgeThreshold(10) { }
157 
159  double threshold; //!< default= 0.04
160  double edgeThreshold; //!< default= 10
161  } SIFTOptions;
162 
164  {
165  TSURFOptions() : rotation_invariant(true),hessianThreshold(600), nOctaves(2), nLayersPerOctave(4) { }
166 
167  /** SURF Options
168  */
169  bool rotation_invariant; //!< Compute the rotation invariant SURF (dim=128) if set to true (default), or the smaller uSURF otherwise (dim=64)
170  int hessianThreshold; //!< Default: 600
171  int nOctaves; //!< Default: 2
172  int nLayersPerOctave; //!< Default: 4
173  } SURFOptions;
174 
176  {
177  /** SpinImages Options
178  */
179  unsigned int hist_size_intensity; //!< Number of bins in the "intensity" axis of the 2D histogram (default=10).
180  unsigned int hist_size_distance; //!< Number of bins in the "distance" axis of the 2D histogram (default=10).
181  float std_dist; //!< Standard deviation in "distance", used for the "soft histogram" (default=0.4 pixels)
182  float std_intensity; //!< Standard deviation in "intensity", used for the "soft histogram" (default=20 units [0,255])
183  unsigned int radius; //!< Maximum radius of the area of which the histogram is built, in pixel units (default=20 pixels)
184  } SpinImagesOptions;
185 
186  /** PolarImagesOptions Options
187  */
189  {
190  unsigned int bins_angle; //!< Number of bins in the "angular" axis of the polar image (default=8).
191  unsigned int bins_distance; //!< Number of bins in the "distance" axis of the polar image (default=6).
192  unsigned int radius; //!< Maximum radius of the area of which the polar image is built, in pixel units (default=20 pixels)
193  } PolarImagesOptions;
194 
195  /** LogPolarImagesOptions Options
196  */
198  {
199  unsigned int radius; //!< Maximum radius of the area of which the log polar image is built, in pixel units (default=30 pixels)
200  unsigned int num_angles; //!< (default=16) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(radius)
201  double rho_scale; //!< (default=5) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(radius)
202  } LogPolarImagesOptions;
203 
204  };
205 
206  TOptions options; //!< Set all the parameters of the desired method here before calling "detectFeatures"
207 
208  /** Constructor
209  */
211 
212  /** Virtual destructor.
213  */
214  virtual ~CFeatureExtraction();
215 
216  /** Extract features from the image based on the method defined in TOptions.
217  * \param img (input) The image from where to extract the images.
218  * \param feats (output) A complete list of features (containing a patch for each one of them if options.patchsize > 0).
219  * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
220  *
221  * \sa computeDescriptors
222  */
223  void detectFeatures(
224  const mrpt::utils::CImage & img,
225  CFeatureList & feats,
226  const unsigned int init_ID = 0,
227  const unsigned int nDesiredFeatures = 0,
228  const TImageROI &ROI = TImageROI()) const;
229 
230  /** 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
231  * \param in_img (input) The image from where to compute the descriptors.
232  * \param inout_features (input/output) The list of features whose descriptors are going to be computed.
233  * \param in_descriptor_list (input) The bitwise OR of one or several descriptors defined in TDescriptorType.
234  *
235  * Each value in "in_descriptor_list" represents one descriptor to be computed, for example:
236  * \code
237  * // This call will compute both, SIFT and Spin-Image descriptors for a list of feature points lstFeats.
238  * fext.computeDescriptors(img, lstFeats, descSIFT | descSpinImages );
239  * \endcode
240  *
241  * \note The SIFT descriptors for already located features can only be computed through the Hess and
242  * CSBinary implementations which may be specified in CFeatureExtraction::TOptions::SIFTOptions.
243  *
244  * \note This call will also use additional parameters from \a options
245  */
246  void computeDescriptors(
247  const mrpt::utils::CImage &in_img,
248  CFeatureList &inout_features,
249  TDescriptorType in_descriptor_list) const;
250 
251 #if 0 // Delete? see comments in .cpp
252  /** Extract more features from the image (apart from the provided ones) based on the method defined in TOptions.
253  * \param img (input) The image from where to extract the images.
254  * \param inList (input) The actual features in the image.
255  * \param outList (output) The list of new features (containing a patch for each one of them if options.patchsize > 0).
256  * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
257  *
258  * \sa The more powerful class: mrpt::vision::CGenericFeatureTracker
259  */
260  void findMoreFeatures( const mrpt::utils::CImage &img,
261  const CFeatureList &inList,
262  CFeatureList &outList,
263  unsigned int nDesiredFeats = 0) const;
264 #endif
265 
266  /** @name Static methods with low-level detector functionality
267  @{ */
268 
269  /** 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.
270  *
271  * 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>.
272  * Note that (x,y) are already scaled to the 0-level image coordinates if octave>0, by means of:
273  *
274  * \code
275  * pt.x = detected.x << octave;
276  * pt.y = detected.y << octave;
277  * \endcode
278  *
279  * If \a append_to_list is true, the \a corners list is not cleared before adding the newly detected feats.
280  *
281  * If a valid pointer is provided for \a out_feats_index_by_row, upon return you will find a vector with
282  * as many entries as rows in the image (the real number of rows, disregarding the value of \a octave).
283  * The number in each entry is the 0-based index (in \a corners) of
284  * the first feature that falls in that line of the image. This index can be used to fasten looking for correspondences.
285  *
286  * \ingroup mrptvision_features
287  */
288  static void detectFeatures_SSE2_FASTER9(
289  const mrpt::utils::CImage &img,
290  TSimpleFeatureList & corners,
291  const int threshold = 20,
292  bool append_to_list = false,
293  uint8_t octave = 0,
294  std::vector<size_t> * out_feats_index_by_row = NULL );
295 
296  /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the detector.
297  * \ingroup mrptvision_features */
298  static void detectFeatures_SSE2_FASTER10(
299  const mrpt::utils::CImage &img,
300  TSimpleFeatureList & corners,
301  const int threshold = 20,
302  bool append_to_list = false,
303  uint8_t octave = 0,
304  std::vector<size_t> * out_feats_index_by_row = NULL );
305 
306  /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the detector.
307  * \ingroup mrptvision_features */
308  static void detectFeatures_SSE2_FASTER12(
309  const mrpt::utils::CImage &img,
310  TSimpleFeatureList & corners,
311  const int threshold = 20,
312  bool append_to_list = false,
313  uint8_t octave = 0,
314  std::vector<size_t> * out_feats_index_by_row = NULL );
315 
316  /** @} */
317 
318  private:
319  /** Compute the SIFT descriptor of the provided features into the input image
320  * \param in_img (input) The image from where to compute the descriptors.
321  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
322  *
323  * \note The SIFT descriptors for already located features can only be computed through the Hess and
324  CSBinary implementations which may be specified in CFeatureExtraction::TOptions::SIFTOptions.
325  */
326  void internal_computeSiftDescriptors( const mrpt::utils::CImage &in_img,
327  CFeatureList &in_features) const;
328 
329 
330  /** Compute the SURF descriptor of the provided features into the input image
331  * \param in_img (input) The image from where to compute the descriptors.
332  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
333  */
334  void internal_computeSurfDescriptors( const mrpt::utils::CImage &in_img,
335  CFeatureList &in_features) const;
336 
337  /** Compute the ORB descriptor of the provided features into the input image
338  * \param in_img (input) The image from where to compute the descriptors.
339  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
340  */
341  void internal_computeORBDescriptors( const mrpt::utils::CImage &in_img,
342  CFeatureList &in_features) const;
343 
344  /** Compute the intensity-domain spin images descriptor of the provided features into the input image
345  * \param in_img (input) The image from where to compute the descriptors.
346  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
347  *
348  * \note Additional parameters from CFeatureExtraction::TOptions::SpinImagesOptions are used in this method.
349  */
350  void internal_computeSpinImageDescriptors( const mrpt::utils::CImage &in_img,
351  CFeatureList &in_features) const;
352 
353  /** Compute a polar-image descriptor of the provided features into the input image
354  * \param in_img (input) The image from where to compute the descriptors.
355  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
356  *
357  * \note Additional parameters from CFeatureExtraction::TOptions::PolarImagesOptions are used in this method.
358  */
359  void internal_computePolarImageDescriptors( const mrpt::utils::CImage &in_img,
360  CFeatureList &in_features) const;
361 
362  /** Compute a log-polar image descriptor of the provided features into the input image
363  * \param in_img (input) The image from where to compute the descriptors.
364  * \param in_features (input/output) The list of features whose descriptors are going to be computed.
365  *
366  * \note Additional parameters from CFeatureExtraction::TOptions::LogPolarImagesOptions are used in this method.
367  */
368  void internal_computeLogPolarImageDescriptors( const mrpt::utils::CImage &in_img,
369  CFeatureList &in_features) const;
370 
371 #if 0 // Delete? see comments in .cpp
372  /** Select good features using the openCV implementation of the KLT method.
373  * \param img (input) The image from where to select extract the images.
374  * \param feats (output) A complete list of features (containing a patch for each one of them if options.patchsize > 0).
375  * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
376  */
377  void selectGoodFeaturesKLT(
378  const mrpt::utils::CImage &inImg,
379  CFeatureList &feats,
380  unsigned int init_ID = 0,
381  unsigned int nDesiredFeatures = 0) const;
382 #endif
383 
384  /** Extract features from the image based on the KLT method.
385  * \param img The image from where to extract the images.
386  * \param feats The list of extracted features.
387  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
388  */
389  void extractFeaturesKLT(
390  const mrpt::utils::CImage &img,
391  CFeatureList &feats,
392  unsigned int init_ID = 0,
393  unsigned int nDesiredFeatures = 0,
394  const TImageROI &ROI = TImageROI()) const;
395 
396  // ------------------------------------------------------------------------------------
397  // BCD
398  // ------------------------------------------------------------------------------------
399  /** Extract features from the image based on the BCD method.
400  * \param img The image from where to extract the images.
401  * \param feats The list of extracted features.
402  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
403  * \param ROI (op. input) Region of Interest. Default: All the image.
404  */
405  void extractFeaturesBCD(
406  const mrpt::utils::CImage &img,
407  CFeatureList &feats,
408  unsigned int init_ID = 0,
409  unsigned int nDesiredFeatures = 0,
410  const TImageROI &ROI = TImageROI()) const;
411 
412  // ------------------------------------------------------------------------------------
413  // SIFT
414  // ------------------------------------------------------------------------------------
415  /** Extract features from the image based on the SIFT method.
416  * \param img The image from where to extract the images.
417  * \param feats The list of extracted features.
418  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
419  * \param ROI (op. input) Region of Interest. Default: All the image.
420  */
421  void extractFeaturesSIFT(
422  const mrpt::utils::CImage &img,
423  CFeatureList &feats,
424  unsigned int init_ID = 0,
425  unsigned int nDesiredFeatures = 0,
426  const TImageROI &ROI = TImageROI()) const;
427 
428  // ------------------------------------------------------------------------------------
429  // ORB
430  // ------------------------------------------------------------------------------------
431  /** Extract features from the image based on the ORB method.
432  * \param img The image from where to extract the images.
433  * \param feats The list of extracted features.
434  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
435  */
436  void extractFeaturesORB(
437  const mrpt::utils::CImage &img,
438  CFeatureList &feats,
439  const unsigned int init_ID = 0,
440  const unsigned int nDesiredFeatures = 0,
441  const TImageROI & ROI = TImageROI()) const;
442 
443 
444  // ------------------------------------------------------------------------------------
445  // SURF
446  // ------------------------------------------------------------------------------------
447  /** Extract features from the image based on the SURF method.
448  * \param img The image from where to extract the images.
449  * \param feats The list of extracted features.
450  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
451  */
452  void extractFeaturesSURF(
453  const mrpt::utils::CImage &img,
454  CFeatureList &feats,
455  unsigned int init_ID = 0,
456  unsigned int nDesiredFeatures = 0,
457  const TImageROI &ROI = TImageROI()) const;
458 
459  // ------------------------------------------------------------------------------------
460  // FAST
461  // ------------------------------------------------------------------------------------
462  /** Extract features from the image based on the FAST method.
463  * \param img The image from where to extract the images.
464  * \param feats The list of extracted features.
465  * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
466  */
467  void extractFeaturesFAST(
468  const mrpt::utils::CImage &img,
469  CFeatureList &feats,
470  unsigned int init_ID = 0,
471  unsigned int nDesiredFeatures = 0,
472  const TImageROI & ROI = TImageROI(),
473  const mrpt::math::CMatrixBool * mask= NULL) const;
474 
475  /** Edward's "FASTER & Better" detector, N=9,10,12 */
476  void extractFeaturesFASTER_N(
477  const int N,
478  const mrpt::utils::CImage &img,
479  CFeatureList &feats,
480  unsigned int init_ID = 0,
481  unsigned int nDesiredFeatures = 0,
482  const TImageROI & ROI = TImageROI()) const;
483 
484 
485  // ------------------------------------------------------------------------------------
486  // my_scale_space_extrema
487  // ------------------------------------------------------------------------------------
488  /** Computes extrema in the scale space.
489  * \param dog_pyr Pyramid of images.
490  * \param octvs Number of considered octaves.
491  * \param intvls Number of intervales in octaves.
492  */
493  void* my_scale_space_extrema(
494  CFeatureList &featList, void* dog_pyr,
495  int octvs, int intvls, double contr_thr, int curv_thr,
496  void* storage ) const;
497 
498  /** Adjust scale if the image was initially doubled.
499  * \param features The sequence of features.
500  */
501  void my_adjust_for_img_dbl( void* features ) const;
502 
503  /** Gets the number of times that a point in the image is higher or lower than the surroundings in the image-scale space
504  * \param dog_pyr Pyramid of images.
505  * \param octvs Number of considered octaves.
506  * \param intvls Number of intervales in octaves.
507  * \param row The row of the feature in the original image.
508  * \param col The column of the feature in the original image.
509  * \param nMin [out]: Times that the feature is lower than the surroundings.
510  * \param nMax [out]: Times that the feature is higher than the surroundings.
511  */
512  void getTimesExtrema( void* dog_pyr, int octvs, int intvls, float row, float col, unsigned int &nMin, unsigned int &nMax ) const;
513 
514  /** Computes the Laplacian value of the feature in the corresponing image in the pyramid.
515  * \param dog_pyr Pyramid of images.
516  * \param octvs Number of considered octaves.
517  * \param intvls Number of intervales in octaves.
518  * \param row The row of the feature in the original image.
519  * \param col The column of the feature in the original image.
520  */
521  double getLaplacianValue( void* dog_pyr, int octvs, int intvls, float row, float col ) const;
522 
523  /** Append a sequence of openCV features into an MRPT feature list.
524  * \param features The sequence of features.
525  * \param list [in-out] The list of MRPT features.
526  * \param init_ID [in] The initial ID for the new features.
527  */
528  void insertCvSeqInCFeatureList( void* features, CFeatureList &list, unsigned int init_ID = 0 ) const;
529 
530  /** Converts a sequence of openCV features into an MRPT feature list.
531  * \param features The sequence of features.
532  * \param list [in-out] The list of MRPT features.
533  * \param init_ID [in][optional] The initial ID for the features (default = 0).
534  * \param ROI [in][optional] The initial ID for the features (default = empty ROI -> not used).
535  */
536  void convertCvSeqInCFeatureList( void* features, CFeatureList &list, unsigned int init_ID = 0, const TImageROI &ROI = TImageROI() ) const;
537 
538  }; // end of class
539  } // end of namespace
540 } // end of namespace
541 #endif
bool useMask
Whether to use a mask for determining the regions where not to look for keypoints (default=false)...
Declares a matrix of booleans (non serializable).
A class for storing images as grayscale or RGB bitmaps.
Definition: CImage.h:101
unsigned int radius
Maximum radius of the area of which the histogram is built, in pixel units (default=20 pixels) ...
TFeatureType featsType
Type of the extracted features.
double rho_scale
(default=5) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(ra...
unsigned int num_angles
(default=16) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(r...
TOptions options
Set all the parameters of the desired method here before calling "detectFeatures".
bool FIND_SUBPIXEL
Indicates if subpixel accuracy is desired for the extracted points (only applicable to KLT and Harris...
The set of parameters for all the detectors & descriptor algorithms.
bool use_KLT_response
(default=false) If true, use CImage::KLT_response to compute the response at each point instead of th...
This class allows loading and storing values and vectors of different types from a configuration text...
float std_dist
Standard deviation in "distance", used for the "soft histogram" (default=0.4 pixels) ...
A structure for defining a ROI within an image.
This base class is used to provide a unified interface to files,memory buffers,..Please see the deriv...
Definition: CStream.h:38
float std_intensity
Standard deviation in "intensity", used for the "soft histogram" (default=20 units [0...
float min_distance
(default=5) minimum distance between features (in pixels)
unsigned int bins_distance
Number of bins in the "distance" axis of the polar image (default=6).
A list of visual features, to be used as output by detectors, as input/output by trackers, etc.
Definition: CFeature.h:211
TDescriptorType
The bitwise OR combination of values of TDescriptorType are used in CFeatureExtraction::computeDescri...
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.
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
unsigned int radius
Maximum radius of the area of which the polar image is built, in pixel units (default=20 pixels) ...
unsigned int bins_angle
Number of bins in the "angular" axis of the polar image (default=8).
unsigned int patchSize
Size of the patch to extract, or 0 if no patch is desired (default=21).
unsigned int radius
Maximum radius of the area of which the log polar image is built, in pixel units (default=30 pixels) ...
bool addNewFeatures
Whether to add the found features to the input feature list or clear it before adding them (default=f...
unsigned int hist_size_distance
Number of bins in the "distance" axis of the 2D histogram (default=10).
Kanade-Lucas-Tomasi feature [SHI&#39;94].
This is a virtual base class for sets of options than can be loaded from and/or saved to configuratio...
The central class from which images can be analyzed in search of different kinds of interest points a...



Page generated by Doxygen 1.8.12 for MRPT 1.3.2 SVN: at Thu Nov 10 13:46:27 UTC 2016