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